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 stack.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_stack_h_ #define _terimber_stack_h_ #include "base/memory.h" BEGIN_TERIMBER_NAMESPACE #pragma pack(4) template < class T > class base_stack { public: class _node; class _node_ { public: _node_() : _next(0) { } _node* _next; }; class _node : public _node_ { public: _node( const T& x ) : _node_(), _value(x) { } T _value; }; protected: base_stack< T >(); ~base_stack< T >(); base_stack< T >(const base_stack< T >& x); public: inline bool empty() const; inline const T& top() const; inline T& top(); class iterator; class const_iterator { public: typedef std::forward_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 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* 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 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_stack< T >::const_iterator begin() const; inline TYPENAME base_stack< T >::iterator begin(); inline TYPENAME base_stack< T >::const_iterator end() const; inline TYPENAME base_stack< T >::iterator end(); inline void clear(); protected: inline TYPENAME base_stack< T >::_node* head(); inline TYPENAME base_stack< T >::_node* head() const; TYPENAME base_stack< T >::_node_ _head; }; template < class T, class A = byte_allocator > class _stack : public base_stack< T > { public: _stack< T, A >(); ~_stack< T, A >(); _stack< T, A >(const _stack< T, A >& x); inline _stack< T, A >& operator=(const _stack< T, A >& x); inline size_t size(); inline TYPENAME _stack< T, A >::iterator push( A& allocator_, const T& x ); inline bool pop(); inline bool pop( node_allocator< TYPENAME base_stack< T >::_node >& allocator_ ); protected: inline TYPENAME _stack< T, A >::_node* _buynode( byte_allocator& allocator_, const T& x ); inline TYPENAME _stack< T, A >::_node* _buynode( node_allocator< TYPENAME base_stack< T >::_node >& allocator_, const T& x ); inline void _freenode( node_allocator< TYPENAME base_stack< T >::_node >& allocator_, TYPENAME _stack< T, A >::_node* p ); }; template < class T > class stack : public base_stack< T > { public: stack< T >( size_t size = os_def_size ); ~stack< T >(); stack< T >(const stack< T >& x); inline stack< T >& operator=(const stack< T >& x); inline size_t size() const; inline TYPENAME stack< T >::iterator push( const T& x ); inline bool pop(); inline void clear(); protected: inline TYPENAME stack< T >::_node* _buynode( const T& x ); inline void _freenode( TYPENAME stack< T >::_node* p ); protected: size_t _length; node_allocator< TYPENAME base_stack< T >::_node > _allocator; }; // class unique_key_generator { unique_key_generator(const unique_key_generator& x); unique_key_generator& operator=(const unique_key_generator& x); public: inline unique_key_generator(size_t capacity = os_def_size ); inline ~unique_key_generator(); inline void clear(); inline size_t generate(); inline void save( size_t key ); private: size_t _last; stack< size_t > _rep; }; #pragma pack() END_TERIMBER_NAMESPACE #endif // _terimber_stack_h_

© Copyright Terimber 2003-.