RmArray.h

//=============================================================================
// filename: RmArray.h                                                         
//                                                                             
//           ATI Research, Inc.                                                
//           3D Application Research Group                                     
//                                                                             
// Description: RenderMonkey's Templated Array Class                           
//                                                                             
//=============================================================================
//   (C) 2004 ATI Research, Inc.  All rights reserved.                         
//=============================================================================

#ifndef _RM_CORE_ARRAY_H_
#define _RM_CORE_ARRAY_H_

#include <Core/RmTypes.h>

//-----------------------------------------------------------------------------
//
//-----------------------------------------------------------------------------
template <class Type>
class RmArray
{
public : 
   //--------------------------------------------------------------------------
   //--------------------------------------------------------------------------
   class const_iterator
   {
      friend RmArray<Type>;

   public :
      //-----------------------------------------------------------------------
      //-----------------------------------------------------------------------
      const_iterator() : 
          m_index(0) 
      {
      }; // End of Constructor

      //-----------------------------------------------------------------------
      //-----------------------------------------------------------------------
      const_iterator( RmArray *pArray, int nIndex ) : 
          m_pArray(pArray),
          m_index(nIndex)
      {
      }; // End of Constructor

      //-----------------------------------------------------------------------
      //-----------------------------------------------------------------------
      ~const_iterator() {};

      //-----------------------------------------------------------------------
      // Operators
      //-----------------------------------------------------------------------

      //-----------------------------------------------------------------------
      //-----------------------------------------------------------------------
      const_iterator& operator++ ()
      {
         m_index++;
         return *this;
      }; // End of operator ++

      //-----------------------------------------------------------------------
      //-----------------------------------------------------------------------
      const_iterator operator++ ( int )
      {
         const_iterator itr(m_pArray,m_index);
         m_index++;

         return itr;
      }; // End of operator ++

      //-----------------------------------------------------------------------
      //-----------------------------------------------------------------------
      const_iterator& operator-- ()
      {
         m_index--;
         return *this;
      }; // End of operator ++

      //-----------------------------------------------------------------------
      //-----------------------------------------------------------------------
      const_iterator operator-- ( int )
      {
         const_iterator itr(m_pArray,m_index);
         m_index--;

         return itr;
      }; // End of operator ++

      //-----------------------------------------------------------------------
      //-----------------------------------------------------------------------
      const Type& operator * () const
      {
         assert(m_pArray!=NULL);
         return (*m_pArray)[m_index];
      }; // End of operator *

      //-----------------------------------------------------------------------
      //-----------------------------------------------------------------------
      bool operator== ( const const_iterator &src )
      {
         if (m_index == src.m_index)
            return true;

         return false;
      }; // End of operator ==

      //-----------------------------------------------------------------------
      //-----------------------------------------------------------------------
      bool operator!= ( const const_iterator &src )
      {
         if (m_index != src.m_index)
            return true;

         return false;
      }; // End of operator ==

      //-----------------------------------------------------------------------
      //-----------------------------------------------------------------------
      bool operator > ( const const_iterator &src )
      {
         return (m_index>src.m_index);
      }; // End of operator >

      //-----------------------------------------------------------------------
      //-----------------------------------------------------------------------
      bool operator < ( const const_iterator &src )
      {
         return (m_index<src.m_index);
      }; // End of operator <

      //-----------------------------------------------------------------------
      //-----------------------------------------------------------------------
      bool operator >= ( const const_iterator &src )
      {
         return (m_index>src.m_index);
      }; // End of operator >=

      //-----------------------------------------------------------------------
      //-----------------------------------------------------------------------
      bool operator <= ( const const_iterator &src )
      {
         return (m_index<=src.m_index);
      }; // End of operator <=

   protected :
      RmArray            *m_pArray; 
      int                 m_index;  
   }; // End of const_iterator

   //--------------------------------------------------------------------------
   //--------------------------------------------------------------------------
   class iterator : public const_iterator
   {
      friend RmArray<Type>;

