---

IOODataBase.h

Go to the documentation of this file.

//====================================================================
//      IOODataBase interface definition
//--------------------------------------------------------------------
//
//      Package    : DbCnv ( The LHCb Offline System)
//
//  Description: Interface of the Db persistenty service
//
//      Author     : M.Frank
//
//====================================================================
#ifndef DBCNV_IOODATABASE_H
#define DBCNV_IOODATABASE_H
// $Header: /nfs/slac/g/glast/ground/cvs/GaudiDb/GaudiDb/IOODataBase.h,v 1.1.1.1 2001/04/18 21:13:34 tlindner Exp $

// C/C++ include files
#include <string>

// Framework include files
#include "GaudiKernel/Kernel.h"
#include "GaudiKernel/StatusCode.h"
#include "GaudiKernel/StreamBuffer.h"
#include "GaudiKernel/IInterface.h"

#include "GaudiDb/DbOOMs.h"
#include "GaudiDb/DbLink.h"
#include "GaudiDb/DbTypeInfo.h"

// Forward declarations
class ISelectStatement;

class IDbSession    {
  // Friend class declaration: this is not a public interface
  friend DbSession;
private:
  // Release (delete) object
  virtual void release() = 0;
  // Open database session
  virtual DbResult open(DbAccessMode mode) = 0;
  // close database session
  virtual DbResult close() = 0;
};

class IDbFederation   {
  friend DbFederation;
private:
  virtual void release()  = 0;
  virtual bool existsDbase(const std::string& name)   const = 0;
  virtual DbResult close()  const = 0;
  virtual DbResult open(dbHandle<DbSession>& sessionH, const std::string& name, DbAccessMode mode) const = 0;
};

class IDbDataBase    {
  friend DbDataBase;
public:
  class Link : public dbHandle<DbLink>   {
    friend DbDataBase;
    Link(const std::string& db, const std::string& cnt, const std::string& obj, const dbHandle<DbLink>& to, long int_id);
    Link() {
    }
    Link(const Link& copy) : dbHandle<DbLink>(copy), dbase(copy.dbase), container(copy.container), object(copy.object)  {
    }
    virtual ~Link()   {
    }
  public:
    std::string dbase;
    std::string container;
    std::string object;
    void serialize(StreamBuffer& buffer);
    void serialize(StreamBuffer& buffer)    const;
    DbResult set(dbHandle<DbLink>& link)    const;
    void print(IMessageSvc* msg, const std::string& tag, const char* opt)   const;
  };
  class Type   {
  public:
    std::string contName;
    std::string objType;
    std::string description;
    Type()     {
    }
    Type(const Type& copy) 
    : contName(copy.contName), 
      objType(copy.objType), 
      description(copy.description)
    {
    }
    Type(const std::string& cont, const std::string& obj, const std::string& desc="") 
    : contName(cont), objType(obj), description(desc)
    {
    }
    virtual ~Type()    {
    }
    void serialize(StreamBuffer& buffer);
    void serialize(StreamBuffer& buffer)    const;
    void print(IMessageSvc* msg, const std::string& tag, const char* opt)   const;
  };
private:
  virtual void release() = 0;
  virtual bool isEqual(const Link* link, const dbHandle<DbLink>* test) = 0;
  virtual DbResult assocEntry(const std::vector<Link*>& links, const dbHandle<DbLink>& test, std::string& db, std::string& cnt, std::string& obj) = 0;
  virtual DbResult close(DbAccessMode mode) const  = 0;
  virtual DbResult open(const dbHandle<DbFederation>& fedH, const std::string& name, DbAccessMode mode)  const  = 0;
  virtual DbResult find(dbHandle<DbContainer>& handle) = 0;
};

class IDbCursor  {
public:
  virtual void release() = 0;
  virtual DbResult next(const dbHandle<DbContainer>& cntH, dbHandle<DbObject>& objH) = 0;
};

class IDbContainer    {
  friend DbContainer;
private:
  virtual void release() = 0;
  virtual long size()  const  = 0;
  virtual DbResult close() const  = 0;
  virtual DbResult open(const dbHandle<DbDataBase>& dbH, const std::string& name, const DbTypeInfo& info, DbAccessMode mode) const = 0;
  virtual DbResult select(ISelectStatement* criteria)  const = 0;
  virtual DbResult unselect() const = 0;
  virtual DbResult find(const dbHandle<DbContainer>& cntH, dbHandle<DbObject>& handle, const dbHandle<DbLink>& link) const = 0;
  virtual DbResult addEntry(const dbHandle<DbObject>& handle)  = 0;
  virtual DbResult updateEntry(const dbHandle<DbObject>& handle)  = 0;
  virtual IDbCursor* makeCursor()  const = 0;
};


// Declaration of the interface ID ( interface id, major version, minor version) 
static const InterfaceID IID_IOODataBase(111, 1 , 0); 

class IOODataBase : virtual public IInterface    {
public:
  static const InterfaceID& interfaceID() { return IID_IOODataBase; }
  typedef DbPersistent* (*CreateP)( const dbHandle<DbContainer>& cntH );
  typedef DbObject*     (*CreateT)( void* buffer);

public:
  virtual StatusCode              initialize       (const std::string& nam) = 0;
  virtual StatusCode              finalize         (void) = 0;
  virtual IMessageSvc*            msgSvc           () = 0;
  virtual unsigned char           type             () const = 0;
  virtual const std::string&      name             () const = 0;
  virtual const std::string&      driver           () const = 0;
  virtual void                    setDriver        (const std::string& drv) = 0;
  virtual const std::string&      server           () const = 0;
  virtual void                    setServer        (const std::string& srv) = 0;
  virtual IDbSession*             createSession    (void) = 0;
  virtual IDbFederation*          createFederation (void) = 0;
  virtual IDbDataBase*            createDataBase   (void) = 0;
  virtual IDbContainer*           createContainer  (void) = 0;
  virtual const DbTypeInfo*       typeInfo         (const std::string& nam)  const = 0;
  virtual DbTypeInfo*             typeInfo         (const std::string& nam)  = 0;
  virtual DbResult                addTypeInfo      (const std::string& nam, DbTypeInfo* info) = 0;
  virtual DbTypeInfo*             addTypeInfo      (const std::string& nam, const std::string& t_type, const std::string& p_type, const std::string& desc, std::vector<DbColumn*>& cols) = 0;
  virtual DbTypeInfo*             addTypeInfo      (const IDbDataBase::Type* pType) = 0;
  virtual DbResult                prepareLink      (const dbObjectHandle<DbObject>& objH, dbHandle<DbLink>& linkH, void* gene) = 0;
};

#endif  // DBCNV_IOODATABASE_H

---