array.h

   1 /*-----------------------------------------------------------------------------
   2   Arrays class
   3   Written by Francois Fleuret <francois.fleuret@inria.fr>
   4   -----------------------------------------------------------------------------*/
   5
   6 #ifndef ARRAY_CC
   7 #define ARRAY_CC
   8
   9 #include <stdio.h>
  10
  11 //-----------------------------------------------------------------------------
  12
  13 extern int arraySize;
  14 void resetArraySize();
  15 int getArraySize();
  16
  17 //-----------------------------------------------------------------------------
  18
  19 extern "C" void abort();
  20
  21 template <class T>
  22 class Array
  23 {
  24 public:
  25   int size;
  26   T* body;
  27
  28   Array(Array<T> &a);
  29   Array(int s);
  30   Array();
  31
  32   ~Array();
  33
  34   static void resetNb();
  35   static int getNb();
  36
  37   void kill();
  38   void copy(Array &a);
  39   void resize(int t);
  40   void set(int p, T t);
  41   T get(int p);
  42   T* getref(int p);
  43   void absorb(Array<T> a);
  44 };
  45
  46 template<class T>
  47 inline Array<T>::Array(int s)
  48 {
  49   size = s;
  50   body = new T[s];
  51 #ifdef DEBUG
  52   arraySize += s*sizeof(T);
  53 #endif
  54 }
  55
  56 template<class T>
  57 inline Array<T>::Array()
  58 {
  59   size = -1;
  60   body = NULL;
  61 }
  62
  63 template<class T>
  64 inline Array<T>::Array(Array<T> &a)
  65 {
  66   int k;
  67 #ifdef DEBUG
  68 //  cerr<<"WARNING ARRAY DUPLICATION : "<<a.size<<" elements\n";
  69 #endif
  70   //  abort();
  71   size = a.size;
  72   body = new T[size];
  73 #ifdef DEBUG
  74   arraySize += size*sizeof(T);
  75 #endif
  76   for(k=0; k<size; k++) body[k] = a.body[k];
  77 }
  78
  79 template<class T>
  80 inline Array<T>::~Array()
  81 {
  82   if(size >= 0)
  83     {
  84       delete[] body;
  85 #ifdef DEBUG
  86       arraySize -= size*sizeof(T);
  87       if(arraySize < 0)
  88         {
  89           cerr<<"ARRAY DEALLOCATION ERROR\n";
  90           abort();
  91         }
  92 #endif
  93     }
  94 }
  95
  96 template<class T>
  97 inline void Array<T>::kill()
  98 {
  99   if(size >= 0)
 100     {
 101       delete[] body;
 102 #ifdef DEBUG
 103       arraySize -= size*sizeof(T);
 104       if(arraySize < 0)
 105         {
 106           cerr<<"ARRAY DEALLOCATION ERROR\n";
 107           abort();
 108         }
 109 #endif
 110       size = -1;
 111     }
 112 }
 113
 114 template<class T>
 115 inline void Array<T>::copy(Array& a)
 116 {
 117   int k;
 118   if(size >= 0)
 119     {
 120       delete[] body;
 121 #ifdef DEBUG
 122       arraySize -= size*sizeof(T);
 123       if(arraySize < 0)
 124         {
 125           cerr<<"ARRAY DEALLOCATION ERROR\n";
 126           abort();
 127         }
 128 #endif
 129       size = -1;
 130     }
 131   size = a.size;
 132   body = new T[size];
 133 #ifdef DEBUG
 134   arraySize += size*sizeof(T);
 135 #endif
 136   for(k=0; k<size; k++) body[k] = a.body[k];
 137 }
 138
 139 template<class T>
 140 inline void Array<T>::resize(int t)
 141 {
 142   if(size >= 0)
 143     {
 144       delete[] body;
 145 #ifdef DEBUG
 146       arraySize -= size*sizeof(T);
 147       if(arraySize < 0)
 148         {
 149           cerr<<"ARRAY DEALLOCATION ERROR\n";
 150           abort();
 151         }
 152 #endif
 153     }
 154   size = t;
 155   body = new T[t];
 156 #ifdef DEBUG
 157   arraySize += t*sizeof(T);
 158 #endif
 159 };
 160
 161 template<class T>
 162 inline void Array<T>::set(int p, T t)
 163 {
 164 #ifdef DEBUG
 165   if((p<0) || (p>=size))
 166     {
 167       cerr<<"ARRAY ERROR in set() size = "<<size<<" indice = "<<p<<"\n";
 168       abort();
 169     }
 170 #endif
 171   body[p] = t;
 172 };
 173
 174 template<class T>
 175 inline T Array<T>::get(int p)
 176 {
 177 #ifdef DEBUG
 178   if((p<0) || (p>=size))
 179     {
 180       cerr<<"ARRAY ERROR in get() size = "<<size<<" indice = "<<p<<"\n";
 181       abort();
 182     }
 183 #endif
 184   return body[p];
 185 };
 186
 187 template<class T>
 188 inline T* Array<T>::getref(int p)
 189 {
 190 #ifdef DEBUG
 191   if((p<0) || (p>=size))
 192     {
 193       cerr<<"ARRAY ERROR in getref() size = "<<size<<" indice = "<<p<<"\n";
 194       abort();
 195     }
 196 #endif
 197   return &body[p];
 198 };
 199
 200 template<class T>
 201 inline void Array<T>::absorb(Array<T> a)
 202 {
 203   if(size >= 0)
 204     {
 205       delete[] body;
 206 #ifdef DEBUG
 207       arraySize -= size*sizeof(T);
 208       if(arraySize < 0)
 209         {
 210           cerr<<"ARRAY DEALLOCATION ERROR\n";
 211           abort();
 212         }
 213 #endif
 214     }
 215   size = a.size;
 216   body = a.body;
 217   a.size = -1;
 218   a.body = NULL;
 219 };
 220
 221 //-----------------------------------------------------------------------------
 222
 223 #endif
 224
 225 //-----------------------------------------------------------------------------