[wxWidgets.git] / utils / HelpGen / src / wxstlvec.h

/////////////////////////////////////////////////////////////////////////////
// Name:        No names yet.
// Purpose:     Contrib. demo
// Author:      Aleksandras Gluchovas
// Modified by:
// Created:     27/09/98
// RCS-ID:      $Id$
// Copyright:   (c) Aleskandars Gluchovas
// Licence:   	wxWindows licence
/////////////////////////////////////////////////////////////////////////////

#ifndef __WXSTLVEC_G__
#define __WXSTLVEC_G__

#ifdef new
#undef new
#endif

#include <memory.h>
#include <string.h>  // imports memmove()
#include <stddef.h>
#if !defined(__WXMAC__) || defined(__DARWIN__)
#  include <sys/types.h>
#endif
#include <limits.h>
#include <new>

// the below macro used internally (see actual interface after this macro)

#define __DEFINE_STL_VECTOR_DEEP( vectorClass, Type ) class vectorClass {\
\
public:\
	typedef Type              value_type;\
	typedef value_type*	      iterator;\
	typedef const value_type* const_iterator;\
	typedef iterator		  pointer;\
	typedef const iterator    const_pointer;\
	typedef value_type&       reference;\
	typedef const value_type& const_reference;\
	typedef size_t            size_type;\
	typedef ptrdiff_t         difference_type;\
\
	typedef iterator       OutputIterator;\
	typedef const_iterator InputIterator;\
\
protected:\
\
	inline void PlacementCopy( const_iterator first, const_iterator last, iterator result )\
	{\
		while ( first != last ) \
			new (result++) value_type(*first++);\
	}\
\
	inline void ConstructObjects( iterator first, iterator last, const value_type& pattern )\
	{\
		while( first != last ) \
			new (first++) value_type(pattern);\
	}\
\
	inline void CopyObjects( iterator first, iterator last, iterator result )\
	{\
		while( first != last ) \
			*result++ = *first++;\
	}\
\
	inline void CopyObjectsBack( iterator first, iterator last, iterator result )\
	{\
		result += difference_type(last,first);\
\
		while( first != last ) \
			*(--result) = *(--last);\
	}\
\
public:\
\
	class reverse_iterator \
	{\
		friend class vectorClass;\
		friend class const_reverse_iterator;\
\
	public:\
		iterator mpPos;\
\
	public:\
\
		reverse_iterator() {}\
\
		reverse_iterator ( iterator pPos )\
		{\
			mpPos = pPos;\
		}\
	\
		int operator==( const reverse_iterator& rhs ) const { return (mpPos == rhs.mpPos); }\
		int operator!=( const reverse_iterator& rhs ) const { return (mpPos != rhs.mpPos); }\
\
		inline reverse_iterator( const reverse_iterator& other )\
		{\
			mpPos = other.mpPos;\
		}\
\
		inline const reverse_iterator& operator--() \
		{\
			--mpPos;\
			return *this;\
		}\
\
		inline reverse_iterator operator--(int)\
		{\
			reverse_iterator tmp = *this;\
			--mpPos;\
			return tmp;\
		}\
\
		inline const reverse_iterator & operator++() \
		{\
			++mpPos;\
			return *this;\
		}\
\
		inline reverse_iterator  operator++(int)\
		{\
			reverse_iterator tmp = *this;\
			++mpPos;\
			return tmp;\
		}\
\
		inline const_reference operator*() const { return *mpPos; }\
	};\
\
\
	class const_reverse_iterator \
	{\
	protected:\
		iterator mpPos;\
	public:\
\
		const_reverse_iterator() {}\
\
		const_reverse_iterator( const iterator pPos )\
		{\
			mpPos = pPos;\
		}\
	\
		int operator==( const const_reverse_iterator& rhs ) const { return (mpPos == rhs.mpPos); }\
		int operator!=( const const_reverse_iterator& rhs ) const { return (mpPos != rhs.mpPos); }\
\
		inline const_reverse_iterator( const reverse_iterator& other )\
		{\
			mpPos = other.mpPos;\
		}\
\
		inline const const_reverse_iterator& operator--() \
		{\
			--mpPos;\
			return *this;\
		}\
\
		inline const_reverse_iterator operator--(int)\
		{\
			const_reverse_iterator tmp = *this;\
			--mpPos;\
			return tmp;\
		}\
\
		inline const const_reverse_iterator & operator++() \
		{\
			++mpPos;\
			return *this;\
		}\
\
		inline const_reverse_iterator operator++(int)\
		{\
			const_reverse_iterator tmp = *this;\
			++mpPos;\
			return tmp;\
		}\
\
		inline const_reference operator*() const { return *mpPos; }\
	};\
\
protected:\
	\
	pointer mpStart;\
	pointer mpEnd;\
	pointer mpEndOfBuf;\
\
protected:\
\
	inline void quick_sort(int low, int hi) \
	{\
	}\
\
	inline void DestructRange( iterator first, iterator last )\
	{\
		typedef value_type value_type_local;\
\
		while ( first != last ) \
		{\
			first->value_type_local::~value_type_local();\
			++first;\
		}\
	}\
