RefTable.h

Go to the documentation of this file.

#ifndef GAUDIKERNEL_REFTABLE_H
#define GAUDIKERNEL_REFTABLE_H 1


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

// 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)
  {
  }
  ~RefTable1to1() override = default;
  
  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)    {
  }
  ~RefTable1toN() override = default;
  
  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