ObjectList.h

Go to the documentation of this file.

#ifndef GAUDIKERNEL_OBJECTLIST_H
#define GAUDIKERNEL_OBJECTLIST_H

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

#include <iomanip>
#include <list>

// 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