AthenaPoolCnvSvc.h

Go to the documentation of this file.

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

 
#include "AthenaPoolCnvSvc/IAthenaPoolCnvSvc.h"
 
#include "GaudiKernel/IClassIDSvc.h"
#include "GaudiKernel/IIncidentListener.h"
#include "GaudiKernel/IIoComponent.h"
#include "GaudiKernel/ServiceHandle.h"
#include "GaudiKernel/ToolHandle.h"
 
#include "StorageSvc/DbType.h"
#include "AthenaBaseComps/AthCnvSvc.h"
#include "AthenaKernel/IAthenaIPCTool.h"
#include "PmbCxxUtils/BasicStopWatch.h"
#include "PoolSvc/IPoolSvc.h"
 
#include <vector>
#include <map>
#include <mutex>
#include <limits>
 
// Forward declarations
class Guid;
 
template <class TYPE> class SvcFactory;

class AthenaPoolCnvSvc : public extends<AthCnvSvc,
                                        IAthenaPoolCnvSvc,
                                        IIncidentListener,
                                        IIoComponent> {
   // Allow the factory class access to the constructor
   friend class SvcFactory<AthenaPoolCnvSvc>;
 
public:

   virtual StatusCode initialize() override;
   virtual StatusCode io_reinit() override;
   virtual StatusCode finalize() override;
   virtual StatusCode io_finalize() override;
   virtual StatusCode stop() override;

   virtual StatusCode createObj(IOpaqueAddress* pAddress, DataObject*& refpObject) override;

   virtual StatusCode createRep(DataObject* pObject, IOpaqueAddress*& refpAddress) override;

   virtual StatusCode fillRepRefs(IOpaqueAddress* pAddress, DataObject* pObject) 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 IPoolSvc* getPoolSvc() override;

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

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

   virtual bool useDetailChronoStat() const 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 convertAddress(const IOpaqueAddress* pAddress, std::string& refAddress) override;

   virtual StatusCode decodeOutputSpec(std::string& connectionSpec, int& outputTech) const override;

   virtual StatusCode registerCleanUp(IAthenaPoolCleanUp* cnv) override;

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

   virtual StatusCode setInputAttributes(const std::string& fileName) override;

   virtual void handle(const Incident& incident) override;

   void flushDataHeaderForms(const std::string& streamName = "*");

   AthenaPoolCnvSvc(const std::string& name, ISvcLocator* pSvcLocator);
   virtual ~AthenaPoolCnvSvc() = default;
 
private: // member functions
   void extractPoolAttributes(const Gaudi::Property<std::vector<std::string>>& property,
       std::vector<std::vector<std::string> >* contAttr,
       std::vector<std::vector<std::string> >* dbAttr,
       std::vector<std::vector<std::string> >* domAttr = 0) const;

   StatusCode processPoolAttributes(std::vector<std::vector<std::string> >& attr,
       const std::string& fileName,
       unsigned long contextId,
       bool doGet = true,
       bool doSet = true,
       bool doClear = true) const;
 
private: // data
   std::string                   m_lastInputFileName;
   ServiceHandle<IPoolSvc>       m_poolSvc{this,"PoolSvc","PoolSvc"};
   ServiceHandle<IClassIDSvc>    m_clidSvc{this,"ClassIDSvc","ClassIDSvc"};
 
protected: // shared with derived services
   PMonUtils::BasicStopWatchResultMap_t m_chronoMap{};
 
private: // properties
   Gaudi::Property<bool> m_useDetailChronoStat{this,"UseDetailChronoStat",false};

   Gaudi::Property<std::map<std::string, std::string>> m_storageTechProp{this, "StorageTechnology", {{"*","ROOTTREEINDEX"}}};
   std::map<std::string, int> m_storageTechMap;
   Gaudi::Property<std::string> m_containerPrefixProp{this,"PoolContainerPrefix","Default"};
   Gaudi::Property<std::string> m_containerNameHintProp{this,"TopLevelContainerName",""};
   Gaudi::Property<std::string> m_branchNameHintProp{this,"SubLevelBranchName", "<type>/<key>"};

   Gaudi::Property<std::vector<std::string>> m_poolAttr{this,"PoolAttributes",{},"Pool Attributes","OrderedSet<std::string>"};
   std::vector<std::vector<std::string> > m_domainAttr;
   std::vector<std::vector<std::string> > m_databaseAttr;
   std::vector<std::vector<std::string> > m_containerAttr;
   std::vector<unsigned int> m_contextAttr;
   std::map<std::string, int> m_fileCommitCounter;
   std::map<std::string, int> m_fileFlushSetting;
   Gaudi::Property<std::vector<std::string>> m_inputPoolAttr{this,"InputPoolAttributes",{}};
   std::vector<std::vector<std::string> > m_inputAttr;
   Gaudi::Property<std::vector<std::string>> m_inputPoolAttrPerEvent{this,"PrintInputAttrPerEvt",{}};
   std::vector<std::vector<std::string> > m_inputAttrPerEvent;

   Gaudi::Property<std::vector<std::string>> m_maxFileSizes{this,"MaxFileSizes",{}};
   long long m_domainMaxFileSize=std::numeric_limits<long long>::max();
   std::map<std::string, long long> m_databaseMaxFileSize;

   std::string m_defContainerType{};
 
protected: // properties
   Gaudi::Property<bool> m_persSvcPerOutput{this,"PersSvcPerOutput",true};
   unsigned outputContextId(const std::string& outputConnection);

   Gaudi::Property<std::string> m_persSvcPerInputType{this,"PersSvcPerInputType",""};
   std::mutex  m_mutex;

   Gaudi::Property<int> m_numberEventsPerWrite{this,"NumberEventsPerWrite",-1};

   Gaudi::Property<bool> m_oneDataHeaderForm { this, "OneDataHeaderForm", false };
   Gaudi::Property<int> m_DHFormCacheSize { this, "maxDHFormCacheSize", 100 };
   Gaudi::Property<bool> m_DHFilterAliases { this, "doFilterDHAliases", true };
 
};
 
#endif