Main Page | Namespace List | Class Hierarchy | Alphabetical List | Class List | File List | Class Members | File Members

ResizeArrayRaw< Elem > Class Template Reference

#include <ResizeArrayRaw.h>

List of all members.

Public Member Functions

int size (void) const
Elem & operator[] (int index) const
 ResizeArrayRaw (void)
 ResizeArrayRaw (const ResizeArrayRaw< Elem > &rar)
 ResizeArrayRaw (Elem **const array, int arraySize, int allocSize)
 ~ResizeArrayRaw (void)
void setResizeParams (int min, float growth)
ResizeArrayRaw< Elem > & operator= (const ResizeArrayRaw< Elem > &rar)
void resize (int size)
int del (int index, int number)
void ins (const Elem &e, int index)
int find (const Elem &e)

Friends

class ResizeArray<Elem>
class SortableResizeArray<Elem>
class ResizeArrayIter<Elem>

template<class Elem>
class ResizeArrayRaw< Elem >

Constructor & Destructor Documentation

template<class Elem>
ResizeArrayRaw< Elem >::ResizeArrayRaw (  void   )  [inline]
 

Definition at line 84 of file ResizeArrayRaw.h.

00084                          : 
00085       array((Elem *)0), varray((unsigned char *)0), arraySize(0), allocSize(0) { 
00086       growthFactor = GrowthFactor;
00087       minSize = MinSize;
00088     }

template<class Elem>
ResizeArrayRaw< Elem >::ResizeArrayRaw (  const ResizeArrayRaw< Elem > &  rar  )  [inline]
 

Definition at line 91 of file ResizeArrayRaw.h.

00091                                                      : 
00092       array((Elem *)0), varray((unsigned char *)0), arraySize(0), allocSize(0) {
00093       growthFactor = rar.growthFactor;
00094       minSize = rar.minSize;
00095       // We want rar.size() slots, but no constructor run on the elements
00096       resizeRaw(rar.size());
00097       CmiMemcpy((void*)array, (void*)rar.array, sizeof(Elem)*rar.size());
00098       arraySize = rar.size();
00099     }

template<class Elem>
ResizeArrayRaw< Elem >::ResizeArrayRaw (  Elem **const   array,
int  arraySize,
int  allocSize
)  [inline]
 

Definition at line 102 of file ResizeArrayRaw.h.

00102                                                                         {
00103       if (allocSize < arraySize) allocSize = arraySize;
00104       this->allocSize = allocSize;
00105       this->arraySize = arraySize;
00106       varray = (unsigned char *)*array;
00107       this->array = (Elem *)*array;
00108       *array = 0;
00109       growthFactor = GrowthFactor;
00110       minSize = MinSize;
00111     }

template<class Elem>
ResizeArrayRaw< Elem >::~ResizeArrayRaw (  void   )  [inline]
 

Definition at line 113 of file ResizeArrayRaw.h.

00113                           {
00114       for (int i=0; i < size(); i++) {
00115         array[i].~Elem();
00116       }
00117       delete[] varray;
00118     }

Member Function Documentation

template<class Elem>
int ResizeArrayRaw< Elem >::del (  int  index,
int  number
)  [inline]
 

Definition at line 161 of file ResizeArrayRaw.h.

Referenced by ResizeArray< AngleElem >::del().

00161                                           {
00162       int i;
00163   
00164       // Fix up number to delete if deletes off end of array
00165       if (index >= arraySize)
00166         number=0; // for inline sake, don't have multiple returns
00167       else if (index+number-1 > arraySize) {
00168         number = index-arraySize+1;
00169       }
00170   
00171       // Destruct objects to be deleted
00172       for (i=index; i < index+number; i++) {
00173         array[i].~Elem();
00174       }
00175   
00176       // Shift down
00177       memmove((void *)(array+index),
00178          (void *)(array+index+number),
00179          (arraySize-number-index)*sizeof(Elem));
00180       
00181       // fixup size of array
00182       arraySize -= number;
00183       return(number);
00184     }

template<class Elem>
int ResizeArrayRaw< Elem >::find (  const Elem &  e  )  [inline]
 

Definition at line 217 of file ResizeArrayRaw.h.

