AthenaPoolConverter.h

Go to the documentation of this file.

/*
  Copyright (C) 2002-2024 CERN for the benefit of the ATLAS collaboration
*/
 
#ifndef ATHENAPOOLCNVSVC_ATHENAPOOLCONVERTER_H
#define ATHENAPOOLCNVSVC_ATHENAPOOLCONVERTER_H
 
#include "GaudiKernel/Converter.h"
#include "GaudiKernel/ServiceHandle.h"
#include "AthenaBaseComps/AthCheckMacros.h"
#include "AthenaBaseComps/AthMessaging.h"
#include "StoreGate/StoreGateSvc.h"
#include "DataModelRoot/RootType.h"
#include "AthenaPoolCnvSvc/IAthenaPoolCleanUp.h"
#include "PoolSvc/IPoolSvc.h"
 
#include <string>
#include <map>
#include <mutex>
 
class IOpaqueAddress;
class DataObject;
class StatusCode;
class IAthenaPoolCnvSvc;
class Guid;
class Placement;
class Token;
 
template <class TYPE> class CnvFactory;
 
class AthenaPoolConverter : public ::Converter, public ::AthMessaging, virtual public IAthenaPoolCleanUp {
 
public:
   virtual ~AthenaPoolConverter();
 
   virtual StatusCode initialize() override;
   virtual StatusCode finalize() override;
 
   virtual long repSvcType() const override;
 
   virtual StatusCode createObj(IOpaqueAddress* pAddr, DataObject*& pObj) override;
 
   virtual StatusCode createRep(DataObject* pObj, IOpaqueAddress*& pAddr) override;
 
   virtual StatusCode fillRepRefs(IOpaqueAddress* pAddr, DataObject* pObj) override;
 
   const ServiceHandle<StoreGateSvc>& detStore() const { return m_detStore; }
 
   static long storageType();
 
   static const CLID& classID();
 
   virtual StatusCode cleanUp(const std::string& output) override;
 
 
protected:
   AthenaPoolConverter(const CLID& id, ISvcLocator* pSvcLocator,
                       const char* name = nullptr);
 
   virtual StatusCode DataObjectToPers(DataObject* pObj, IOpaqueAddress*& pAddr) = 0;
 
   virtual StatusCode DataObjectToPool(IOpaqueAddress* pAddr, DataObject* pObj) = 0;
 
   virtual StatusCode PoolToDataObject(DataObject*& pObj, const Token* token,
                                       const std::string& key) = 0;
 
   virtual Placement setPlacementWithType(const std::string& tname, const std::string& key, const std::string& output);
   virtual Placement setPlacement(const std::string& key, const std::string& output) = 0;
 
   virtual const DataObject* getDataObject() const;
 
   bool compareClassGuid(const Guid &guid) const;
 
protected: // data
   ServiceHandle<StoreGateSvc> m_detStore;
   ServiceHandle<IAthenaPoolCnvSvc> m_athenaPoolCnvSvc;
   RootType              m_classDesc;
 
   typedef std::map<std::string, RootType>            ClassMap;
   typedef ClassMap::const_iterator                   ClassMapIt;
   std::string           m_className;
   ClassMap              m_classDescs;
 
   std::string m_containerPrefix;
   std::string m_containerNameHint;
   std::string m_branchNameHint;
 
   const DataObject*     m_dataObject;
   const Token*          m_i_poolToken;
 
   typedef std::mutex CallMutex;
   CallMutex m_conv_mut;
};
 
#endif