AthCnvSvc.h

Go to the documentation of this file.

 
/*
  Copyright (C) 2002-2024 CERN for the benefit of the ATLAS collaboration
*/
 
// AthCnvSvc.h 
// Header file for class AthCnvSvc
// Author: S.Binet<binet@cern.ch>
#ifndef ATHENABASECOMPS_ATHCNVSVC_H
#define ATHENABASECOMPS_ATHCNVSVC_H 1
 
// STL includes
#include <string>
#include <unordered_map>
#include <mutex>
 
// GaudiKernel
#include "GaudiKernel/IConversionSvc.h"
#include "GaudiKernel/IAddressCreator.h"
 
// AthenaBaseComps
#include "AthenaBaseComps/AthService.h"
 
// Forward declaration
class ISvcLocator;
template <class TYPE> class SvcFactory;
 

 
class AthCnvSvc : public extends<::AthService,
                                 ::IConversionSvc,
                                 ::IAddressCreator>
{
  friend class SvcFactory<AthCnvSvc>;
 
public:
  class WorkerEntry {
    friend class AthCnvSvc;
  private:
    CLID        m_class;
    IConverter* m_converter;
  public:
    WorkerEntry(const CLID& cl, IConverter* cnv) 
      : m_class(cl), m_converter(cnv)       {
    }
    WorkerEntry(const WorkerEntry& copy)
      : m_class(copy.m_class), m_converter(copy.m_converter)    {
    }
    WorkerEntry& operator = (const WorkerEntry& copy)   {
      m_class     = copy.m_class;
      m_converter = copy.m_converter;
      return *this;
    }
    virtual ~WorkerEntry()  {
    }
    IConverter*     converter()  {
      return m_converter;
    }
    const CLID&     clID()  const {
      return m_class;
    }
    // comparison operators
    bool operator == (const WorkerEntry& rhs)   
    {
      return rhs.clID() == clID();
    }
    bool operator < (const WorkerEntry& rhs)
    {
      return this->clID() < rhs.clID();
    }
  };
  typedef std::unordered_map<CLID,WorkerEntry> Workers;

  // Public methods: 
public: 
 
  // Copy constructor: 

  AthCnvSvc( const std::string& name, ISvcLocator* pSvcLocator, long type );
 
  // Assignment operator: 
  //AthCnvSvc &operator=(const AthCnvSvc &alg); 


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



  virtual long repSvcType() const override;

  virtual const CLID& objType() const override;

  virtual 
  StatusCode setDataProvider(IDataProviderSvc* pService) override;

  virtual SmartIF<IDataProviderSvc>& dataProvider() const override;

  virtual
  StatusCode setConversionSvc(IConversionSvc* svc) override;

  virtual 
  SmartIF<IConversionSvc>& conversionSvc() const override;

  virtual
  StatusCode setAddressCreator(IAddressCreator* creator) override;

  virtual
  SmartIF<IAddressCreator>& addressCreator() const override;
  
  virtual
  StatusCode createObj(IOpaqueAddress* pAddress,DataObject*& refpObject) override;

  virtual
  StatusCode fillObjRefs(IOpaqueAddress* pAddress, DataObject* pObject) override;

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

  virtual
  StatusCode updateObjRefs(IOpaqueAddress* pAddress, DataObject* pObject) override;

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

  virtual
  StatusCode fillRepRefs(IOpaqueAddress* pAddress,DataObject* pObject) override;

  virtual
  StatusCode updateRep(IOpaqueAddress* pAddress, DataObject* pObject) override;

  virtual
  StatusCode updateRepRefs(IOpaqueAddress* pAddress, DataObject* pObject) override;

  virtual
  StatusCode addConverter(const CLID& clid) override;

  virtual
  StatusCode addConverter(IConverter* pConverter) override;

  virtual
  StatusCode removeConverter(const CLID& clid) override;

  virtual
  IConverter* converter(const CLID& wanted) override;

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

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

  virtual
  StatusCode commitOutput(const std::string& output, bool do_commit) override;


  virtual
  StatusCode disconnectOutput(const std::string& output);



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

  virtual 
  StatusCode convertAddress (const IOpaqueAddress* pAddress,
                             std::string& refAddress) override;

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

  virtual
  StatusCode updateServiceState(IOpaqueAddress* pAddress);


  // Private data: 
private: 
  AthCnvSvc(); //< not implemented
  AthCnvSvc (const AthCnvSvc&); //< not implemented
  AthCnvSvc& operator= (const AthCnvSvc&); //< not implemented

  // Protected data and methods: 
protected:

  virtual ~AthCnvSvc(); 

  virtual 
  IConverter* createConverter (long typ, const CLID& clid,
                               const ICnvFactory* fac);

  virtual 
  StatusCode configureConverter (long typ, const CLID& clid, IConverter* cnv);

  virtual 
  StatusCode initializeConverter (long typ, const CLID& clid, IConverter* cnv);

  virtual 
  StatusCode activateConverter (long typ, const CLID& clid, IConverter* cnv);
  
  virtual 
  void loadConverter(DataObject* pObject);

  virtual
  SmartIF<IAddressCreator>& addressCreator()
  {
    return m_addressCreator;
  }
 
  StatusCode makeCall (int typ,
                       bool ignore_add,
                       bool ignore_obj,
                       bool update,
                       IOpaqueAddress*& pAddress, 
                       DataObject*& pObject);

  SmartIF<IDataProviderSvc>   m_dataSvc;
  SmartIF<IAddressCreator>    m_addressCreator;
  SmartIF<IConversionSvc>     m_cnvSvc;
  long                m_type;
  Workers             m_workers;
  typedef std::recursive_mutex CallMutex;
  CallMutex           m_conv_mut;
}; 
 
// I/O operators

// Inline methods: 
 
#endif //> !ATHENABASECOMPS_ATHCNVSVC_H