Converter.h

Go to the documentation of this file.

#ifndef GAUDIKERNEL_CONVERTER_H
#define GAUDIKERNEL_CONVERTER_H

// generic experiment headers
#include "GaudiKernel/IConverter.h"
#include "GaudiKernel/ISvcLocator.h"
#include "GaudiKernel/IService.h"
#include "GaudiKernel/ConversionSvc.h"
#include "GaudiKernel/IDataProviderSvc.h"
#include "GaudiKernel/IDataManagerSvc.h"

// Forward declarations
class IMessageSvc;
class IRegistry;

class GAUDI_API Converter : public implements<IConverter> {
public:
#ifndef __REFLEX__
  typedef Gaudi::PluginService::Factory<IConverter*,
                                        ISvcLocator*> Factory;
#endif

  StatusCode initialize() override;

  StatusCode finalize() override;

  StatusCode setDataProvider(IDataProviderSvc* svc) override;

  SmartIF<IDataProviderSvc>& dataProvider() const override;

  StatusCode setConversionSvc(IConversionSvc* svc) override;

  SmartIF<IConversionSvc>& conversionSvc() const override;

  StatusCode setAddressCreator(IAddressCreator* creator) override;

  SmartIF<IAddressCreator>& addressCreator() const override;

  const CLID& objType() const override;

  // MSF: Masked to generate compiler error due to interface change
  virtual long i_repSvcType() const;

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

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

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

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

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

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

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

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

  Converter(long storage_type, const CLID& class_type, ISvcLocator* svc = 0);

  template <class T>
  StatusCode service( const std::string& name, T*& psvc, bool createIf = false ) const {
    return service_i(name, createIf, T::interfaceID(), (void**)&psvc);
  }

  template <class T>
  StatusCode service( const std::string& type, const std::string& name, T*& psvc) const {
    return service_i(type, name, T::interfaceID(), (void**)&psvc);
  }

  SmartIF<IService> service(const std::string& name, const bool createIf = true) const;

protected:

  ~Converter() override = default;

  SmartIF<ISvcLocator>& serviceLocator() const;
  SmartIF<IMessageSvc>& msgSvc() const;
  // Obsoleted name, kept due to the backwards compatibility
  SmartIF<IMessageSvc>& messageService() const;
  SmartIF<IDataManagerSvc>& dataManager() const;

private:

  long              m_storageType;
  const CLID        m_classType;
  mutable SmartIF<IAddressCreator> m_addressCreator;
  mutable SmartIF<IDataProviderSvc> m_dataProvider;
  mutable SmartIF<IDataManagerSvc>  m_dataManager;
  mutable SmartIF<IConversionSvc>   m_conversionSvc;
  mutable SmartIF<ISvcLocator>      m_svcLocator;
  mutable SmartIF<IMessageSvc> m_messageSvc;

  StatusCode service_i(const std::string& svcName,
               bool createIf,
               const InterfaceID& iid,
               void** ppSvc) const;
  StatusCode service_i(const std::string& svcType,
               const std::string& svcName,
               const InterfaceID& iid,
               void** ppSvc) const;
};


// Identified class for converters' factories
class GAUDI_API ConverterID final{
public:
  ConverterID( long stype, CLID clid ) : m_stype(stype), m_clid(clid) {}
  inline bool operator ==(const ConverterID& id) const {
    return m_stype == id.m_stype && m_clid == id.m_clid;
  }
private:
  friend std::ostream& operator << ( std::ostream&, const ConverterID&);
  long m_stype;
  CLID m_clid;
};

inline std::ostream& operator << ( std::ostream& s, const ConverterID& id) {
  return s << "CNV_" << id.m_stype << "_" << id.m_clid;
}


#ifndef GAUDI_NEW_PLUGIN_SERVICE
template <class T>
class CnvFactory final {
public:
#ifndef __REFLEX__
  template <typename S, typename... Args>
  static typename S::ReturnType create(Args&&... a1) {
    return new T(std::forward<Args>(a1)...);
  }
#endif
};

// Macro to declare component factories
#define DECLARE_CONVERTER_FACTORY(x) \
    DECLARE_FACTORY_WITH_CREATOR_AND_ID(x, CnvFactory< x >, \
        ConverterID(x::storageType(), x::classID()), Converter::Factory)
#define DECLARE_NAMESPACE_CONVERTER_FACTORY(n, x) \
    DECLARE_CONVERTER_FACTORY(n::x)

#else

// Macro to declare component factories
#define DECLARE_CONVERTER_FACTORY(x) \
    DECLARE_COMPONENT_WITH_ID(x, ConverterID(x::storageType(), x::classID()))
#define DECLARE_NAMESPACE_CONVERTER_FACTORY(n, x) \
    DECLARE_CONVERTER_FACTORY(n::x)

#endif

#endif // GAUDIKERNEL_CONVERTER_H