\
	inline iterator DoInsert(iterator position, const value_type& x)\
	{\
		if ( mpEnd < mpEndOfBuf )\
		{\
			new (mpEnd) value_type(*(mpEnd-1) );\
	    \
			CopyObjectsBack( position, mpEnd, position + 1 );\
	    \
			*position = x;\
	    \
			++mpEnd;\
	    \
			return position;\
		}\
	    \
		size_type minBufLen = WXSTL_VECTOR_MIN_BUF_SIZE/sizeof(value_type);\
	    \
		size_type doubledSize = size()*2;\
	    \
		size_type newLen = ( doubledSize < minBufLen ) ? minBufLen : doubledSize;\
	    \
		iterator pNewStart = (iterator)( new char[newLen*sizeof(value_type)] );\
	    \
		PlacementCopy( mpStart, position, pNewStart );\
	    \
		iterator atPosition = pNewStart + difference_type( position - mpStart );\
	    \
		new (atPosition) value_type(x);\
	    \
		iterator newPos = atPosition;\
	    \
		++atPosition;\
	    \
		if ( mpStart ) \
		{\
			PlacementCopy( position, mpEnd, atPosition );\
			DestructRange( mpStart, mpEnd );\
			delete [](char*)mpStart;\
		}\
	    \
		mpEnd = atPosition + difference_type( mpEnd - position );\
	    \
		mpStart    = pNewStart;\
		mpEndOfBuf = pNewStart + newLen;\
	    \
		return newPos;\
	}\
\
public:\
\
	inline vectorClass() : mpStart(0), \
						   mpEnd(0),\
						   mpEndOfBuf(0)\
	{}\
\
	inline vectorClass( const_iterator first, const_iterator last )\
		: mpStart(0),\
		  mpEnd(0),\
		  mpEndOfBuf(0)\
		\
		{ while( first != last ) push_back( *first++ ); }\
\
	inline vectorClass( size_type n, const value_type& value = value_type() )\
		: mpStart(0),\
		  mpEnd(0),\
		  mpEndOfBuf(0)\
		\
		{ for( size_type i = 0; i != n; ++i ) push_back( value ); }\
\
	inline const vectorClass& operator=( const vectorClass& other )\
	{\
		if (mpStart) \
		{\
			DestructRange( begin(), end() );\
			delete [](char*)mpStart; \
		}\
\
		size_t newLen = difference_type( other.mpEndOfBuf - other.mpStart );\
\
		mpStart = (iterator)( new char[newLen*sizeof(value_type)] );\
\
		PlacementCopy( other.begin(), other.end(), mpStart );\
\
		mpEnd = mpStart + other.size();\
\
		mpEndOfBuf = mpStart + newLen;\
\
		return *this;\
	}\
\
	inline vectorClass( const vectorClass& other )\
		: mpStart(0),\
		  mpEnd(0),\
		  mpEndOfBuf(0)\
	{\
		this->operator=( other );\
	}\
\
	inline ~vectorClass() \
	{ \
		if (mpStart) \
		{\
			DestructRange( begin(), end() );\
			delete [](char*)mpStart; \
		}\
	}\
\
	inline iterator begin() { return mpStart; }\
\
	inline const_iterator begin() const { return mpStart; }\
\
	inline iterator end() { return mpEnd; }\
\
	inline const_iterator end() const { return mpEnd; }\
\
	inline size_type size() const { return (size_type)difference_type(mpEnd-mpStart); }\
\
	inline size_type max_size() const { return UINT_MAX/sizeof(value_type); }\
\
	inline size_type capacity() const \
			{ return difference_type(mpEndOfBuf-mpStart)/sizeof(value_type); }\
\
	inline int empty() const { return mpStart == mpEnd; }\
\
	inline reference operator[](size_type n) { return *(mpStart+n); }\
\
	inline const_reference operator[](size_type n) const { return *(mpStart+n); }\
\
	inline reference front() { return (*mpStart); }\
	\
	inline const_reference front() const { return (*mpStart); }\
\
	inline reference back() { return (*(mpEnd-1)); }\
\
	inline const_reference back() const { return (*(mpEnd-1)); }\
\
	inline void reserve(size_type n) {}\
\
	inline void push_back(const value_type& x)\
	{\
		if ( mpEnd != mpEndOfBuf ) \
		{\
			new (mpEnd) value_type(x);\
			++mpEnd;\
		}\
		else\
			DoInsert( mpEnd, x );\
	}\
\
	inline iterator insert(iterator position, const value_type& x = value_type())\
	{\
		if ( position == mpEnd && mpEnd != mpEndOfBuf )\
		{\
			new (mpEnd) value_type(x);\
			++mpEnd;\
			return (mpEnd-1);\
		}\
		else return DoInsert( position, x );\
	}\
\
	inline void pop_back()\
	{\
		DestructRange( mpEnd-1, mpEnd );\
\
		--mpEnd;\
	}\
\
	inline void erase(iterator first, iterator last)\
	{\
		if ( last == mpEnd )\
		{\
			DestructRange( first, last );\
			mpEnd = first;\
			return;\
		}\
	    \
		CopyObjects( last, last + difference_type( mpEnd - last ), first );\
	    \
		iterator newEnd = mpEnd - difference_type( last - first );\
		DestructRange( newEnd, mpEnd );\
	    \
		mpEnd = newEnd;\
	}\
\
	inline void erase( iterator position )\
	{\
		erase( position, position + 1 );\
	}\
\
	inline void sort()\
	{\
		if ( size() < 2 ) return;\
		quick_sort( 0, size()-1 );\
	}\
}

/////////////////////////////// shallow-copy container ///////////////////////

#define __DEFINE_STL_VECTOR_SHALLOW( vectorClass, Type ) class vectorClass {\
\
public:\
	typedef Type              value_type;\
	typedef value_type*	      iterator;\
	typedef const value_type* const_iterator;\
	typedef iterator		  pointer;\
	typedef const iterator    const_pointer;\
	typedef value_type&       reference;\
	typedef const value_type& const_reference;\
	typedef size_t            size_type;\
	typedef ptrdiff_t         difference_type;\
\
	typedef iterator       OutputIterator;\
	typedef const_iterator InputIterator;\
