SharedObjectsContainer.h

Go to the documentation of this file.

#ifndef GAUDIKERNEL_SHAREDOBJECTSCONTAINER_H
#define GAUDIKERNEL_SHAREDOBJECTSCONTAINER_H 1
// ============================================================================
// Include files
// ============================================================================
// STD & STL
// ============================================================================
#include <algorithm>
#include <vector>
// ============================================================================
// GaudiKernel
// ============================================================================
#include "GaudiKernel/Kernel.h"
#include "GaudiKernel/ClassID.h"
#include "GaudiKernel/ObjectContainerBase.h"
// ============================================================================
template <class TYPE>
class SharedObjectsContainer : public ObjectContainerBase
{
public:
  // ==========================================================================
  typedef std::vector<const TYPE*>   ConstVector ;
  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 ;
  // ==========================================================================
public:
  // ==========================================================================
  // the default constructor (creates the empty vector)
  SharedObjectsContainer () = default;
  // move constructor and move assignement
  SharedObjectsContainer(SharedObjectsContainer&&) = default;
  SharedObjectsContainer& operator=(SharedObjectsContainer&&) = default;
  // the constructor from the data
  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 ) ;
  }
  // ==========================================================================
public:
  // ==========================================================================
  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;
  }
  // ==========================================================================
public:
  // ==========================================================================
  inline const ConstVector& data    () const { return m_data ; }
  operator const ConstVector& () const { return data () ; }
  // ==========================================================================
public:
  // ==========================================================================
  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 ;
  }
  // ==========================================================================
public:
  // ==========================================================================
  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) ; }
  // ==========================================================================
public:
  // ==========================================================================
  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   () ; }
  // ==========================================================================
public:
  // ==========================================================================
  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  () ; }
  // ==========================================================================
public:
  // ==========================================================================
  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        ; }
  // ==========================================================================
public: // ObjectContainerBase methods:
  // ==========================================================================
  long index( const ContainedObject* object ) const override
  {
    auto _i = std::find ( begin() , end() , object ) ;
    return end() != _i ? ( _i - begin() ) : -1 ;                  // RETURN
  }
  ContainedObject* containedObject ( long index ) const override
  {
    if ( 0 > index || !(index < (long) size () ) ) { return nullptr; }    // RETURN
    const ContainedObject* co = m_data[index] ;
    return const_cast<ContainedObject*>( co ) ;
  }
  size_type numberOfObjects() const override { return m_data.size() ; }
  long add ( ContainedObject* object) override
  {
    if ( !object ) { return -1 ; }                           // RETURN
    TYPE* _obj = dynamic_cast<TYPE*> ( object ) ;
    if ( !_obj   ) { return -1 ; }                           // RETURN
    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 ; }                          // RETURN
    const size_type pos = _i - begin() ;
    m_data.erase ( _i ) ;
    return pos ;                                                // RETURN
  }
  // ==========================================================================
private:
  // ==========================================================================
  // the actual data
  ConstVector m_data ; // the actual data
  // ==========================================================================
};
// ============================================================================
// The END
// ============================================================================
#endif // GAUDIKERNEL_SHAREDOBJECTSCONTAINER_H
// ============================================================================