ObjectVector.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 <vector>
 
// 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;
 
  typedef typename std::vector<TYPE*>::pointer       pointer;
  typedef typename std::vector<TYPE*>::const_pointer const_pointer;
 
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 0;
    }
    long idx = std::distance( begin(), i );
    // 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 idx;
  }

  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 const* containedObject( long dist ) const override { return m_vector[dist]; }
  ContainedObject*       containedObject( long dist ) 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;
};