Referenced by ResizeArray< AngleElem >::find().

00217                                    {
00218       for (int i=0; i<arraySize; i++)
00219         if (array[i] == e) return i;
00220       return -1;
00221     }

template<class Elem>
void ResizeArrayRaw< Elem >::ins (  const Elem &  e,
int  index
)  [inline]
 

Definition at line 190 of file ResizeArrayRaw.h.

Referenced by ResizeArray< AngleElem >::add(), and ResizeArray< AngleElem >::insert().

00190                                               {
00191       // Size array depending if index is in current array or reaches beyond.
00192       if (index < arraySize) {
00193         resizeRaw(arraySize+1);
00194         // Shift up
00195         memmove((void *)(array+index+1),
00196           (void *)(array+index),
00197           (arraySize-index)*sizeof(Elem));
00198       } else {
00199         resizeRaw(index+1);
00200       }
00201       
00202       // Write in new element via assignment - allows any refcounting
00203       // etc. to take place correctly!
00204       new((void *)&array[index]) Elem;
00205       array[index] = e;
00206     
00207       // Take care of fill and setting correct arraySize 
00208       if (index > arraySize) {
00209         for (Elem *tmp = array+arraySize; tmp < array+index; tmp++) {
00210           new ((void *)tmp) Elem;
00211         }
00212         arraySize = index+1;
00213       } else
00214         arraySize++;
00215     }

template<class Elem>
ResizeArrayRaw<Elem>& ResizeArrayRaw< Elem >::operator= (  const ResizeArrayRaw< Elem > &  rar  )  [inline]
 

Definition at line 129 of file ResizeArrayRaw.h.

00129                                                                        {
00130       growthFactor = rar.growthFactor;
00131       minSize = rar.minSize;
00132   
00133       // Clean up this array
00134       resize(0);
00135       resizeRaw(rar.size());
00136   
00137       CmiMemcpy((void*)array, (void*)rar.array, sizeof(Elem)*rar.size());
00138       arraySize = rar.size();
00139       return *this;
00140     }

template<class Elem>
Elem& ResizeArrayRaw< Elem >::operator[] (  int  index  )  const [inline]
 

Definition at line 81 of file ResizeArrayRaw.h.

00081 { return array[index]; }

template<class Elem>
void ResizeArrayRaw< Elem >::resize (  int  size  )  [inline]
 

Definition at line 145 of file ResizeArrayRaw.h.

Referenced by ResizeArray< AngleElem >::resize(), and ResizeArray< AngleElem >::ResizeArray().

00145                           {
00146       int i;
00147   
00148       if (size < arraySize) {
00149         for (i=size; i<arraySize; i++) {
00150           array[i].~Elem();
00151         }
00152       } else if (size > arraySize) {
00153         resizeRaw(size);
00154         for (i=arraySize; i<size; i++) {
00155           new ((void *)&array[i]) Elem;
00156         }
00157       }
00158       arraySize = size;
00159     }

template<class Elem>
void ResizeArrayRaw< Elem >::setResizeParams (  int  min,
float  growth
)  [inline]
 

Definition at line 122 of file ResizeArrayRaw.h.

00122                                                 {
00123       minSize = min;
00124       growthFactor = growth;
00125     }

template<class Elem>
int ResizeArrayRaw< Elem >::size (  void   )  const [inline]
 

Definition at line 80 of file ResizeArrayRaw.h.

Referenced by ResizeArray< AngleElem >::add(), ResizeArrayRaw< AngleElem >::operator=(), ResizeArrayRaw< AngleElem >::ResizeArrayRaw(), and ResizeArray< AngleElem >::size().

00080 { return arraySize; }

Friends And Related Function Documentation

template<class Elem>
friend class ResizeArray<Elem> [friend]
 

Definition at line 76 of file ResizeArrayRaw.h.

template<class Elem>
friend class ResizeArrayIter<Elem> [friend]
 

Definition at line 78 of file ResizeArrayRaw.h.

template<class Elem>
friend class SortableResizeArray<Elem> [friend]
 

Definition at line 77 of file ResizeArrayRaw.h.

The documentation for this class was generated from the following file:
Generated on Sat Oct 11 04:07:48 2008 for NAMD by  doxygen 1.3.9.1