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