kc3-lang/ftgl

diff --git a/include/FTVector.h b/include/FTVector.h
index 4203e3e..96c59c4 100644
--- a/include/FTVector.h
+++ b/include/FTVector.h
@@ -1,261 +1,168 @@
-/*
-  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
+template <typename FT_VECTOR_ITEM_TYPE>
+class FTGL_EXPORT FTVector
 {
-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);
+    public:
   
-  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:
+        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;
+
+        FTVector()
+        {
+            Size = NumberOfItems = 0;
+            Items = 0;
+        }
+
+        virtual ~FTVector()
+        {
+            clear();
+        }
+
+        FTVector& operator = ( const FTVector& v)
+        {
+            // Warning: the vector is not cleared and resized to v capacity for
+            // efficiency reasons.
+            // clear();
+            reserve(v.capacity());
   
-  void expand(size_type = 0);
-
-private:
-
-  size_type Size;
-  size_type NumberOfItems;
-  value_type* Items;
+            iterator ptr = begin();
+            const_iterator vbegin = v.begin();
+            const_iterator vend = v.end();
+
+            while (vbegin != vend)
+            {
+                *ptr++ = *vbegin++;
+            }
+            NumberOfItems = v.size();
+            return *this;
+        }
+
+        size_type size() const
+        {
+            return NumberOfItems; 
+        }
+        
+        size_type capacity() const
+        { 
+            return Size; 
+        }
+
+        iterator begin()
+        { 
+            return Items; 
+        }
+
+        iterator end()
+        { 
+            return begin() + size(); 
+        }
+
+        const_iterator begin() const
+        { 
+          return Items; 
+        }
+
+        const_iterator end() const
+        { 
+            return begin() + size(); 
+        }
+
+        bool empty() const
+        { 
+            return size() == 0; 
+        }
+
+        reference operator []( size_type pos)
+        { 
+            return (*(begin() + pos)); 
+        }
+
+        const_reference operator []( size_type pos) const
+        { 
+            return (*(begin() + pos)); 
+        }
+
+
+        void clear()
+        {
+            if (Size)
+            {
+                delete [] Items;
+                Size = NumberOfItems = 0;
+                Items = 0;
+            }
+        }
+
+        void reserve( size_type n)
+        {
+            if( capacity() < n)
+            {
+                expand(n);
+            }
+        }
+
+        void push_back( const value_type& x)
+        {
+            if( size() == capacity())
+            {
+                expand();
+            }
+            
+            (*this)[size()] = x;
+            NumberOfItems++;
+        }
+
+        void resize( size_type, value_type)
+        {
+            reserve(n);
+            iterator end = end();
+            iterator end_capacity = begin() + capacity();
+        
+            while (end != end_capacity)
+            {
+                *end++ = x;
+            }
+        }
+
+
+    protected:
+        void expand( size_type size_hint = 0)
+        {
+            // Allocate new vector (size doubles)
+            size_type new_size = (size() == 0) ? 256 : size() * 2;
+            if( size_hint)
+            {
+                while( new_size < size_hint)
+                {
+                    new_size *= 2;
+                }
+            }
+          
+            value_type *ptr = new value_type[new_size];
+        
+            // Copy values to new vector
+            iterator begin = this->begin();
+            iterator end = this->end();
+            while( begin != end)
+            {
+                *ptr++ = *begin++;
+            }
+        
+            // Deallocate old vector and use new vector
+            delete [] Items;
+            Items = ptr;
+            Size = new_size;
+        }
+
+
+    private:
+        size_type Size;
+        size_type NumberOfItems;
+        value_type* Items;
 };
 
-
-inline 
-FT_VECTOR_CLASS_NAME::FT_VECTOR_CLASS_NAME()
-{
-  this->Size = this->NumberOfItems = 0;
-  this->Items = 0;
-}
-
-
-inline 
-FT_VECTOR_CLASS_NAME::~FT_VECTOR_CLASS_NAME()
-{
-  this->clear();
-}
-
-
-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->NumberOfItems = v.size();
-  return *this;
-}
-
-
-inline 
-FT_VECTOR_CLASS_NAME::size_type FT_VECTOR_CLASS_NAME::size() const 
-{ 
-  return this->NumberOfItems; 
-}
-
-
-inline 
-FT_VECTOR_CLASS_NAME::size_type FT_VECTOR_CLASS_NAME::capacity() const 
-{ 
-  return this->Size; 
-}
-
-
-inline 
-FT_VECTOR_CLASS_NAME::iterator FT_VECTOR_CLASS_NAME::begin() 
-{ 
-  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::begin() const 
-{ 
-  return this->Items; 
-}
-
-
-inline 
-FT_VECTOR_CLASS_NAME::const_iterator FT_VECTOR_CLASS_NAME::end() const 
-{ 
-  return this->begin() + this->size(); 
-}
-
-
-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) 
-{ 
-  return (*(begin() + pos)); 
-}
-
-
-inline 
-FT_VECTOR_CLASS_NAME::const_reference FT_VECTOR_CLASS_NAME::operator [](FT_VECTOR_CLASS_NAME::size_type pos) const 
-{ 
-  return (*(begin() + pos)); 
-}
-
-
-inline 
-void FT_VECTOR_CLASS_NAME::clear()
-{
-  if (this->Size)
-    {
-#if FT_VECTOR_CLASS_DEBUG    
-    printf("FT_VECTOR_CLASS_NAME: clear() (%d / %d)\n", 
-           this->size(), this->capacity());
-#endif
-    delete [] this->Items;
-    this->Size = this->NumberOfItems = 0;
-    this->Items = 0;
-    }
-}
-
-
-inline 
-void FT_VECTOR_CLASS_NAME::expand(size_type size_hint)
-{
-#if FT_VECTOR_CLASS_DEBUG    
-  printf("FT_VECTOR_CLASS_NAME: expand() (%d / %d) hint: %d\n", 
-         this->size(), this->capacity(), size_hint);
-#endif
-
-  // Allocate new vector (size doubles)
-
-  size_type new_size = (this->size() == 0) ? 256 : this->size() * 2;
-  if (size_hint)
-    {
-    while (new_size < size_hint)
-      {
-      new_size *= 2;
-      }
-    }
-  
-  value_type *ptr = new value_type[new_size];
-
-  // Copy values to new vector
-
-  iterator begin = this->begin();
-  iterator end = this->end();
-  while (begin != end)
-    {
-    *ptr++ = *begin++;
-    }
-
-  // Deallocate old vector and use new vector
-
-  delete [] this->Items;
-  this->Items = ptr;
-  this->Size = new_size;
-}
-
-
-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 
-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->NumberOfItems++;
-}
-
-
-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
-  this->reserve(n);
-  iterator end = this->end();
-  iterator end_capacity = this->begin() + this->capacity();
-  while (end != end_capacity)
-    {
-    *end++ = x;
-    }
-}
diff --git a/include/FTVectoriser.h b/include/FTVectoriser.h
index a3231a7..5077bb4 100644
--- a/include/FTVectoriser.h
+++ b/include/FTVectoriser.h
@@ -8,6 +8,8 @@
 #include FT_GLYPH_H
 
 #include "FTGL.h"
+
+#include "FTVector.h"
 #include "FTGlyph.h"
 
 #ifndef CALLBACK
@@ -70,9 +72,6 @@ class FTGL_EXPORT ftPoint
 };
 
 
-#include "FTPointVector.h"
-
-
 /**
  * FTContour class is a container of points that describe an outline
  * point data.
@@ -132,7 +131,7 @@ class FTGL_EXPORT FTContour
         /**
          *  The list of points in this contour
          */
