KeyedContainer.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/KeyedObject.h>
#include <GaudiKernel/KeyedObjectManager.h>
#include <GaudiKernel/ObjectContainerBase.h>
#include <algorithm>
#include <iterator>
 
namespace GaudiDict {
  template <class T>
  struct KeyedContainerDict;
}

template <class DATATYPE, class MAPPING = Containers::HashMap>
class GAUDI_API KeyedContainer : public ObjectContainerBase {
  friend struct GaudiDict::KeyedContainerDict<DATATYPE>;
 
public:
  typedef DATATYPE contained_type;
  typedef MAPPING container_type;


  typedef typename std::vector<contained_type*> seq_type;
  typedef typename contained_type::key_type key_type;
  typedef typename seq_type::value_type value_type;
  typedef typename seq_type::reference reference;
  typedef typename seq_type::const_reference const_reference;
  typedef typename seq_type::iterator iterator;
  typedef typename seq_type::const_iterator const_iterator;
  typedef typename seq_type::reverse_iterator reverse_iterator;
  typedef typename seq_type::const_reverse_iterator const_reverse_iterator;
private:
  typedef typename Containers::traits<container_type, contained_type> traits;


  container_type m_cont;
  seq_type m_sequential;
  seq_type* m_random;

#ifdef CHECK_KEYED_CONTAINER
  value_type i_object( const key_type& k ) const {
    if ( 0 == m_cont.isDirect() ) {
      if ( traits::checkBounds( m_random, k ) ) {
        value_type p = *( m_random->begin() + traits::hash( k ) );
        if ( traits::checkKey( p, k ) ) { return p; }
      }
      return 0;
    }
    value_type p = value_type( m_cont.object( traits::hash( k ) ) );
    return traits::checkKey( p, k ) ? p : 0;
  }
#else
  inline value_type i_object( const key_type& k ) const {
    return 0 == m_cont.isDirect() ? value_type( *( m_random->begin() + traits::hash( k ) ) )
                                  : value_type( m_cont.object( traits::hash( k ) ) );
  }
#endif
  long i_erase( const_reference v, const key_type& k ) {
    value_type p = value_type( m_cont.erase( traits::hash( k ), v ) );
    if ( p ) {
      if ( p->parent() == this ) { p->setParent( 0 ); }
    }
    return traits::release( p ) <= 0 ? (long)Containers::OBJ_ERASED : (long)Containers::OBJ_DELETED;
  }

  struct _InsertRelease {
    KeyedContainer<DATATYPE, MAPPING>* m_obj;
    _InsertRelease( KeyedContainer<DATATYPE, MAPPING>* p ) : m_obj( p ) {}
    void operator()( value_type p ) {
      m_obj->insert( p );
      traits::release( p );
    }
  };

  struct _RemoveRelease {
    ObjectContainerBase* m_obj;
    _RemoveRelease( ObjectContainerBase* p ) : m_obj( p ) {}
    void operator()( value_type p ) {
      const ObjectContainerBase* par = p->parent();
      if ( par == m_obj ) { p->setParent( 0 ); }
      traits::release( p );
    }
  };

 
public:

  KeyedContainer( void ) {
    // avoid problems with strict-aliasing rules
    seq_type** rptr = &m_random;
    seq_type*  sptr = &m_sequential;
    m_cont.setup( (void*)sptr, (void**)rptr );
  }
  KeyedContainer( KeyedContainer&& other )
      : ObjectContainerBase( std::move( other ) )
      , m_cont( std::move( other.m_cont ) )
      , m_sequential( std::move( other.m_sequential ) ) {
    m_cont.setup( (void*)&m_sequential, (void**)&m_random );
    std::for_each( begin(), end(), [this]( ContainedObject* obj ) { obj->setParent( this ); } );
 
    other.m_cont.setup( (void*)&other.m_sequential, (void**)&other.m_random );
  }
  KeyedContainer( const KeyedContainer& ) = delete;
  ~KeyedContainer() override;


  const CLID& clID() const override { return this->classID(); }
  static const CLID& classID() {
    static CLID clid = contained_type::classID() + container_type::classID();
    return clid;
  }



  size_type numberOfObjects() const override { return m_sequential.size(); }
  long add( ContainedObject* pObject ) override;

  long remove( ContainedObject* pObject ) override;

