ObjectList.h

Go to the documentation of this file.

/***********************************************************************************\
* (c) Copyright 1998-2025 CERN for the benefit of the LHCb and ATLAS collaborations *
*                                                                                   *
* This software is distributed under the terms of the Apache version 2 licence,     *
* copied verbatim in the file "LICENSE".                                            *
*                                                                                   *
* In applying this licence, CERN does not waive the privileges and immunities       *
* granted to it by virtue of its status as an Intergovernmental Organization        *
* or submit itself to any jurisdiction.                                             *
\***********************************************************************************/
#pragma once
 
#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;
  }
 
  const ContainedObject* containedObject( long dist ) const override {
    return dist < size() ? *std::next( begin(), dist ) : nullptr;
  }
  ContainedObject* containedObject( long dist ) 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;
};