TPTools/TPTools/ITPConverter.h

Go to the documentation of this file.

// -*- c++ -*-
 
/*
  Copyright (C) 2002-2020 CERN for the benefit of the ATLAS collaboration
*/
 
#ifndef ATHENAPOOLCNVSVC_ITPConverter_H
#define ATHENAPOOLCNVSVC_ITPConverter_H 1

 
#include "AthenaKernel/ITPCnvBase.h"
#include "AthenaPoolUtilities/TPObjRef.h"
 
#include <typeinfo>
#include <typeindex>
#include <string>
 
 
class MsgStream;
class TopLevelTPCnvBase;

class ITPConverter  : public ITPCnvBase
{
protected:
  ITPConverter() {} 
public:
  virtual ~ITPConverter() = default;

  virtual void  setTopConverter( TopLevelTPCnvBase *topConverter, 
                 const TPObjRef::typeID_t& TPtypeID ) = 0;
  
  virtual void  setRuntimeTopConverter( TopLevelTPCnvBase *topConverter ) = 0;

  virtual TopLevelTPCnvBase*   topConverter() { return 0; }
  virtual const TopLevelTPCnvBase* topConverter() const { return 0; }

  virtual const TPObjRef::typeID_t&   typeID() const = 0;

  virtual const std::type_info& transBaseTInfo() const = 0;

  virtual void  reservePStorage( size_t size ) = 0;

  virtual void  converterNotFound( const std::type_info& converterType,
                   ITPConverter *c,
                   const std::string& typeName,
                   MsgStream& log ) const;

  virtual void  converterNotFound( unsigned typeID,
                   ITPConverter *c,
                   const std::string& typeName,
                   MsgStream& log ) const;
};
 
 
 
 
//--------------  TPConverterTypeMap<CONVERTER_BASE>  -------------
#include <map>

template<class CONVERTER_BASE>
class TPConverterTypeMap {
public:
  typedef   std::map<const std::type_index, CONVERTER_BASE*>    TId_Map_t;
  typedef   typename TId_Map_t::iterator    iterator;
 
  TPConverterTypeMap() {}

  CONVERTER_BASE *  findConverter(const std::type_info &objTypeInfo) const;

  void      addConverter(CONVERTER_BASE *converter,
                 const std::type_info &objTypeInfo);

  iterator  begin() { return m_cnvRegistry.begin(); }

  iterator  end() { return m_cnvRegistry.end(); }
  
protected:
  TId_Map_t    m_cnvRegistry; 
};
 
 
 
 
 
template<class CONVERTER_BASE>
inline
CONVERTER_BASE *
TPConverterTypeMap<CONVERTER_BASE>
::findConverter(const std::type_info &objTypeInfo) const
{
   typename TId_Map_t::const_iterator   iter = m_cnvRegistry.find( std::type_index(objTypeInfo) );
   return (iter == m_cnvRegistry.end())?
      0 : iter->second; 
}
 
 
template<class CONVERTER_BASE>
inline
void
TPConverterTypeMap<CONVERTER_BASE>
::addConverter(CONVERTER_BASE *converter, const std::type_info &objTypeInfo)
{
   m_cnvRegistry[std::type_index(objTypeInfo)] = converter;
}
 
 
 
#endif