  ContainedObject*       containedObject( long key_value ) override { return i_object( traits::makeKey( key_value ) ); }
  ContainedObject const* containedObject( long key_value ) const override {
    return i_object( traits::makeKey( key_value ) );
  }

  long index( const ContainedObject* p ) const override;
  virtual size_type containedObjects( std::vector<ContainedObject*>& v ) const;


  size_type size() const { return m_sequential.size(); }
  bool empty() const { return m_sequential.empty(); }
  void reserve( size_type value ) { m_cont.reserve( value ); }
  void clear() { erase( begin(), end() ); }
  virtual const std::vector<const ContainedObject*>* containedObjects() const;
  StatusCode update() override;


  iterator begin() { return m_sequential.begin(); }
  const_iterator begin() const { return m_sequential.begin(); }
  iterator end() { return m_sequential.end(); }
  const_iterator end() const { return m_sequential.end(); }
  reverse_iterator rbegin() { return m_sequential.rbegin(); }
  const_reverse_iterator rbegin() const { return m_sequential.rbegin(); }
  reverse_iterator rend() { return m_sequential.rend(); }
  const_reverse_iterator rend() const { return m_sequential.rend(); }


  value_type object( const key_type& kval ) const { return i_object( kval ); }

  value_type operator()( const key_type& kval ) const { return i_object( kval ); }


  long erase( const key_type& kval ) { return i_erase( 0, kval ); }

  long erase( const value_type val ) { return ( val ) ? i_erase( val, val->key() ) : (long)Containers::OBJ_NOT_FOUND; }

  long erase( iterator pos ) { return erase( *pos ); }

  void erase( iterator pos_start, iterator pos_stop, bool use_temp = false );

  const key_type& insert( const value_type val, const key_type& kval );
 
  const key_type& insert( std::unique_ptr<contained_type> val, const key_type& kval ) {
    return insert( val.release(), kval );
  }

  const key_type& insert( const value_type val );
 
  const key_type& insert( std::unique_ptr<contained_type> val ) { return insert( val.release() ); }
};

 
// Destructor
template <class DATATYPE, class MAPPING>
inline KeyedContainer<DATATYPE, MAPPING>::~KeyedContainer() {
  clear();
  m_cont.clear();
}
 
// Configure direct access
template <class DATATYPE, class MAPPING>
inline StatusCode KeyedContainer<DATATYPE, MAPPING>::update() {
  int count = 0;
  m_cont.clearDirect();
  for ( typename seq_type::value_type v : m_sequential ) {
    if ( v ) {
      if ( !v->hasKey() ) {
        traits::setKey( v, v->key() );
        traits::addRef( v );
      }
      long k0 = traits::hash( v->key() );
      if ( m_cont.insertDirect( this, v, v, k0 ) == Containers::OBJ_INSERTED ) {}
    } else {
      ++count;
    }
  }
  if ( count > 0 ) { Containers::cannotInsertToContainer(); }
  return StatusCode::SUCCESS;
}
 
// Retrieve the full content of the object container by reference.
template <class DATATYPE, class MAPPING>
inline const std::vector<const ContainedObject*>* KeyedContainer<DATATYPE, MAPPING>::containedObjects() const {
  return reinterpret_cast<const std::vector<const ContainedObject*>*>( ( 0 == m_cont.isDirect() ) ? m_random
                                                                                                  : &m_sequential );
}
 
template <class DATATYPE, class MAPPING>
inline const typename KeyedContainer<DATATYPE, MAPPING>::key_type&
KeyedContainer<DATATYPE, MAPPING>::insert( const value_type val, const key_type& kval ) {
  if ( val ) {
    long k0 = traits::hash( kval );
    if ( !val->hasKey() || ( traits::hash( val->key() ) == k0 ) ) {
      if ( m_cont.insert( this, val, val, k0 ) == Containers::OBJ_INSERTED ) {
        if ( !val->hasKey() ) traits::setKey( val, kval );
        traits::addRef( val );
        return val->key();
      }
    }
  }
  // Cannot insert object...indicate bad object insertion...
  Containers::cannotInsertToContainer();
  return val->key();
}
 
