00001
00002
00003
00004
00005
00006
00007 #ifndef __cmt_vector_h__
00008 #define __cmt_vector_h__
00009
00010 #include <stdlib.h>
00011
00012 template <class T> class cmt_vector
00013 {
00014 public:
00015 typedef T element_type;
00016 typedef T* element_ptr;
00017 typedef T** frame_ptr;
00018
00019 cmt_vector ()
00020 {
00021 _data = 0;
00022 _frames = 0;
00023 _size = 0;
00024 }
00025
00026 cmt_vector (const cmt_vector& other)
00027 {
00028 _data = 0;
00029 _frames = 0;
00030 _size = 0;
00031
00032 cmt_vector<T>& me = *this;
00033
00034 extend (other._size);
00035 for (int i = 0; i < _size; i++)
00036 {
00037 me.element_at (i) = other.element_at (i);
00038 }
00039 }
00040
00041 cmt_vector (int n)
00042 {
00043 _data = 0;
00044 _frames = 0;
00045 _size = 0;
00046
00047 extend (n);
00048 }
00049
00050 ~cmt_vector ()
00051 {
00052 if (_data != 0)
00053 {
00054 for (int i = 0; i < _frames; i++)
00055 {
00056 delete[] _data[i];
00057 _data[i] = 0;
00058 }
00059 #ifdef CMT_USE_NEW_DELETE
00060 delete[] _data;
00061 #else
00062 free (_data);
00063 #endif
00064 }
00065 _data = 0;
00066 _frames = 0;
00067 _size = 0;
00068 }
00069
00070 void push_back (const T& object)
00071 {
00072 extend (1);
00073 element_at (_size - 1) = object;
00074 }
00075
00076 T& add ()
00077 {
00078 resize (size() + 1);
00079 return (back ());
00080 }
00081
00082 void pop_back ()
00083 {
00084 if (_size > 0) _size--;
00085 }
00086
00087 void erase (int index)
00088 {
00089 if ((_data == 0) ||
00090 (index < 0) ||
00091 (index >= _size))
00092 {
00093 return;
00094 }
00095
00096 for (int i = index; i < (_size - 1); i++)
00097 {
00098 element_at (i) = element_at (i + 1);
00099 }
00100
00101 _size--;
00102 }
00103
00104 cmt_vector& operator = (const cmt_vector& other)
00105 {
00106 clear ();
00107
00108 cmt_vector<T>& me = *this;
00109
00110 extend (other._size);
00111 for (int i = 0; i < _size; i++)
00112 {
00113 element_at (i) = other.element_at (i);
00114 }
00115
00116 return (me);
00117 }
00118
00119 T& operator [] (int index) const
00120 {
00121 if ((_data == 0) ||
00122 (index < 0) ||
00123 (index >= _size))
00124 {
00125 static T object;
00126 return (object);
00127 }
00128 else
00129 {
00130 return (element_at (index));
00131 }
00132 }
00133
00134 T& operator [] (int index)
00135 {
00136 if ((_data == 0) ||
00137 (index < 0) ||
00138 (index >= _size))
00139 {
00140 static T object;
00141 return (object);
00142 }
00143 else
00144 {
00145 return (element_at (index));
00146 }
00147 }
00148
00149 T& back () const
00150 {
00151 if ((_data == 0) ||
00152 (_size == 0))
00153 {
00154 static T object;
00155 return (object);
00156 }
00157 else
00158 {
00159 return (element_at (_size - 1));
00160 }
00161 }
00162
00163 T& back ()
00164 {
00165 if ((_data == 0) ||
00166 (_size == 0))
00167 {
00168 static T object;
00169 return (object);
00170 }
00171 else
00172 {
00173 return (element_at (_size - 1));
00174 }
00175 }
00176
00177 void resize (int new_size)
00178 {
00179 if (new_size < 0) return;
00180
00181 extend (new_size - _size);
00182 _size = new_size;
00183 }
00184
00185 int size () const
00186 {
00187 return (_size);
00188 }
00189
00190 void clear ()
00191 {
00192 _size = 0;
00193 }
00194
00195 frame_ptr get_frame () const
00196 {
00197 return (_data);
00198 }
00199
00200 int get_frame_number () const
00201 {
00202 return (_frames);
00203 }
00204
00205 int get_frame_size () const
00206 {
00207 return (frame_size);
00208 }
00209
00210 private:
00211
00212 enum {frame_size = 4};
00213
00214 T& element_at (int index)
00215 {
00216 int frame = index / frame_size;
00217 return (_data[frame][index % frame_size]);
00218 }
00219
00220 T& element_at (int index) const
00221 {
00222 int frame = index / frame_size;
00223 return (_data[frame][index % frame_size]);
00224 }
00225
00226 int frames (int n)
00227 {
00228 return ((n == 0) ? 0 : ((n - 1) / frame_size) + 1);
00229 }
00230
00231 void extend (int n)
00232 {
00233 if (n <= 0) return;
00234
00235 _size += n;
00236
00237 int f = frames (_size);
00238 if (f > _frames)
00239 {
00240 if (_data == 0)
00241 {
00242
00243 #ifdef CMT_USE_NEW_DELETE
00244 _data = new element_ptr [f];
00245 #else
00246 _data = (frame_ptr) malloc (f * sizeof (element_ptr));
00247 #endif
00248
00249 }
00250 else
00251 {
00252
00253 #ifdef CMT_USE_NEW_DELETE
00254 frame_ptr new_data;
00255
00256 new_data = new element_ptr [f];
00257 for (int i = 0; i < _frames; i++)
00258 {
00259 new_data[i] = _data[i];
00260 }
00261 delete[] _data;
00262 _data = new_data;
00263 #else
00264 _data = (frame_ptr) realloc (_data, f * sizeof (element_ptr));
00265 #endif
00266
00267 }
00268
00269 for (int i = _frames; i < f; i++)
00270 {
00271 _data[i] = new T[frame_size];
00272 }
00273
00274 _frames = f;
00275 }
00276 }
00277
00278 frame_ptr _data;
00279 int _frames;
00280 int _size;
00281 };
00282
00283 #endif