Main Page | Class Hierarchy | Class List | File List | Class Members | File Members

cmt_vector.h

Go to the documentation of this file.
00001 //-----------------------------------------------------------
00002 // Copyright Christian Arnault LAL-Orsay CNRS
00003 // arnault@lal.in2p3.fr
00004 // See the complete license in cmt_license.txt "http://www.cecill.info". 
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

Generated on Mon May 2 10:25:06 2005 for CMT by doxygen 1.3.5