Main Page   Class Hierarchy   Alphabetical List   Compound List   File List   Compound Members

FXArray.h

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