AthCnvSvc.h

Go to the documentation of this file.

 
/*
  Copyright (C) 2002-2019 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
  : virtual public ::IConversionSvc,
    virtual public ::IAddressCreator,
            public ::AthService
{ 
  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();
  virtual StatusCode finalize();
  virtual StatusCode queryInterface (const InterfaceID& riid,
                                     void** ppvInterface);
 
 
  virtual long repSvcType() const;
 
  const CLID& objType() const;
 
  virtual 
  StatusCode setDataProvider(IDataProviderSvc* pService);
 
  virtual SmartIF<IDataProviderSvc>& dataProvider()  const;
 
  virtual
  StatusCode setConversionSvc(IConversionSvc* svc);
 
  virtual 
  SmartIF<IConversionSvc>& conversionSvc()    const;
 
  virtual
  StatusCode setAddressCreator(IAddressCreator* creator);
 
  virtual
  SmartIF<IAddressCreator>& addressCreator()   const;
  
  virtual
  StatusCode createObj(IOpaqueAddress* pAddress,DataObject*& refpObject);
 
  virtual
  StatusCode fillObjRefs(IOpaqueAddress* pAddress, DataObject* pObject);
 
  virtual
  StatusCode updateObj(IOpaqueAddress* pAddress, DataObject* refpObject);
 
  virtual
  StatusCode updateObjRefs(IOpaqueAddress* pAddress, DataObject* pObject);
 
  virtual
  StatusCode createRep(DataObject* pObject, IOpaqueAddress*& refpAddress);
 
  virtual
  StatusCode fillRepRefs(IOpaqueAddress* pAddress,DataObject* pObject);
 
  virtual
  StatusCode updateRep(IOpaqueAddress* pAddress, DataObject* pObject);
 
  virtual
  StatusCode updateRepRefs(IOpaqueAddress* pAddress, DataObject* pObject);
 
  virtual
  StatusCode addConverter(const CLID& clid);
 
  virtual
  StatusCode addConverter(IConverter* pConverter);
 
  virtual
  StatusCode removeConverter(const CLID& clid);
 
  virtual
  IConverter* converter(const CLID& wanted);
 
  virtual
  StatusCode connectOutput(const std::string& outputFile,
                                   const std::string& openMode);
 
  virtual
  StatusCode connectOutput(const std::string& output);
 
  virtual
  StatusCode commitOutput(const std::string& output, bool do_commit);
 
 
  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);
 
  virtual 
  StatusCode convertAddress (const IOpaqueAddress* pAddress,
                             std::string& refAddress);
 
  virtual
  StatusCode createAddress (long svc_type, 
                            const CLID& clid,
                            const std::string& refAddress,
                            IOpaqueAddress*& refpAddress);
 
  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