PHObjectVectorSTL.h

Go to the documentation of this file.

#ifndef __PHOBJECTVECTORSTL_H__
#define __PHOBJECTVECTORSTL_H__

#include "PHObjectVector.h"
#include <vector>

template<typename BASE, typename DERIVED>
class PHObjectVectorSTL : public PHObjectVector<BASE>
{
 public:
  typedef PHObjectVectorSTL<BASE,DERIVED> self;
  typedef BASE* value_type;
  typedef unsigned int size_type;

  PHObjectVectorSTL(const size_type defaultcapacity=10,
                    const size_type maxcapacity=100);
  PHObjectVectorSTL(const self& other);
  self& operator=(const self& other);

  virtual ~PHObjectVectorSTL();

  virtual value_type add(const size_type& index);
  
  virtual value_type add(const size_type& index, const value_type& value);

  virtual size_type capacity() const;

  virtual PHObjectVectorSTL<BASE,DERIVED>* clone() const;

  virtual PHObjectVectorSTL<BASE,DERIVED>* create() const;

  virtual bool empty() const { return fSize==0; }

  virtual void erase(const size_type& index);

  virtual value_type get(const size_type& index) const;
  
  virtual void identify(std::ostream& os = std::cout) const;

  virtual int isValid() const { return 1; }

  virtual void Reset();

  virtual bool reserve(const size_type&);

  virtual bool resize(const size_type& newsize, value_type v = value_type());

  virtual size_type size() const;

 private:
  void copyTo(self& other) const;
  void deallocate();
  bool expand(const size_type& n);
  void init(size_type n);
  bool expand_for(const size_type& index);

  size_type fDefaultCapacity;
  size_type fMaxCapacity;
  size_type fSize;
  std::vector<value_type> fArray;

  ClassDefT(PHObjectVectorSTL,1)
};

ClassDef2T2(PHObjectVectorSTL,BASE,DERIVED)

#ifndef __CINT__

ClassImp2T(PHObjectVectorSTL,BASE,DERIVED)

#include "phool.h"
#include <cassert>
#include <iomanip>
#include <iostream>

//_____________________________________________________________________________
template<typename BASE, typename DERIVED>
PHObjectVectorSTL<BASE,DERIVED>::PHObjectVectorSTL(const size_type defaultcapacity, const size_type maxcapacity)
  : fDefaultCapacity(defaultcapacity),
    fMaxCapacity(maxcapacity),
    fSize(0),
    fArray(0)
{
  std::cout << PHWHERE << "PHObjectVectorSTL<" << BASE::Class()->GetName() 
       << "," << DERIVED::Class()->GetName() 
       << "> default ctor" 
            << std::endl;
  init(fDefaultCapacity);
}

//_____________________________________________________________________________
template<typename BASE, typename DERIVED>
PHObjectVectorSTL<BASE,DERIVED>::PHObjectVectorSTL
(const PHObjectVectorSTL<BASE,DERIVED>& other) 
  : PHObjectVector<BASE>(),
    fDefaultCapacity(0),
    fMaxCapacity(0),
    fSize(0),
    fArray(0)
{
  std::cout << PHWHERE << "PHObjectVectorSTL<" << BASE::Class()->GetName() 
            << "," << DERIVED::Class()->GetName() 
            << "> copy ctor" 
            << std::endl;
  other.copyTo(*this);
}

//_____________________________________________________________________________
template<typename BASE, typename DERIVED>
PHObjectVectorSTL<BASE,DERIVED>& 
PHObjectVectorSTL<BASE,DERIVED>::operator=(const PHObjectVectorSTL<BASE,DERIVED>&
                                          other)
{
  std::cout << PHWHERE << "PHObjectVectorSTL<" << BASE::Class()->GetName() 
            << "," << DERIVED::Class()->GetName() 
            << "> assignement operator"
            << std::endl;
  if ( this != &other ) 
    {
      other.copyTo(*this);
    }
  return *this;
}

