TopLevelTPCnvBase.h

Go to the documentation of this file.

/*
  Copyright (C) 2002-2020 CERN for the benefit of the ATLAS collaboration
*/
 
#ifndef TPTOPLEVELTPCNVBASE_H
#define TPTOPLEVELTPCNVBASE_H
 
#include <set>
#include <map>
 
#include "AthenaPoolUtilities/TPObjRef.h"
class TPCnvTokenList_p1;
#include "ITPConverter.h"
 
class TopLevelTPCnvBase
{
public: 
  TopLevelTPCnvBase() : m_typeIDCount(0) { }
 
  virtual ~TopLevelTPCnvBase() { } 
 
  // ------------- Methods for elemental TP converter management 
  
  virtual void  addTPConverter( ITPConverter *cnv );
 
  virtual void  addTPConverterForReading( ITPConverter *cnv );
 
private:
  virtual void  addTPConverterForWriting( ITPConverter *cnv );
 
public:
  virtual void  addExtTPConverterForReading( ITPConverter *cnv );
 
  virtual void  addTPConvertersTo( TopLevelTPCnvBase *dest );
 
  virtual void  addTPConvertersForReadingTo( TopLevelTPCnvBase *dest );
 
  ITPConverter*    converterForType( const std::type_info &info ) const {
     return m_converters.findConverter( info );
  }
 
 ITPConverter*     converterForRef( const TPObjRef &ref ) const {
     convIdMap_t::const_iterator  iter = m_convIdMap.find( ref.typeID() );
     return (iter == m_convIdMap.end())?
    0 : iter->second;
  }
 
 
  // ---------------------   methods dealing with the persistent
  // object owned by the topl-level converter
 
  virtual bool  hasTLPersObject() const = 0;
 
  virtual void* getTLPersObjectAsVoid() = 0;
 
  virtual const void*   getTLPersObjectAsVoid() const = 0;
 
  virtual void  createTLPersObject() = 0;
 
  virtual void  deleteTLPersObject() = 0;
 
  virtual void  clearTLPersObject() = 0;
 
  virtual void  setTLPersObject(void* persObj) = 0;
 
 
  // ----------- methods dealing with the token list
 
  
  virtual TPCnvTokenList_p1*    getTokenListVar() = 0;
 
  virtual TPCnvTokenList_p1*    getTokenListVarFrom( void *persObj ) = 0;
  
 
  // ----  other methods
 
  virtual unsigned short    getConverterID() = 0;
  
protected:
  void  rememberConverter( TopLevelTPCnvBase *cnv )
  {
     m_registeredTLConverters.insert(cnv);
  }
 
  bool  hasConvertersFrom( TopLevelTPCnvBase *cnv )
  {
     return m_registeredTLConverters.find(cnv) != m_registeredTLConverters.end();
  }
 
  
protected:
  
  typedef std::map<unsigned, ITPConverter*> convIdMap_t;
 
  convIdMap_t               m_convIdMap;
 
  TPConverterTypeMap< ITPConverter >    m_converters;
 
  std::set<TopLevelTPCnvBase*> m_registeredTLConverters;
 
  unsigned              m_typeIDCount;
};
 
 
#endif