\
protected:\
\
	inline void PlacementCopy( const_iterator first, const_iterator last, iterator result )\
	{\
		memcpy(result, first, int(difference_type(last-first)*sizeof(value_type)) );\
	}\
\
	inline void ConstructObjects( iterator first, iterator last, const value_type& pattern )\
	{\
			if ( sizeof(pattern) == 1 )\
			\
				memset( first, int(difference_type(last-first)/sizeof(value_type)), \
				        int(*((char*)&pattern)) );\
			else\
				while( first != last ) \
					*first++ = pattern;\
	}\
\
	inline void CopyObjects( iterator first, iterator last, iterator result )\
	{\
		memcpy(result, first, int(difference_type(last-first)*sizeof(value_type)) );\
	}\
\
	inline void CopyObjectsBack( iterator first, iterator last, iterator result )\
	{\
		memmove(result, first, int(difference_type(last-first)*sizeof(value_type)) );\
	}\
\
public:\
\
	class reverse_iterator \
	{\
		friend class vectorClass;\
		friend class const_reverse_iterator;\
\
	public:\
		iterator mpPos;\
\
	public:\
\
		reverse_iterator() {}\
\
		reverse_iterator ( iterator pPos )\
		{\
			mpPos = pPos;\
		}\
	\
		int operator==( const reverse_iterator& rhs ) const { return (mpPos == rhs.mpPos); }\
		int operator!=( const reverse_iterator& rhs ) const { return (mpPos != rhs.mpPos); }\
\
		inline reverse_iterator( const reverse_iterator& other )\
		{\
			mpPos = other.mpPos;\
		}\
\
		inline const reverse_iterator& operator--() \
		{\
			--mpPos;\
			return *this;\
		}\
\
		inline reverse_iterator operator--(int)\
		{\
			reverse_iterator tmp = *this;\
			--mpPos;\
			return tmp;\
		}\
\
		inline const reverse_iterator & operator++() \
		{\
			++mpPos;\
			return *this;\
		}\
\
		inline reverse_iterator  operator++(int)\
		{\
			reverse_iterator tmp = *this;\
			++mpPos;\
			return tmp;\
		}\
\
		inline const_reference operator*() const { return *mpPos; }\
	};\
\
\
	class const_reverse_iterator \
	{\
	protected:\
		iterator mpPos;\
	public:\
\
		const_reverse_iterator() {}\
\
		const_reverse_iterator( const iterator pPos )\
		{\
			mpPos = pPos;\
		}\
	\
		int operator==( const const_reverse_iterator& rhs ) const { return (mpPos == rhs.mpPos); }\
		int operator!=( const const_reverse_iterator& rhs ) const { return (mpPos != rhs.mpPos); }\
\
		inline const_reverse_iterator( const reverse_iterator& other )\
		{\
			mpPos = other.mpPos;\
		}\
\
		inline const const_reverse_iterator& operator--() \
		{\
			--mpPos;\
			return *this;\
		}\
\
		inline const_reverse_iterator operator--(int)\
		{\
			const_reverse_iterator tmp = *this;\
			--mpPos;\
			return tmp;\
		}\
\
		inline const const_reverse_iterator & operator++() \
		{\
			++mpPos;\
			return *this;\
		}\
\
		inline const_reverse_iterator operator++(int)\
		{\
			const_reverse_iterator tmp = *this;\
			++mpPos;\
			return tmp;\
		}\
\
		inline const_reference operator*() const { return *mpPos; }\
	};\
\
protected:\
	\
	pointer mpStart;\
	pointer mpEnd;\
	pointer mpEndOfBuf;\
\
protected:\
\
	inline void quick_sort(int low, int hi) \
	{\
	}\
\
	inline void DestructRange( iterator first, iterator last )\
	{\
	}\
\
	inline iterator DoInsert(iterator position, const value_type& x)\
	{\
		if ( mpEnd < mpEndOfBuf )\
		{\
			new (mpEnd) value_type(*(mpEnd-1) );\
	    \
			CopyObjectsBack( position, mpEnd, position + 1 );\
	    \
			*position = x;\
	    \
			++mpEnd;\
	    \
			return position;\
		}\
	    \
		size_type minBufLen = WXSTL_VECTOR_MIN_BUF_SIZE/sizeof(value_type);\
	    \
		size_type doubledSize = size()*2;\
	    \
		size_type newLen = ( doubledSize < minBufLen ) ? minBufLen : doubledSize;\
	    \
		iterator pNewStart = (iterator)( new char[newLen*sizeof(value_type)] );\
	    \
		PlacementCopy( mpStart, position, pNewStart );\
	    \
		iterator atPosition = pNewStart + difference_type( position - mpStart );\
	    \
		new (atPosition) value_type(x);\
	    \
		iterator newPos = atPosition;\
	    \
		++atPosition;\
	    \
		if ( mpStart ) \
		{\
			PlacementCopy( position, mpEnd, atPosition );\
			DestructRange( mpStart, mpEnd );\
			delete [](char*)mpStart;\
		}\
	    \
		mpEnd = atPosition + difference_type( mpEnd - position );\
	    \
		mpStart    = pNewStart;\
		mpEndOfBuf = pNewStart + newLen;\
	    \
		return newPos;\
	}\
\
public:\
\
	inline vectorClass() : mpStart(0), \
						   mpEnd(0),\
						   mpEndOfBuf(0)\
	{}\
\
	inline vectorClass( const_iterator first, const_iterator last )\
		: mpStart(0),\
		  mpEnd(0),\
		  mpEndOfBuf(0)\
		\
		{ while( first != last ) push_back( *first++ ); }\
\
	inline vectorClass( size_type n, const value_type& value = value_type() )\
		: mpStart(0),\
		  mpEnd(0),\
		  mpEndOfBuf(0)\
		\
		{ for( size_type i = 0; i != n; ++i ) push_back( value ); }\
