---

TValVectorT.hh

#ifndef _T_VAL_VECTOR_T_HH
#define _T_VAL_VECTOR_T_HH

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


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


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

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


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


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


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


template <class T>
void TValVectorT<T>::Append (const T& a)
{
  Resize ();
  
  myVector[myNumElementsUsed] = new T (a);
  myNumElementsUsed++;
}


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


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


template <class T>
void TValVectorT<T>::Resize (int n)
{
  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] = new T;
    }
  else if (myNumElementsUsed >= 0)
    myNumElementsUsed = n;
}


template <class T>
void TValVectorT<T>::Resize (int n, const 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] = new T (a);
    }
  else if (myNumElementsUsed >= 0)
    myNumElementsUsed = n;
}


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


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


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


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


template <class T>
void TValVectorT<T>::Copy (const TValVectorT<T>& vec)
{
  myNumElementsUsed  = vec.myNumElementsUsed;
  myNumElementsAvail = vec.myNumElementsAvail;
  
  myVector = (T **) malloc (vec.myNumElementsAvail * sizeof(T *));
  if (! myVector)
    throw TMemoryException ();
  
  for (int i = 0; i < vec.myNumElementsUsed; i++)
    myVector[i] = new T (*vec.myVector[i]);
}

#endif // _T_VAL_VECTOR_T_HH

---