ObjectVector.h

Go to the documentation of this file.

#ifndef GAUDIKERNEL_OBJECTVECTOR_H
#define GAUDIKERNEL_OBJECTVECTOR_H


// Include files
#include "GaudiKernel/Kernel.h"
#include "GaudiKernel/ClassID.h"
#include "GaudiKernel/StreamBuffer.h"
#include "GaudiKernel/ObjectContainerBase.h"

#include <vector>
#include <iomanip>


// Definition of the CLID for this class defined in ClassID.h
//static const CLID CLID_ObjectList = (1<<17);  // ObjectVector   (bit 17 set)

template <class TYPE>
class ObjectVector : public ObjectContainerBase {

public:
  typedef TYPE                                                 contained_type;
  typedef typename std::vector<TYPE*>::value_type              value_type;

  typedef typename std::vector<TYPE*>::reference               reference;
  typedef typename std::vector<TYPE*>::const_reference         const_reference;

  typedef typename std::vector<TYPE*>::iterator                iterator;
  typedef typename std::vector<TYPE*>::const_iterator          const_iterator;

  typedef typename std::vector<TYPE*>::reverse_iterator        reverse_iterator;
  typedef typename std::vector<TYPE*>::const_reverse_iterator  const_reverse_iterator;
#ifdef _WIN32
  typedef typename std::vector<TYPE*>::_Tptr                   pointer;
  typedef typename std::vector<TYPE*>::_Ctptr                  const_pointer;
#else
  typedef typename std::vector<TYPE*>::pointer                 pointer;
  typedef typename std::vector<TYPE*>::const_pointer           const_pointer;
#endif

public:
  ObjectVector()
    : m_vector(0) { }
  ObjectVector( const char* /* name */ )
    : m_vector(0) { }
  ObjectVector( const ObjectVector<TYPE>& value )
    : ObjectContainerBase(), m_vector(value.m_vector) { }

  virtual ~ObjectVector() {
    for( typename ObjectVector<TYPE>::iterator i = begin(); i != end(); i++ ) {
      // Set the back pointer to 0 to avoid repetitional searching
      // for the object in the container, and deleting the object
      (*i)->setParent (0);
      delete *i;
    }
  }

  virtual const CLID& clID() const {
    return ObjectVector<TYPE>::classID();
  }
  static const CLID& classID() {
    static CLID clid = TYPE::classID() + CLID_ObjectVector;
    return clid;
  }

  const ObjectVector<TYPE>& operator = (const ObjectVector<TYPE> &right) {
    m_vector = right.m_vector;
    return *this;
  }

  typename ObjectVector<TYPE>::iterator begin () {
    return m_vector.begin();
  }

  typename ObjectVector<TYPE>::const_iterator begin () const {
    return m_vector.begin();
  }

  typename ObjectVector<TYPE>::iterator end () {
    return m_vector.end();
  }

  typename ObjectVector<TYPE>::const_iterator end () const {
    return m_vector.end();
  }

  typename ObjectVector<TYPE>::reverse_iterator rbegin () {
    return m_vector.rbegin();
  }

  typename ObjectVector<TYPE>::const_reverse_iterator rbegin () const {
    return m_vector.rbegin();
  }

  typename ObjectVector<TYPE>::reverse_iterator rend () {
    return m_vector.rend();
  }

  typename ObjectVector<TYPE>::const_reverse_iterator rend () const {
    return m_vector.rend();
  }

  typename ObjectVector<TYPE>::size_type size () const {
    return m_vector.size();
  }

  virtual typename ObjectVector<TYPE>::size_type numberOfObjects() const {
    return m_vector.size();
  }

  typename ObjectVector<TYPE>::size_type max_size () const {
    return m_vector.max_size();
  }

  typename ObjectVector<TYPE>::size_type capacity () const {
    return m_vector.capacity();
  }

  void reserve( typename ObjectVector<TYPE>::size_type value ) {
    m_vector.reserve( value );
  }

  bool empty () const {
    return m_vector.empty();
  }

  typename ObjectVector<TYPE>::reference front () {
    return m_vector.front();
  }

  typename ObjectVector<TYPE>::const_reference front () const {
    return m_vector.front();
  }

