---

DbImplementation.h

Go to the documentation of this file.

//====================================================================
//      DbCnvImpl definitions
//--------------------------------------------------------------------
//
//      Package    : System ( The LHCb Offline System)
//
//      Author     : M.Frank
//====================================================================
#ifndef DBCNV_DBIMPLEMENTATION_H
#define DBCNV_DBIMPLEMENTATION_H 1

#include "GaudiKernel/IProperty.h"
#include "GaudiKernel/PropertyMgr.h"
#include "GaudiDb/IOODataBase.h"
#include "GaudiDb/DbContainer.h"

// STL include files
#include <map>

// Forward declarations
class IMessageSvc;
class ISvcLocator;
class IObjManager;
class DbImplementation   {
protected:
  IMessageSvc*            m_messageSvc;
  unsigned char           m_type;
  IOODataBase*            m_ooDB;
  mutable std::string     m_name;
  std::string             m_driver;
  std::string             m_server;
protected:
  virtual ~DbImplementation();
public:
  DbImplementation(IOODataBase* idb, IMessageSvc* msg, unsigned char typ, const std::string& name="");
  unsigned char type()  const;
  const std::string& name()  const;
  const std::string& driver()  const;
  const std::string& server()  const;
  IMessageSvc* messageSvc();
  IOODataBase* db();
};

class OODataBaseImplementation
    : virtual public IInterface, 
      virtual public IOODataBase, 
      virtual public IProperty
{
private:
  typedef std::map<std::string, DbTypeInfo*>   DataTypes;
  DataTypes               m_types;
protected:
  long                    m_refCount;
  unsigned char           m_type;
  mutable std::string     m_name;
  std::string             m_driver;
  std::string             m_server;
  std::string             m_defTType;
  std::string             m_defPType;
  ISvcLocator*            m_svcLocator;
  IMessageSvc*            m_messageSvc;
  PropertyMgr*            m_propertyMgr;
  IObjManager*            m_objMgr;
protected:
  OODataBaseImplementation(IInterface* loc, unsigned char typ);
  virtual ~OODataBaseImplementation();
public:
  virtual unsigned long addRef();
  virtual unsigned long release();
  virtual StatusCode queryInterface(const IID& riid, void** ppvInterface);
  virtual StatusCode initialize       (const std::string& name);
  virtual StatusCode              finalize (void);
  virtual unsigned char type()  const;
  virtual const std::string& name()  const;
  virtual const std::string& driver()  const;
  virtual void setDriver(const std::string& drv);
  virtual const std::string& server()  const;
  virtual void  setServer(const std::string& srv);
  virtual const DbTypeInfo* typeInfo(const std::string& nam) const;
  virtual DbTypeInfo* typeInfo(const std::string& nam);
  virtual DbResult addTypeInfo(const std::string& nam, DbTypeInfo * info);
  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);
  virtual DbTypeInfo* addTypeInfo(const IDbDataBase::Type* pType);
  virtual DbResult prepareLink(const dbObjectHandle<DbObject>& objH, dbHandle<DbLink>& linkH, void* gen);
  // Default implementations for ISetProperty
  virtual StatusCode setProperty(const Property& p);
  virtual StatusCode setProperty( std::istream& s );
  virtual StatusCode setProperty( const std::string& n, const std::string& v);
  virtual StatusCode getProperty(Property* p) const;
  virtual const Property& getProperty( const std::string& name) const;
  virtual StatusCode getProperty( const std::string& n, std::string& v ) const;
  virtual const std::vector<Property*>& getProperties( ) const;

  // Method for setting declared properties to the values
  // specifed for the job.
  virtual StatusCode setProperties();

  template <class T>
  StatusCode declareProperty( const std::string& name, T& property ) const {
        m_propertyMgr->declareProperty(name, property);
        return StatusCode::SUCCESS;
  }

  IMessageSvc* msgSvc();
  const IMessageSvc* msgSvc()  const;
};

class DbSessionImplementation 
: public DbImplementation, virtual public IDbSession
{
protected:
  DbAccessMode       m_state;
  virtual ~DbSessionImplementation();
public:
  DbSessionImplementation(IOODataBase* idb, IMessageSvc* msg, unsigned char typ);
  virtual void release();
  static IDbSession* getSession(const dbHandle<DbSession>& sessionH);
};

class DbFederationImplementation 
: public DbImplementation, virtual public IDbFederation
{
protected:
  virtual ~DbFederationImplementation();
public:
  DbFederationImplementation(IOODataBase* idb, IMessageSvc* msg, unsigned char typ);
  virtual void release();
  static IDbFederation* getFederation(const dbHandle<DbFederation>& fedH);
};

class DbDataBaseImplementation 
: public DbImplementation, virtual public IDbDataBase
{
protected:
  dbHandle<DbContainer>  m_links;
  DbAccessMode           m_mode;
protected:
  virtual ~DbDataBaseImplementation();
public:
  DbDataBaseImplementation(IOODataBase* idb, IMessageSvc* msg, unsigned char typ);
  virtual void release();
  virtual DbResult find(dbHandle<DbContainer>& handle);
  virtual bool isEqual(const IDbDataBase::Link* link, const dbHandle<DbLink>* test);
  virtual DbResult assocEntry(const std::vector<IDbDataBase::Link*>& links, const dbHandle<DbLink>& test, std::string& db, std::string& cnt, std::string& obj);
  static IDbDataBase* getDataBase(const dbHandle<DbDataBase>& dbH);
};

class DbContainerImplementation 
: public DbImplementation, virtual public IDbContainer
{
protected:
  virtual ~DbContainerImplementation();
public:
  DbContainerImplementation(IOODataBase* idb, IMessageSvc* msg, unsigned char typ);
  virtual void release();
  static DbResult remove(dbHandle<DbContainer>& cntH, dbHandle<DbObject>& enclosed);
  static IDbContainer* getContainer(const dbHandle<DbContainer>& cntH);
};

//##############################################################################
// Inline code:

// Access to OODataBase type
inline unsigned char DbImplementation::type()  const   {
  return m_type;
}

// Access to Message service
inline IMessageSvc* DbImplementation::messageSvc()   {
  return m_messageSvc;
}

inline IOODataBase* DbImplementation::db()   {
  return m_ooDB;
}

// Access object's name
inline const std::string& DbImplementation::name()  const    {
  return m_name;
}

// Access driver's name
inline const std::string& DbImplementation::driver()  const    {
  return m_driver;
}

// Access database server's name
inline const std::string& DbImplementation::server()  const    {
  return m_server;
}

//##############################################################################
#endif // DBCNV_DBIMPLEMENTATION_H

---