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 Service, 
                        virtual public IConversionSvc,
                        virtual public IPersistencySvc,
                        virtual public IAddressCreator  {
protected:
  friend class SvcFactory<PersistencySvc>;
  friend class Factory<PersistencySvc,IService* (std::string,ISvcLocator *)>;

  class ServiceEntry {
    long             m_serviceType;
    IService*        m_service;
    IConversionSvc*  m_cnvService;
    IAddressCreator* m_addrCreator;
  public:
    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()  {
    }
    IService*           service()   const   {
      return m_service;
    }
    IConversionSvc*     conversionSvc()  const    {
      return m_cnvService;
    }
    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 IDataProviderSvc* dataProvider()    const;

  virtual StatusCode setConversionSvc(IConversionSvc* svc);

  virtual IConversionSvc* conversionSvc()    const;

  virtual StatusCode setAddressCreator(IAddressCreator* creator);

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


  StatusCode queryInterface(const InterfaceID& riid, void** ppvUnknown);


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

  virtual ~PersistencySvc();
protected:

  IConversionSvc* service(const std::string& nam);

  IConversionSvc* service(long service_type);

  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;
  IDataProviderSvc*   m_dataSvc;
  Services            m_cnvServices;
  IConversionSvc*     m_cnvDefault;
  StringArrayProperty m_svcNames;
  bool                m_enable;
};
#endif // PERSISTENCYSVC_PERSISTENCYSVC_H