KeyedContainer.h

Go to the documentation of this file.

#ifndef GAUDIKERNEL_KEYEDCONTAINER_H
#define GAUDIKERNEL_KEYEDCONTAINER_H

// Include files
#include <algorithm>
#include <iterator>

namespace GaudiDict
{
  template <class T>
  struct KeyedContainerDict;
}

// Framework include files
#include "GaudiKernel/KeyedObject.h"
#include "GaudiKernel/KeyedObjectManager.h"
#include "GaudiKernel/ObjectContainerBase.h"

// Forward declarations
// template <class T, class M> class KeyedContainer;

#ifdef WIN32
#define FORCE_INLINE __forceinline
#else
#define FORCE_INLINE inline
#endif

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
  FORCE_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 )
      : 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 ) 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( const value_type val );
};

// 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();
  typename seq_type::iterator i = m_sequential.begin();
  typename seq_type::iterator s = m_sequential.end();
  for ( ; i != s; i++ ) {
    typename seq_type::value_type v = *i;
    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 (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
{
  typename seq_type::const_iterator i = m_sequential.begin();
  typename seq_type::const_iterator s = m_sequential.end();
  vec.clear();
  vec.reserve( size() );
  for ( ; i != s; i++ ) {
    ContainedObject* p = const_cast<typename seq_type::value_type>( *i );
    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           = (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 );
}

#undef FORCE_INLINE
#endif // GAUDIKERNEL_KEYEDCONTAINER_H