PHObjectHandleVectorv2.h

Go to the documentation of this file.

#ifndef __PHOBJECTHANDLEVECTORV2_H__
#define __PHOBJECTHANDLEVECTORV2_H__

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

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

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

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

  virtual ~PHObjectHandleVectorv2();

  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;
  std::vector<BASE*> fArray;
  mutable std::vector<value_type*> fKeepAlive; 

  ClassDefT(PHObjectHandleVectorv2,1)
};

ClassDef2T2(PHObjectHandleVectorv2,BASE,DERIVED)

ClassImp2T(PHObjectHandleVectorv2,BASE,DERIVED)

#ifndef __CINT__

//   template< typename Container >
//   void ez_release(Container& c)
//   {
//     typename Container::iterator it;
//     for ( it = c.begin(); it != c.end(); ++it ) 
//       {
//      delete *it;
//      *it = 0;
//       }
//   }


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

//_____________________________________________________________________________
template<typename BASE, typename DERIVED>
PHObjectHandleVectorv2<BASE,DERIVED>::PHObjectHandleVectorv2
(const PHObjectHandleVectorv2<BASE,DERIVED>& other)
{
  //  cout << PHWHERE << "PHObjectHandleVectorv2<" << BASE::Class()->GetName() 
  //       << "," << DERIVED::Class()->GetName() 
  //       << "> copy ctor" 
  //       << endl;
  other.copyTo(*this);
}

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

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

//_____________________________________________________________________________
template<typename BASE, typename DERIVED>
typename PHObjectHandleVectorv2<BASE,DERIVED>::value_type
PHObjectHandleVectorv2<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;
  delete fKeepAlive[index];
  fKeepAlive[index]=0;
  if (index+1>fSize)
    {
      fSize=index+1; 
   }
  return get(index);
}

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

  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);
  delete fKeepAlive[index];
  fKeepAlive[index] = 0;

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

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

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

  other.fSize = size();

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

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

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

//_____________________________________________________________________________
template<typename BASE, typename DERIVED>
void
PHObjectHandleVectorv2<BASE,DERIVED>::deallocate()
{  
  isAliveCapacityok();
  for ( size_t i = 0; i < fKeepAlive.size(); ++i ) 
    {
      if ( fKeepAlive[i] == 0 )
        {
          delete fArray[i];
          fArray[i] = 0;
        }
      else
        {
          delete fKeepAlive[i];
          fKeepAlive[i] = 0;
        }
    }
  fKeepAlive.clear();
  fArray.clear();
  fSize=0;
}

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

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

  return first;
}

template<class T>
void dump(const std::vector<T*>& v)
{
  std::cout << "dump v.size=" << v.size() << std::endl;

  for ( size_t i = 0; i < v.size(); ++i )
    {
      std::cout << "dump "<< i << " " << v[i] << std::endl;
    }
}

