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 <functional>
#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>
{
public:
  class WorkerEntry final {
  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;
    }
    IConverter*     converter()  {
      return m_converter;
    }
    const CLID&     clID()  const {
      return m_class;
    }
  };

  class CnvTest : public std::unary_function<WorkerEntry, bool>   {
  private:
    const CLID m_test;
  public:
    CnvTest(const CLID& test) : m_test(test)    {
    }
    bool operator()( const WorkerEntry& testee ) const {
        return m_test == testee.clID();
    }
  };

public:

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

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

protected:
  virtual ~ConversionSvc();

  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;

private:
  ConversionSvc(const ConversionSvc&);
  ConversionSvc& operator= (const ConversionSvc&);
};
#endif // GAUDIKERNEL_CONVERSIONSVC_H