ObjectList.h

Go to the documentation of this file.

#ifndef GAUDIKERNEL_OBJECTLIST_H
#define GAUDIKERNEL_OBJECTLIST_H


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

#include <list>
#include <iomanip>


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

template <class TYPE>
class ObjectList : public ObjectContainerBase {

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

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

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

  typedef typename std::list<TYPE*>::reverse_iterator          reverse_iterator;
  typedef typename std::list<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:
  ObjectList() = default;

  ObjectList( const ObjectList<TYPE>& ) = delete;
  ObjectList& operator=( const ObjectList<TYPE>& ) = delete;

  ~ObjectList() override {
    clear();
  }

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

  typename ObjectList<TYPE>::iterator begin () {
    return m_list.begin();
  }

  typename ObjectList<TYPE>::const_iterator begin () const {
    return m_list.begin();
  }

  typename ObjectList<TYPE>::iterator end () {
    return m_list.end();
  }

  typename ObjectList<TYPE>::const_iterator end () const {
    return m_list.end();
  }

  typename ObjectList<TYPE>::reverse_iterator rbegin () {
    return m_list.rbegin();
  }

  typename ObjectList<TYPE>::const_reverse_iterator rbegin () const {
    return m_list.rbegin();
  }

  typename ObjectList<TYPE>::reverse_iterator rend () {
    return m_list.rend();
  }

  typename ObjectList<TYPE>::const_reverse_iterator rend () const {
    return m_list.rend();
  }

  typename ObjectList<TYPE>::size_type size () const {
    // C++11: std::list::size is constant (pre C++11 it could be linear!)
    return m_list.size();
  }
  typename ObjectList<TYPE>::size_type numberOfObjects() const override {
    return m_list.size();
  }

  typename ObjectList<TYPE>::size_type max_size () const {
    return m_list.max_size();
  }

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

  typename ObjectList<TYPE>::reference front () {
    return m_list.front();
  }

  typename ObjectList<TYPE>::const_reference front () const {
    return m_list.front();
  }

  typename ObjectList<TYPE>::reference back () {
    return m_list.back();
  }

  typename ObjectList<TYPE>::const_reference back () const {
    return m_list.back();
  }

  void push_back( typename ObjectList<TYPE>::const_reference value ) {
    if( value->parent() ) {
      const_cast<ObjectContainerBase*>(value->parent())->remove(value);
    }
    value->setParent(this);
    m_list.push_back(value);
  }

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

  void pop_back () {
    auto position = m_list.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_list.pop_back();
  }

  long remove(ContainedObject* value) override {
    // Find the object of value value
    long idx = 0;
    auto iter = std::find_if( begin(), end(), [&](const ContainedObject* i) { return i == value; } );
    if( iter == end() )  {
      // Object cannot be released from the container,
      // as it is not contained in it
      return -1;
    }

    // Set the back pointer to 0 to avoid repetitional searching
    // for the object in the container and deleting the object
    (*iter)->setParent(nullptr);
    erase(iter);
    return idx;
  }

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

  void erase( typename ObjectList<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_list.erase(position);
  }

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

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

  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  dist < size() ? *std::next( begin(), dist ) : nullptr;
  }

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

private:
  std::list<TYPE*> m_list;
};


#endif    // GAUDI_OBJECTLIST_H