| // -*- C++ -*- |
| #ifndef __STD_LIST_SPEC__ |
| #define __STD_LIST_SPEC__ |
| |
| /*************************************************************************** |
| * |
| * list_spec.h - list <_TypeT*> partial specialization |
| * |
| *************************************************************************** |
| * |
| * Copyright (c) 1994 |
| * Hewlett-Packard Company |
| * |
| * Permission to use, copy, modify, distribute and sell this software |
| * and its documentation for any purpose is hereby granted without fee, |
| * provided that the above copyright notice appear in all copies and |
| * that both that copyright notice and this permission notice appear |
| * in supporting documentation. Hewlett-Packard Company makes no |
| * representations about the suitability of this software for any |
| * purpose. It is provided "as is" without express or implied warranty. |
| * |
| *************************************************************************** |
| * |
| * Licensed to the Apache Software Foundation (ASF) under one or more |
| * contributor license agreements. See the NOTICE file distributed |
| * with this work for additional information regarding copyright |
| * ownership. The ASF licenses this file to you under the Apache |
| * License, Version 2.0 (the "License"); you may not use this file |
| * except in compliance with the License. You may obtain a copy of |
| * the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or |
| * implied. See the License for the specific language governing |
| * permissions and limitations under the License. |
| * |
| * Copyright 1994-2006 Rogue Wave Software. |
| * |
| **************************************************************************/ |
| |
| |
| #include <rw/_defs.h> |
| |
| |
| #ifndef __STD_LIST__ |
| # include <list> |
| #endif // __STD_LIST__ |
| |
| |
| _RWSTD_NAMESPACE (std) { |
| |
| |
| template class list <void*, allocator <void*> >; |
| |
| |
| template <class _TypeT> |
| class list <_TypeT*, allocator <_TypeT*> > |
| { |
| typedef allocator <_TypeT*> _Allocator; |
| typedef _RWSTD_REBIND (_Allocator, void*) __imp_alloc_type; |
| typedef list <void*, __imp_alloc_type> __imp_type; |
| typedef _TYPENAME __imp_type::iterator __imp_iterator; |
| typedef _TYPENAME __imp_type::const_iterator __imp_const_iterator; |
| |
| __imp_type __imp; |
| |
| public: |
| |
| typedef _TypeT* value_type; |
| typedef _Allocator allocator_type; |
| |
| typedef _TYPENAME allocator_type::reference reference; |
| typedef _TYPENAME allocator_type::const_reference const_reference; |
| typedef _TYPENAME allocator_type::pointer pointer; |
| typedef _TYPENAME allocator_type::const_pointer const_pointer; |
| typedef _TYPENAME allocator_type::size_type size_type; |
| typedef _TYPENAME allocator_type::difference_type difference_type; |
| |
| protected: |
| |
| typedef _STD::iterator <bidirectional_iterator_tag, value_type, |
| difference_type, pointer, reference> __it; |
| typedef _STD::iterator <bidirectional_iterator_tag, value_type, |
| difference_type, const_pointer, const_reference> __cit; |
| |
| public: |
| |
| class const_iterator; |
| |
| class iterator : public __it |
| { |
| typedef _TYPENAME __imp_type::iterator __imp_iter; |
| |
| __imp_iter __imp; |
| |
| friend class list<_TypeT, allocator <_TypeT> >; |
| friend class const_iterator; |
| |
| // implicit conversions from and to implementation-specific iterator |
| // used only internally |
| iterator (const __imp_iter &imp) |
| : __imp (imp) {} |
| |
| operator __imp_iter () { |
| return __imp; |
| } |
| |
| public: |
| iterator () {} |
| |
| bool operator== (const iterator& x) const { |
| return __imp == x.__imp; |
| } |
| |
| bool operator!= (const iterator& x) const { |
| return !(*this == x); |
| } |
| |
| __iterator_base::reference operator* () const { |
| return __iterator_base::reference (*__imp); |
| } |
| |
| |
| #ifndef _RWSTD_NO_NONCLASS_ARROW_RETURN |
| |
| __iterator_base::pointer operator-> () const { |
| return __iterator_base::pointer (&*__imp); |
| } |
| |
| #endif // _RWSTD_NO_NONCLASS_ARROW_RETURN |
| |
| |
| iterator& operator++ () { |
| ++__imp; |
| return *this; |
| } |
| |
| iterator operator++ (int) { |
| iterator tmp = *this; |
| ++*this; |
| return tmp; |
| } |
| |
| iterator& operator-- () { |
| --__imp; |
| return *this; |
| } |
| |
| iterator operator-- (int) { |
| iterator tmp = *this; |
| --*this; |
| return tmp; |
| } |
| }; |
| |
| |
| class const_iterator : public __cit |
| { |
| typedef _TYPENAME __imp_type::const_iterator __imp_iter; |
| |
| __imp_iter __imp; |
| |
| friend class list<_TypeT,allocator<_TypeT> >; |
| |
| const_iterator (const __imp_iter &imp) |
| : __imp (imp) { } |
| |
| public: |
| |
| const_iterator () { } |
| |
| const_iterator (const iterator &x) |
| : __imp (x.__imp) { } |
| |
| bool operator== (const const_iterator& x) const { |
| return __imp == x.__imp; |
| } |
| |
| bool operator!= (const const_iterator &x) const { |
| return !(*this == x); |
| } |
| |
| const_reference operator* () const { |
| return const_reference (*__imp); |
| } |
| |
| |
| #ifndef _RWSTD_NO_NONCLASS_ARROW_RETURN |
| |
| const_pointer operator-> () const { |
| return const_pointer (&*__imp); |
| } |
| |
| #endif // _RWSTD_NO_NONCLASS_ARROW_RETURN |
| |
| |
| const_iterator& operator++ () { |
| ++__imp; |
| return *this; |
| } |
| |
| const_iterator operator++ (int) { |
| const_iterator tmp = *this; |
| ++*this; |
| return tmp; |
| } |
| |
| const_iterator& operator-- () { |
| --__imp; |
| return *this; |
| } |
| |
| const_iterator operator-- (int) { |
| const_iterator tmp = *this; |
| --*this; |
| return tmp; |
| } |
| }; |
| |
| |
| #if !defined (_RWSTD_NO_CLASS_PARTIAL_SPEC) |
| |
| typedef _STD::reverse_iterator <const_iterator> const_reverse_iterator; |
| typedef _STD::reverse_iterator <iterator> reverse_iterator; |
| |
| #else |
| |
| typedef __reverse_bi_iterator <const_iterator, |
| bidirectional_iterator_tag, value_type, |
| const_reference, const_pointer, difference_type> |
| const_reverse_iterator; |
| typedef __reverse_bi_iterator <iterator, |
| bidirectional_iterator_tag, value_type, |
| reference, pointer, difference_type> |
| reverse_iterator; |
| |
| #endif |
| |
| |
| _EXPLICIT list (const _Allocator &alloc _RWSTD_DEFAULT_ARG (_Allocator())) |
| : __imp (alloc) { } |
| |
| _EXPLICIT list (size_type n, |
| const_reference x _RWSTD_DEFAULT_ARG (value_type ()), |
| const _Allocator &alloc _RWSTD_DEFAULT_ARG (_Allocator ())) |
| : __imp (n, x, alloc) { } |
| |
| |
| #ifdef _RWSTD_NO_DEFAULT_TEMPLATE_ARGS |
| |
| list () |
| : __imp () { } |
| |
| list (size_type n, const_reference x) |
| : __imp (n, x) { } |
| |
| #endif // _RWSTD_NO_DEFAULT_TEMPLATE_ARGS |
| |
| |
| #ifndef _RWSTD_NO_MEMBER_TEMPLATES |
| |
| template<class InputIterator> |
| list (InputIterator first, InputIterator last, |
| const _Allocator& alloc _RWSTD_DEFAULT_ARG (_Allocator ())) |
| : __imp (first, last, alloc) { } |
| |
| list (const_iterator first, const_iterator last, |
| const _Allocator& alloc _RWSTD_DEFAULT_ARG (_Allocator ())) |
| : __imp (first, last, alloc) { } |
| |
| |
| #ifdef _RWSTD_NO_DEFAULT_TEMPLATE_ARGS |
| |
| list (const_iterator first, const_iterator last) |
| : __imp (first, last) { } |
| |
| #endif // _RWSTD_NO_DEFAULT_TEMPLATE_ARGS |
| #endif // _RWSTD_NO_MEMBER_TEMPLATES |
| |
| |
| list (const list& x) |
| : __imp (x.__imp) |
| { } |
| |
| list& operator= (const list& x) { |
| __imp = x.__imp; |
| return *this; |
| } |
| |
| |
| #ifndef _RWSTD_NO_MEMBER_TEMPLATES |
| |
| template <class InputIterator> |
| void assign (InputIterator first, InputIterator last) { |
| __imp.assign (first, last); |
| } |
| |
| #else // defined (_RWSTD_NO_MEMBER_TEMPLATES) |
| |
| void assign (const_iterator first, const_iterator last) { |
| __imp.assign (first, last); |
| } |
| |
| #endif // _RWSTD_NO_MEMBER_TEMPLATES |
| |
| |
| void assign (size_type n, const_reference x) { |
| __imp.assign (n, x); |
| } |
| |
| allocator_type get_allocator () const { |
| return allocator_type (__imp.get_allocator ()); |
| } |
| |
| iterator begin () { |
| return __imp.begin (); |
| } |
| |
| const_iterator begin () const { |
| return __imp.begin (); |
| } |
| |
| iterator end () { |
| return __imp.end (); |
| } |
| |
| const_iterator end () const { |
| return __imp.end (); |
| } |
| |
| reverse_iterator rbegin () { |
| return reverse_iterator (end ()); |
| } |
| |
| const_reverse_iterator rbegin () const { |
| return const_reverse_iterator (end ()); |
| } |
| |
| reverse_iterator rend () { |
| return reverse_iterator (begin ()); |
| } |
| |
| const_reverse_iterator rend () const { |
| return const_reverse_iterator (begin ()); |
| } |
| |
| bool empty () const { |
| return __imp.empty (); |
| } |
| |
| size_type size () const { |
| return __imp.size (); |
| } |
| |
| size_type max_size () const { |
| return __imp.max_size (); |
| } |
| |
| void resize (size_type new_size) { |
| __imp.resize (new_size); |
| } |
| |
| void resize (size_type new_size, const_reference x) { |
| __imp.resize (new_size, x); |
| } |
| |
| reference front () { |
| return reference (__imp.front ()); |
| } |
| |
| const_reference front () const { |
| return const_reference (__imp.front ()); |
| } |
| |
| reference back () { |
| return reference (__imp.back ()); |
| } |
| |
| const_reference back () const { |
| return const_reference (__imp.back ()); |
| } |
| |
| void push_front (const_reference x) { |
| __imp.push_front (x); |
| } |
| |
| void push_back (const_reference x) { |
| __imp.push_back (x); |
| } |
| |
| void pop_front () { |
| __imp.pop_front (); |
| } |
| |
| void pop_back () { |
| __imp.pop_back (); |
| } |
| |
| iterator insert (iterator pos, const_reference x) { |
| return __imp.insert (pos, x); |
| } |
| |
| |
| #ifndef _RWSTD_NO_MEMBER_TEMPLATES |
| |
| template <class InputIterator> |
| void insert (iterator pos, InputIterator first, InputIterator last) { |
| __imp.insert (pos, first, last); |
| } |
| |
| #else // if defined (_RWSTD_NO_MEMBER_TEMPLATES) |
| |
| void insert (iterator pos, const_iterator first, const_iterator last) { |
| __imp.insert (pos, first, last); |
| } |
| |
| #endif // _RWSTD_NO_MEMBER_TEMPLATES |
| |
| |
| void insert (iterator pos, size_type n, const_reference x) { |
| __imp.insert (pos, n, x); |
| } |
| |
| iterator erase (iterator pos) { |
| return __imp.erase (pos); |
| } |
| |
| iterator erase (iterator first, iterator last) { |
| return __imp.erase (first, last); |
| } |
| |
| void swap (list &x) { |
| __imp.swap (x.__imp); |
| } |
| |
| void clear () { |
| __imp.clear (); |
| } |
| |
| void splice (iterator pos, list &x) { |
| __imp.splice (pos, x.__imp); |
| } |
| |
| void splice (iterator pos, list &x, iterator i) { |
| __imp.splice (pos, x.__imp, i); |
| } |
| |
| void splice (iterator pos, list &x, iterator first, iterator last) { |
| __imp.splice (pos, x.__imp, first, last); |
| } |
| |
| void remove (const_reference x) { |
| __imp.remove (x); |
| } |
| |
| void unique () { |
| __imp.unique (); |
| } |
| |
| void merge (list &x) { |
| __imp.merge (x.__imp); |
| } |
| |
| void reverse () { |
| __imp.reverse (); |
| } |
| |
| void sort () { |
| __imp.sort (); |
| } |
| |
| |
| #ifndef _RWSTD_NO_MEMBER_TEMPLATES |
| |
| template <class Predicate> |
| void remove_if (Predicate pred) { |
| __imp.remove_if (pred); |
| } |
| |
| template <class BinaryPredicate> |
| void unique (BinaryPredicate pred) { |
| __imp.unique (pred); |
| } |
| |
| template <class _Compare> |
| void merge (list &x, _Compare comp) { |
| __imp.merge (x, comp); |
| } |
| |
| template <class _Compare> |
| void sort (_Compare comp) { |
| __imp.sort (comp); |
| } |
| |
| #endif // _RWSTD_NO_MEMBER_TEMPLATES |
| |
| |
| #ifndef _RWSTD_NO_EXT_ALLOC_SIZE |
| |
| size_type allocation_size () const { |
| return __imp.allocation_size (); |
| } |
| |
| size_type allocation_size (size_type new_size) { |
| return __imp.allocation_size (new_size); |
| } |
| |
| #endif // _RWSTD_NO_EXT_ALLOC_SIZE |
| }; |
| |
| |
| template <class _TypeT> |
| inline bool operator== (const list <_TypeT*, allocator <_TypeT*> > &x, |
| const list <_TypeT*, allocator <_TypeT*> > &y) |
| { |
| return x.size () == y.size () && equal (x.begin (), x.end (), y.begin ()); |
| } |
| |
| template <class _TypeT> |
| inline bool operator< (const list <_TypeT*, allocator <_TypeT*> > &x, |
| const list <_TypeT*, allocator <_TypeT*> > &y) |
| { |
| return lexicographical_compare (x.begin (), x.end (), y.begin (), y.end ()); |
| } |
| |
| |
| #if !defined (_RWSTD_NO_NAMESPACE) || !defined (_RWSTD_NO_PART_SPEC_OVERLOAD) |
| |
| template <class _TypeT> |
| inline bool operator!= (const list <_TypeT*, allocator <_TypeT*> > &x, |
| const list <_TypeT*, allocator <_TypeT*> > &y) |
| { |
| return !(x == y); |
| } |
| |
| template <class _TypeT> |
| inline bool operator> (const list <_TypeT*, allocator <_TypeT*> > &x, |
| const list <_TypeT*, allocator <_TypeT*> > &y) |
| { |
| return y < x; |
| } |
| |
| template <class _TypeT> |
| inline bool operator>= (const list <_TypeT*, allocator <_TypeT*> > &x, |
| const list <_TypeT*, allocator <_TypeT*> > &y) |
| { |
| return !(x < y); |
| } |
| |
| template <class _TypeT> |
| inline bool operator<= (const list <_TypeT*, allocator <_TypeT*> > &x, |
| const list <_TypeT*, allocator <_TypeT*> > &y) |
| { |
| return !(y < x); |
| } |
| |
| template <class _TypeT> |
| inline void swap (list <_TypeT*, allocator <_TypeT*> > &a, |
| list <_TypeT*, allocator <_TypeT*> > &b) |
| { |
| a.swap (b); |
| } |
| |
| #endif // !defined(_RWSTD_NO_NAMESPACE) || !defined(_RWSTD_NO_PART_SPEC_OVERLOAD) |
| |
| |
| } // namespace std |
| |
| |
| #endif /*__STD_LIST_SPEC__*/ |