RefTable.h

Go to the documentation of this file.

#ifndef GAUDIKERNEL_REFTABLE_H
#define GAUDIKERNEL_REFTABLE_H 1

// Include files
#include "GaudiKernel/DataObject.h"
#include "GaudiKernel/HashMap.h" // Cannot use maps through sharable images....
#include "GaudiKernel/Kernel.h"
#include "GaudiKernel/SmartRef.h"
#include "GaudiKernel/SmartRefVector.h"
#include "GaudiKernel/StreamBuffer.h"

// Externals
static const CLID CLID_RefTable1to1 = 300;
static const CLID CLID_RefTable1toN = 301;

//------------------------------------------------------------------------------
//
// Implementation and definition of template classes
// RefTableBase, RefTable1to1, RefTable1toN
//
// Author                  :  Markus Frank
//
//------------------------------------------------------------------------------
template <class FROM, class MAPENTRY>
class RefTableBase : public DataObject
{
public:
  // Type of the key
  typedef FROM KeyType;
  // Type of map entries
  typedef MAPENTRY EntryType;
  // My own type
  typedef RefTableBase<FROM, EntryType> BaseType;
  typedef GaudiUtils::HashMap<const void*, EntryType> TableType;
  typedef TableType::iterator iterator;
  typedef TableType::const_iterator const_iterator;
  CLID m_clid;

private:
  TableType m_table;
  SmartRef<KeyType> m_fromRef;

protected:
  bool insertMapElement( const KeyType* from, EntryType& to ) { return m_table.insert( from, to ); }
  EntryType* i_reference( const KeyType* from )
  {
    auto i = m_table.find( from );
    return i != 0 ? &( i->second ) : nullptr;
  }
  const EntryType* i_reference( const KeyType* from ) const
  {
    auto i = m_table.find( from );
    return i != m_table.end() ? &( i->second ) : nullptr;
  }

public:
  RefTableBase( const CLID& clid, int len ) : m_clid( clid ), m_table( len ) {}
  virtual ~RefTableBase() = default;
  virtual void clear() { m_table.clear(); }
  iterator begin() { return m_table.begin(); }
  const_iterator begin() const { return m_table.begin(); }
  iterator end() { return m_table.end(); }
  const_iterator end() const { return m_table.end(); }
  long size() const { return m_table.size(); }
  void reserve( int len ) { m_table.reserve( len ); }
  virtual StreamBuffer& serialize( StreamBuffer& s ) const
  {
    DataObject::serialize( s ) << m_table.size();
    // for (TableType::const_iterator i = m_table.begin(), stop = m_table.end(); i != stop; i++ )    {
    //  SmartRef<KeyType> fromRef;
    //  fromRef = (KeyType*)(*i).first;
    //  s << fromRef(this);
    //  s << (*i).second(this);
    //}
    return s;
  }
  virtual StreamBuffer& serialize( StreamBuffer& s )
  {
    long siz;
    DataObject::serialize( s ) >> siz;
    m_table.reserve( siz );
    // for ( long i = 0; i < siz; i++ )   {
    //  SmartRef<KeyType> fromRef;
    //  EntryType entry;
    //  s >> fromRef(this);
    //  s >> entry(this);
    //  insertMapElement( fromRef, entry);
    //}
    return s;
  }
};

template <class FROM, class TO>
class RefTable1to1 : public RefTableBase<FROM, SmartRef<TO>>
{
public:
  RefTable1to1( const CLID& clid, int len = 16 ) : RefTableBase<FROM, SmartRef<TO>>( clid, len ) {}

  virtual const CLID& clID() const { return m_clid; }
  bool insert( const FROM* from, TO* to ) { return insertMapElement( from, EntryType( to ) ); }
  bool insert( const FROM* from, const EntryType& to )
  {
    // We MUST check the environment of the smart pointer!
    if ( 0 != to.data() || StreamBuffer::INVALID != to.hintID() ) {
      return insertMapElement( from, EntryType( to ) );
    }
    return false;
  }
  TO* reference( const FROM* from )
  {
    EntryType* e = i_reference( from );
    return ( 0 == e ) ? 0 : ( *e );
  }

  const TO* reference( const FROM* from ) const
  {
    auto e = i_reference( from );
    return e ? *e : nullptr;
  }

  bool isReferenced( const FROM* from, const TO* to ) const
  {
    auto e = i_reference( from );
    return e && ( *e == to );
  }
  bool isReferenced( const FROM* from, const EntryType& to )
  {
    const EntryType* e = i_reference( from );
    return assoc && ( *e != to ) && ( e->target() == to.target() );
  }
};

template <class FROM, class TO>
class RefTable1toN : public RefTableBase<FROM, SmartRefVector<TO>>
{
public:
  RefTable1toN( const CLID& clid, int len = 16 ) : RefTableBase<FROM, SmartRefVector<TO>>( clid, len ) {}

  virtual const CLID& clID() const { return m_clid; }
  bool insert( const FROM* from, TO* to )
  {
    EntryType* entry = i_reference( from );
    if ( 0 == entry ) {
      bool result         = insertMapElement( from, EntryType() );
      EntryType* newEntry = i_reference( from );
      if ( !( 0 == newEntry ) ) {
        newEntry->push_back( SmartRef<TO>( to ) );
        return true;
      }
      return false;
    }
    entry->push_back( SmartRef<TO>( to ) );
    return true;
  }
  bool insert( const FROM* from, const SmartRef<TO>& to )
  {
    EntryType* entry = i_reference( from );
    if ( 0 == entry ) {
      bool result         = insertMapElement( from, EntryType() );
      EntryType* newEntry = i_reference( from );
      if ( !( 0 == newEntry ) ) {
        newEntry->push_back( to );
        return true;
      }
      return false;
    }
    entry->push_back( to );
    return true;
  }
  bool insert( const FROM* from, const EntryType& to )
  {
    return insertMapElement( from, const_cast<EntryType&>( to ) );
  }
  EntryType& reference( const FROM* from )
  {
    static EntryType empty;
    EntryType* e = i_reference( from );
    return e ? *e : empty;
  }
  const EntryType& reference( const FROM* from ) const
  {
    static const EntryType empty;
    EntryType* e = i_reference( from );
    return e ? *e : empty;
  }
  bool isReferenced( const FROM* from, const EntryType& to )
  {
    auto e = i_reference( from );
    return e && ( *e == to );
  }
  bool isReferenced( const FROM* from, const TO* to ) { return isReferenced( from, SmartRef<TO>( to ) ); }
  bool isReferenced( const FROM* from, const SmartRef<TO>& to )
  {
    const EntryType* e = i_reference( from );
    return assoc && std::find( e->begin(), e->end(), to ) != e->end();
  }
};

#endif // GAUDIKERNEL_REFTABLE_H