PHObjectHandleVector.h

Go to the documentation of this file.

#ifndef __PHOBJECTHANDLEVECTOR_H__
#define __PHOBJECTHANDLEVECTOR_H__

#include "PHObject.h"
#include "phool.h"
#include <iterator>
#include <cassert>
#include "PHObjectHandle.h"

template<typename BASE> class PHObjectHandle;
template<typename BASE> class PHObjectHandleVectorIterator;
template<typename BASE> class PHObjectHandleVector;

template<typename BASE>
class PHObjectHandleVectorIterator
{
public:

  typedef PHObjectHandleVectorIterator<BASE> iterator;
  typedef std::random_access_iterator_tag iterator_category;
  typedef PHObjectHandle<BASE> value_type;
  typedef PHObjectHandleVector<BASE> container;
  typedef int difference_type;
  typedef value_type& reference;
  typedef const value_type& const_reference;
  typedef value_type* pointer;

  PHObjectHandleVectorIterator() : fCont(0), fPos(0) {}

  PHObjectHandleVectorIterator(container* cont, unsigned int pos) 
    : fCont(cont), fPos(pos) 
  {
  }

  PHObjectHandleVectorIterator(const iterator& other)
  {
    fPos = other.fPos;
    fCont = other.fCont;
  }

  virtual ~PHObjectHandleVectorIterator() {}

  reference operator*();

  void increment() { ++fPos; }
  void decrement() { --fPos; }

  iterator& operator++() 
  { 
    increment(); return *this; 
  }
  iterator operator++(int)
  {
    iterator old = *this;
    increment();
    return old;
  }

  iterator& operator--() 
  {
    decrement(); return *this; 
  }
  iterator operator--(int) 
  { 
    iterator old = *this;
    decrement(); 
    return old; 
  }

  iterator& operator+=(difference_type n)
  { 
    fPos+=n; return *this; 
  }
  iterator operator+(difference_type n) const
  { 
    iterator newone = *this;
    newone += n;
    return newone;
  }

  iterator& operator-=(difference_type n)
  { 
    fPos-=n; return *this; 
  }
  iterator operator-(difference_type n) const
  { 
    iterator newone = *this;
    newone -= n;
    return newone;
  }

  bool operator==(const iterator& rhs) const
  {
    return (fCont==rhs.fCont && fPos==rhs.fPos); 
  }

  bool operator!=(const iterator& rhs) const
  {
    return (fCont!=rhs.fCont || fPos!=rhs.fPos); 
  }
  
  difference_type
  operator-(const iterator& other) const
  {
    return fPos - other.fPos;
  }

  difference_type
  operator+(const iterator& other) const
  {
    return fPos + other.fPos;
  }

  iterator
  operator[](difference_type n) const
  {
    return iterator(fCont,n);
  }

  bool operator < (const iterator& other) const
  {
    return ( *this - other < 0 );
  }

  bool operator <= (const iterator& other) const
  {
    return ( *this - other <= 0 );
  }

  bool operator > (const iterator& other)
  {
    return ( *this - other > 0 );
  }
 
  bool operator >= (const iterator& other)
  {
    return ( *this - other >= 0);
  }

private:
  container* fCont;
  unsigned int fPos;

  ClassDefT(PHObjectHandleVectorIterator,1)
};

ClassDefT2(PHObjectHandleVectorIterator,BASE)

ClassImpT(PHObjectHandleVectorIterator,BASE)


template<typename BASE>
class PHObjectHandleVectorConstIterator
{
public:

  typedef PHObjectHandleVectorConstIterator<BASE> iterator;
  typedef std::random_access_iterator_tag iterator_category;
  typedef const PHObjectHandle<BASE> value_type;
  typedef const PHObjectHandleVector<BASE> container;
  typedef int difference_type;
  typedef value_type& reference;
  typedef const value_type& const_reference;
  typedef value_type* pointer;

  PHObjectHandleVectorConstIterator() : fCont(0), fPos(0) {}

  PHObjectHandleVectorConstIterator(const container* cont, unsigned int pos) 
    : fCont(cont), fPos(pos) 
  {
  }

  PHObjectHandleVectorConstIterator(const iterator& other)
  {
    fPos = other.fPos;
    fCont = other.fCont;
  }

  virtual ~PHObjectHandleVectorConstIterator() {}

  const_reference operator*();

  void increment() { ++fPos; }
  void decrement() { --fPos; }

  iterator& operator++() 
  { 
    increment(); return *this; 
  }
  iterator operator++(int)
  {
    iterator old = *this;
    increment();
    return old;
  }

  iterator& operator--() 
  {
    decrement(); return *this; 
  }
  iterator operator--(int) 
  { 
    iterator old = *this;
    decrement(); 
    return old; 
  }

  iterator& operator+=(difference_type n)
  { 
    fPos+=n; return *this; 
  }
  iterator operator+(difference_type n) const
  { 
    iterator newone = *this;
    newone += n;
    return newone;
  }

  iterator& operator-=(difference_type n)
  { 
    fPos-=n; return *this; 
  }
  iterator operator-(difference_type n) const
  { 
    iterator newone = *this;
    newone -= n;
    return newone;
  }

