ftvector.h

a very goog book

/*
  Provides a non-STL alternative to the STL vector<...>
  used inside FTvectorizer and FTGlyphContainer.
  
  Implementation:
    - Dynamically resizable container.
    - Try to mimic the calls made to the STL vector API.

  Caveats:
    - No templates, use poor macro substition where :
      FT_VECTOR_CLASS_NAME: is the name of the class
      FT_VECTOR_ITEM_TYPE: is the type of the object to store
*/

#define FT_VECTOR_CLASS_DEBUG 0

#include "FTGL.h"

class FTGL_EXPORT FT_VECTOR_CLASS_NAME
{
public:
  
  typedef FT_VECTOR_ITEM_TYPE value_type;
  typedef value_type& reference;
  typedef const value_type& const_reference;
  typedef value_type* iterator;
  typedef const value_type* const_iterator;
  typedef size_t size_type;

  FT_VECTOR_CLASS_NAME();

  virtual ~FT_VECTOR_CLASS_NAME();

  FT_VECTOR_CLASS_NAME& operator =(const FT_VECTOR_CLASS_NAME& v);
  
  size_type size() const;
  size_type capacity() const;
  iterator begin();
  iterator end();
  const_iterator begin() const;
  const_iterator end() const;
  bool empty() const;

  reference operator [](size_type pos);
  const_reference operator [](size_type pos) const;

  void clear();
  void reserve(size_type);
  void push_back(const value_type&);
  void resize(size_type, value_type);

protected:
  
  void expand(size_type = 0);

private:

  size_type Capacity;
  size_type Size;
  value_type* Items;
};


inline 
FT_VECTOR_CLASS_NAME::FT_VECTOR_CLASS_NAME()
{
  this->Capacity = this->Size = 0;
  this->Items = 0;
}


inline 
FT_VECTOR_CLASS_NAME::size_type FT_VECTOR_CLASS_NAME::size() const 
{ 
  return this->Size; 
}


inline 
FT_VECTOR_CLASS_NAME::size_type FT_VECTOR_CLASS_NAME::capacity() const 
{ 
  return this->Capacity; 
}


inline 
FT_VECTOR_CLASS_NAME::iterator FT_VECTOR_CLASS_NAME::begin() 
{ 
  return this->Items; 
}


inline 
FT_VECTOR_CLASS_NAME::const_iterator FT_VECTOR_CLASS_NAME::begin() const 
{ 
  return this->Items; 
}


inline 
FT_VECTOR_CLASS_NAME::iterator FT_VECTOR_CLASS_NAME::end() 
{ 
  return this->begin() + this->size(); 
}


inline 
FT_VECTOR_CLASS_NAME::const_iterator FT_VECTOR_CLASS_NAME::end() const 
{ 
  return this->begin() + this->size(); 
}


inline 
void FT_VECTOR_CLASS_NAME::clear()
{
  if (this->Capacity)
    {
#if FT_VECTOR_CLASS_DEBUG
    printf("FT_VECTOR_CLASS_NAME:     clear() (%d / %d)\n", 
           this->size(), this->capacity());
#endif
    delete [] this->Items;
    this->Capacity = this->Size = 0;
    this->Items = 0;
    }
}


inline 
FT_VECTOR_CLASS_NAME::~FT_VECTOR_CLASS_NAME()
{
  this->clear();
}


inline 
void FT_VECTOR_CLASS_NAME::expand(size_type capacity_hint)
{
#if FT_VECTOR_CLASS_DEBUG    
  printf("FT_VECTOR_CLASS_NAME:    expand() (%d / %d) hint: %d\n", 
         this->size(), this->capacity(), capacity_hint);
#endif

  // Allocate new vector (capacity doubles)

  size_type new_capacity = (this->capacity() == 0) ? 256 : this->capacity()* 2;
  if (capacity_hint)
    {
    while (new_capacity < capacity_hint)
      {
      new_capacity *= 2;
      }
    }
  
  value_type *new_items = new value_type[new_capacity];

  // Copy values to new vector

  iterator begin = this->begin();
  iterator end = this->end();
  value_type *ptr = new_items;
  while (begin != end)
    {
    *ptr++ = *begin++;
    }

  // Deallocate old vector and use new vector

  if (this->Capacity)
    {
    delete [] this->Items;
    }
  this->Items = new_items;
  this->Capacity = new_capacity;
}


inline 
void FT_VECTOR_CLASS_NAME::reserve(size_type n)
{
#if FT_VECTOR_CLASS_DEBUG    
  printf("FT_VECTOR_CLASS_NAME:   reserve() (%d / %d) n: %d\n", 
         this->size(), this->capacity(), n);
#endif
  if (this->capacity() < n)
    {
    this->expand(n);
    }
}


inline 
FT_VECTOR_CLASS_NAME& FT_VECTOR_CLASS_NAME::operator =(const FT_VECTOR_CLASS_NAME& v)
{
  // Warning: the vector is not cleared and resized to v capacity for
  // efficiency reasons.
  // this->clear();
  this->reserve(v.capacity());
  
  iterator ptr = this->begin();
  const_iterator vbegin = v.begin();
  const_iterator vend = v.end();

  while (vbegin != vend)
    {
    *ptr++ = *vbegin++;
    }
  this->Size = v.size();
  return *this;
}


inline 
bool FT_VECTOR_CLASS_NAME::empty() const 
{ 
  return this->size() == 0; 
}


inline 
FT_VECTOR_CLASS_NAME::reference FT_VECTOR_CLASS_NAME::operator [](FT_VECTOR_CLASS_NAME::size_type pos) 
{ 
#if FT_VECTOR_CLASS_DEBUG    
  printf("FT_VECTOR_CLASS_NAME:        []() (%d / %d) pos: %d\n", 
         this->size(), this->capacity(), pos);
#endif
  return (*(begin() + pos)); 
}


inline 
FT_VECTOR_CLASS_NAME::const_reference FT_VECTOR_CLASS_NAME::operator [](FT_VECTOR_CLASS_NAME::size_type pos) const 
{ 
#if FT_VECTOR_CLASS_DEBUG    
  printf("FT_VECTOR_CLASS_NAME:        []() (%d / %d) pos: %d\n", 
         this->size(), this->capacity(), pos);
#endif
  return (*(begin() + pos)); 
}


inline 
void FT_VECTOR_CLASS_NAME::push_back(const value_type& x)
{
#if FT_VECTOR_CLASS_DEBUG    
  printf("FT_VECTOR_CLASS_NAME: push_back() (%d / %d)\n", 
         this->size(), this->capacity());
#endif
  if (this->size() == this->capacity())
    {
    this->expand();
    }
  (*this)[this->size()] = x;
  this->Size++;
}


inline 
void FT_VECTOR_CLASS_NAME::resize(size_type n, value_type x)
{
#if FT_VECTOR_CLASS_DEBUG    
  printf("FT_VECTOR_CLASS_NAME:    resize() (%d / %d) n: %d\n", 
         this->size(), this->capacity(), n);
#endif
  if (n == this->size())
    {
    return;
    }
  this->reserve(n);
  iterator begin, end;
  if (n >= this->Size)
    {
    begin = this->end();
    end = this->begin() + n;
    }
  else
    {
    begin = this->begin() + n;
    end = this->end();
    }
  while (begin != end)
    {
    *begin++ = x;
    }
  this->Size = n;
}