PoolDbCnvSvc.h

Go to the documentation of this file.

// $Id: PoolDbCnvSvc.h,v 1.14 2008/01/23 14:31:50 hmd Exp $
//====================================================================
//      PoolDbCnvSvc definition
//--------------------------------------------------------------------
//
//      Author     : M.Frank
//====================================================================
#ifndef POOLDB_POOLDBCNVSVC_H
#define POOLDB_POOLDBCNVSVC_H
// $Header: /tmp/svngaudi/tmp.jEpFh25751/Gaudi/GaudiPoolDb/GaudiPoolDb/PoolDbCnvSvc.h,v 1.14 2008/01/23 14:31:50 hmd Exp $

// Framework include files
#include "GaudiPoolDb/IPoolDbMgr.h"
#include "GaudiKernel/ConversionSvc.h"
#include "GaudiKernel/DataObject.h"
#include "StorageSvc/DbSession.h"
#include "StorageSvc/DbDomain.h"
#include "StorageSvc/DbDatabase.h"
#include "StorageSvc/DbContainer.h"
#include "StorageSvc/DbOptionCallback.h"
#include "StorageSvc/DbDefaultDataHandler.h"


#include <map>

// Forward declarations
class IPoolCacheSvc;
class IDataManagerSvc;
namespace Gaudi {
  class IIncidentSvc;
  class IFileCatalog;
  class IIODataManager;
  class IDataConnection;
}
class PoolDbDataConnection;

class PoolDbCnvSvc : public ConversionSvc, 
                     public pool::DbOptionCallback,
                     virtual public IPoolDbMgr
{
public:
  struct DbH  {
    pool::DbDatabase     first;
    pool::DbTransaction* second;
    int                  count;

    DbH(const pool::DbDatabase& db, pool::DbTransaction* tr, int cr)
    : first(db), second(tr), count(cr) {}
    DbH(const DbH& c) 
    : first(c.first), second(c.second), count(c.count) {}
  };
  typedef std::pair< void*, const ROOT::Reflex::Type >      ObjH;
  typedef std::map<std::string, DbH>                        DbMap;
  typedef std::map<std::string, std::string>                DbFidMap;

protected:
  std::string              m_cacheSvcName;

  std::string              m_implementation;

  std::string              m_serverConnect;

  bool                     m_safeTransactions;

  std::vector<std::string> m_domainOpts;

  std::vector<std::string> m_databaseOpts;

  std::vector<std::string> m_containerOpts;

  IDataManagerSvc*         m_dataMgr;

  IPoolCacheSvc*           m_cacheSvc;

  PoolDbDataConnection*    m_current;

  pool::DbDefaultDataHandler m_handler;

  pool::DbDomain           m_domH;

  std::string              m_shareFiles;

  bool                     m_checkFIDs;

  Gaudi::IFileCatalog*     m_catalog;

  Gaudi::IIODataManager*   m_ioMgr;

  IIncidentSvc*            m_incidentSvc;

  bool                     m_incidentEnabled;
public:
  PoolDbCnvSvc(const std::string& name, ISvcLocator* svc);

  virtual ~PoolDbCnvSvc();

  virtual StatusCode updateServiceState(IOpaqueAddress* pAddress);

  StatusCode error(const std::string& msg, bool rethrow=true);

  StatusCode setDataProvider(IDataProviderSvc* pDataSvc);

public:

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

  virtual StatusCode initialize();

  virtual StatusCode finalize();

  virtual IConverter* createConverter(long typ, 
                                      const CLID& wanted, 
                                      const ICnvFactory* fac);

  virtual void loadConverter(DataObject*);
  
  virtual IPoolCacheSvc* cacheSvc() const {  return m_cacheSvc; }

  virtual StatusCode accessStorageType(const std::string& type_string, 
                                       long& gaudi_type);

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


  StatusCode  connectDatabase(int typ, 
                              const std::string& outputFile, 
                              pool::DbAccessMode openMode,
                              PoolDbDataConnection** con);

  StatusCode connectContainer(        pool::DbDatabase& dbH,
                                      const std::string& cntName, 
                                      pool::DbAccessMode openMode, 
                                      const pool::DbTypeInfo* shape,
                                      pool::DbContainer& cntH);

  virtual StatusCode connectContainer(int typ, 
                                      const std::string& dbName,
                                      const std::string& cntName,
                                      pool::DbAccessMode openMode,
                                      const pool::DbTypeInfo* shape,
                                      pool::DbContainer& cntH
                                      );

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

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

  virtual StatusCode connect(const std::string& dbName, 
                             const std::string& cntName,
                             pool::DbContainer& cntH);

  virtual StatusCode disconnect(const std::string& dbName);

  virtual StatusCode createAddress( long                 svc_type,
                                    const CLID&          clid,
                                    const std::string*   par, 
                                    const unsigned long* ip,
                                    IOpaqueAddress*&     refpAddress);
  
  virtual StatusCode createAddress( pool::Token*         pToken,
                                    PoolDbAddress**      ppAddress);
  
  virtual pool::DbSelect* createSelect(const std::string& criteria,
                                       const std::string& dbName,
                                       const std::string& cntName);

  virtual pool::DbSelect* createSelect(const std::string& criteria,
                                       pool::DbDatabase&  dbH,
                                       const std::string& cntName);

  virtual StatusCode markWrite(     pool::DataCallBack* call,
                                    const std::string& cntName,
                                    PoolDbAddress**    ppAddr=0);

  virtual StatusCode markUpdate(    pool::DataCallBack* call,
                                    PoolDbAddress*     pAddr);

  virtual StatusCode read(          pool::DataCallBack* call,
                                    PoolDbAddress*     pAddr);


  virtual StatusCode read(          pool::DataCallBack* call,
                                    pool::Token& tok);
};
#endif  // POOLDB_POOLDBCNVSVC_H