PHObjectHandleVectorv1.h

Go to the documentation of this file.

#ifndef __PHOBJECTHANDLEVECTORV1_H__
#define __PHOBJECTHANDLEVECTORV1_H__

#include "PHObjectHandleVector.h"
#include "TClonesArray.h"
#include <iostream>
#include <vector>

template<typename BASE, typename DERIVED>
class PHObjectHandleVectorv1 : public PHObjectHandleVector<BASE>
{
public:

  typedef PHObjectHandleVectorv1<BASE,DERIVED> self;
  typedef PHObjectHandle<BASE> value_type;
  typedef unsigned int size_type;
  typedef PHObjectHandleVectorIterator<BASE> iterator;

  PHObjectHandleVectorv1();
  PHObjectHandleVectorv1(const self& other);
  self& operator=(const self& other);

  virtual ~PHObjectHandleVectorv1();

  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 self* clone() const;

  virtual self* create() const;

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

  virtual iterator erase(iterator first, iterator last);

  virtual iterator erase(iterator pos) { return erase(pos,pos+1); }

  virtual const value_type& get(const size_type& index) const;

  virtual value_type& get(const size_type& index);

  virtual void identify(std::ostream& os = std::cout) const;

  virtual iterator insert(iterator pos, size_type n, const value_type& value);

  virtual iterator insert(iterator pos, const value_type& value)
  { return insert(pos,1,value); }

  virtual bool remove(const size_type& index);

  virtual void reserve(const size_type& thesize);

  virtual void Reset();

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

  virtual bool resize(const size_type& newsize)
  { return resize(newsize,value_type()); }
  
  virtual size_type size() const;

private:

  void copyTo(self& other) const;
  void deallocate();
  void delete_last(size_type n);
  bool expand(const size_type& n);
  void init(size_type n);
  bool expand_for(const size_type& index);
  void isAliveCapacityok() const;
  static const unsigned int fgDefaultCapacity = 10;
  static const unsigned int fgMaxCapacity = 1000;

  size_type fSize;
  TClonesArray* fArray;

  ClassDefT(PHObjectHandleVectorv1,1)
};

ClassDef2T2(PHObjectHandleVectorv1,BASE,DERIVED)

#ifndef __CINT__

ClassImp2T(PHObjectHandleVectorv1,BASE,DERIVED)

//_____________________________________________________________________________
template<typename BASE, typename DERIVED>
PHObjectHandleVectorv1<BASE,DERIVED>::PHObjectHandleVectorv1()
  : fSize(0),
    fArray(0)
{
  std::cout << PHWHERE << "PHObjectHandleVectorv1<" << BASE::Class()->GetName() 
            << "," << DERIVED::Class()->GetName() 
            << "> default ctor" 
            << std::endl;
  init(fgDefaultCapacity);
}

//_____________________________________________________________________________
template<typename BASE, typename DERIVED>
PHObjectHandleVectorv1<BASE,DERIVED>::PHObjectHandleVectorv1
(const PHObjectHandleVectorv1<BASE,DERIVED>& other)
  : PHObjectHandleVector<BASE>(),
    fSize(0),
    fArray(0)
{
  other.copyTo(*this);
}

//_____________________________________________________________________________
template<typename BASE, typename DERIVED>
PHObjectHandleVectorv1<BASE,DERIVED>& 
PHObjectHandleVectorv1<BASE,DERIVED>::operator=(const PHObjectHandleVectorv1<BASE,DERIVED>&
                                          other)
{
  if ( this != &other ) 
    {
      other.copyTo(*this);
    }
  return *this;
}

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

//_____________________________________________________________________________
template<typename BASE, typename DERIVED>
typename PHObjectHandleVectorv1<BASE,DERIVED>::value_type&
PHObjectHandleVectorv1<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;
          throw;
        }                      
    }

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

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

//_____________________________________________________________________________
template<typename BASE, typename DERIVED>
typename PHObjectHandleVectorv1<BASE,DERIVED>::value_type&
PHObjectHandleVectorv1<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.get());

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

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

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

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

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

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

  other.fSize = size();

  for ( size_t i = 0; i < size(); ++i ) 
    {
      assert(0==1);
  //     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;
//      }
//      other.fKeepAlive[i] = new value_type(newone);
    }
}

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

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

//_____________________________________________________________________________
template<typename BASE, typename DERIVED>
void
PHObjectHandleVectorv1<BASE,DERIVED>::deallocate()
{  
  if ( fArray )
    {
      fArray->Delete();
    }
  delete fArray;
  fArray=0;
  fSize=0;
}

