---

     

---

CHMvector.h

#ifndef __CHM_VECTOR__
#define __CHM_VECTOR__
//---------------------------------------------------------------------------
// Module: CHMvector
//
// Description:
//
// Simple templated reference vector class
//
// The objects stored in the template must support 
// Item& operator=(const Item&)
//
// By default the vector will grow in chunks of 10 - however the grow factor
// can be altered or made into a product - i.e. growing by a multiple of the
// grow factor rather than a fixed step.  Growing is expensive -
// time will be saved if the vector can be pre-sized.
//
// Last Edit Date: $Date: 2002-10-16 21:28:30 $
//
//---------------------------------------------------------------------------

#include <CHM/CHMerrorClass.h>

template<class Item>
class CHMvector
{
public:
   CHMvector(size_t GrowFactor = 10,
             size_t InitialSize=0,
             CHMboolean GrowByDouble=false);
   ~CHMvector();

   Item& operator[](size_t Index);
   const Item& operator[](size_t Index) const;

   void insert(const Item& Value, size_t Index);

   void remove(size_t Index);

   size_t size() const;

   void resize(size_t NewSize);

   void clear();

   void push_back(const Item& Value);
   Item& pop_back();
   Item& back();
   CHMvector<Item>& operator=(const CHMvector<Item>& Original);
private:
   size_t m_GrowBy;
   size_t m_Size;
   size_t m_Capacity;

   CHMboolean m_GrowByDouble;

   Item* m_pData;

   void grow(size_t RequiredSize);

   CHMvector(const CHMvector<Item>& Original) {}
};

template<class Item>
CHMvector<Item>::CHMvector
(
   size_t GrowBy,
   size_t InitialSize,
   CHMboolean GrowByDouble
) : m_GrowBy(GrowBy),
    m_Size(InitialSize),
    m_Capacity(InitialSize),
    m_GrowByDouble(GrowByDouble)
{
   CHM_ASSERT(GrowBy > 0);
   if (m_Capacity > 0)
   {
      m_pData = new Item[m_Capacity];
   }
   else
   {
      m_pData = NULL;
   }
}

template<class Item>
CHMvector<Item>::~CHMvector()
{
   delete []m_pData;
}

template<class Item>
void CHMvector<Item>::clear()
{
   m_Size = 0;
}

template<class Item>
Item& CHMvector<Item>::operator[](size_t Index)
{
   CHM_ASSERT(Index < m_Size);
   return m_pData[Index];
}

template<class Item>
const Item& CHMvector<Item>::operator[](size_t Index) const
{
   CHM_ASSERT(Index < m_Size);
   return m_pData[Index];
}

template<class Item>
size_t CHMvector<Item>::size() const
{
   return m_Size;
}

template<class Item>
void CHMvector<Item>::resize(size_t NewSize)
{
   CHM_ASSERT(NewSize >= m_Size);
   if (NewSize == m_Size)
   {
      // no need to resize...
      return;
   }
   if (m_Capacity < NewSize)
   {
      grow(NewSize);
   }
   m_Size = NewSize;
}

template<class Item>
void CHMvector<Item>::remove(size_t Index)
{
   CHM_ASSERT(Index < m_Size);
   for(size_t ItemIndex = Index;
       ItemIndex < m_Size-1;
       ++ItemIndex)
   {
      m_pData[ItemIndex] = m_pData[ItemIndex+1];
   }
   m_Size--;
}

template<class Item>
void CHMvector<Item>::insert(const Item& Value, size_t Index)
{
   CHM_ASSERT(Index <= m_Size)
   if (m_Size == m_Capacity)
   {
       grow(m_Capacity+1);
   }
   CHM_ASSERT(m_Size < m_Capacity);


   for (size_t CopyIndex = m_Size;
        CopyIndex > Index;
        --CopyIndex)
   {
      m_pData[CopyIndex] = m_pData[CopyIndex-1];
   }
   m_pData[Index] = Value;
   m_Size++;
}

template<class Item>
void CHMvector<Item>::push_back(const Item& Value)
{
   if (m_Size == m_Capacity)
   {
      grow(m_Capacity+1);
   }
   CHM_ASSERT(m_Size < m_Capacity);

   m_pData[m_Size] = Value;
   m_Size++;
}

template<class Item>
Item& CHMvector<Item>::pop_back()
{
   CHM_ASSERT(m_Size > 0);
   m_Size--;
   return m_pData[m_Size];
}

template<class Item>
Item& CHMvector<Item>::back()
{
   CHM_ASSERT(m_Size > 0);
   return m_pData[m_Size-1];
}

template<class Item>
void CHMvector<Item>::grow(size_t RequiredSize)
{
   CHM_ASSERT(RequiredSize > 0);
   CHM_ASSERT(m_GrowBy > 0);
   size_t NewCapacity(m_Capacity);
   if (m_GrowByDouble)
   {
      if (NewCapacity == 0)
      {
         NewCapacity = 1;
      }
      while (NewCapacity < RequiredSize)
      {
         NewCapacity = m_GrowBy * NewCapacity;
      }
   }
   else
   {
      while (NewCapacity < RequiredSize)
      {
         NewCapacity = m_GrowBy + NewCapacity;
      }
   }

   Item* pNewData = new Item[NewCapacity];
   size_t ItemIndex;
   for(ItemIndex = 0;
       ItemIndex < m_Size;
       ItemIndex++)
   {
      pNewData[ItemIndex] = m_pData[ItemIndex];
   }
   delete []m_pData;
   m_pData = pNewData;
   m_Capacity = NewCapacity;
}

template<class Item>
CHMvector<Item>& CHMvector<Item>::operator=(const CHMvector<Item>& Original)
{
   m_GrowBy = Original.m_GrowBy;
   m_Size   = Original.m_Size;
   m_Capacity = Original.m_Capacity;
   m_GrowByDouble = Original.m_GrowByDouble;
   CHM_ASSERT(m_Size <= m_Capacity);
   delete []m_pData;
   m_pData = new Item[m_Capacity];
   for (size_t DataIndex = 0; DataIndex < m_Size; ++DataIndex)
   {
      m_pData[DataIndex] = Original.m_pData[DataIndex];
   }
   return *this; 
}
#endif // end of defensive include

---