• Main Page
  • Namespaces
  • Classes
  • Files
  • File List
  • File Members

src/util/header/Array.inl

Go to the documentation of this file.
00001 
00002 #define CHECKTRUE(expr) {if((expr) == true) return false;}
00003 
00004 template<typename T>
00005 Array<T>::Array(){
00006         array = 0;
00007         init(0);
00008 }
00009 
00010 template<typename T>
00011 Array<T>::Array(uint size){
00012         array = 0;
00013         init(size);
00014 }
00015 
00016 template<typename T>
00017 Array<T>::Array(uint size, uint num, ...){
00018         ASSERT(num <= size);
00019         array = new T[len = size];
00020         T* in = (T*)(((char*)&num)+sizeof(uint));
00021         for(uint i=0; i<num; i++)
00022                 array[i] = in[i];
00023         last = num;
00024 }
00025 
00026 template<typename T>
00027 Array<T>::~Array(void){
00028         clear();
00029 }
00030 
00031 template<typename T>
00032 bool Array<T>::init(uint size){
00033         uninit();
00034         if(size > 0){
00035                 array = new T[len = size];
00036                 last = 0;
00037         }
00038         return true;
00039 }
00040 
00041 template<typename T>
00042 void Array<T>::uninit(void){
00043         clear();
00044         SAVEDELETEARRAY(array);
00045 }
00046 
00047 template<typename T>
00048 uint Array<T>::used(void){
00049         return last;
00050 }
00051 
00052 template<typename T>
00053 uint Array<T>::size(void){
00054         return last;
00055 }
00056 
00057 template<typename T>
00058 uint Array<T>::length(void){
00059         return len;
00060 }
00061 
00062 template<typename T>
00063 bool Array<T>::has(T data, uint* out){
00064         for(uint i=0; i<size(); i++)
00065                 if(array[i] == data){
00066                         if(out) *out=i;
00067                         return true;
00068                 }
00069         return false;
00070 }
00071 
00072 template<typename T>
00073 bool Array<T>::resize(uint size){
00074         // check if the list
00075         // should be resized
00076         if(size == len)
00077                 return true;
00078         if(size <= 0 || size < last)
00079                 return false;
00080 
00081         // create temporary
00082         T* oldArray = array;
00083         T* newArray = new T[size];
00084         // copy the old list into the new
00085         for(uint i=0; i<last && i<size; i++)
00086                 newArray[i] = array[i];
00087 
00088         // delete the old
00089         // list and use the
00090         // temporary list
00091         // Note: at first set array to new array
00092         // so array is always valid (for threading)
00093         if(size < len)
00094                 len = size;
00095         array = newArray;
00096         if(len < size)
00097                 len = size;
00098         SAVEDELETEARRAY(oldArray);
00099         return true;
00100 }
00101 
00102 template<typename T>
00103 T Array<T>::get(uint index){
00104         assert(index < len);
00105         return array[index];
00106 }
00107 
00108 template<typename T>
00109 T& Array<T>::getRef(uint index){
00110         assert(index < len);
00111         return array[index];
00112 }
00113 
00114 template<typename T>
00115 void Array<T>::set(uint index, T data){
00116         assert(index < last);
00117         array[index] = data;
00118 }
00119 
00120 template<typename T>
00121 bool Array<T>::add(T data){
00122         if(len < last) return false;
00123         array[last++] = data;
00124         return true;
00125 }
00126 
00127 template<typename T>
00128 bool Array<T>::insert(uint index, T data){
00129         if(len < last  || index < last) return false;
00130         for(uint i=last; index<i; i--)
00131                 array[i] = array[i-1];
00132         array[index] = data;
00133         last++;
00134         return true;
00135 }
00136 
00137 template<typename T>
00138 bool Array<T>::replace(T oldItem, T newItem){
00139         for(uint i = 0; i < last; i++)
00140                 if(array[i] == oldItem)
00141                         return array[i] = newItem, true;
00142         return false;
00143 }
00144 
00145 template<typename T>
00146 bool Array<T>::replaceIndex(uint index, T newItem){
00147         if(index < last)
00148                 return array[index] = newItem, true;
00149         return false;
00150 }
00151 
00152 template<typename T>
00153 void Array<T>::remove(T data){
00154         for(uint i = 0; i < last; i++)
00155                 if(array[i] == data){
00156                         removeIndex(i);
00157                         break;
00158                 }
00159 }
00160 
00161 template<typename T>
00162 void Array<T>::removeIndex(uint index){
00163         assert(index < last);
00164         for(--last; index<last; index++)
00165                 array[index] = array[index+1];
00166         memset(&array[last], 0, sizeof(T));
00167 }
00168 
00169 template<typename T>
00170 void Array<T>::clear(void){
00171         last = 0;
00172 }
00173 
00174 template<typename T>
00175 T Array<T>::operator [] (uint index){
00176         assert(index < len);
00177         return array[index];
00178 }
00179 
00180 template<typename T>
00181 const T Array<T>::operator [] (uint index) const{
00182         assert(index < len);
00183         return array[index];
00184 }
00185 
00186 #undef CHECKTRUE

Generated on Fri Jun 18 2010 17:48:40 for Cannonball by  doxygen 1.7.0