  bool operator==(const iterator& rhs) const
  {
    return (fCont==rhs.fCont && fPos==rhs.fPos); 
  }

  bool operator!=(const iterator& rhs) const
  {
    return (fCont!=rhs.fCont || fPos!=rhs.fPos); 
  }
  
  difference_type
  operator-(const iterator& other) const
  {
    return fPos - other.fPos;
  }

  difference_type
  operator+(const iterator& other) const
  {
    return fPos + other.fPos;
  }

  iterator
  operator[](difference_type n) const
  {
    return iterator(fCont,n);
  }

  bool operator < (const iterator& other) const
  {
    return ( *this - other < 0 );
  }

  bool operator <= (const iterator& other) const
  {
    return ( *this - other <= 0 );
  }

  bool operator > (const iterator& other)
  {
    return ( *this - other > 0 );
  }
 
  bool operator >= (const iterator& other)
  {
    return ( *this - other >= 0);
  }

private:
  container* fCont;
  unsigned int fPos;

  ClassDefT(PHObjectHandleVectorConstIterator,1)
};

ClassDefT2(PHObjectHandleVectorConstIterator,BASE)

ClassImpT(PHObjectHandleVectorConstIterator,BASE)

template<typename BASE>
PHObjectHandle<BASE>* 
make_dummy()
{ 
  // this is just to pacify the compiler w.r.t. the
  // PHObjectHandleVector::get methods (which have to return
  // something, even if dummy -remember that anyway
  // PHObjectHandleVector<BASE> ought to be pure virtual so you
  // won't use it directly).
  return new PHObjectHandle<BASE>;
}


//_____________________________________________________________________________
template<typename BASE>
class PHObjectHandleVector : public PHObject
{
public:

  typedef PHObjectHandle<BASE> value_type;
  typedef const value_type& const_reference;
  typedef value_type& reference;
  typedef unsigned int size_type;
  typedef PHObjectHandleVectorIterator<BASE> iterator;
  typedef PHObjectHandleVectorConstIterator<BASE> const_iterator;

  virtual ~PHObjectHandleVector() {}

  virtual value_type& add(const size_type& index) = 0;

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

  iterator begin()
  { return iterator(this,0); }

  const_iterator begin() const
  { return const_iterator(this,0); }

  virtual size_type capacity() const
  { PHOOL_VIRTUAL_WARNING; return 0; }

  virtual PHObjectHandleVector<BASE>* clone() const
  { PHOOL_VIRTUAL_WARNING; return 0; }

  virtual PHObjectHandleVector<BASE>* create() const
  { PHOOL_VIRTUAL_WARNING; return 0; }

  virtual bool empty() const
  { PHOOL_VIRTUAL_WARNING; return true; }

  iterator end()
  { return iterator(this,size()); }

  const_iterator end() const
  { return const_iterator(this,size()); }

  virtual iterator erase(iterator first, iterator last)
  { PHOOL_VIRTUAL_WARNING; return first; }

  virtual iterator erase(iterator pos)
  { PHOOL_VIRTUAL_WARNING; return pos; }

  virtual const_reference get(const size_type& index) const
  { PHOOL_VIRTUAL_WARNING; return *make_dummy<BASE>(); }

  virtual reference get(const size_type& index)
  { PHOOL_VIRTUAL_WARNING; return *make_dummy<BASE>(); }

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

  virtual iterator insert(iterator pos, size_t n, const value_type& value)
  { PHOOL_VIRTUAL_WARNING; return pos; }

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

  virtual int isValid() const
  { PHOOL_VIRTUAL_WARNING; return 0; }

  virtual bool remove(const size_type& index)
  { PHOOL_VIRTUAL_WARNING; return false; }

  virtual void reserve(const size_type& thesize)
  { PHOOL_VIRTUAL_WARNING; }

  virtual void Reset()
  { PHOOL_VIRTUAL_WARNING; }

  virtual bool resize(const size_type& newsize, const value_type& value)
  { PHOOL_VIRTUAL_WARNING; return false; }

  virtual bool resize(const size_type& newsize)
  { PHOOL_VIRTUAL_WARNING; return false;}

  virtual size_type size() const
  { PHOOL_VIRTUAL_WARNING; return 0; }

protected:

  PHObjectHandleVector<BASE>& operator=(const PHObjectHandleVector<BASE>&);

  ClassDefT(PHObjectHandleVector,1)
};

ClassDefT2(PHObjectHandleVector,BASE)
  ClassImpT(PHObjectHandleVector,BASE)

#ifndef __CINT__

//_____________________________________________________________________________
//_____________________________________________________________________________
  
template<typename BASE>
typename PHObjectHandleVectorIterator<BASE>::reference
PHObjectHandleVectorIterator<BASE>::operator*()
{
  return fCont->get(fPos);
}

template<typename BASE>
typename PHObjectHandleVectorConstIterator<BASE>::const_reference
PHObjectHandleVectorConstIterator<BASE>::operator*()
{
  return fCont->get(fPos);
}

#endif

#endif