\
	inline const vectorClass& operator=( const vectorClass& other )\
	{\
		if (mpStart) \
		{\
			DestructRange( begin(), end() );\
			delete [](char*)mpStart; \
		}\
\
		size_t newLen = difference_type( other.mpEndOfBuf - other.mpStart );\
\
		mpStart = (iterator)( new char[newLen*sizeof(value_type)] );\
\
		PlacementCopy( other.begin(), other.end(), mpStart );\
\
		mpEnd = mpStart + other.size();\
\
		mpEndOfBuf = mpStart + newLen;\
\
		return *this;\
	}\
\
	inline vectorClass( const vectorClass& other )\
		: mpStart(0),\
		  mpEnd(0),\
		  mpEndOfBuf(0)\
	{\
		this->operator=( other );\
	}\
\
	inline ~vectorClass() \
	{ \
		if (mpStart) \
		{\
			DestructRange( begin(), end() );\
			delete [](char*)mpStart; \
		}\
	}\
\
	inline iterator begin() { return mpStart; }\
\
	inline const_iterator begin() const { return mpStart; }\
\
	inline iterator end() { return mpEnd; }\
\
	inline const_iterator end() const { return mpEnd; }\
\
	inline size_type size() const { return (size_type)difference_type(mpEnd-mpStart); }\
\
	inline size_type max_size() const { return UINT_MAX/sizeof(value_type); }\
\
	inline size_type capacity() const \
			{ return difference_type(mpEndOfBuf-mpStart)/sizeof(value_type); }\
\
	inline int empty() const { return mpStart == mpEnd; }\
\
	inline reference operator[](size_type n) { return *(mpStart+n); }\
\
	inline const_reference operator[](size_type n) const { return *(mpStart+n); }\
\
	inline reference front() { return (*mpStart); }\
	\
	inline const_reference front() const { return (*mpStart); }\
\
	inline reference back() { return (*(mpEnd-1)); }\
\
	inline const_reference back() const { return (*(mpEnd-1)); }\
\
	inline void reserve(size_type n) {}\
\
	inline void push_back(const value_type& x)\
	{\
		if ( mpEnd != mpEndOfBuf ) \
		{\
			new (mpEnd) value_type(x);\
			++mpEnd;\
		}\
		else\
			DoInsert( mpEnd, x );\
	}\
\
	inline iterator insert(iterator position, const value_type& x = value_type())\
	{\
		if ( position == mpEnd && mpEnd != mpEndOfBuf )\
		{\
			new (mpEnd) value_type(x);\
			++mpEnd;\
			return (mpEnd-1);\
		}\
		else return DoInsert( position, x );\
	}\
\
	inline void pop_back()\
	{\
		DestructRange( mpEnd-1, mpEnd );\
\
		--mpEnd;\
	}\
\
	inline void erase(iterator first, iterator last)\
	{\
		if ( last == mpEnd )\
		{\
			DestructRange( first, last );\
			mpEnd = first;\
			return;\
		}\
	    \
		CopyObjects( last, last + difference_type( mpEnd - last ), first );\
	    \
		iterator newEnd = mpEnd - difference_type( last - first );\
		DestructRange( newEnd, mpEnd );\
	    \
		mpEnd = newEnd;\
	}\
\
	inline void erase( iterator position )\
	{\
		erase( position, position + 1 );\
	}\
\
	inline void sort()\
	{\
		if ( size() < 2 ) return;\
		quick_sort( 0, size()-1 );\
	}\
}


// redefine below symbol to change the default allocation unit of vector content buffer
#define WXSTL_VECTOR_MIN_BUF_SIZE 64

// defines vector class, where objects are copied
// using "deep-copy" sematics (i.e. by calling their copy constructors)

