PersistencySvc.h

Go to the documentation of this file.

//  ============================================================
//
//  PersistencySvc.h
//  ------------------------------------------------------------
//
//  Package   : PersistencySvc
//
//  Author    : Markus Frank
//
//  ===========================================================
#ifndef PERSISTENCYSVC_PERSISTENCYSVC_H
#define PERSISTENCYSVC_PERSISTENCYSVC_H 1

// Framework include files
#include "GaudiKernel/Service.h"
#include "GaudiKernel/IConversionSvc.h"
#include "GaudiKernel/IPersistencySvc.h"
#include "GaudiKernel/IAddressCreator.h"
#include "GaudiKernel/IDataProviderSvc.h"

// STL include files
#include <map>
#include <algorithm>
#include <functional>

class PersistencySvc  : public extends3<Service,
                                        IConversionSvc,
                                        IPersistencySvc,
                                        IAddressCreator> {
protected:

  class ServiceEntry final {
    long             m_serviceType;
    mutable SmartIF<IService>        m_service;
    mutable SmartIF<IConversionSvc>  m_cnvService;
    mutable SmartIF<IAddressCreator> m_addrCreator;
  public:
    ServiceEntry( long type,
        SmartIF<IService> svc,
        SmartIF<IConversionSvc> cnv,
        SmartIF<IAddressCreator> cr)
    : m_serviceType  ( type ),
      m_service      ( std::move(svc) ),
      m_cnvService   ( std::move(cnv) ),
      m_addrCreator  ( std::move(cr) )
    { }
    ServiceEntry( long type,
        IService* svc,
        IConversionSvc* cnv,
        IAddressCreator* cr)  {
      m_serviceType  = type;
      m_addrCreator  = cr;
      m_cnvService   = cnv;
      m_service      = svc;
    }
    ServiceEntry(const ServiceEntry& )  = default;

    SmartIF<IService>&           service()   const   {
      return m_service;
    }
    SmartIF<IConversionSvc>&     conversionSvc()  const    {
      return m_cnvService;
    }
    SmartIF<IAddressCreator>&    addrCreator()  const    {
      return m_addrCreator;
    }
    long svcType()  const {
      return m_serviceType;
    }
  };
  typedef std::map<long,ServiceEntry> Services;
/*
  class SvcTest : public std::unary_function<ServiceEntry, bool>   {
  public:
    SvcTest(long test) : m_test(test)    {
    }
    bool operator()( const ServiceEntry& testee )  {
        return m_test == testee.svcType() ? true : false;
    }
  protected:
       long m_test;
  };
*/
public:

  long repSvcType() const override;

  const CLID& objType() 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 setDataProvider(IDataProviderSvc* pStore) 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 addConverter(IConverter* pConverter) override;

  StatusCode addConverter(const CLID& clid) override;

  IConverter* converter(const CLID& clid) override;

  StatusCode removeConverter(const CLID& clid) override;

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

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

  StatusCode createAddress(long svc_type,
                                   const CLID& clid,
                                   const std::string* pars,
                                   const unsigned long* ipars,
                                   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;

  StatusCode addCnvService(IConversionSvc* service) override;

  StatusCode removeCnvService(long type) override;

  StatusCode setDefaultCnvService(long type) override;

  StatusCode getService(long service_type, IConversionSvc*& refpSvc) override;

  StatusCode getService(const std::string& service_type, IConversionSvc*& refpSvc) override;

  StatusCode initialize() override;

  StatusCode finalize() override;

  PersistencySvc(const std::string& name, ISvcLocator* svc);

  ~PersistencySvc() override = default;
protected:

  SmartIF<IConversionSvc>& service(const std::string& nam);

  SmartIF<IConversionSvc>& service(long service_type);

  SmartIF<IAddressCreator>& addressCreator(long service_type);

  void encodeAddrHdr(long service_type,
             const CLID& clid,
             std::string& address) const;

  void decodeAddrHdr(const std::string& address,
             long& service_type,
             CLID& clid,
             std::string& address_trailer) const;


  StatusCode makeCall(int typ, IOpaqueAddress*& pAddress, DataObject*& pObject);

  bool enable(bool value);

  void svcNamesHandler( Property& theProp );

  long                m_cnvDefType = TEST_StorageType;
  mutable SmartIF<IDataProviderSvc>   m_dataSvc;
  Services            m_cnvServices;
  mutable SmartIF<IConversionSvc>     m_cnvDefault;
  StringArrayProperty m_svcNames;
  bool                m_enable = true;

  mutable SmartIF<IAddressCreator> m_addrCreator;
};
#endif // PERSISTENCYSVC_PERSISTENCYSVC_H