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