PHObjectVectorTCA.h

Go to the documentation of this file.

#ifndef __PHOBJECTVECTORTCA_H__
#define __PHOBJECTVECTORTCA_H__

#include "PHObjectVector.h"
class TClonesArray;

template<typename BASE, typename DERIVED>
class PHObjectVectorTCA : public PHObjectVector<BASE>
{
 public:
  typedef PHObjectVectorTCA<BASE,DERIVED> self;
  typedef BASE* value_type;
  typedef const value_type& const_reference;
  typedef value_type& reference;
  typedef unsigned int size_type;

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

  virtual ~PHObjectVectorTCA();

  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 PHObjectVectorTCA<BASE,DERIVED>* clone() const;

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

  virtual bool empty() const { return size()==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& n);

  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();
  void delete_last(const size_type& n);
  bool expand(const size_type& n);
  void init(size_type n);
  bool expand_for(const size_type& index);

  size_type fDefaultCapacity;
  size_type fMaxCapacity;
  TClonesArray* fArray;

  ClassDefT(PHObjectVectorTCA,1)
};

ClassDef2T2(PHObjectVectorTCA,BASE,DERIVED)

#ifndef __CINT__

ClassImp2T(PHObjectVectorTCA,BASE,DERIVED)

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

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

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

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

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

//_____________________________________________________________________________
template<typename BASE, typename DERIVED>
typename PHObjectVectorTCA<BASE,DERIVED>::value_type
PHObjectVectorTCA<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();
        }                      
    }

  new ((*fArray)[index]) DERIVED;

  return get(index);
}

//_____________________________________________________________________________
template<typename BASE, typename DERIVED>
typename PHObjectVectorTCA<BASE,DERIVED>::value_type
PHObjectVectorTCA<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<const DERIVED*>(value);

  if ( !test && value )
    {
      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();
        }                      
    }

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

  return get(index);
}

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

//_____________________________________________________________________________
template<typename BASE, typename DERIVED>
void
PHObjectVectorTCA<BASE,DERIVED>::copyTo
(PHObjectVectorTCA<BASE,DERIVED>& other) const
{
  other.fDefaultCapacity = fDefaultCapacity;
  other.fMaxCapacity = fMaxCapacity;

  other.init(size());

  for ( size_t i = 0; i < size(); ++i ) 
    {
      DERIVED* ptr = static_cast<DERIVED*>(get(i));
      TClonesArray& arr = *(other.fArray);      
      if (ptr)
        {
          std::cout << "Copying " << i << std::endl;
          new ( arr[i] ) DERIVED(*ptr);
        }
      else
        {
          std::cout << i << " is null" << std::endl;
        }
    }
}

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

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

//_____________________________________________________________________________
template<typename BASE, typename DERIVED>
void
PHObjectVectorTCA<BASE,DERIVED>::deallocate()
{  
  if ( fArray )
    {
      fArray->Delete();
    }
}

//_____________________________________________________________________________
template<typename BASE, typename DERIVED>
bool
PHObjectVectorTCA<BASE,DERIVED>::expand(const size_type& newcap)
{
  if ( newcap <= fMaxCapacity )
    {
      assert(fArray!=0);
      fArray->Expand(newcap);
      return true;
    }
  else
    {
      std::cerr << "PHObjectVectorTCA<BASE,DERIVED>::expand : attempting to go"
                << " above maxsize of " << fMaxCapacity
                << ". That's a *big* failure probably. Maybe a missing Reset ?"
                << std::endl;
      return false;
    }
}

//_____________________________________________________________________________
template<typename BASE, typename DERIVED>
typename PHObjectVectorTCA<BASE,DERIVED>::value_type
PHObjectVectorTCA<BASE,DERIVED>::get(const size_type& index) const
{
  return static_cast<value_type>(fArray->At(index));
}

//_____________________________________________________________________________
template<typename BASE, typename DERIVED>
void
PHObjectVectorTCA<BASE,DERIVED>::identify(std::ostream& os) const
{
  os << "PHObjectVectorTCA<" << BASE::Class()->GetName()
     << "," << DERIVED::Class()->GetName()
     << ">::identify() " 
     << "size=" << size() 
     << " capacity=" << capacity()
     << " maxcapacity=" << fMaxCapacity
     << 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
PHObjectVectorTCA<BASE,DERIVED>::init(size_type n)
{
  deallocate();
  reserve(n);
}

//_____________________________________________________________________________
template<typename BASE, typename DERIVED>
bool
PHObjectVectorTCA<BASE,DERIVED>::reserve(const size_type& n)
{
  if ( n <= fMaxCapacity )
    {
      if (!fArray)
        {
          fArray = new TClonesArray(DERIVED::Class()->GetName(),n);
        }
      else
        {
          fArray->Expand(n);
        }
      return true;
    }
  else
    {
      std::cerr << PHWHERE << "Attempting to reserve more than MaxCapacity="
                << fMaxCapacity
                << std::endl;
      return false;
    }
}

//_____________________________________________________________________________
template<typename BASE, typename DERIVED>
void
PHObjectVectorTCA<BASE,DERIVED>::Reset()
{
  assert(fArray!=0);
  fArray->Delete();
}

//_____________________________________________________________________________
template<typename BASE, typename DERIVED>
bool
PHObjectVectorTCA<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() )
    {
      // Append elements.
      size_type si = size();
      bool ok = reserve(newsize);
      if (!ok)
        {
          return false;
        }
      for ( size_type i = si; i < newsize; ++i )
        {
          add(i,static_cast<DERIVED*>(v));
        }
      return true;
    }
  else
    {
      // Delete elements.
      delete_last(size()-newsize);
    }
  return true;
}

//_____________________________________________________________________________
template<typename BASE, typename DERIVED>
void
PHObjectVectorTCA<BASE,DERIVED>::delete_last(const size_type& n)
{
  for ( size_type i = 0; i < n; ++i )
    {
      erase(size()-1);
    }
}

//_____________________________________________________________________________
template<typename BASE, typename DERIVED>
void
PHObjectVectorTCA<BASE,DERIVED>::erase(const size_type& i)
{
  std::cout << PHWHERE << "size=" << size() << " Erasing at index="
            << i << std::endl;
  fArray->RemoveAt(i);
  std::cout << "newsize=" << size() << std::endl;
}

//_____________________________________________________________________________
template<typename BASE, typename DERIVED>
bool
PHObjectVectorTCA<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 PHObjectVectorTCA<BASE,DERIVED>::size_type
PHObjectVectorTCA<BASE,DERIVED>::size() const
{
  return fArray->GetLast()+1;
}

#endif

#endif