//_____________________________________________________________________________
template<typename BASE, typename DERIVED>
PHObjectVectorSTL<BASE,DERIVED>::~PHObjectVectorSTL()
{
  deallocate();
}

//_____________________________________________________________________________
template<typename BASE, typename DERIVED>
typename PHObjectVectorSTL<BASE,DERIVED>::value_type
PHObjectVectorSTL<BASE,DERIVED>::add(const size_type& index)
{
  if ( index >= capacity() )
    {
      // try to reallocate more space
      bool ok = expand_for(index);
      if (!ok)
        {
          std::cerr << PHWHERE << " object is full ?!" << std::endl;
          return value_type();
        }                      
    }

  fArray[index] = new DERIVED;

  if (index+1>fSize)
    {
      fSize=index+1; 
   }

  return get(index);
}

//_____________________________________________________________________________
template<typename BASE, typename DERIVED>
typename PHObjectVectorSTL<BASE,DERIVED>::value_type
PHObjectVectorSTL<BASE,DERIVED>::add(const size_type& index,
                                    const value_type& value)
{
  // we must first insure that the value we got is of the
  // type we expect...
  const DERIVED* test = 
    dynamic_cast<DERIVED*>(value);

  assert(test!=0);

  if (!test)
    {
      std::cerr << PHWHERE << " handle is of the wrong type" << std::endl;
      return value_type();
    }

  if ( index >= capacity() )
    {
      // try to reallocate more space
      bool ok = expand_for(index);
      if (!ok)
        {
          std::cerr << PHWHERE << " object is full ?!" << std::endl;
          return value_type();
        }                      
    }

  // the next line implies that the DERIVED class must
  // have a copy ctor (that should be fairly common, should'nt it ?)
  fArray[index] = new DERIVED(*test);

  if (index+1>fSize)
    {
      fSize=index+1;
    }
  return get(index);
}

//_____________________________________________________________________________
template<typename BASE, typename DERIVED>
typename PHObjectVectorSTL<BASE,DERIVED>::size_type
PHObjectVectorSTL<BASE,DERIVED>::capacity() const
{
  return fArray.capacity();
}

//_____________________________________________________________________________
template<typename BASE, typename DERIVED>
void
PHObjectVectorSTL<BASE,DERIVED>::copyTo
(PHObjectVectorSTL<BASE,DERIVED>& other) const
{
  other.init(size());

  other.fSize = size();
  other.fDefaultCapacity = fDefaultCapacity;
  other.fMaxCapacity = fMaxCapacity;

  for ( size_t i = 0; i < size(); ++i ) 
    {
      BASE* newone = static_cast<BASE*>(fArray[i]->clone());
      delete other.fArray[i];
      other.fArray[i] = newone;
    }
}

//_____________________________________________________________________________
template<typename BASE, typename DERIVED>
PHObjectVectorSTL<BASE,DERIVED>*
PHObjectVectorSTL<BASE,DERIVED>::clone() const
{
  return new PHObjectVectorSTL<BASE,DERIVED>(*this);
}

//_____________________________________________________________________________
template<typename BASE, typename DERIVED>
PHObjectVectorSTL<BASE,DERIVED>*
PHObjectVectorSTL<BASE,DERIVED>::create() const
{
  return new PHObjectVectorSTL<BASE,DERIVED>();
}

//_____________________________________________________________________________
template<typename BASE, typename DERIVED>
void
PHObjectVectorSTL<BASE,DERIVED>::deallocate()
{  
  for ( size_type i = 0; i < fArray.size(); ++i )
    {
      delete fArray[i];       
    }
  fArray.clear();
  fSize=0;
}

//_____________________________________________________________________________
template<typename BASE, typename DERIVED>
bool
PHObjectVectorSTL<BASE,DERIVED>::expand(const size_type& newcap)
{
  if ( newcap <= fMaxCapacity )
    {  

      std::vector<BASE*> copyArray = fArray;

      fArray.resize(newcap,0);

      std::copy(copyArray.begin(),copyArray.end(),fArray.begin());

      return true;
    }
  else
    {
      std::cerr << "PHObjectVectorSTL<BASE,DERIVED>::expand : attempting to go"
                << " above maxsize of " << fMaxCapacity
                << ". That's a *big* failure probably."
                << std::endl;
      return false;
    }
}