  typename ObjectVector<TYPE>::reference back () {
    return m_vector.back();
  }

  typename ObjectVector<TYPE>::const_reference back () const {
    return m_vector.back();
  }

  void push_back( typename ObjectVector<TYPE>::const_reference value )  {
    if( 0 != value->parent() ) {
      const_cast<ObjectContainerBase*>(value->parent())->remove(value);
    }
    value->setParent(this);
    m_vector.push_back(value);
  }

  virtual long add(ContainedObject* pObject) {
    try {
      typename ObjectVector<TYPE>::value_type ptr =
            dynamic_cast<typename ObjectVector<TYPE>::value_type>(pObject);
      if ( 0 != ptr ) {
        push_back(ptr);
        return m_vector.size()-1;
      }
    }
    catch(...) {
    }
    return -1;
  }

  void pop_back () {
    typename ObjectVector<TYPE>::value_type position = m_vector.back();
    // Set the back pointer to 0 to avoid repetitional searching
    // for the object in the container, and deleting the object
    position->setParent (0);
    delete position;
    // Removing from the container itself
    m_vector.pop_back();
  }

  virtual long remove(ContainedObject* value) {
    // Find the object of the value value
    typename ObjectVector<TYPE>::iterator i;
    for( i = begin(); i != end(); i++ ) {
      if( value == *i ) {
        break;
      }
    }
    if( end() == i )  {
      // Object cannot be released from the conatiner,
      // as it is not contained in it
      return StatusCode::FAILURE;
    }
    else  {
      // Set the back pointer to 0 to avoid repetitional searching
      // for the object in the container and deleting the object
      (*i)->setParent (0);
      erase(i);
      return StatusCode::SUCCESS;
    }
  }

  typename ObjectVector<TYPE>::iterator insert( typename ObjectVector<TYPE>::iterator position,
                                                typename ObjectVector<TYPE>::const_reference value ) {
    value->setParent(this);
    typename ObjectVector<TYPE>::iterator i = m_vector.insert(position, value);
    return i;
  }

  void erase( typename ObjectVector<TYPE>::iterator position ) {
    if( 0 != (*position)->parent() ) {
      // Set the back pointer to 0 to avoid repetitional searching
      // for the object in the container, and deleting the object
      (*position)->setParent (0);
      delete *position;
    }
    // Removing from the container itself
    m_vector.erase(position);
  }

  void erase( typename ObjectVector<TYPE>::iterator first,
              typename ObjectVector<TYPE>::iterator last ) {
    for(typename ObjectVector<TYPE>::iterator i = first; i != last; i++ ) {
      // Set the back pointer to 0 to avoid repetitional searching
      // for the object in the container, and deleting the object
      (*i)->setParent(0);
      delete *i;
    }
    // Removing from the container itself
    m_vector.erase(first, last);
  }

  void clear()    {
    erase(begin(), end());
  }

  typename ObjectVector<TYPE>::reference
    operator[] (typename ObjectVector<TYPE>::size_type n) {
    return m_vector[n];
  }

  typename ObjectVector<TYPE>::const_reference
    operator[] (typename ObjectVector<TYPE>::size_type n) const {
    return m_vector[n];
  }

  virtual long index( const ContainedObject* obj ) const {
    long i;
    for( i = 0; i < (long)m_vector.size(); i++ ) {
      if( m_vector[i] == obj ) {
        return i;
      }
    }
    return -1;
  }

  virtual ContainedObject* containedObject( long dist ) const {
    return m_vector[dist];
  }

  virtual std::ostream& fillStream( std::ostream& s ) const {
    s << "class ObjectVector :    size = "
      << std::setw(12)
      << size() << "\n";
    // Output the base class
    //ObjectContainerBase::fillStream(s);
    if ( 0 != size() ) {
      s << "\nContents of the STL vector :";
      long   count = 0;
      typename ObjectVector<TYPE>::const_iterator iter;
      for( iter = m_vector.begin(); iter != m_vector.end(); iter++, count++ ) {
        s << "\nIndex "
          << std::setw(12)
          << count
          << " of object of type " << **iter;
      }
    }
    return s;
  }

private:
  std::vector<TYPE*>     m_vector;
};

#endif    // GAUDIKERNEL_OBJECTVECTOR_H