#define WXSTL_VECTOR(ELEMENT_CLASS) \
__DEFINE_STL_VECTOR_DEEP(_WXSTL_VECTOR_##ELEMENT_CLASS, ELEMENT_CLASS)

// defines vector class, where objects are copied
// using "shallow-copy" sematics (i.e. instead of calling
// their constructors, memcpy() and memmove() are used to copy their raw data)


#define WXSTL_VECTOR_SHALLOW_COPY(ELEMENT_CLASS) __DEFINE_STL_VECTOR_SHALLOW(_WXSTL_VECTORSC_##ELEMENT_CLASS, ELEMENT_CLASS)

#endif
Commit	Line	Data
cecfc5e7 VZ	1	/////////////////////////////////////////////////////////////////////////////
	2	// Name: No names yet.
	3	// Purpose: Contrib. demo
	4	// Author: Aleksandras Gluchovas
	5	// Modified by:
	6	// Created: 27/09/98
	7	// RCS-ID: $Id$
	8	// Copyright: (c) Aleskandars Gluchovas
	9	// Licence: wxWindows licence
	10	/////////////////////////////////////////////////////////////////////////////
	11
	12	#ifndef __WXSTLVEC_G__
	13	#define __WXSTLVEC_G__
	14
3d05544e JS	15	#ifdef new
	16	#undef new
	17	#endif
	18
cecfc5e7 VZ	19	#include <memory.h>
	20	#include <string.h> // imports memmove()
	21	#include <stddef.h>
ad053960 GD	22	#if !defined(__WXMAC__) \|\| defined(__DARWIN__)
	23	# include <sys/types.h>
	24	#endif
cecfc5e7 VZ	25	#include <limits.h>
	26	#include <new>
	27
	28	// the below macro used internally (see actual interface after this macro)
	29
	30	#define __DEFINE_STL_VECTOR_DEEP( vectorClass, Type ) class vectorClass {\
	31	\
	32	public:\
	33	typedef Type value_type;\
	34	typedef value_type* iterator;\
	35	typedef const value_type* const_iterator;\
	36	typedef iterator pointer;\
	37	typedef const iterator const_pointer;\
	38	typedef value_type& reference;\
	39	typedef const value_type& const_reference;\
	40	typedef size_t size_type;\
	41	typedef ptrdiff_t difference_type;\
	42	\
	43	typedef iterator OutputIterator;\
	44	typedef const_iterator InputIterator;\
	45	\
	46	protected:\
	47	\
	48	inline void PlacementCopy( const_iterator first, const_iterator last, iterator result )\
	49	{\
	50	while ( first != last ) \
	51	new (result++) value_type(*first++);\
	52	}\
	53	\
	54	inline void ConstructObjects( iterator first, iterator last, const value_type& pattern )\
	55	{\
	56	while( first != last ) \
	57	new (first++) value_type(pattern);\
	58	}\
	59	\
	60	inline void CopyObjects( iterator first, iterator last, iterator result )\
	61	{\
	62	while( first != last ) \
	63	result++ = first++;\
	64	}\
	65	\
	66	inline void CopyObjectsBack( iterator first, iterator last, iterator result )\
	67	{\
	68	result += difference_type(last,first);\
	69	\
	70	while( first != last ) \
	71	(--result) = (--last);\
	72	}\
	73	\
	74	public:\
	75	\
	76	class reverse_iterator \
	77	{\
	78	friend class vectorClass;\
	79	friend class const_reverse_iterator;\
	80	\
	81	public:\
	82	iterator mpPos;\
	83	\
	84	public:\
	85	\
	86	reverse_iterator() {}\
	87	\
	88	reverse_iterator ( iterator pPos )\
89	{\
90	mpPos = pPos;\
91	}\
92	\
93	int operator==( const reverse_iterator& rhs ) const { return (mpPos == rhs.mpPos); }\
94	int operator!=( const reverse_iterator& rhs ) const { return (mpPos != rhs.mpPos); }\
95	\
96	inline reverse_iterator( const reverse_iterator& other )\
97	{\
98	mpPos = other.mpPos;\
99	}\
100	\
101	inline const reverse_iterator& operator--() \
102	{\
103	--mpPos;\
104	return *this;\
105	}\
106	\
107	inline reverse_iterator operator--(int)\
108	{\
109	reverse_iterator tmp = *this;\
110	--mpPos;\
111	return tmp;\
112	}\
113	\
114	inline const reverse_iterator & operator++() \
115	{\
116	++mpPos;\
117	return *this;\
118	}\
119	\
120	inline reverse_iterator operator++(int)\
121	{\
122	reverse_iterator tmp = *this;\
123	++mpPos;\
124	return tmp;\
125	}\
126	\
127	inline const_reference operator() const { return mpPos; }\
128	};\
129	\
130	\
131	class const_reverse_iterator \
132	{\
133	protected:\
134	iterator mpPos;\
135	public:\
136	\
137	const_reverse_iterator() {}\
138	\
139	const_reverse_iterator( const iterator pPos )\
140	{\
141	mpPos = pPos;\
142	}\
143	\
144	int operator==( const const_reverse_iterator& rhs ) const { return (mpPos == rhs.mpPos); }\
145	int operator!=( const const_reverse_iterator& rhs ) const { return (mpPos != rhs.mpPos); }\
146	\
147	inline const_reverse_iterator( const reverse_iterator& other )\
148	{\
149	mpPos = other.mpPos;\
150	}\
151	\
152	inline const const_reverse_iterator& operator--() \
153	{\
154	--mpPos;\
155	return *this;\
156	}\
157	\
158	inline const_reverse_iterator operator--(int)\
159	{\
160	const_reverse_iterator tmp = *this;\
161	--mpPos;\
162	return tmp;\
163	}\
164	\
165	inline const const_reverse_iterator & operator++() \
166	{\
167	++mpPos;\
168	return *this;\
169	}\
170	\
171	inline const_reverse_iterator operator++(int)\
172	{\
173	const_reverse_iterator tmp = *this;\
174	++mpPos;\
175	return tmp;\
176	}\
177	\
178	inline const_reference operator() const { return mpPos; }\
179	};\
180	\
181	protected:\
182	\
183	pointer mpStart;\
184	pointer mpEnd;\
185	pointer mpEndOfBuf;\
186	\
187	protected:\
188	\
189	inline void quick_sort(int low, int hi) \
190	{\
191	}\
192	\
193	inline void DestructRange( iterator first, iterator last )\
194	{\
195	typedef value_type value_type_local;\
196	\
197	while ( first != last ) \
198	{\
199	first->value_type_local::~value_type_local();\
200	++first;\
201	}\
202	}\
203	\
204	inline iterator DoInsert(iterator position, const value_type& x)\
205	{\
206	if ( mpEnd < mpEndOfBuf )\
207	{\
208	new (mpEnd) value_type(*(mpEnd-1) );\
209	\
210	CopyObjectsBack( position, mpEnd, position + 1 );\
211	\
212	*position = x;\
213	\
214	++mpEnd;\
215	\
216	return position;\
217	}\
218	\
219	size_type minBufLen = WXSTL_VECTOR_MIN_BUF_SIZE/sizeof(value_type);\
220	\
221	size_type doubledSize = size()*2;\
222	\
223	size_type newLen = ( doubledSize < minBufLen ) ? minBufLen : doubledSize;\
224	\
225	iterator pNewStart = (iterator)( new char[newLen*sizeof(value_type)] );\
226	\
227	PlacementCopy( mpStart, position, pNewStart );\
228	\
229	iterator atPosition = pNewStart + difference_type( position - mpStart );\
230	\
231	new (atPosition) value_type(x);\
232	\
233	iterator newPos = atPosition;\
234	\
235	++atPosition;\
236	\
237	if ( mpStart ) \
238	{\
239	PlacementCopy( position, mpEnd, atPosition );\
240	DestructRange( mpStart, mpEnd );\
241	delete [](char*)mpStart;\
242	}\
243	\
244	mpEnd = atPosition + difference_type( mpEnd - position );\
245	\
246	mpStart = pNewStart;\
247	mpEndOfBuf = pNewStart + newLen;\
248	\
249	return newPos;\
250	}\
251	\
252	public:\
253	\
254	inline vectorClass() : mpStart(0), \
255	mpEnd(0),\
256	mpEndOfBuf(0)\
257	{}\
258	\
259	inline vectorClass( const_iterator first, const_iterator last )\
260	: mpStart(0),\
261	mpEnd(0),\
262	mpEndOfBuf(0)\
263	\
264	{ while( first != last ) push_back( *first++ ); }\
265	\
266	inline vectorClass( size_type n, const value_type& value = value_type() )\
267	: mpStart(0),\
268	mpEnd(0),\
269	mpEndOfBuf(0)\
270	\
271	{ for( size_type i = 0; i != n; ++i ) push_back( value ); }\
272	\
273	inline const vectorClass& operator=( const vectorClass& other )\
274	{\
275	if (mpStart) \
276	{\
277	DestructRange( begin(), end() );\
278	delete [](char*)mpStart; \
279	}\
280	\
281	size_t newLen = difference_type( other.mpEndOfBuf - other.mpStart );\
282	\
283	mpStart = (iterator)( new char[newLen*sizeof(value_type)] );\
284	\
285	PlacementCopy( other.begin(), other.end(), mpStart );\
286	\
287	mpEnd = mpStart + other.size();\
288	\
289	mpEndOfBuf = mpStart + newLen;\
290	\
291	return *this;\
292	}\
293	\
294	inline vectorClass( const vectorClass& other )\
295	: mpStart(0),\
296	mpEnd(0),\
297	mpEndOfBuf(0)\
298	{\
299	this->operator=( other );\
300	}\
301	\
302	inline ~vectorClass() \
303	{ \
304	if (mpStart) \
305	{\
306	DestructRange( begin(), end() );\
307	delete [](char*)mpStart; \
308	}\
309	}\
310	\
311	inline iterator begin() { return mpStart; }\
312	\
313	inline const_iterator begin() const { return mpStart; }\
314	\
315	inline iterator end() { return mpEnd; }\
316	\
317	inline const_iterator end() const { return mpEnd; }\
318	\
319	inline size_type size() const { return (size_type)difference_type(mpEnd-mpStart); }\
320	\
321	inline size_type max_size() const { return UINT_MAX/sizeof(value_type); }\
322	\
323	inline size_type capacity() const \
324	{ return difference_type(mpEndOfBuf-mpStart)/sizeof(value_type); }\
325	\
326	inline int empty() const { return mpStart == mpEnd; }\
327	\
328	inline reference operator[](size_type n) { return *(mpStart+n); }\
329	\
330	inline const_reference operator[](size_type n) const { return *(mpStart+n); }\
331	\
332	inline reference front() { return (*mpStart); }\
333	\
334	inline const_reference front() const { return (*mpStart); }\
335	\
336	inline reference back() { return (*(mpEnd-1)); }\
337	\
338	inline const_reference back() const { return (*(mpEnd-1)); }\
339	\
340	inline void reserve(size_type n) {}\
341	\
342	inline void push_back(const value_type& x)\
343	{\
344	if ( mpEnd != mpEndOfBuf ) \
345	{\
346	new (mpEnd) value_type(x);\
347	++mpEnd;\
348	}\
349	else\
350	DoInsert( mpEnd, x );\
351	}\
352	\
353	inline iterator insert(iterator position, const value_type& x = value_type())\
354	{\
355	if ( position == mpEnd && mpEnd != mpEndOfBuf )\
356	{\
357	new (mpEnd) value_type(x);\
358	++mpEnd;\
359	return (mpEnd-1);\
360	}\
361	else return DoInsert( position, x );\
362	}\
363	\
364	inline void pop_back()\
365	{\
366	DestructRange( mpEnd-1, mpEnd );\
367	\
368	--mpEnd;\
369	}\
370	\
371	inline void erase(iterator first, iterator last)\
372	{\
373	if ( last == mpEnd )\
374	{\
375	DestructRange( first, last );\
376	mpEnd = first;\
377	return;\
378	}\
379	\
380	CopyObjects( last, last + difference_type( mpEnd - last ), first );\
381	\
382	iterator newEnd = mpEnd - difference_type( last - first );\
383	DestructRange( newEnd, mpEnd );\
384	\
385	mpEnd = newEnd;\
386	}\
387	\
388	inline void erase( iterator position )\
389	{\
390	erase( position, position + 1 );\
391	}\
392	\
393	inline void sort()\
394	{\
395	if ( size() < 2 ) return;\
396	quick_sort( 0, size()-1 );\
397	}\
398	}
399
400	/////////////////////////////// shallow-copy container ///////////////////////
401
402	#define __DEFINE_STL_VECTOR_SHALLOW( vectorClass, Type ) class vectorClass {\
403	\
404	public:\
405	typedef Type value_type;\
406	typedef value_type* iterator;\
407	typedef const value_type* const_iterator;\
408	typedef iterator pointer;\
409	typedef const iterator const_pointer;\
410	typedef value_type& reference;\
411	typedef const value_type& const_reference;\
412	typedef size_t size_type;\
413	typedef ptrdiff_t difference_type;\
414	\
415	typedef iterator OutputIterator;\
416	typedef const_iterator InputIterator;\
417	\
418	protected:\
419	\
420	inline void PlacementCopy( const_iterator first, const_iterator last, iterator result )\
421	{\
422	memcpy(result, first, int(difference_type(last-first)*sizeof(value_type)) );\
423	}\
424	\
425	inline void ConstructObjects( iterator first, iterator last, const value_type& pattern )\
426	{\
427	if ( sizeof(pattern) == 1 )\
428	\
429	memset( first, int(difference_type(last-first)/sizeof(value_type)), \
430	int(((char)&pattern)) );\
431	else\
432	while( first != last ) \
433	*first++ = pattern;\
434	}\
435	\
436	inline void CopyObjects( iterator first, iterator last, iterator result )\
437	{\
438	memcpy(result, first, int(difference_type(last-first)*sizeof(value_type)) );\
439	}\
440	\
441	inline void CopyObjectsBack( iterator first, iterator last, iterator result )\
442	{\
443	memmove(result, first, int(difference_type(last-first)*sizeof(value_type)) );\
444	}\
445	\
446	public:\
447	\
448	class reverse_iterator \
449	{\
450	friend class vectorClass;\
451	friend class const_reverse_iterator;\
452	\
453	public:\
454	iterator mpPos;\
455	\
456	public:\
457	\
458	reverse_iterator() {}\
459	\
460	reverse_iterator ( iterator pPos )\
461	{\
462	mpPos = pPos;\
463	}\
464	\
465	int operator==( const reverse_iterator& rhs ) const { return (mpPos == rhs.mpPos); }\
466	int operator!=( const reverse_iterator& rhs ) const { return (mpPos != rhs.mpPos); }\
467	\
468	inline reverse_iterator( const reverse_iterator& other )\
469	{\
470	mpPos = other.mpPos;\
471	}\
472	\
473	inline const reverse_iterator& operator--() \
474	{\
475	--mpPos;\
476	return *this;\
477	}\
478	\
479	inline reverse_iterator operator--(int)\
480	{\
481	reverse_iterator tmp = *this;\
482	--mpPos;\
483	return tmp;\
484	}\
485	\
486	inline const reverse_iterator & operator++() \
487	{\
488	++mpPos;\
489	return *this;\
490	}\
491	\
492	inline reverse_iterator operator++(int)\
493	{\
494	reverse_iterator tmp = *this;\
495	++mpPos;\
496	return tmp;\
497	}\
498	\
499	inline const_reference operator() const { return mpPos; }\
500	};\
501	\
502	\
503	class const_reverse_iterator \
504	{\
505	protected:\
506	iterator mpPos;\
507	public:\
508	\
509	const_reverse_iterator() {}\
510	\
511	const_reverse_iterator( const iterator pPos )\
512	{\
513	mpPos = pPos;\
514	}\
515	\
516	int operator==( const const_reverse_iterator& rhs ) const { return (mpPos == rhs.mpPos); }\
517	int operator!=( const const_reverse_iterator& rhs ) const { return (mpPos != rhs.mpPos); }\
518	\
519	inline const_reverse_iterator( const reverse_iterator& other )\
520	{\
521	mpPos = other.mpPos;\
522	}\
523	\
524	inline const const_reverse_iterator& operator--() \
525	{\
526	--mpPos;\
527	return *this;\
528	}\
529	\
530	inline const_reverse_iterator operator--(int)\
531	{\
532	const_reverse_iterator tmp = *this;\
533	--mpPos;\
534	return tmp;\
535	}\
536	\
537	inline const const_reverse_iterator & operator++() \
538	{\
539	++mpPos;\
540	return *this;\
541	}\
542	\
543	inline const_reverse_iterator operator++(int)\
544	{\
545	const_reverse_iterator tmp = *this;\
546	++mpPos;\
547	return tmp;\
548	}\
549	\
550	inline const_reference operator() const { return mpPos; }\
551	};\
552	\
553	protected:\
554	\
555	pointer mpStart;\
556	pointer mpEnd;\
557	pointer mpEndOfBuf;\
558	\
559	protected:\
560	\
561	inline void quick_sort(int low, int hi) \
562	{\
563	}\
564	\
565	inline void DestructRange( iterator first, iterator last )\
566	{\
567	}\
568	\
569	inline iterator DoInsert(iterator position, const value_type& x)\
570	{\
571	if ( mpEnd < mpEndOfBuf )\
572	{\
573	new (mpEnd) value_type(*(mpEnd-1) );\
574	\
575	CopyObjectsBack( position, mpEnd, position + 1 );\
576	\
577	*position = x;\
578	\
579	++mpEnd;\
580	\
581	return position;\
582	}\
583	\
584	size_type minBufLen = WXSTL_VECTOR_MIN_BUF_SIZE/sizeof(value_type);\
585	\
586	size_type doubledSize = size()*2;\
587	\
588	size_type newLen = ( doubledSize < minBufLen ) ? minBufLen : doubledSize;\
589	\
590	iterator pNewStart = (iterator)( new char[newLen*sizeof(value_type)] );\
591	\
592	PlacementCopy( mpStart, position, pNewStart );\
593	\
594	iterator atPosition = pNewStart + difference_type( position - mpStart );\
595	\
596	new (atPosition) value_type(x);\
597	\
598	iterator newPos = atPosition;\
599	\
600	++atPosition;\
601	\
602	if ( mpStart ) \
603	{\
604	PlacementCopy( position, mpEnd, atPosition );\
605	DestructRange( mpStart, mpEnd );\
606	delete [](char*)mpStart;\
607	}\
608	\
609	mpEnd = atPosition + difference_type( mpEnd - position );\
610	\
611	mpStart = pNewStart;\
612	mpEndOfBuf = pNewStart + newLen;\
613	\
614	return newPos;\
615	}\
616	\
617	public:\
618	\
619	inline vectorClass() : mpStart(0), \
620	mpEnd(0),\
621	mpEndOfBuf(0)\
622	{}\
623	\
624	inline vectorClass( const_iterator first, const_iterator last )\
625	: mpStart(0),\
626	mpEnd(0),\
627	mpEndOfBuf(0)\
628	\
629	{ while( first != last ) push_back( *first++ ); }\
630	\
631	inline vectorClass( size_type n, const value_type& value = value_type() )\
632	: mpStart(0),\
633	mpEnd(0),\
634	mpEndOfBuf(0)\
635	\
636	{ for( size_type i = 0; i != n; ++i ) push_back( value ); }\
637	\
638	inline const vectorClass& operator=( const vectorClass& other )\
639	{\
640	if (mpStart) \
641	{\
642	DestructRange( begin(), end() );\
643	delete [](char*)mpStart; \
644	}\
645	\
646	size_t newLen = difference_type( other.mpEndOfBuf - other.mpStart );\
647	\
648	mpStart = (iterator)( new char[newLen*sizeof(value_type)] );\
649	\
650	PlacementCopy( other.begin(), other.end(), mpStart );\
651	\
652	mpEnd = mpStart + other.size();\
653	\
654	mpEndOfBuf = mpStart + newLen;\
655	\
656	return *this;\
657	}\
658	\
659	inline vectorClass( const vectorClass& other )\
660	: mpStart(0),\
661	mpEnd(0),\
662	mpEndOfBuf(0)\
663	{\
664	this->operator=( other );\
665	}\
666	\
667	inline ~vectorClass() \
668	{ \
669	if (mpStart) \
670	{\
671	DestructRange( begin(), end() );\
672	delete [](char*)mpStart; \
673	}\
674	}\
675	\
676	inline iterator begin() { return mpStart; }\
677	\
678	inline const_iterator begin() const { return mpStart; }\
679	\
680	inline iterator end() { return mpEnd; }\
681	\
682	inline const_iterator end() const { return mpEnd; }\
683	\
684	inline size_type size() const { return (size_type)difference_type(mpEnd-mpStart); }\
685	\
686	inline size_type max_size() const { return UINT_MAX/sizeof(value_type); }\
687	\
688	inline size_type capacity() const \
689	{ return difference_type(mpEndOfBuf-mpStart)/sizeof(value_type); }\
690	\
691	inline int empty() const { return mpStart == mpEnd; }\
692	\
693	inline reference operator[](size_type n) { return *(mpStart+n); }\
694	\
695	inline const_reference operator[](size_type n) const { return *(mpStart+n); }\
696	\
697	inline reference front() { return (*mpStart); }\
698	\
699	inline const_reference front() const { return (*mpStart); }\
700	\
701	inline reference back() { return (*(mpEnd-1)); }\
702	\
703	inline const_reference back() const { return (*(mpEnd-1)); }\
704	\
705	inline void reserve(size_type n) {}\
706	\
707	inline void push_back(const value_type& x)\
708	{\
709	if ( mpEnd != mpEndOfBuf ) \
710	{\
711	new (mpEnd) value_type(x);\
712	++mpEnd;\
713	}\
714	else\
715	DoInsert( mpEnd, x );\
716	}\
717	\
718	inline iterator insert(iterator position, const value_type& x = value_type())\
719	{\
720	if ( position == mpEnd && mpEnd != mpEndOfBuf )\
721	{\
722	new (mpEnd) value_type(x);\
723	++mpEnd;\
724	return (mpEnd-1);\
725	}\
726	else return DoInsert( position, x );\
727	}\
728	\
729	inline void pop_back()\
730	{\
731	DestructRange( mpEnd-1, mpEnd );\
732	\
733	--mpEnd;\
734	}\
735	\
736	inline void erase(iterator first, iterator last)\
737	{\
738	if ( last == mpEnd )\
739	{\
740	DestructRange( first, last );\
741	mpEnd = first;\
742	return;\
743	}\
744	\
745	CopyObjects( last, last + difference_type( mpEnd - last ), first );\
746	\
747	iterator newEnd = mpEnd - difference_type( last - first );\
748	DestructRange( newEnd, mpEnd );\
749	\
750	mpEnd = newEnd;\
751	}\
752	\
753	inline void erase( iterator position )\
754	{\
755	erase( position, position + 1 );\
756	}\
757	\
758	inline void sort()\
759	{\
760	if ( size() < 2 ) return;\
761	quick_sort( 0, size()-1 );\
762	}\
763	}
764
765
766
767	// redefine below symbol to change the default allocation unit of vector content buffer
768	#define WXSTL_VECTOR_MIN_BUF_SIZE 64
769
770	// defines vector class, where objects are copied
771	// using "deep-copy" sematics (i.e. by calling their copy constructors)
772
773	#define WXSTL_VECTOR(ELEMENT_CLASS) \
774	__DEFINE_STL_VECTOR_DEEP(_WXSTL_VECTOR_##ELEMENT_CLASS, ELEMENT_CLASS)
775
776	// defines vector class, where objects are copied
777	// using "shallow-copy" sematics (i.e. instead of calling
778	// their constructors, memcpy() and memmove() are used to copy their raw data)
779
780
781	#define WXSTL_VECTOR_SHALLOW_COPY(ELEMENT_CLASS) __DEFINE_STL_VECTOR_SHALLOW(_WXSTL_VECTORSC_##ELEMENT_CLASS, ELEMENT_CLASS)
782
783	#endif