//_____________________________________________________________________________
template<typename BASE, typename DERIVED>
typename PHObjectVectorSTL<BASE,DERIVED>::value_type
PHObjectVectorSTL<BASE,DERIVED>::get(const size_type& index) const
{
  return fArray[index];
}

//_____________________________________________________________________________
template<typename BASE, typename DERIVED>
void
PHObjectVectorSTL<BASE,DERIVED>::identify(std::ostream& os) const
{
  os << "PHObjectVectorSTL<" << BASE::Class()->GetName()
     << "," << DERIVED::Class()->GetName()
     << ">::identify() " 
     << "size=" << size() 
     << " capacity=" << capacity()
     << " fArray.size=" << fArray.size()
     << " fArray.capacity=" << fArray.capacity()
     << std::endl;

  for ( size_t i = 0; i < capacity(); ++i ) 
    {
      BASE* object = get(i);
      if ( object)
        {
          os << std::setw(5) << i << " ptr=" << object << std::endl;
          object->identify(os);
        }
    }
}

//_____________________________________________________________________________
template<typename BASE, typename DERIVED>
void
PHObjectVectorSTL<BASE,DERIVED>::init(size_type n)
{
  deallocate();
  reserve(n);
}

//_____________________________________________________________________________
template<typename BASE, typename DERIVED>
bool
PHObjectVectorSTL<BASE,DERIVED>::reserve(const size_type& n)
{
  if ( n <= fMaxCapacity )
    {
      fArray.resize(n);
      return true;
    }
  else
    {
      std::cerr << PHWHERE << "Attempting to reserve more than MaxCapacity="
                << fMaxCapacity
                << std::endl;
      return false;
    }
}

//_____________________________________________________________________________
template<typename BASE, typename DERIVED>
void
PHObjectVectorSTL<BASE,DERIVED>::Reset()
{
  for ( size_type i = 0; i < fArray.size(); ++i )
    {
      delete fArray[i];
      fArray[i]=0;
    }
  fSize=0;
}

//_____________________________________________________________________________
template<typename BASE, typename DERIVED>
void
PHObjectVectorSTL<BASE,DERIVED>::erase(const size_type& i)
{
  delete fArray[i];
  fArray[i]=0;
  --fSize;
}

//_____________________________________________________________________________
template<typename BASE, typename DERIVED>
bool
PHObjectVectorSTL<BASE,DERIVED>::resize(const size_type& newsize,
                                        value_type v)
{ 
  if ( newsize > fMaxCapacity )
    {
      std::cerr << PHWHERE << "Attempting to resize above MaxCapacity="
                << fMaxCapacity
                << std::endl;
      return false;
    }
 
  if ( newsize > size() )
    {
      fArray.resize(newsize,v);
    }
  else
    {
      size_type n = size()-newsize;
      while ( n > 0 )
        {
          delete fArray[size()-1];
          fArray[size()-1]=0;
          --n;
          --fSize;
        }
      assert(fSize==newsize);
    }

  fSize=newsize;
  return true;
}

//_____________________________________________________________________________
template<typename BASE, typename DERIVED>
bool
PHObjectVectorSTL<BASE,DERIVED>::expand_for(const size_type& index)
{
  size_type capa = capacity();

  while ( index >= capa && capa < fMaxCapacity ) 
    {
      capa = std::min(capa*2,fMaxCapacity);
    }
  if ( index >= capa )
    {
      return false;
    }
  else
    {
      assert(capa>capacity());
      return expand(capa);
    }
}

//_____________________________________________________________________________
template<typename BASE, typename DERIVED>
typename PHObjectVectorSTL<BASE,DERIVED>::size_type
PHObjectVectorSTL<BASE,DERIVED>::size() const
{
  return fSize;
}

#endif

#endif