00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022
00023
00024
00025
00026
00027
00028 #ifndef _terimber_vector_h_
00029 #define _terimber_vector_h_
00030
00031 #include "base/memory.h"
00032
00033 BEGIN_TERIMBER_NAMESPACE
00034 #pragma pack(4)
00035
00038 template < class T >
00039 class base_vector
00040 {
00041 protected:
00043 base_vector();
00045 ~base_vector();
00047 base_vector(const base_vector& x);
00048 public:
00052 typedef T* iterator;
00055 typedef const T* const_iterator;
00057 inline
00058 bool
00059 empty() const;
00061 inline
00062 size_t
00063 size() const;
00066 inline const T& operator[](size_t p) const;
00069 inline T& operator[](size_t p);
00071 inline const_iterator begin() const;
00073 inline iterator begin();
00075 inline const_iterator end() const;
00077 inline iterator end();
00078 protected:
00079 T* _first;
00080 size_t _length;
00081 };
00082
00086 template < class T, class A = byte_allocator >
00087 class _vector : public base_vector< T >
00088 {
00089 public:
00091 _vector< T, A >();
00093 ~_vector< T, A >();
00097 _vector< T, A >(const _vector< T, A >& x);
00101 _vector< T, A >& operator=(const _vector< T, A >& x);
00103 inline
00104 bool
00105 assign( A& allocator_,
00106 TYPENAME _vector< T, A >::const_iterator first,
00107 TYPENAME _vector< T, A >::const_iterator last
00108 );
00110 inline
00111 bool
00112 assign( A& allocator_,
00113 size_t n,
00114 const T& x = T()
00115 );
00118 inline
00119 bool
00120 assign( A& allocator_,
00121 const _vector< T, A >& x
00122 );
00125 inline
00126 bool
00127 resize( A& allocator_,
00128 size_t n,
00129 const T& x
00130 );
00132
00133 inline
00134 bool
00135 resize( A& allocator_,
00136 size_t n
00137 );
00138
00141 inline
00142 void
00143 reduce( size_t n
00144 );
00145
00147
00148 inline
00149 void
00150 clear();
00151
00153 inline
00154 void
00155 clear( array_allocator< T >& allocator_
00156 );
00157
00158 private:
00161 inline
00162 void
00163 _reduce( size_t n
00164 );
00166 inline
00167 T*
00168 _buynodes( byte_allocator& allocator_,
00169 size_t n
00170 );
00172 inline
00173 T*
00174 _buynodes( array_allocator< T >& allocator_,
00175 size_t n
00176 );
00177 };
00178
00181 template < class T >
00182 class vector : public base_vector< T >
00183 {
00184 public:
00186 vector< T >( size_t capacity = os_def_size
00187 );
00189 ~vector< T >();
00191 vector< T >(const vector< T >& x);
00193 inline
00194 vector< T >&
00195 operator=(const vector< T >& x);
00197 inline
00198 bool
00199 assign( TYPENAME vector< T >::const_iterator first,
00200 TYPENAME vector< T >::const_iterator last
00201 );
00203 inline
00204 bool
00205 assign( size_t n,
00206 const T& x = T()
00207 );
00209 inline
00210 bool
00211 assign( const vector< T >& x
00212 );
00215 inline
00216 bool
00217 resize( size_t n,
00218 const T& x = T()
00219 );
00221 inline
00222 void
00223 clear();
00224
00225 private:
00227 inline
00228 void
00229 _reduce( size_t n
00230 );
00232 inline
00233 T*
00234 _buynodes( size_t n
00235 );
00236 private:
00237 array_allocator< T > _allocator;
00238 };
00239
00240 #pragma pack()
00241 END_TERIMBER_NAMESPACE
00242
00243 #endif // _terimber_vector_h_
00244