   public :
      //-----------------------------------------------------------------------
      //-----------------------------------------------------------------------
      iterator() : const_iterator()
      {
      }; // End of Constructor

      //-----------------------------------------------------------------------
      //-----------------------------------------------------------------------
      iterator( RmArray *pArray, int nIndex ) : const_iterator(pArray,nIndex)
      {
      }; // End of Constructor

      //-----------------------------------------------------------------------
      //-----------------------------------------------------------------------
      ~iterator() {};

      //-----------------------------------------------------------------------
      // Operator
      //-----------------------------------------------------------------------

      //-----------------------------------------------------------------------
      //-----------------------------------------------------------------------
      iterator& operator++ ()
      {
         m_index++;
         return *this;
      }; // End of operator ++

      //-----------------------------------------------------------------------
      //-----------------------------------------------------------------------
      iterator operator++ ( int )
      {
         iterator itr(m_pArray,m_index);
         m_index++;

         return itr;
      }; // End of operator ++

      //-----------------------------------------------------------------------
      //-----------------------------------------------------------------------
      iterator& operator-- ()
      {
         m_index--;
         return *this;
      }; // End of operator ++

      //-----------------------------------------------------------------------
      //-----------------------------------------------------------------------
      iterator operator-- ( int )
      {
         iterator itr(m_pArray,m_index);
         m_index--;

         return itr;
      }; // End of operator ++

      //-----------------------------------------------------------------------
      //-----------------------------------------------------------------------
      Type& operator * ()
      {
         assert(m_pArray!=NULL);
         return (*m_pArray)[m_index];
      }; // End of operator *

      //-----------------------------------------------------------------------
      //-----------------------------------------------------------------------
      bool operator== ( const iterator &src )
      {
         if (m_index == src.m_index)
            return true;

         return false;
      }; // End of operator ==

      //-----------------------------------------------------------------------
      //-----------------------------------------------------------------------
      bool operator!= ( const iterator &src )
      {
         if (m_index != src.m_index)
            return true;

         return false;
      }; // End of operator ==

      //-----------------------------------------------------------------------
      //-----------------------------------------------------------------------
      bool operator > ( const iterator &src )
      {
         return (m_index>src.m_index);
      }; // End of operator >

      //-----------------------------------------------------------------------
      //-----------------------------------------------------------------------
      bool operator < ( const iterator &src )
      {
         return (m_index<src.m_index);
      }; // End of operator <

      //-----------------------------------------------------------------------
      //-----------------------------------------------------------------------
      bool operator >= ( const iterator &src )
      {
         return (m_index>src.m_index);
      }; // End of operator >=

      //-----------------------------------------------------------------------
      //-----------------------------------------------------------------------
      bool operator <= ( const iterator &src )
      {
         return (m_index<=src.m_index);
      }; // End of operator <=

   }; // End of iterator

public :
   //--------------------------------------------------------------------------
   //--------------------------------------------------------------------------
   RmArray() : 
      m_nNumItems(0),
      m_nNumReserved(0),
      m_pTable(NULL),
      m_incrementSize(1)
   {
   }; // End of Constructor

   //--------------------------------------------------------------------------
   //--------------------------------------------------------------------------
   RmArray( const RmArray<Type> &src ) : 
      m_nNumItems(0),
      m_nNumReserved(0),
      m_pTable(NULL)
   {
      if (src.capacity()>0)
      {
         AllocTable(src.capacity(),false);
         memcpy( m_pTable, src.m_pTable, sizeof(Type)*m_nNumReserved );

         m_nNumItems = src.size();
      } // End if
   }; // End of Constructor

   //--------------------------------------------------------------------------
   //--------------------------------------------------------------------------
   ~RmArray()
   {
      clear();
   }; // End of Destructor

   //--------------------------------------------------------------------------
   // Information Accessor
   //--------------------------------------------------------------------------
   
