00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022
00023
00024
00025
00026
00027
00028
00029
00030 #ifndef DIME_ARRAY_H
00031 #define DIME_ARRAY_H
00032
00033 #include <stdlib.h>
00034
00035 #include <dime/Basic.h>
00036
00037
00038
00039
00040
00041
00042
00043
00044
00045
00046
00047
00048
00049
00050
00051
00052
00053
00054
00055 #ifdef _MSC_VER // Microsoft Visual C++
00056 #pragma warning(disable:4251)
00057 #pragma warning(disable:4275)
00058 #endif // _MSC_VER
00059
00060
00061 template <class T>
00062 class dimeArray
00063 {
00064 public:
00065 dimeArray(const int initsize = 4);
00066 ~dimeArray();
00067
00068 void append(const T &value);
00069 void append(const dimeArray<T> &array);
00070 void prepend(const dimeArray<T> &array);
00071 void insertElem(const int idx, const T &value);
00072 void setElem(const int index, const T &value);
00073 T getElem(const int index) const;
00074 void getElem(const int index, T &elem) const;
00075 T getLastElem() const;
00076 void getLastElem(T &elem) const;
00077 T &operator [](const int index);
00078 T operator [](const int index) const;
00079 void removeElem(const int index);
00080 void removeElemFast(const int index);
00081 void reverse();
00082 void setCount(const int count);
00083 void makeEmpty(const int initsize = 4);
00084 void freeMemory();
00085 int count() const;
00086 int allocSize() const;
00087 T *arrayPointer();
00088 const T *constArrayPointer() const;
00089 void shrinkToFit();
00090
00091 private:
00092 void growArray();
00093 T *array;
00094 int num;
00095 int size;
00096
00097 };
00098
00099 template <class T> inline
00100 dimeArray<T>::dimeArray(const int size)
00101 {
00102 this->array = new T[size];
00103 this->size = size;
00104 this->num = 0;
00105 }
00106
00107 template <class T> inline
00108 dimeArray<T>::~dimeArray()
00109 {
00110 delete [] this->array;
00111 }
00112
00113 template <class T> inline void
00114 dimeArray<T>::growArray()
00115 {
00116 int oldsize = this->size;
00117 T *oldarray = this->array;
00118 this->size <<= 1;
00119 this->array = new T[this->size];
00120 for (int i = 0; i < oldsize; i++) this->array[i] = oldarray[i];
00121 delete [] oldarray;
00122 }
00123
00124 template <class T> inline void
00125 dimeArray<T>::append(const T &elem)
00126 {
00127 if (this->num >= this->size) growArray();
00128 this->array[this->num++] = elem;
00129 }
00130
00131
00132 template <class T> inline void
00133 dimeArray<T>::append(const dimeArray<T> &array)
00134 {
00135 while (this->size <= this->num+array.count()) growArray();
00136 for (int i=0;i<array.count();i++)
00137 this->array[this->num++] = array[i];
00138 }
00139
00140 template <class T> inline void
00141 dimeArray<T>::prepend(const dimeArray<T> &array)
00142 {
00143 int newsize=this->num+array.count();
00144 int i;
00145 if (this->size<=newsize) {
00146 T *oldarray=this->array;
00147 this->array=new T[newsize];
00148 this->size=newsize;
00149 for (i=0;i<array.count(); i++) this->array[i] = array[i];
00150 for (i=0;i<this->num;i++) this->array[i+array.count()] = oldarray[i];
00151 delete[] oldarray;
00152 }
00153 else {
00154 for (i=0;i<this->num;i++) this->array[array.count()+i]=this->array[i];
00155 for (i=0;i<array.count();i++) this->array[i] = array[i];
00156 }
00157 this->num+=array.count();
00158 }
00159
00160 template <class T> inline void
00161 dimeArray<T>::insertElem(const int idx, const T &elem)
00162 {
00163 int n = this->num;
00164 this->append(elem);
00165 if (idx < n) {
00166 for (int i = n; i > idx; i--) {
00167 this->array[i] = this->array[i-1];
00168 }
00169 this->array[idx] = elem;
00170 }
00171 }
00172
00173 template <class T> inline void
00174 dimeArray<T>::setElem(const int index, const T &elem)
00175 {
00176 while (index >= this->size) growArray();
00177 if (this->num <= index) this->num = index+1;
00178 this->array[index] = elem;
00179 }
00180
00181 template <class T> inline T
00182 dimeArray<T>::getElem(const int index) const
00183 {
00184 return this->array[index];
00185 }
00186
00187 template <class T> inline void
00188 dimeArray<T>::getElem(const int index, T &elem) const
00189 {
00190 elem = this->array[index];
00191 }
00192
00193 template <class T> inline T
00194 dimeArray<T>::getLastElem() const
00195 {
00196 return this->array[this->num-1];
00197 }
00198
00199 template <class T> inline void
00200 dimeArray<T>::getLastElem(T &elem) const
00201 {
00202 elem = this->array[this->num-1];
00203 }
00204
00205 template <class T> inline T &
00206 dimeArray<T>::operator [](const int index)
00207 {
00208 while (index >= this->size) growArray();
00209 if (this->num <= index) this->num = index + 1;
00210 return this->array[index];
00211 }
00212
00213 template <class T> inline T
00214 dimeArray<T>::operator [](const int index) const
00215 {
00216 return this->array[index];
00217 }
00218
00219 template <class T> inline void
00220 dimeArray<T>::removeElem(const int index)
00221 {
00222 if (this->num <= 0 || index >= this->num) return;
00223 for (int i = index; i < this->num-1; i++)
00224 this->array[i] = this->array[i+1];
00225 this->num--;
00226 }
00227
00228 template <class T> inline void
00229 dimeArray<T>::removeElemFast(const int index)
00230 {
00231 this->array[index] = this->array[--this->num];
00232 }
00233
00234 template <class T> inline void
00235 dimeArray<T>::reverse()
00236 {
00237 T tmp;
00238 for (int i=0;i<this->num/2;i++) {
00239 tmp=this->array[i];
00240 this->array[i]=this->array[this->num-1-i];
00241 this->array[this->num-1-i]=tmp;
00242 }
00243 }
00244
00245 template <class T> inline void
00246 dimeArray<T>::setCount(const int count)
00247 {
00248 if (count < this->num)
00249 this->num = count;
00250 }
00251
00252 template <class T> inline int
00253 dimeArray<T>::count() const
00254 {
00255 return this->num;
00256 }
00257
00258 template <class T> inline int
00259 dimeArray<T>::allocSize() const
00260 {
00261 return this->size;
00262 }
00263
00264 template <class T> inline T *
00265 dimeArray<T>::arrayPointer()
00266 {
00267 return this->array;
00268 }
00269
00270 template <class T> inline const T *
00271 dimeArray<T>::constArrayPointer() const
00272 {
00273 return this->array;
00274 }
00275
00276 template <class T> inline void
00277 dimeArray<T>::makeEmpty(const int initsize)
00278 {
00279 delete [] this->array;
00280 this->array = new T[initsize];
00281 this->size = initsize;
00282 this->num = 0;
00283 }
00284
00285 template <class T> inline void
00286 dimeArray<T>::freeMemory()
00287 {
00288 delete [] this->array;
00289 this->array = NULL;
00290 this->size = 0;
00291 this->num = 0;
00292 }
00293
00294 template <class T> inline void
00295 dimeArray<T>::shrinkToFit()
00296 {
00297 T *oldarray = this->array;
00298 this->array = new T[this->num];
00299 for (int i = 0; i < this->num; i++) this->array[i] = oldarray[i];
00300 this->size = this->num;
00301 delete [] oldarray;
00302 }
00303
00304 #endif // ! DIME_ARRAY_H
00305