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"

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

// Forward declarations
template <class TYPE> class SvcFactory;
namespace { template <class P, class S> class Factory; }

class PersistencySvc  : public extends3<Service,
                                        IConversionSvc,
                                        IPersistencySvc,
                                        IAddressCreator> {
protected:
  friend class SvcFactory<PersistencySvc>;
  friend class Factory<PersistencySvc,IService* (std::string,ISvcLocator *)>;

  class ServiceEntry {
    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_addrCreator  = cr;
      m_cnvService   = cnv;
      m_service      = svc;
    }
    ServiceEntry( long type,
        IService* svc,
        IConversionSvc* cnv,
        IAddressCreator* cr)  {
      m_serviceType  = type;
      m_addrCreator  = cr;
      m_cnvService   = cnv;
      m_service      = svc;
    }
    ServiceEntry(const ServiceEntry& copy)  {
      m_serviceType  = copy.m_serviceType;
      m_addrCreator  = copy.m_addrCreator;
      m_cnvService   = copy.m_cnvService;
      m_service      = copy.m_service;
    }
    virtual ~ServiceEntry()  {
    }
    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)    {
    }
    virtual ~SvcTest()    {
    }
    bool operator()( const ServiceEntry& testee )  {
        return m_test == testee.svcType() ? true : false;
    }
  protected:
       long m_test;
  };
*/
public:


  long repSvcType() const;

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

  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 addConverter(IConverter* pConverter);

  virtual StatusCode addConverter(const CLID& clid);

  virtual IConverter* converter(const CLID& clid);

  virtual StatusCode removeConverter(const CLID& clid);

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

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

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

  virtual StatusCode removeCnvService(long type);

  virtual StatusCode setDefaultCnvService(long type);

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

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


  virtual StatusCode initialize();

  virtual StatusCode finalize();


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

  virtual ~PersistencySvc();
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;
  mutable SmartIF<IDataProviderSvc>   m_dataSvc;
  Services            m_cnvServices;
  mutable SmartIF<IConversionSvc>     m_cnvDefault;
  StringArrayProperty m_svcNames;
  bool                m_enable;

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