//_____________________________________________________________________________
template<typename BASE, typename DERIVED>
void
PHObjectHandleVectorv1<BASE,DERIVED>::delete_last(size_type n)
{
  for ( size_type i = 0; i < n; ++i )
    {
      assert(size()>=1);
      size_type pos = size()-1;
      fArray->RemoveAt(pos);
      --fSize;
    }
}

//_____________________________________________________________________________
template<typename BASE, typename DERIVED>
typename PHObjectHandleVectorv1<BASE,DERIVED>::iterator
PHObjectHandleVectorv1<BASE,DERIVED>::erase
(PHObjectHandleVectorv1<BASE,DERIVED>::iterator first,
 PHObjectHandleVectorv1<BASE,DERIVED>::iterator last)
{
  std::copy(last,end(),first);
  
  delete_last(last-first);

  return first;
}

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

//_____________________________________________________________________________
template<typename BASE, typename DERIVED>
const typename PHObjectHandleVectorv1<BASE,DERIVED>::value_type&
PHObjectHandleVectorv1<BASE,DERIVED>::get(const size_type& index) const
{
  TObject* obj = fArray->At(index);
  assert(obj!=0);
  value_type* val = static_cast<value_type*>(obj);
  return *val;
}

//_____________________________________________________________________________
template<typename BASE, typename DERIVED>
typename PHObjectHandleVectorv1<BASE,DERIVED>::value_type&
PHObjectHandleVectorv1<BASE,DERIVED>::get(const size_type& index)
{
  TObject* obj = fArray->At(index);
  assert(obj!=0);
  value_type* val = static_cast<value_type*>(obj);
  return *val;
}

//_____________________________________________________________________________
template<typename BASE, typename DERIVED>
void
PHObjectHandleVectorv1<BASE,DERIVED>::identify(std::ostream& os) const
{
  os << "PHObjectHandleVectorv1<" << BASE::Class()->GetName()
     << "," << DERIVED::Class()->GetName()
     << ">::identify() " 
     << "size=" << size() 
     << " capacity=" << capacity()
     << " fArray.size=" << fArray->GetLast()
     << " fArray.capacity=" << fArray->GetSize()
     << std::endl;
  for ( size_t i = 0; i < capacity(); ++i ) 
    {
      os << i << " ptr=" << fArray->At(i)
         << " " << " kptr=";
      if ( fArray->At(i) )
        {
          value_type* val = static_cast<value_type*>(fArray->At(i));
          (*val)->identify();
        }
      os << std::endl;
    }
}

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

//_____________________________________________________________________________
template<typename BASE, typename DERIVED>
typename PHObjectHandleVectorv1<BASE,DERIVED>::iterator
PHObjectHandleVectorv1<BASE,DERIVED>::insert(iterator pos, size_type n, const value_type& val)
{
  size_type c = pos + n - begin();

  if ( c > capacity() )
    {
      std::cout << "insert : will have to expand" << std::endl;
      bool ok = expand_for(c);
      if (!ok)
        {
          return end();
        }
    }

  ++fSize;

  std::copy(pos,pos+n,pos+1);

  *pos = val;

  new ((*fArray)[pos-begin()]) DERIVED(*(static_cast<DERIVED*>((*pos).get())));

  fSize +=n ;
  return begin()+n;
}

//_____________________________________________________________________________
template<typename BASE, typename DERIVED>
bool
PHObjectHandleVectorv1<BASE,DERIVED>::remove(const size_type& index)
{
  if ( index < size() ) 
    {
      erase(begin()+index);
      return true;
    }
  else
    {
      return false;
    }
}

//_____________________________________________________________________________
template<typename BASE, typename DERIVED>
void
PHObjectHandleVectorv1<BASE,DERIVED>::reserve(const size_type& n)
{
  if (!fArray)
    {
      fArray = new TClonesArray(value_type::Class()->GetName(),n);
    }
  else
    {
      fArray->Expand(n);
    }
 
}

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

//_____________________________________________________________________________
template<typename BASE, typename DERIVED>
bool
PHObjectHandleVectorv1<BASE,DERIVED>::resize(const size_type& newsize,
                                             const value_type& /*value*/)
{
  reserve(newsize);
  return true;
}

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

  while ( index >= capa && capa < fgMaxCapacity ) 
    {
      capa *= 2;
    }
  if ( capa >= fgMaxCapacity )
    {
      return false;
    }
  else
    {
      assert(capa>capacity());
      return expand(capa);
    }
}

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

#endif // __CINT__

#endif