-        typedef FTPointVector PointVector;
+        typedef FTVector<ftPoint> PointVector;
         PointVector pointList;
         
     private:
@@ -168,7 +167,7 @@ class FTGL_EXPORT FTTesselation
         size_t size() const { return pointList.size();}
 
         GLenum meshType;
-        typedef FTPointVector PointVector;
+        typedef FTVector<ftPoint> PointVector;
         PointVector pointList;
         
     private:
@@ -176,9 +175,6 @@ class FTGL_EXPORT FTTesselation
 };
 
 
-#include "FTTesselationVector.h"
-
-
 class FTGL_EXPORT FTMesh
 {
     public:
@@ -195,10 +191,10 @@ class FTGL_EXPORT FTMesh
         void Error( GLenum e) { err = e;}
         GLenum Error() const { return err;}
 
-        typedef FTPointVector PointVector;
+        typedef FTVector<ftPoint> PointVector;
         PointVector tempPool;
         
-        typedef FTTesselationVector TesselationVector;
+        typedef FTVector<FTTesselation*> TesselationVector;
         TesselationVector tess;
         
     protected:
@@ -213,8 +209,6 @@ class FTGL_EXPORT FTMesh
 };
 
 
-#include "FTContourVector.h"
-
 
 /**
  * FTVectoriser class is a helper class that converts font outlines into
@@ -345,7 +339,7 @@ class FTGL_EXPORT FTVectoriser
         /**
          * The list of contours in this outline
          */
-        typedef FTContourVector ContourVector;
+        typedef FTVector<FTContour*> ContourVector;
         ContourVector contourList;
             
         /**