---

TPtrVectorT.hh

#ifndef _T_PTR_VECTOR_T_HH
#define _T_PTR_VECTOR_T_HH

#include <stdlib.h>
#include <string.h>
#include "TBoundsException.hh"
#include "TMemoryException.hh"

template <class T>
class TPtrVectorT
{
public:
  
  TPtrVectorT ();
  
  TPtrVectorT (int n, T *a = NULL);
  
  inline TPtrVectorT (TPtrVectorT<T> &vec) { Copy (vec); }
  
  ~TPtrVectorT () { Clear (); }
  
  void Append (T *a);
  
  void Apply (void (*fn)(T *, void *), void *d);
  
  void Clear ();
  
  void ClearAndDestroy ();
  
  inline int Entries () const { return myNumElementsUsed; }
  
  void Resize (int n, T *a = NULL);
  
  void Sort (bool reverse = false);
  
  inline T*& operator[](int i) const;
  
  TPtrVectorT<T>& operator=(const TPtrVectorT<T> &vec);
  
  
private:
  
  void Resize ();
  
  void Copy (TPtrVectorT<T> &vec);
  
  /* Allocate pointers in chunks of this number. */
  static const int BLOCK_SIZE;
  static const int BLOCK_MASK;
  
  /* Vector containing pointers. */
  T **myVector;
  
  /* Number of elements used in ptr vector. */
  int myNumElementsUsed;
  
  /* Number of elements available in ptr vector. */
  int myNumElementsAvail;
};


template <class T>
const int TPtrVectorT<T>::BLOCK_SIZE =  16;

template <class T>
const int TPtrVectorT<T>::BLOCK_MASK = ~15;


template <class T>
TPtrVectorT<T>::TPtrVectorT ()
  : myVector (0),
    myNumElementsUsed (0),
    myNumElementsAvail (0)
{
}


template <class T>
TPtrVectorT<T>::TPtrVectorT (int n, T *a)
  : myVector (0),
    myNumElementsUsed (0),
    myNumElementsAvail (0)
{
  Resize (n, a);
}


template <class T>
void TPtrVectorT<T>::Append (T *a)
{
  Resize ();
  
  myVector[myNumElementsUsed] = a;
  myNumElementsUsed++;
}


template <class T>
void TPtrVectorT<T>::Apply (void (*fn)(T *, void *), void *d)
{
  for (int i = 0; i < myNumElementsUsed; i++)
    fn (myVector[i], d);
}


template <class T>
void TPtrVectorT<T>::Clear ()
{
  if (myVector)
    {
      free (myVector);
      myVector = 0;
    }
  
  myNumElementsUsed = 0;
  myNumElementsAvail = 0;
}


template <class T>
void TPtrVectorT<T>::ClearAndDestroy ()
{
  for (int i = 0; i < myNumElementsUsed; i++)
    if (myVector[i])
      delete myVector[i];
  
  Clear ();
}


template <class T>
void TPtrVectorT<T>::Resize (int n, T *a)
{
  if (n > myNumElementsUsed)
    {
      if (n > myNumElementsAvail)
        {
          myNumElementsAvail = (n + (BLOCK_SIZE - 1)) & BLOCK_MASK;
          myVector = (T **) realloc (myVector,
                                     myNumElementsAvail * sizeof(T *));
          if (! myVector)
            throw TMemoryException ();
        }
      
      for (; myNumElementsUsed < n; myNumElementsUsed++)
        myVector[myNumElementsUsed] = a;
    }
  else if (myNumElementsUsed >= 0)
    myNumElementsUsed = n;
}


/* FIXME */
template <class T>
void TPtrVectorT<T>::Sort (bool reverse)
{
}


template <class T>
T*& TPtrVectorT<T>::operator[](int i) const
{
#ifdef TOOLS_BOUND_CHECK
  if (i >= myNumElementsUsed || i < 0)
    throw TBoundsException ();
#endif
  
  return myVector[i];
}


template <class T>
TPtrVectorT<T>& TPtrVectorT<T>::operator=(const TPtrVectorT<T> &vec)
{
  /* Only copy if different objects. */
  if (&vec != this)
    {
      if (myVector)
        free (myVector);
      
      Copy (vec);
    }
  
  return *this;
}


template <class T>
void TPtrVectorT<T>::Resize ()
{
  if (myNumElementsUsed == myNumElementsAvail)
    {
      myNumElementsAvail += BLOCK_SIZE;
      myVector = (T **) realloc (myVector, myNumElementsAvail * sizeof(T *));
      if (! myVector)
        throw TMemoryException ();
    }
}


template <class T>
void TPtrVectorT<T>::Copy (TPtrVectorT<T> &vec)
{
  myNumElementsUsed  = vec.myNumElementsUsed;
  myNumElementsAvail = vec.myNumElementsAvail;
  
  myVector = (T **) malloc (myNumElementsAvail * sizeof(T *));
  if (! myVector)
    throw TMemoryException ();
  
  memcpy (myVector, vec.myVector, sizeof (T *) * myNumElementsAvail);
}

#endif // _T_PTR_VECTOR_T_HH

---