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() = default;
  ObjectVector( const ObjectVector<TYPE>& ) = delete;
  ObjectVector& operator=( const ObjectVector<TYPE>& ) = delete;
  ObjectVector(ObjectVector&& rhs)
      : ObjectContainerBase(std::move(rhs))
      , m_vector{std::move(rhs.m_vector)}
  {
    std::for_each(begin(), end(), [this](TYPE* obj) {obj->setParent(this);});
  }

  ~ObjectVector() override {
    for( auto& i : m_vector )  {
      // Set the back pointer to 0 to avoid repetitional searching
      // for the object in the container, and deleting the object
      i->setParent (nullptr);
      delete i;
    }
  }

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


  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();
  }

  typename ObjectVector<TYPE>::size_type numberOfObjects() const override {
    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( value->parent() ) {
      const_cast<ObjectContainerBase*>(value->parent())->remove(value);
    }
    value->setParent(this);
    m_vector.push_back(value);
  }

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

  void pop_back () {
    auto 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(nullptr);
    delete position;
    // Removing from the container itself
    m_vector.pop_back();
  }

  long remove(ContainedObject* value) override {
    // Find the object of the value value
    auto i = std::find_if( begin(), end(), [&](const ContainedObject* j) { return j==value; } );
    if( i == end() )  {
      // Object cannot be released from the conatiner,
      // as it is not contained in it
      return StatusCode::FAILURE;
    }
    // Set the back pointer to 0 to avoid repetitional searching
    // for the object in the container and deleting the object
    (*i)->setParent (nullptr);
    erase(i);
    return StatusCode::SUCCESS;
  }

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

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

  void erase( typename ObjectVector<TYPE>::iterator first,
              typename ObjectVector<TYPE>::iterator last ) {
    for(auto 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(nullptr);
      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];
  }

  long index( const ContainedObject* obj ) const override {
    auto i = std::find_if( begin(), end(), [&](const ContainedObject *o)
                           { return o == obj; } );
    return i!=end() ? std::distance( begin(), i ) : -1 ;
  }

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

  std::ostream& fillStream( std::ostream& s ) const override {
    s << "class ObjectVector :    size = "
      << std::setw(12)
      << size() << "\n";
    // Output the base class
    //ObjectContainerBase::fillStream(s);
    if ( !empty() ) {
      s << "\nContents of the STL vector :";
      long   count = 0;
      for(const auto& i : m_vector) {
        s << "\nIndex "
          << std::setw(12)
          << count++
          << " of object of type " << *i;
      }
    }
    return s;
  }

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

#endif    // GAUDIKERNEL_OBJECTVECTOR_H