Main Page   Class Hierarchy   Compound List   File List   Compound Members   File Members  

cmt_vector.h

Go to the documentation of this file.
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

Generated at Thu Apr 11 16:49:44 2002 for CMT by doxygen1.2.3 written by Dimitri van Heesch, © 1997-2000