---

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;

class PersistencySvc  : public Service, 
                        virtual public IConversionSvc,
                        virtual public IPersistencySvc,
                        virtual public IAddressCreator  {
protected:
  friend class SvcFactory<PersistencySvc>;
  class ServiceEntry {
    unsigned char    m_serviceType;
    IConversionSvc*  m_service;
    IAddressCreator* m_addrCreator;
  public:
    ServiceEntry(unsigned char type, IConversionSvc* svc, IAddressCreator* cr)  {
      m_serviceType  = type;
      m_addrCreator  = cr;
      m_service      = svc;
    }
    ServiceEntry(const ServiceEntry& copy)  {
      m_serviceType  = copy.m_serviceType;
      m_addrCreator  = copy.m_addrCreator;
      m_service      = copy.m_service;
    }  
    virtual ~ServiceEntry()  {
    }
    IConversionSvc*     service()  {
      return m_service;
    }
    IAddressCreator*    addrCreator()  {
      return m_addrCreator;
    }
    unsigned char svcType()  const {
      return m_serviceType;
    }
  };
  typedef std::map<unsigned char,ServiceEntry> Services;
/*
  class SvcTest : public std::unary_function<ServiceEntry, bool>   {
  public:
    SvcTest(unsigned char test) : m_test(test)    {
    }
    virtual ~SvcTest()    {
    }
    bool operator()( const ServiceEntry& testee )  {
        return m_test == testee.svcType() ? true : false;
    }
  protected:
       unsigned char m_test;
  };
*/
public:


  virtual StatusCode initialize();

  virtual StatusCode finalize();

  unsigned char repSvcType() const;

  virtual StatusCode createObj(IOpaqueAddress* pAddress, DataObject*& refpObject);

  virtual StatusCode updateObj(IOpaqueAddress* pAddress, DataObject* pObject);

  virtual StatusCode updateReps(IDataSelector* pSelector);

  virtual StatusCode createReps(IDataSelector* pSelector);

  virtual StatusCode setStore(IDataProviderSvc* pStore);

  virtual StatusCode addConverter(IConverter* pConverter);

  virtual StatusCode addConverter(const ICnvFactory& refFactory);

  virtual StatusCode removeConverter(const CLID& clid);

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

  virtual StatusCode createAddress(const GenericLinkBase & link, 
                                   const std::string& dbName, 
                                   const std::string& contName, 
                                   const std::string& objName, 
                                   IOpaqueAddress*& refpAddress);

  virtual StatusCode createAddress(unsigned char type, 
                                   const CLID& classId,
                                   const std::string& dbName, 
                                   const std::string& contName, 
                                   int seqId,
                                   IOpaqueAddress*& refpAddress);
  virtual StatusCode setAddressCreator(IAddressCreator* creator);


  virtual StatusCode addCnvService(IConversionSvc* service);

  virtual StatusCode removeCnvService(unsigned char type);

  virtual StatusCode setDefaultCnvService(unsigned char type);

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

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


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

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

  virtual ~PersistencySvc();

  IConversionSvc* service(unsigned char service_type);

  IAddressCreator* addressCreator(unsigned char service_type);

  void       svcNamesHandler( Property& theProp );
  StatusCode decodeSvcNames( );

  unsigned char     m_cnvDefType;
  IDataProviderSvc* m_dataSvc;
  Services          m_cnvServices;
  IConversionSvc*   m_cnvDefault;
  StringArrayProperty m_svcNames;
  std::vector<IConversionSvc*> m_knownSvc;
};
#endif // PERSISTENCYSVC_PERSISTENCYSVC_H

---