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/ClassID.h"
#include "GaudiKernel/Kernel.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; }
  // ==========================================================================
  // ObjectContainerBase methods:
  // ==========================================================================
public:
  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
// ============================================================================