   //--------------------------------------------------------------------------
   //--------------------------------------------------------------------------
   int  size() const { return m_nNumItems; };

   //--------------------------------------------------------------------------
   //--------------------------------------------------------------------------
   bool empty() const { return (m_nNumItems==0); };

   //--------------------------------------------------------------------------
   //--------------------------------------------------------------------------
   int  capacity() const { return m_nNumReserved; };

   //--------------------------------------------------------------------------
   //--------------------------------------------------------------------------
   bool reserve( int reserveSize )
   {
      if (AllocTable(reserveSize,true)==false)
         return false;

      if (m_nNumReserved<m_nNumItems)
         m_nNumItems = m_nNumReserved;

      return true;
   }; // End of reserve

   //--------------------------------------------------------------------------
   //--------------------------------------------------------------------------
   bool resize( int newSize )
   {
      if (newSize>=m_nNumReserved)
      {
         if (AllocTable(newSize,true)==false)
            return false;
      } // End if

      m_nNumItems = newSize;
      return true;
   }; // End of resize

   //--------------------------------------------------------------------------
   //--------------------------------------------------------------------------
   bool clear()
   {
      DeallocTable();
      return true;
   }; // End of reserve

   //--------------------------------------------------------------------------
   //--------------------------------------------------------------------------
   bool push_back( Type data )
   {
      if (m_nNumItems>=m_nNumReserved)
      {
         if (AllocTable(m_nNumReserved+m_incrementSize,true)==false)
            return false;
      } // End if

      m_pTable[m_nNumItems] = data;
      m_nNumItems++;
      return true;
   }; // End of push_back

   //--------------------------------------------------------------------------
   //--------------------------------------------------------------------------
   bool push_front( Type data )
   {
      if (m_nNumItems>=m_nNumReserved)
      {
         if (AllocTable(m_nNumReserved+1,true)==false)
            return false;
      } // End if

      shiftData(0,1);
      m_pTable[0] = data;
      m_nNumItems++;

      return true;
   }; // End of push_front

   //--------------------------------------------------------------------------
   //--------------------------------------------------------------------------
   bool remove( Type data )
   {
      // may need to optimize this later
      int i = m_nNumItems-1;
      while (i>=0)
      {
         // Iterate from back and if we find a match, shift data
         // to remove data
         if (m_pTable[i]==data)
         {
            shiftData(i+1,-1);            
            m_nNumItems--;
            i-= 2;
         } // End if
         else
         {
            i--;
         } // End else
      } // End while

      return true;
   }; // End of remove

   //--------------------------------------------------------------------------
   //--------------------------------------------------------------------------
   iterator erase( iterator &itr )
   {
      assert(itr.m_index<m_nNumItems);
      shiftData(itr.m_index+1,-1);

      iterator nextItr(this,itr.m_index);
      m_nNumItems--;

      return nextItr;
   }; // End of erase

   //--------------------------------------------------------------------------
   // Iterator Functions
   //--------------------------------------------------------------------------

   //--------------------------------------------------------------------------
   //--------------------------------------------------------------------------
   iterator begin()
   {
      iterator itr(this,0);
      return itr;
   }; // End of begin

   //--------------------------------------------------------------------------
   //--------------------------------------------------------------------------
   const_iterator begin() const
   {
      const_iterator itr(this,0);
      return itr;
   }; // End of begin

   //--------------------------------------------------------------------------
   //--------------------------------------------------------------------------
   iterator end()
   {
      iterator itr(this,m_nNumItems);
      return itr;
   }; // End of end

   //--------------------------------------------------------------------------
   //--------------------------------------------------------------------------
   const_iterator end() const
   {
      const_iterator itr(this,m_nNumItems);
      return itr;
   }; // End of end

   //--------------------------------------------------------------------------
   // As Row Table
   //--------------------------------------------------------------------------

   //--------------------------------------------------------------------------
   //--------------------------------------------------------------------------
   operator Type*       () { return m_pTable; };

