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/IAddressCreator.h"
#include "GaudiKernel/IConversionSvc.h"
#include "GaudiKernel/IDataProviderSvc.h"
#include "GaudiKernel/IPersistencySvc.h"
#include "GaudiKernel/Service.h"

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

class PersistencySvc : public extends<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 final {
    public:
      SvcTest(long test) : m_test(test)    {
      }
      bool operator()( const ServiceEntry& testee ) const {
          return m_test == testee.svcType();
      }
    private:
         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 );

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( Gaudi::Details::PropertyBase& theProp );

  long m_cnvDefType = TEST_StorageType;
  mutable SmartIF<IDataProviderSvc> m_dataSvc;
  Services m_cnvServices;
  mutable SmartIF<IConversionSvc> m_cnvDefault;

  Gaudi::Property<std::vector<std::string>> m_svcNames{
      this, "CnvServices", {}, "Names of services to be requested from the service locator and added by default"};

  bool m_enable = true;

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