Branch data     Line data    Source code

       1                 :            : //-------------------------------------------------------------------------
       2                 :            : // Purpose       : Simple array template
       3                 :            : //
       4                 :            : // Special Notes : 
       5                 :            : //
       6                 :            : // Creator       : Jason Kraftcheck
       7                 :            : //
       8                 :            : // Creation Date : 01/11/02
       9                 :            : //-------------------------------------------------------------------------
      10                 :            : 
      11                 :            : #ifndef VG_ARRAY_HPP
      12                 :            : #define VG_ARRAY_HPP
      13                 :            : 
      14                 :            : #include <assert.h>
      15                 :            : 
      16                 :            : template <class T> class VGArray
      17                 :            : {
      18                 :            :   public:
      19                 :            :   
      20                 :            :     VGArray( int initial_size = 0 );
      21                 :            :     
      22                 :            :     ~VGArray();
      23                 :            :     
      24                 :            :     inline int size() const;
      25                 :            :     // get current array size
      26                 :            :     
      27                 :            :     void size( int new_size );
      28                 :            :     // increase or decrease size of array
      29                 :            :     
      30                 :            :     void size_end( int new_size );
      31                 :            :     // increase or decrease size, populating the 
      32                 :            :     // new array begining with the last element at the
      33                 :            :     // previous size in the last slot of the new size,
      34                 :            :     // and filling the array in decreasing index order.
      35                 :            :     
      36                 :            :     inline void push( const T& entry );
      37                 :            :     // increase array size by 1 and add entry at last index
      38                 :            :     
      39                 :            :     inline const T& pop();
      40                 :            :     // decrease array size by 1 and return removed entry
      41                 :            :     
      42                 :            :     inline T& operator[]( int index );
      43                 :            :     
      44                 :            :     inline const T& operator[]( int index ) const;
      45                 :            :     
      46                 :            :     void remove( int index );
      47                 :            :     // remove entry at index and shift all higher indices down
      48                 :            :     
      49                 :            :     void insert( const T& entry, int index );
      50                 :            :     // insert entry at specified index, shifting all higher indices up
      51                 :            :     
      52                 :            :     int find( const T& entry, int search_from = 0 ) const;
      53                 :            :     // find the index of an occurance of the passed entry
      54                 :            :     // in the array.  search starts from search_from and
      55                 :            :     // ends at the last index.  -1 is returned if no match
      56                 :            :     // is found.
      57                 :            :     
      58                 :            :     void reverse();
      59                 :            :     // Reverse order of list.
      60                 :            :     
      61                 :            :   private:
      62                 :            :   
      63                 :            :     const VGArray& operator=( const VGArray<T>& );
      64                 :            :     VGArray( const VGArray<T>& );
      65                 :            :       //- do not allow assignment
      66                 :            :   
      67                 :            :     static int storage( int size );
      68                 :            :       //- calculate storage to allocate for specified size
      69                 :            :       //- (smallest power-2 greater than size)
      70                 :            :   
      71                 :            :     T* data_;
      72                 :            :     int storage_;
      73                 :            :     int size_;
      74                 :            : };
      75                 :            : 
      76                 :            : #include "VGArray.cpp"
      77                 :            : 
      78                 :            : template <class T> inline
      79                 :          0 : int VGArray<T>::size() const
      80                 :          0 :   { return size_; }
      81                 :            : 
      82                 :            : template <class T> inline
      83                 :          0 : T& VGArray<T>::operator[]( int index )
      84                 :            : {
      85 [ #  # ][ #  # ]:          0 :   assert( index >= 0 && index < size_ );
         [ #  # ][ #  # ]
      86                 :          0 :   return data_[index];
      87                 :            : }
      88                 :            : 
      89                 :            : template <class T> inline
      90                 :          0 : const T& VGArray<T>::operator[]( int index ) const
      91                 :            : {
      92 [ #  # ][ #  # ]:          0 :   assert( index >= 0 && index < size_ );
         [ #  # ][ #  # ]
         [ #  # ][ #  # ]
      93                 :          0 :   return data_[index];
      94                 :            : }
      95                 :            :   
      96                 :            : template <class T> inline
      97                 :          0 : void VGArray<T>::push( const T& entry )
      98                 :            : {
      99                 :          0 :   int s = size_;
     100                 :          0 :   size( s + 1 );
     101                 :          0 :   data_[s] = entry;
     102                 :          0 : }
     103                 :            : 
     104                 :            : #endif