   //--------------------------------------------------------------------------
   //--------------------------------------------------------------------------
   operator const Type* () const { return m_pTable; };

   //--------------------------------------------------------------------------
   // Indexer functions
   //--------------------------------------------------------------------------
   
   //--------------------------------------------------------------------------
   //--------------------------------------------------------------------------
   Type& operator[] ( int nIndex )
   {
      assert(nIndex<m_nNumItems);
      return m_pTable[nIndex];
   }; // End of operator[]

   //--------------------------------------------------------------------------
   //--------------------------------------------------------------------------
   const Type& operator[] ( int nIndex ) const
   {
      assert(nIndex<m_nNumItems);
      return m_pTable[nIndex];
   }; // End of operator[]

   //--------------------------------------------------------------------------
   //--------------------------------------------------------------------------
   void operator = ( const RmArray<Type> &src )
   {
      if (src.capacity()>0)
      {
         AllocTable(src.capacity(),false);
         memcpy( m_pTable, src.m_pTable, sizeof(Type)*m_nNumReserved );

         m_nNumItems = src.size();
      } // End if
   }; // End of operator =

   //--------------------------------------------------------------------------
   //--------------------------------------------------------------------------
   void SetIncrementSize( int size )
   {
      assert(size>0);

      m_incrementSize = size;
   }; // End of SetIncrementSize

   //--------------------------------------------------------------------------
   //--------------------------------------------------------------------------
   int GetIncrementSize() const { return m_incrementSize; };

private :
   int        m_nNumItems;     
   int        m_nNumReserved;  
   Type      *m_pTable;        

   //--------------------------------------------------------------------------
   // Allocation/Deallocation of array
   //--------------------------------------------------------------------------
   
   //--------------------------------------------------------------------------
   //--------------------------------------------------------------------------
   bool AllocTable( int newSize, bool bPreserve )
   {
      if (m_nNumReserved==newSize)
         return true;

      if (newSize==0)
      {
         DeallocTable();
         return true;
      } // End if

      int copySize = m_nNumItems;
      if (copySize>newSize)
         copySize = newSize;

      Type *pNewTable = (Type*)RmAllocateBuffer(newSize*sizeof(Type));
      if (pNewTable==NULL)
         return false;

      int i;
      for (i=0;i<newSize;i++)
      {
         pNewTable[i] = Type();
      } // End if

      if (bPreserve) // Do the copy, if we have to preserve data
      {
         for (i=0;i<copySize;i++)
         {
            pNewTable[i] = m_pTable[i];
         } // End for
      } // End if

      DeallocTable();
      m_pTable       = pNewTable;
      m_nNumItems    = copySize;
      m_nNumReserved = newSize; 

      return true;
   }; // End of AllocTable

   //--------------------------------------------------------------------------
   //--------------------------------------------------------------------------
   void DeallocTable()
   {
      if (m_pTable!=NULL)
      {
         RmDeallocateBuffer((RM_BYTE*)m_pTable);
         m_nNumItems = 0;
         m_nNumReserved = 0;
         m_pTable = NULL;
      } // End if
   }; // End of DeallocTable

   //--------------------------------------------------------------------------
   //--------------------------------------------------------------------------
   bool shiftData( int startIndex, int direction )
   {
      if (direction>0)
      {
         assert((m_nNumItems+direction)<=m_nNumReserved);
         int i;
         for (i=m_nNumItems-1;i>=startIndex;i--)
         {
            m_pTable[i+direction] = m_pTable[i];
         } // End for
      } // End if
      else
      {
         assert((m_nNumItems+direction)>=0);
         int i;
         for (i=startIndex;i<m_nNumItems;i++)
         {
            m_pTable[i+direction] = m_pTable[i];
         } // End for
      } // End else

      return true;
   } // End of shiftData

private :
   int m_incrementSize; 
}; // End of RmArray


#endif

---