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