ConversionSvc.h

Go to the documentation of this file.

#ifndef GAUDIKERNEL_CONVERSIONSVC_H
#define GAUDIKERNEL_CONVERSIONSVC_H 1

// Include files
#include <vector>
#include <algorithm>
#include <utility>
#include "GaudiKernel/Kernel.h"
#include "GaudiKernel/Service.h"
#include "GaudiKernel/IConversionSvc.h"
#include "GaudiKernel/IAddressCreator.h"
#include "GaudiKernel/IDataProviderSvc.h"


class GAUDI_API ConversionSvc: public extends<Service,
                                              IConversionSvc,
                                              IAddressCreator>
{
  class WorkerEntry final {
    CLID        m_class;
    IConverter* m_converter;
  public:
    WorkerEntry(const CLID& cl, IConverter* cnv)
      : m_class(cl), m_converter(cnv)       {
      if (m_converter) m_converter->addRef();
    }

    ~WorkerEntry() {
      if (m_converter) m_converter->release();
    }

    WorkerEntry(WorkerEntry&& orig) noexcept
    : m_class{ orig.m_class },
      m_converter{ std::exchange( orig.m_converter, nullptr ) } {
    }

    WorkerEntry& operator=(WorkerEntry&& orig) noexcept {
      m_class = orig.m_class;
      std::swap( m_converter, orig.m_converter );
      return *this;
    }

    WorkerEntry(const WorkerEntry& copy) = delete;
    WorkerEntry& operator = (const WorkerEntry& copy) = delete;

    IConverter*     converter()  {
      return m_converter;
    }

    const CLID&     clID()  const {
      return m_class;
    }
  };


public:
  ConversionSvc(const std::string& name, ISvcLocator* svc, long type);

  ConversionSvc(const ConversionSvc&) = delete;
  ConversionSvc& operator= (const ConversionSvc&) = delete;


  StatusCode initialize() override;

  StatusCode finalize() override;

  long repSvcType() const override;

  const CLID& objType() const override;

  StatusCode setDataProvider(IDataProviderSvc* pService) 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;

  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;

  StatusCode addConverter(const CLID& clid) override;

  StatusCode addConverter(IConverter* pConverter) override;

  StatusCode removeConverter(const CLID& clid) override;

  IConverter* converter(const CLID& wanted) override;

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

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

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

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

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

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

  virtual StatusCode updateServiceState(IOpaqueAddress* pAddress);

protected:

  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;
  }

protected:
  StatusCode makeCall( int typ,
                       bool ignore_add,
                       bool ignore_obj,
                       bool update,
                       IOpaqueAddress*& pAddress,
                       DataObject*& pObject);

  mutable SmartIF<IDataProviderSvc>   m_dataSvc;
  mutable SmartIF<IAddressCreator>    m_addressCreator;
  mutable SmartIF<IConversionSvc>     m_cnvSvc;
  long                m_type;
  std::vector<WorkerEntry> m_workers;

};
#endif // GAUDIKERNEL_CONVERSIONSVC_H