// Insert object
template <class DATATYPE, class MAPPING> // inline
const typename KeyedContainer<DATATYPE, MAPPING>::key_type&
KeyedContainer<DATATYPE, MAPPING>::insert( const value_type val ) {
  if ( 0 != val ) {
    if ( val->hasKey() ) {
      if ( m_cont.insert( this, val, val, traits::hash( val->key() ) ) == Containers::OBJ_INSERTED ) {
        traits::addRef( val );
        return val->key();
      }
    }
    long k0;
    if ( m_cont.insert( this, val, val, &k0 ) == Containers::OBJ_INSERTED ) {
      traits::setKey( val, traits::makeKey( k0 ) );
      traits::addRef( val );
      return val->key();
    }
  }
  // Cannot insert object...indicate bad object insertion...
  Containers::cannotInsertToContainer();
  return val->key();
}
 
template <class DATATYPE, class MAPPING>
inline long KeyedContainer<DATATYPE, MAPPING>::index( const ContainedObject* p ) const {
  const contained_type* ptr = dynamic_cast<const contained_type*>( p );
  if ( ptr ) return traits::identifier( ptr->key() );
  return -1;
}
 
// Retrieve the full content of the object container.
template <class DATATYPE, class MAPPING>
inline typename KeyedContainer<DATATYPE, MAPPING>::size_type
KeyedContainer<DATATYPE, MAPPING>::containedObjects( std::vector<ContainedObject*>& vec ) const {
  vec.clear();
  vec.reserve( size() );
  for ( typename seq_type::value_type v : m_sequential ) {
    ContainedObject* p = const_cast<typename seq_type::value_type>( v );
    vec.push_back( p );
  }
  return vec.size();
}
 
// ObjectContainerBase overload: Add an object to the container.
template <class DATATYPE, class MAPPING>
inline long KeyedContainer<DATATYPE, MAPPING>::add( ContainedObject* pObject ) {
  return traits::identifier( insert( dynamic_cast<typename seq_type::value_type>( pObject ) ) );
}
 
// ObjectContainerBase overload: Remove an object from the container.
template <class DATATYPE, class MAPPING>
inline long KeyedContainer<DATATYPE, MAPPING>::remove( ContainedObject* p ) {
  contained_type* p1 = dynamic_cast<contained_type*>( p );
  if ( p1 ) { // Normal case; object still fully intact
    return this->erase( p1 );
  } else if ( p ) {
    const ObjectContainerBase* par = p->parent();
    // The following should never occur: object is in a funny state,
    // Because the parent was explicitly set to NULL in the
    // KeyeObject destructor.
    // - It cannot be a KeyedObject:  It would not have a parent
    // - Still the parent is present: We are not in the destructor
    //                                of KeyedObject
    if ( par ) { Containers::invalidContainerOperation(); }
    return m_cont.erase( 0, p ) == 0 ? (long)Containers::OBJ_ERASED : (long)Containers::OBJ_NOT_FOUND;
  }
  return (long)Containers::OBJ_NOT_FOUND;
}
 
template <class DATATYPE, class MAPPING>
inline void KeyedContainer<DATATYPE, MAPPING>::erase( iterator start_pos, iterator stop_pos, bool use_tmp ) {
  bool is_start = start_pos == m_sequential.begin();
  bool is_stop  = stop_pos == m_sequential.end();
  if ( is_start && is_stop ) {
    // Nothing special. Taken care of by Keyed object manager
  } else if ( is_start || is_stop || use_tmp ) {
    std::vector<DATATYPE*> tmp( m_sequential.begin(), start_pos );
    tmp.insert( tmp.end(), stop_pos, m_sequential.end() );
    std::for_each( tmp.begin(), tmp.end(), traits::addRef );
    this->erase( m_sequential.begin(), m_sequential.end() );
    std::for_each( tmp.begin(), tmp.end(), _InsertRelease( this ) );
    return;
  }
  std::for_each( start_pos, stop_pos, _RemoveRelease( this ) );
  seq_type*                    sptr = &m_sequential; // avoid problems with strict-aliasing rules
  std::vector<void*>*          v    = reinterpret_cast<std::vector<void*>*>( sptr );
  std::vector<void*>::iterator i1   = v->begin() + std::distance( m_sequential.begin(), start_pos );
  std::vector<void*>::iterator i2   = v->begin() + std::distance( m_sequential.begin(), stop_pos );
  m_cont.erase( i1, i2 ); // cppcheck-suppress iterators1
}