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