AthenaPoolSharedIOCnvSvc.h

Go to the documentation of this file.

/*
  Copyright (C) 2002-2026 CERN for the benefit of the ATLAS collaboration
*/
 
#ifndef ATHENAPOOLCNVSVC_ATHENAPOOLSHAREDIOCNVSVC_H
#define ATHENAPOOLCNVSVC_ATHENAPOOLSHAREDIOCNVSVC_H

 
#include "AthenaPoolCnvSvc.h"
#include "AthenaKernel/IDataShare.h"
#include "AthenaKernel/IAthenaSerializeSvc.h"
 
// Forward declarations
class Guid;
 
namespace RootAuxDynIO {
   class IFactoryTool;
   class IAuxDynShare;
}
 
template <class TYPE> class SvcFactory;

class AthenaPoolSharedIOCnvSvc : public extends<AthenaPoolCnvSvc,
                    IDataShare> {
   // Allow the factory class access to the constructor
   friend class SvcFactory<AthenaPoolSharedIOCnvSvc>;
 
public:

   virtual StatusCode initialize() override;
   virtual StatusCode finalize() override;

   virtual StatusCode connectOutput(const std::string& outputConnectionSpec,
           const std::string& openMode) override;

   virtual StatusCode connectOutput(const std::string& outputConnectionSpec) override;

   virtual StatusCode commitOutput(const std::string& outputConnectionSpec, bool doCommit) override;

   virtual StatusCode disconnectOutput(const std::string& outputConnectionSpec) override;

   virtual Token* registerForWrite(Placement* placement, const void* obj, const RootType& classDesc) override;

   virtual void setObjPtr(void*& obj, const Token* token) override;

   StatusCode createAddress(long svcType,
           const CLID& clid,
           const std::string* par,
           const unsigned long* ip,
           IOpaqueAddress*& refpAddress) override;

   virtual StatusCode createAddress(long svcType,
           const CLID& clid,
           const std::string& refAddress,
           IOpaqueAddress*& refpAddress) override;

   virtual StatusCode cleanUp(const std::string& connection) override;

   virtual StatusCode makeServer(int num) override;

   virtual StatusCode makeClient(int num) override;

   virtual StatusCode readData() override;

   virtual StatusCode commitCatalog() override;

   StatusCode abortSharedWrClients(int client_n);

   virtual void handle(const Incident& incident) override;

   AthenaPoolSharedIOCnvSvc(const std::string& name, ISvcLocator* pSvcLocator);
   virtual ~AthenaPoolSharedIOCnvSvc();
 
private: // data
   ServiceHandle<IAthenaSerializeSvc> m_serializeSvc{this,"AthenaRootSerializeSvc","AthenaRootSerializeSvc"};
   std::unique_ptr<RootAuxDynIO::IFactoryTool> m_auxDynTool;
   ToolHandle<IAthenaIPCTool>    m_inputStreamingTool{this,"InputStreamingTool",{}};
   std::unique_ptr<RootAuxDynIO::IAuxDynShare> m_auxInput;
   ToolHandle<IAthenaIPCTool>    m_outputStreamingTool{this,"OutputStreamingTool",{}};
   std::unique_ptr<RootAuxDynIO::IAuxDynShare> m_auxOutput;
 
   bool m_streamServerActive=false;
   int m_metadataClient=0;
 
private: // properties
   Gaudi::Property<std::string> m_metadataContainerProp{this,"OutputMetadataContainer","MetaData"};
   Gaudi::Property<std::vector<std::string>> m_metadataContainersAug{this, "OutputMetadataContainers", {}, "Metadata containers used for augmentations"};

   Gaudi::Property<int> m_makeStreamingToolClient{this,"MakeStreamingToolClient",0};
   Gaudi::Property<int> m_streamingTechnology{this,"StreamingTechnology",-1};
   Gaudi::Property<bool> m_parallelCompression{this,"ParallelCompression",true};
   Gaudi::Property<std::string> m_streamPortString{this,"StreamPortString","?pmerge=localhost:0"};
   std::map<std::string, int> m_fileCommitCounter;
   Gaudi::Property<std::map<std::string, int>> m_fileFlushSetting{this,"FileFlushSetting",{}};
};
 
#endif