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 extends2<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:

  virtual StatusCode initialize();

  virtual StatusCode finalize();

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

  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