Thread portable class Gate portable class Timer class Pool class Terimber 2.0 About C++

Downloads Products & Services Support Clients Open Source About Home / Open source / Terimber 2.0 list.h Go to the documentation of this file. /* * The Software License * ================================================================================= * Copyright (c) 2003-.The Terimber Corporation. All rights reserved. * ================================================================================= * Redistributions of source code must retain the above copyright notice, * this list of conditions and the following disclaimer. * Redistributions in binary form must reproduce the above copyright notice, * this list of conditions and the following disclaimer in the documentation * and/or other materials provided with the distribution. * The end-user documentation included with the redistribution, if any, * must include the following acknowledgment: * "This product includes software developed by the Terimber Corporation." * ================================================================================= * THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESSED OR IMPLIED WARRANTIES, * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY * AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. * IN NO EVENT SHALL THE TERIMBER CORPORATION OR ITS CONTRIBUTORS BE LIABLE FOR * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON * ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * ================================================================================ */ #ifndef _terimber_list_h_ #define _terimber_list_h_ #include "base/memory.h" BEGIN_TERIMBER_NAMESPACE #pragma pack(4) template < class T > class base_list { base_list< T >(const base_list< T >& x); base_list< T >& operator=(const base_list< T >& x); public: class _node; class _node_ { public: _node_() : _next(0), _prev(0) { } _node* _next; _node* _prev; }; class _node : public _node_ { public: _node(const T& x) : _node_(), _value(x) { } T _value; }; protected: inline base_list< T >(); inline ~base_list< T >(); public: inline bool empty() const; inline const T& front() const; inline T& front(); inline const T& back() const; inline T& back(); class iterator; class const_iterator { public: typedef std::bidirectional_iterator_tag iterator_category; typedef size_t size_type; typedef T* pointer; typedef const T* const_pointer; typedef T& reference; typedef const T& const_reference; typedef T value_type; typedef size_t difference_type; inline const_iterator(_node* p ) : _ptr(p) {} inline const_iterator(const iterator& x ) : _ptr(x._ptr) {} inline const T& operator*() const { return _ptr->_value; } inline const T* operator->() const { return &(_ptr->_value); } inline const_iterator operator++() { _ptr = _ptr->_next; return *this; } inline const_iterator operator++(int) { const_iterator tmp = _ptr; _ptr = _ptr->_next; return tmp; } inline const_iterator operator--() { _ptr = _ptr->_prev; return *this; } inline const_iterator operator--(int) { const_iterator tmp = _ptr; _ptr = _ptr->_prev; return tmp; } inline bool operator==(const const_iterator& x) const { return _ptr == x._ptr; } inline bool operator!=(const const_iterator& x) const { return _ptr != x._ptr; } inline _node* next() const { return _ptr->_next; } inline _node* prev() const { return _ptr->_prev; } inline _node* node() const { return _ptr; } protected: _node* _ptr; }; class iterator : public const_iterator { public: inline iterator( _node* p ) : const_iterator(p) { } inline T& operator*() const { return this->_ptr->_value; } inline T* operator->() const { return &(this->_ptr->_value); } inline iterator operator++() { this->_ptr = this->_ptr->_next; return *this; } inline iterator operator++(int) { iterator tmp = this->_ptr; this->_ptr = this->_ptr->_next; return tmp; } inline iterator operator--() { this->_ptr = this->_ptr->_prev; return *this; } inline iterator operator--(int) { iterator tmp = this->_ptr; this->_ptr = this->_ptr->_prev; return tmp; } inline bool operator==(const iterator& x) const { return this->_ptr == x._ptr; } inline bool operator!=(const iterator& x) const { return this->_ptr != x._ptr; } }; inline TYPENAME base_list< T >::const_iterator begin() const; inline TYPENAME base_list< T >::iterator begin(); inline TYPENAME base_list< T >::const_iterator end() const; inline TYPENAME base_list< T >::iterator end(); inline void clear(); protected: inline TYPENAME base_list< T >::_node* head(); inline TYPENAME base_list< T >::_node* head() const; TYPENAME base_list< T >::_node_ _head; }; template < class T, class A = byte_allocator > class _list : public base_list< T > { public: inline _list< T, A >(); inline ~_list< T, A >(); inline _list< T, A >(const _list< T, A >& x); inline _list< T, A >& operator=(const _list< T, A >& x); inline void assign( A& allocator_, const _list< T, A >& x ); inline void assign( A& allocator_, TYPENAME _list< T, A >::const_iterator first, TYPENAME _list< T, A >::const_iterator last ); inline void assign( A& allocator_, size_t n, const T& x = T() ); inline size_t size() const; inline TYPENAME _list< T, A >::iterator push_back( A& allocator_, const T& x ); inline TYPENAME _list< T, A >::iterator push_front( A& allocator_, const T& x ); inline bool pop_front(); inline bool pop_front( node_allocator< TYPENAME base_list< T >::_node >& allocator_ ); inline bool pop_back(); inline bool pop_back( node_allocator< TYPENAME base_list< T >::_node >& allocator_ ); inline TYPENAME _list< T, A >::iterator insert( A& allocator_, TYPENAME _list< T, A >::iterator it, const T& x = T() ); inline void insert( A& allocator_, TYPENAME _list< T, A >::iterator it, size_t n, const T& x ); inline void insert( A& allocator_, TYPENAME _list< T, A >::iterator it, TYPENAME _list< T, A >::const_iterator first, TYPENAME _list< T, A >::const_iterator last ); inline void remove( const T& x ); inline void remove( node_allocator< TYPENAME base_list< T >::_node >& allocator_, const T& x ); inline TYPENAME _list< T, A >::iterator erase( TYPENAME _list< T, A >::iterator iter ); inline TYPENAME _list< T, A >::iterator erase( node_allocator< TYPENAME base_list< T >::_node >& allocator_, TYPENAME _list< T, A >::iterator iter ); inline TYPENAME _list< T, A >::iterator erase( TYPENAME _list< T, A >::iterator first, TYPENAME _list< T, A >::iterator last ); inline TYPENAME _list< T, A >::iterator erase( node_allocator< TYPENAME base_list< T >::_node >& allocator_, TYPENAME _list< T, A >::iterator first, TYPENAME _list< T, A >::iterator last ); private: inline TYPENAME _list< T, A >::iterator remove( TYPENAME _list< T, A >::iterator iter ); inline TYPENAME _list< T, A >::iterator remove( node_allocator< TYPENAME base_list< T >::_node >& allocator_, TYPENAME _list< T, A >::iterator iter ); inline TYPENAME _list< T, A >::_node* _buynode( byte_allocator& allocator_, const T& x ); inline TYPENAME _list< T, A >::_node* _buynode( node_allocator< TYPENAME base_list< T >::_node >& allocator_, const T& x ); inline void _freenode( node_allocator< TYPENAME base_list< T >::_node >& allocator_, TYPENAME _list< T, A >::_node* p ); }; template < class T > class list : public base_list< T > { public: list< T >( size_t size = os_def_size ); ~list< T >(); list< T >(const list< T >& x); list< T >& operator=(const list< T >& x); inline void clear(); inline void assign( const list< T >& x ); inline void assign( TYPENAME list< T >::const_iterator first, TYPENAME list< T >::const_iterator last ); inline void assign( size_t n, const T& x = T() ); inline size_t size() const; inline TYPENAME list< T >::iterator push_back( const T& x ); inline TYPENAME list< T >::iterator push_front( const T& x ); inline bool pop_front(); inline bool pop_back(); TYPENAME list< T >::iterator insert( TYPENAME list< T >::iterator it, const T& x = T() ); // calling copy constructor void insert( TYPENAME list< T >::iterator it, size_t n, const T& x ); void insert( TYPENAME list< T >::iterator it, TYPENAME list< T >::const_iterator first, TYPENAME list< T >::const_iterator last ); inline void remove( const T& x ); inline TYPENAME list< T >::iterator erase( TYPENAME list< T >::iterator iter ); inline TYPENAME list< T >::iterator erase( TYPENAME list< T >::iterator first, TYPENAME list< T >::iterator last ); private: inline TYPENAME list< T >::iterator remove( TYPENAME list< T >::iterator iter ); protected: inline TYPENAME list< T >::_node* _buynode( const T& x ); inline void _freenode( TYPENAME list< T >::_node* p ); protected: size_t _length; node_allocator< TYPENAME base_list< T >::_node > _allocator; }; #pragma pack() END_TERIMBER_NAMESPACE #endif // _terimber_list_h_

© Copyright Terimber 2003-.