![]() |
Main Page Class Hierarchy Alphabetical List Compound List File List Compound Members
![]() |
00001 /******************************************************************************** 00002 * * 00003 * G e n e r i c A r r a y * 00004 * * 00005 ********************************************************************************* 00006 * Copyright (C) 1997,2002 by Jeroen van der Zijp. All Rights Reserved. * 00007 ********************************************************************************* 00008 * This library is free software; you can redistribute it and/or * 00009 * modify it under the terms of the GNU Lesser General Public * 00010 * License as published by the Free Software Foundation; either * 00011 * version 2.1 of the License, or (at your option) any later version. * 00012 * * 00013 * This library is distributed in the hope that it will be useful, * 00014 * but WITHOUT ANY WARRANTY; without even the implied warranty of * 00015 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU * 00016 * Lesser General Public License for more details. * 00017 * * 00018 * You should have received a copy of the GNU Lesser General Public * 00019 * License along with this library; if not, write to the Free Software * 00020 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA. * 00021 ********************************************************************************* 00022 * $Id: FXArray.h,v 1.11 2002/01/18 22:46:41 jeroen Exp $ * 00023 ********************************************************************************/ 00024 #ifndef FXARRAY_H 00025 #define FXARRAY_H 00026 00027 00028 00029 /************************* D e f i n i t i o n *******************************/ 00030 00031 00032 template<class TYPE> 00033 class FXArray { 00034 TYPE *list; // List of items 00035 FXint number; // Used slots 00036 FXint total; // Total slots 00037 FXint grow; // Grow amount 00038 public: 00039 FXArray(); 00040 FXArray(const FXArray<TYPE>& orig); 00041 FXArray<TYPE>& operator=(const FXArray<TYPE> &orig); 00042 inline FXint no() const; 00043 inline TYPE* data() const; 00044 inline FXint size() const; 00045 void size(FXint n); 00046 FXint inc() const; 00047 void inc(FXint n); 00048 inline const TYPE& operator [](FXint i) const; 00049 inline TYPE& operator [](FXint i); 00050 void insert(FXint pos,const TYPE& p); 00051 void append(const TYPE& p); 00052 void prepend(const TYPE& p); 00053 void remove(FXint pos); 00054 void extract(const TYPE& p); 00055 FXint find(const TYPE& p); 00056 void trunc(); 00057 void clear(); 00058 void save(FXStream& store) const; 00059 void load(FXStream& store); 00060 ~FXArray(); 00061 }; 00062 00063 00064 /********************** I m p l e m e n t a t i o n ************************/ 00065 00066 00067 // Construct as empty 00068 template<class TYPE> 00069 FXArray<TYPE>::FXArray(){ 00070 list=NULL; 00071 number=0; 00072 total=0; 00073 grow=0; 00074 } 00075 00076 00077 // Copy construct 00078 template<class TYPE> 00079 FXArray<TYPE>::FXArray(const FXArray<TYPE>& orig){ 00080 number=orig.number; 00081 total=orig.total; 00082 grow=orig.grow; 00083 allocElms(list,total); 00084 constructElms(list,number); 00085 copyElms(list,orig.list,number); 00086 } 00087 00088 00089 // Return number of elements 00090 template<class TYPE> 00091 FXint FXArray<TYPE>::no() const { 00092 return number; 00093 } 00094 00095 00096 // Return pointer to the list 00097 template<class TYPE> 00098 TYPE* FXArray<TYPE>::data() const { 00099 return list; 00100 } 00101 00102 00103 // Return size of list 00104 template<class TYPE> 00105 FXint FXArray<TYPE>::size() const { 00106 return total; 00107 } 00108 00109 00110 // Return grow delta 00111 template<class TYPE> 00112 FXint FXArray<TYPE>::inc() const { 00113 return grow; 00114 } 00115 00116 00117 // Set grow delta 00118 template<class TYPE> 00119 void FXArray<TYPE>::inc(FXint g){ 00120 FXASSERT(g>=0); 00121 grow=g; 00122 } 00123 00124 00125 // Return element rvalue 00126 template<class TYPE> 00127 const TYPE& FXArray<TYPE>::operator[](FXint i) const { 00128 FXASSERT(0<=i&&i<number); 00129 return list[i]; 00130 } 00131 00132 00133 // Return element lvalue 00134 template<class TYPE> 00135 TYPE& FXArray<TYPE>::operator[](FXint i){ 00136 FXASSERT(0<=i&&i<number); 00137 return list[i]; 00138 } 00139 00140 00141 // Assign an array 00142 template<class TYPE> 00143 FXArray<TYPE>& FXArray<TYPE>::operator=(const FXArray<TYPE>& orig){ 00144 if(this!=&orig){ 00145 destructElms(list,number); 00146 freeElms(list); 00147 number=orig.number; 00148 total=orig.total; 00149 grow=orig.grow; 00150 allocElms(list,total); 00151 constructElms(list,number); 00152 copyElms(list,orig.list,number); 00153 } 00154 return *this; 00155 } 00156 00157 00158 // Set new size 00159 template<class TYPE> 00160 void FXArray<TYPE>::size(FXint n){ 00161 FXASSERT(n>=0); 00162 if(n!=number){ 00163 if(n<number){ 00164 destructElms(&list[n],number-n); // Destruct old elements 00165 if(n==0){ 00166 freeElms(list); 00167 total=0; 00168 } 00169 } 00170 else{ 00171 if(n>total){ 00172 TYPE *ptr; 00173 FXint s=total+grow; 00174 if(grow==0) s=total+total; 00175 if(s<n) s=n; 00176 allocElms(ptr,s); 00177 constructElms(ptr,n); // Construct blank elements 00178 copyElms(ptr,list,number); // Uses assignment operator 00179 destructElms(list,number); // Destruct old ones 00180 freeElms(list); 00181 list=ptr; 00182 total=s; 00183 } 00184 FXASSERT(n<=total); 00185 constructElms(&list[number],n-number); // Construct new elements 00186 } 00187 number=n; 00188 } 00189 } 00190 00191 00192 // Insert element anywhere 00193 template<class TYPE> 00194 void FXArray<TYPE>::insert(FXint pos,const TYPE& p){ 00195 FXint s=number-pos; 00196 size(number+1); 00197 moveElms(&list[pos+1],&list[pos],s); 00198 list[pos]=p; 00199 } 00200 00201 00202 // Append element at end 00203 template<class TYPE> 00204 void FXArray<TYPE>::append(const TYPE& p){ 00205 FXint s=number; 00206 size(number+1); 00207 list[s]=p; 00208 } 00209 00210 00211 // Prepend element at begin 00212 template<class TYPE> 00213 void FXArray<TYPE>::prepend(const TYPE& p){ 00214 FXint s=number; 00215 size(number+1); 00216 moveElms(&list[1],&list[0],s); 00217 list[0]=p; 00218 } 00219 00220 00221 // Remove element at pos 00222 template<class TYPE> 00223 void FXArray<TYPE>::remove(FXint pos){ 00224 FXint s=number; 00225 moveElms(&list[pos],&list[pos+1],s-pos-1); // Uses assignment operator 00226 size(s-1); 00227 } 00228 00229 00230 // Find element, -1 if not found 00231 template<class TYPE> 00232 FXint FXArray<TYPE>::find(const TYPE& p){ 00233 FXint s=number; 00234 while(s!=0 && !(list[s-1]==p)) s--; 00235 return s-1; 00236 } 00237 00238 00239 // Extract element 00240 template<class TYPE> 00241 void FXArray<TYPE>::extract(const TYPE& p){ 00242 FXint s=number; 00243 while(s-- != 0){ 00244 if(list[s]==p){ 00245 moveElms(&list[s],&list[s+1],number-s); // Uses assignment operator 00246 size(number-1); 00247 break; 00248 } 00249 } 00250 } 00251 00252 00253 // Trunc excess 00254 template<class TYPE> 00255 void FXArray<TYPE>::trunc(){ 00256 size(number); 00257 } 00258 00259 00260 // Clear the list 00261 template<class TYPE> 00262 void FXArray<TYPE>::clear(){ 00263 size(0); 00264 } 00265 00266 00267 // Save operator 00268 template<class TYPE> 00269 void FXArray<TYPE>::save(FXStream& store) const { 00270 store << number << total << grow; 00271 saveElms(store,list,number); // Uses save operator 00272 } 00273 00274 00275 // Load operator 00276 template<class TYPE> 00277 void FXArray<TYPE>::load(FXStream& store){ 00278 destructElms(list,number); // Destruct elements 00279 freeElms(list); 00280 store >> number >> total >> grow; 00281 allocElms(list,total); 00282 constructElms(list,number); // Fresh elements 00283 loadElms(store,list,number); // Uses load operator 00284 } 00285 00286 00287 // Destruct list 00288 template<class TYPE> 00289 FXArray<TYPE>::~FXArray(){ 00290 destructElms(list,number); 00291 freeElms(list); 00292 } 00293 00294 00295 #endif