//_____________________________________________________________________________
template<typename BASE, typename DERIVED>
bool
PHObjectHandleVectorv2<BASE,DERIVED>::expand(const size_type& newcap)
{
  if ( newcap < fgMaxCapacity )
    {
      std::vector<BASE*> copyArray = fArray;
      std::vector<value_type*> copyKeepAlive = fKeepAlive;

      fArray.resize(newcap,0);
      fKeepAlive.resize(newcap,0);

      std::copy(copyArray.begin(),copyArray.end(),fArray.begin());
      std::copy(copyKeepAlive.begin(),copyKeepAlive.end(),fKeepAlive.begin());
      
      return true;
    }
  else
    {
      std::cerr << "PHObjectHandleVectorv2<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 PHObjectHandleVectorv2<BASE,DERIVED>::value_type&
PHObjectHandleVectorv2<BASE,DERIVED>::get(const size_type& index) const
{
   //check if fKeepAlive capacity  ok
  isAliveCapacityok();
  if ( !fKeepAlive[index] )
    {
      BASE* p = fArray[index];
      fKeepAlive[index] = new value_type(p);
    }
  return *(fKeepAlive[index]);
}

//_____________________________________________________________________________
template<typename BASE, typename DERIVED>
typename PHObjectHandleVectorv2<BASE,DERIVED>::value_type&
PHObjectHandleVectorv2<BASE,DERIVED>::get(const size_type& index)
{
   //check if fKeepAlive capacity  ok
  isAliveCapacityok();
  if ( !fKeepAlive[index] )
    {
      BASE* p = fArray[index];
      fKeepAlive[index] = new value_type(p);
    }
  return *(fKeepAlive[index]);
}

//_____________________________________________________________________________
template<typename BASE, typename DERIVED>
void
PHObjectHandleVectorv2<BASE,DERIVED>::identify(std::ostream& os) const
{
  os << "PHObjectHandleVectorv2<" << BASE::Class()->GetName()
     << "," << DERIVED::Class()->GetName()
     << ">::identify() " 
     << "size=" << size() 
     << " capacity=" << capacity()
     << " fArray.size=" << fArray.size()
     << " fArray.capacity=" << fArray.capacity()
     << std::endl;
  //check if fKeepAlive capacity  ok
  isAliveCapacityok();
  for ( size_t i = 0; i < capacity(); ++i ) 
    {
      os << i << " ptr=" << fArray[i]
         << " " << " kptr=";
      if ( fKeepAlive[i] )
        {
          os << fKeepAlive[i]->get() 
             << " use=" << fKeepAlive[i]->use_count()
             << " ";
          if ( fKeepAlive[i]->get() )
            {
              std::cout << (*(fKeepAlive[i]->get()));
            }
        }
      else
        {
          os << "0";
        }
      os << std::endl;
    }
}

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

//_____________________________________________________________________________
template<typename BASE, typename DERIVED>
typename PHObjectHandleVectorv2<BASE,DERIVED>::iterator
PHObjectHandleVectorv2<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.deepcopy();  
  fArray[pos-begin()] = (*pos).get();

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

//_____________________________________________________________________________
template<typename BASE, typename DERIVED>
bool
PHObjectHandleVectorv2<BASE,DERIVED>::remove(const size_type& index)
{
  if ( index < size() ) 
    {
      erase(begin()+index);
      //      delete fKeepAlive[index];
      //      fKeepAlive[index] = 0;
      //      fArray[index] = 0;
      return true;
    }
  else
    {
      return false;
    }
}

//_____________________________________________________________________________
template<typename BASE, typename DERIVED>
void
PHObjectHandleVectorv2<BASE,DERIVED>::reserve(const size_type& n)
{
  fArray.resize(n,0);
  fKeepAlive.resize(n,0);
  //  cout << PHWHERE << "::reserve fArray.size="
  //       << fArray.size() << " capacity=" << fArray.capacity()
  //       << endl;
}

//_____________________________________________________________________________
template<typename BASE, typename DERIVED>
void
PHObjectHandleVectorv2<BASE,DERIVED>::Reset()
{

  isAliveCapacityok();

  //  identify();

  for ( size_t i = 0; i < fKeepAlive.size(); ++i ) 
    {
      if ( fKeepAlive[i] == 0 )
        {
          //      cout << PHWHERE << "Deleting" << fArray[i] << endl;
          delete fArray[i];
          fArray[i] = 0;
        }
      else
        {
          delete fKeepAlive[i];
          fKeepAlive[i] = 0;
        }
    }
  fArray.clear();
  fArray.resize(capacity(),0);
  fKeepAlive.resize(capacity(),0);
  fSize=0;
}

//_____________________________________________________________________________
template<typename BASE, typename DERIVED>
bool
PHObjectHandleVectorv2<BASE,DERIVED>::resize(const size_type& newsize,
                                       const value_type& value)
{
  if ( newsize < size() )
    {
      erase(begin()+newsize,end());
      return true;
    }
  else
    {
      iterator it = insert(end(),newsize-size(),value); 
      if ( it != end() )
        {
          return true;
        }
      else
        {
          return false;
        }
    }
}

//_____________________________________________________________________________
template<typename BASE, typename DERIVED>
bool
PHObjectHandleVectorv2<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 PHObjectHandleVectorv2<BASE,DERIVED>::size_type
PHObjectHandleVectorv2<BASE,DERIVED>::size() const
{
  return fSize;
}
//_____________________________________________________________________________
template<typename BASE, typename DERIVED>
void
PHObjectHandleVectorv2<BASE,DERIVED>::isAliveCapacityok() const
{
  if (fKeepAlive.capacity()<capacity())
    {
      std::vector<value_type*> copyKeepAlive = fKeepAlive;

      fKeepAlive.resize(capacity(),0); 

      std::copy(copyKeepAlive.begin(),copyKeepAlive.end(),fKeepAlive.begin());
    }
}
#endif // __CINT__

#endif