SharedObjectsContainer.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 <algorithm>
#include <vector>

template <class TYPE>
class SharedObjectsContainer : public ObjectContainerBase {
public:
  typedef std::vector<const TYPE*> ConstVector;
  // various types (to make STL happy)
  typedef typename ConstVector::value_type             value_type;
  typedef typename ConstVector::size_type              size_type;
  typedef typename ConstVector::reference              reference;
  typedef typename ConstVector::const_reference        const_reference;
  typedef typename ConstVector::iterator               iterator;
  typedef typename ConstVector::const_iterator         const_iterator;
  typedef typename ConstVector::reverse_iterator       reverse_iterator;
  typedef typename ConstVector::const_reverse_iterator const_reverse_iterator;
 
  SharedObjectsContainer()                                      = default;
  SharedObjectsContainer( SharedObjectsContainer&& )            = default;
  SharedObjectsContainer& operator=( SharedObjectsContainer&& ) = default;
  SharedObjectsContainer( const ConstVector& data ) : m_data( data ) {}
  SharedObjectsContainer( ConstVector&& data ) : m_data( std::move( data ) ) {}

  template <class DATA>
  SharedObjectsContainer( DATA first, DATA last ) : m_data( first, last ) {}
  template <class DATA, class PREDICATE>
  SharedObjectsContainer( DATA first, DATA last, const PREDICATE& cut ) {
    insert( first, last, cut );
  }

  const CLID& clID() const override { return SharedObjectsContainer<TYPE>::classID(); }
  static const CLID& classID() {
    static const CLID s_clid = ( ( static_cast<CLID>( -1 ) << 16 )    // 16 used and 16 empty bits
                                 & !CLID_ObjectVector                 // not an ObjectVector
                                 & !CLID_ObjectList                   // not an ObjectList
                                 & !static_cast<CLID>( 0x00030000 )   // not a  KeyedContainer/map
                                 & !static_cast<CLID>( 0x00040000 ) ) // not a  KeyedContainer/hashmap
                               + TYPE::classID();                     // the specific CLID from the contents
    //
    return s_clid;
  }

  inline const ConstVector& data() const { return m_data; }
  operator const ConstVector&() const { return data(); }
  size_type size() const { return m_data.size(); }
  bool empty() const { return m_data.empty(); }
  void push_back( const TYPE* object ) { m_data.push_back( object ); }
  void insert( const TYPE* object ) { m_data.push_back( object ); }
  template <class DATA>
  void insert( DATA first, DATA last ) {
    m_data.insert( end(), first, last );
  }

  template <class DATA, class PREDICATE>
  void insert( DATA first, DATA last, const PREDICATE& cut ) {
    m_data.reserve( m_data.size() + std::distance( first, last ) );
    std::copy_if( first, last, std::back_inserter( m_data ), std::cref( cut ) );
  }

  template <class OUTPUT, class PREDICATE>
  OUTPUT get( const PREDICATE& cut, OUTPUT output ) const {
    return std::copy_if( begin(), end(), output, std::cref( cut ) );
  }

  void erase( iterator i ) { m_data.erase( i ); }
  template <class PREDICATE>
  void erase( const PREDICATE& cut ) {
    m_data.erase( std::remove_if( begin(), end(), cut ), end() );
  }

  bool erase( const TYPE* object ) {
    auto i = std::find( begin(), end(), object );
    if ( end() == i ) { return false; }
    m_data.erase( i );
    return true;
  }

  reference operator[]( size_type index ) { return m_data[index]; }
  const_reference operator[]( size_type index ) const { return m_data[index]; }
  reference operator()( size_type index ) { return m_data[index]; }
  const_reference operator()( size_type index ) const { return m_data[index]; }
  reference at( size_type index ) { return m_data.at( index ); }
  const_reference        at( size_type index ) const { return m_data.at( index ); }
  iterator               begin() { return m_data.begin(); }
  iterator               end() { return m_data.end(); }
  const_iterator         begin() const { return m_data.begin(); }
  const_iterator         end() const { return m_data.end(); }
  reverse_iterator       rbegin() { return m_data.rbegin(); }
  reverse_iterator       rend() { return m_data.rend(); }
  const_reverse_iterator rbegin() const { return m_data.rbegin(); }
  const_reverse_iterator rend() const { return m_data.rend(); }
  reference front() { return m_data.front(); }
  const_reference front() const { return m_data.front(); }
  reference back() { return m_data.back(); }
  const_reference back() const { return m_data.back(); }
  bool operator==( const SharedObjectsContainer& right ) const { return &right == this || right.m_data == m_data; }
  bool operator==( const ConstVector& right ) const { return m_data == right; }
  bool operator<( const SharedObjectsContainer& right ) const { return m_data < right.m_data; }
  bool operator<( const ConstVector& right ) const { return m_data < right; }
  // ==========================================================================
  // ObjectContainerBase methods:
  // ==========================================================================
  long index( const ContainedObject* object ) const override {
    auto _i = std::find( begin(), end(), object );
    return end() != _i ? ( _i - begin() ) : -1;
  }

  const ContainedObject* containedObject( long index ) const override {
    if ( 0 > index || !( index < (long)size() ) ) { return nullptr; }
    return m_data[index];
  }
  ContainedObject* containedObject( long index ) override {
    if ( 0 > index || !( index < (long)size() ) ) { return nullptr; }
    return &const_cast<TYPE&>( *m_data[index] );
  }

  size_type numberOfObjects() const override { return m_data.size(); }
  long add( ContainedObject* object ) override {
    if ( !object ) { return -1; }
    TYPE* _obj = dynamic_cast<TYPE*>( object );
    if ( !_obj ) { return -1; }
    const size_type pos = size();
    push_back( _obj );
    return pos;
  }

  long remove( ContainedObject* value ) override {
    auto _i = std::find( begin(), end(), value );
    if ( end() == _i ) { return -1; }
    const size_type pos = _i - begin();
    m_data.erase( _i );
    return pos;
  }
 
private:
  ConstVector m_data; // the actual data
};