---

DbImplementation.cpp

Go to the documentation of this file.

//====================================================================
//      Basic implementation base classes
//--------------------------------------------------------------------
//
//      Package    : DbCnv ( The LHCb Offline System)
//
//      Author     : M.Frank
//====================================================================
#define DBCNV_DBIMPLEMENTATION_CPP 1

#include "GaudiDb/DbImplementation.h"
#include "GaudiDb/DbSession.h"
#include "GaudiDb/DbFederation.h"
#include "GaudiDb/DbDataBase.h"

#include "GaudiKernel/IFactory.h"
#include "GaudiKernel/IMessageSvc.h"
#include "GaudiKernel/ISvcLocator.h"
#include "GaudiKernel/IObjManager.h"
#include "GaudiKernel/IJobOptionsSvc.h"
#include "GaudiKernel/GenericAddress.h"
#include "GaudiKernel/PropertyMgr.h"

// Standard Constructor
DbImplementation::DbImplementation(IOODataBase* idb, 
                                   IMessageSvc* msg, 
                                   unsigned char typ, 
                                   const std::string& name)   {
  m_type = typ;
  m_ooDB = idb;
  m_name = name;
  m_messageSvc = msg;
  if ( m_messageSvc )    m_messageSvc->addRef();
  if ( m_ooDB       )    m_ooDB->addRef();
  if ( m_ooDB       )    m_driver = m_ooDB->driver();
  if ( m_ooDB       )    m_server = m_ooDB->server();
}

// Standard destructor
DbImplementation::~DbImplementation()   {
  if ( m_ooDB       )    m_ooDB->release();
  if ( m_messageSvc )    m_messageSvc->release();
}

// Standard Constructor
OODataBaseImplementation::OODataBaseImplementation(IInterface* loc, unsigned char typ)
  : m_refCount(0), 
    m_type(typ),
    m_name(""),
    m_driver("NoDriver"),
    m_server("(local)"),
    m_svcLocator(0),
    m_messageSvc(0),
    m_propertyMgr(0),
    m_objMgr(0)
{
  if ( loc )    {
    loc->queryInterface(IID_ISvcLocator, (void**)&m_svcLocator);
    loc->queryInterface(IID_IObjManager, (void**)&m_objMgr);
  }
  m_propertyMgr = new PropertyMgr();
  declareProperty("Driver", m_driver);
  declareProperty("Server", m_server);
}

// Standard destructor
OODataBaseImplementation::~OODataBaseImplementation()   {
  m_types.erase(m_types.begin(), m_types.end());
  if ( 0 != m_svcLocator ) m_svcLocator->release();
  if ( 0 != m_objMgr     ) m_objMgr->release();
  delete m_propertyMgr;
}

// Allow access to message service
IMessageSvc* OODataBaseImplementation::msgSvc()   {
  return m_messageSvc;
}

// Allow access to message service (CONST)
const IMessageSvc* OODataBaseImplementation::msgSvc()  const    {
  return m_messageSvc;
}

// IInterface implementation: Increase reference count
unsigned long OODataBaseImplementation::addRef()    {
  return ++m_refCount;
}

// IInterface implementation: Decrease reference count
unsigned long OODataBaseImplementation::release()   {
  long cnt = --m_refCount;
  if ( cnt <= 0 )   {
    delete this;
  }
  return cnt;
}

// IInterface implementation: Query interface
StatusCode OODataBaseImplementation::queryInterface(const IID& riid, void** ppvInterface)  {
  if ( riid == IID_IInterface )   {
    *ppvInterface = (IInterface*)this;
  }
  else if ( riid == IID_IOODataBase )  {
    *ppvInterface = (IOODataBase*)this;
  }
  else if ( riid == IID_IProperty )  {
    *ppvInterface = (IProperty*)this;
  }
  else   {
    return NO_INTERFACE;
  }
  addRef();
  return SUCCESS;
}

// IOODataBase implementation: Access Db name
const std::string& OODataBaseImplementation::name()   const   {
  return m_name;
}

// IOODataBase implementation: Access to OODataBase type
unsigned char OODataBaseImplementation::type()  const   {
  return m_type;
}

// IOODataBase implementation: Access driver's name
const std::string& OODataBaseImplementation::driver()  const    {
  return m_driver;
}

// IOODataBase implementation: Set driver's name
void OODataBaseImplementation::setDriver(const std::string& drv)    {
  m_driver = drv;
}

// IOODataBase implementation: Access database server's name
const std::string& OODataBaseImplementation::server()  const    {
  return m_server;
}

// IOODataBase implementation: Set database server's name
void OODataBaseImplementation::setServer(const std::string& srv)    {
  m_server = srv;
}

// IOODataBase implementation: Initialize the database
StatusCode OODataBaseImplementation::initialize       (const std::string& name)  {
  StatusCode status = StatusCode::FAILURE;
  m_name  =  name;
  m_name += ".DataBase";
  if ( 0 != m_svcLocator )    {
        status = m_svcLocator->getService( "MessageSvc", IID_IMessageSvc, (IInterface*&)m_messageSvc);
    if ( status.isSuccess() )   {
      setProperties();
    }
  }
  return status;
}

// IOODataBase implementation: Finalize the database
StatusCode OODataBaseImplementation::finalize (void)   {
  return StatusCode::SUCCESS;
}

// Request type information to database (CONST)
const DbTypeInfo* OODataBaseImplementation::typeInfo(const std::string& name) const  {
  DataTypes::const_iterator itm = m_types.find( name );
  if( itm != m_types.end() ) { // found name in the known list
    return (*itm).second;
  }
  return 0;
}

// Request type information to database
DbTypeInfo* OODataBaseImplementation::typeInfo(const std::string& name)  {
  DataTypes::iterator itm = m_types.find( name );
  if( itm != m_types.end() ) { // found name in the known list
    return (*itm).second;
  }
  return 0;
}

// Add type information to database
DbResult OODataBaseImplementation::addTypeInfo(const std::string& name, DbTypeInfo * info)   {
  std::pair<DataTypes::iterator, bool> p = m_types.insert(DataTypes::value_type( name, info) );
  if ( p.second )   {
    info->makeDescription();
    return DbOOMs::DbSuccess;
  }
  return DbOOMs::DbError;
}

// IOODataBase implementation: Create type information item for object binding
DbTypeInfo* OODataBaseImplementation::addTypeInfo(const std::string& nam, const std::string& t_type, const std::string& p_type, const std::string& desc, std::vector<DbColumn*>& cols)    {
  DbTypeInfo* typ = 0;
  if ( 0 != m_objMgr )    {
    typ = typeInfo(nam);
    if ( 0 == typ )   {
      std::string ptyp(p_type), ttyp(t_type);
      if ( ptyp == "" ) ptyp = m_defPType;
      if ( ttyp == "" ) ttyp = m_defTType;
      std::string facT="DbFactory<"+ttyp+">";
      std::string facP="DbFactory<"+ptyp+">";
      const IFactory* fT = m_objMgr->objFactory(facT);
      const IFactory* fP = m_objMgr->objFactory(facP);
      if ( fT && fP )    {
        std::vector<DbColumn*> columns;
        DbTypeInfo::CreateT crT = (DbTypeInfo::CreateT)fT->instantiate((IInterface*)0);
        DbTypeInfo::CreateP crP = (DbTypeInfo::CreateP)fP->instantiate((IInterface*)1);
        DbTypeInfo::CreateC crC = (DbTypeInfo::CreateC)fP->instantiate((IInterface*)2);
        long t_size = long(fT->instantiate((IInterface*)11));
        long p_size = long(fP->instantiate((IInterface*)11));
        (*crC)(columns);
        for ( long i = 0, len = cols.size(); i < len; i++ )   {
          columns.push_back(cols[i]);
        }
        cols.erase(cols.begin(), cols.end());
        typ = new DbTypeInfo(crP, ptyp, p_size, crT, ttyp, t_size, nam, desc, m_type, columns);
        if ( addTypeInfo(nam, typ) )    {
          return typ;
        }
        delete typ;
        typ = 0;
      }
    }
  }
  return typ;
}

// IOODataBase implementation: Create type information item for object binding
DbTypeInfo* OODataBaseImplementation::addTypeInfo(const IDbDataBase::Type* pType)    {
  DbTypeInfo* typ = DbTypeInfo::create(pType);
  if ( typ )    {
    DbTypeInfo* typ2 = typeInfo(typ->name());
    if ( typ2 )   {
      delete typ;
      return typ2;
    }
    if ( 0 != m_objMgr )    {
      std::string facT="DbFactory<"+typ->typeNameT()+">";
      std::string facP="DbFactory<"+typ->typeNameP()+">";
      const IFactory* fT = m_objMgr->objFactory(facT);
      const IFactory* fP = m_objMgr->objFactory(facP);
      if ( fT && fP )    {
        DbTypeInfo::CreateT crT = (DbTypeInfo::CreateT)fT->instantiate((IInterface*)0);
        DbTypeInfo::CreateP crP = (DbTypeInfo::CreateP)fP->instantiate((IInterface*)1);
        typ->setCreateT(crT);
        typ->setCreateP(crP);
        if ( addTypeInfo(typ->name(), typ) )      {
          return typ;
        }
      }
    }
    delete typ;
  }
  return 0;
}

// Prepare link between objects
DbResult OODataBaseImplementation::prepareLink(const dbObjectHandle<DbObject>& objH, dbHandle<DbLink>& linkH, void* gen)   {
  unsigned char typ = objH.type();
  if ( typ == OBJY_StorageType ) {
    dbHandle<DbLink>::GENERIC* gene = (dbHandle<DbLink>::GENERIC*)gen;
    unsigned short* src = (unsigned short*)linkH.genericInfo()->m_info;
    unsigned short* tar = (unsigned short*)gene->m_info;
    for ( int i = 0; i < 4; i++ )   {
      tar[i] = src[i];
    }
    return DbOOMs::DbSuccess;
  }
  return DbOOMs::DbError;
}

// IProperty implementation
// Delegate to the Property manager
StatusCode OODataBaseImplementation::setProperty(const Property& p) {
        return m_propertyMgr->setProperty(p);
}

StatusCode OODataBaseImplementation::setProperty(std::istream& s) {
        return m_propertyMgr->setProperty(s);
}

StatusCode OODataBaseImplementation::setProperty(const std::string& n, const std::string& v) {
        return m_propertyMgr->setProperty(n,v);
}

StatusCode OODataBaseImplementation::getProperty(Property* p) const {
        return m_propertyMgr->getProperty(p);
}

const Property& OODataBaseImplementation::getProperty( const std::string& name) const  {
        return m_propertyMgr->getProperty(name);
}

StatusCode OODataBaseImplementation::getProperty(const std::string& n, std::string& v ) const {
        return m_propertyMgr->getProperty(n,v);
}

const std::vector<Property*>& OODataBaseImplementation::getProperties( ) const {
        return m_propertyMgr->getProperties();
}

// Use the job options service to set declared properties
StatusCode OODataBaseImplementation::setProperties() {
        IJobOptionsSvc* jos = 0;
        StatusCode sc = m_svcLocator->getService( "JobOptionsSvc", IID_IJobOptionsSvc, 
                                            (IInterface*&) jos);
    if( !sc.isSuccess() )  return StatusCode::FAILURE;

    jos->setMyProperties( name(), this );

        return StatusCode::SUCCESS;
}

// Standard Constructor
DbSessionImplementation::DbSessionImplementation(IOODataBase* idb, 
                                                 IMessageSvc* msg, 
                                                 unsigned char typ)
: DbImplementation(idb, msg, typ)
{
  m_state = DbOOMs::NOT_OPEN;
}

// Standard Destructor
DbSessionImplementation::~DbSessionImplementation()   {
}

// Release instance (Abstract interfaces do not expose destructor!)
void DbSessionImplementation::release()    {
  delete this;
}

// Get session implementation from handle
IDbSession* DbSessionImplementation::getSession(const dbHandle<DbSession>& sessionH)    {
  IDbSession* ptr = 0;
  if ( sessionH.isValid() )     {
    ptr = sessionH.info();
  }
  return ptr;
}

// Standard Constructor
DbFederationImplementation::DbFederationImplementation(IOODataBase* idb, 
                                                       IMessageSvc* msg, 
                                                       unsigned char typ)
: DbImplementation(idb, msg, typ)
{
}

// Standard Destructor
DbFederationImplementation::~DbFederationImplementation()   {
}

// Release instance (Abstract interfaces do not expose destructor!)
void DbFederationImplementation::release()    {
  delete this;
}

// Get Federation implementation from handle
IDbFederation* DbFederationImplementation::getFederation(const dbHandle<DbFederation>& FederationH)    {
  IDbFederation* ptr = 0;
  if ( FederationH.isValid() )     {
    ptr = FederationH.info();
  }
  return ptr;
}

// Standard constructor
DbDataBaseImplementation::DbDataBaseImplementation(IOODataBase* idb, 
                                                   IMessageSvc* msg, 
                                                   unsigned char typ)
: DbImplementation(idb, msg, typ)
{
}

// Standard Destructor
DbDataBaseImplementation::~DbDataBaseImplementation()  {
}

// Release instance (Abstract interfaces do not expose destructor!)
void DbDataBaseImplementation::release()    {
  delete this;
}

// Find container in database: to be overridden
DbResult DbDataBaseImplementation::find(dbHandle<DbContainer>& /* handle */ )  {
  return DbOOMs::DbSuccess;
}

// Check two links for equality
bool DbDataBaseImplementation::isEqual(const IDbDataBase::Link* link, const dbHandle<DbLink>* test)    {
  if ( link->clID() == test->clID() )   {
    const unsigned char  type      = link->svcType();
    const unsigned long* info      = test->genericInfo()->m_info;
    const unsigned long* link_info = link->genericInfo()->m_info;
    if ( type != OBJY_StorageType && type != TEST_StorageType )   {
      return info[0] == link_info[1];
    }
    else  {
      return info[0] == link_info[0] && info[1] == link_info[1];
    }
  }
  return false;
}

DbResult DbDataBaseImplementation::assocEntry(const std::vector<IDbDataBase::Link*>& links, const dbHandle<DbLink>& test, std::string& db, std::string& cnt, std::string& obj)   {
  const unsigned long* info = test.genericInfo()->m_info;
  const unsigned long  lnk  = info[0];
  if ( /* lnk >= 0 && */ lnk < links.size() )   {
    Link* link = links[lnk];
    bool result = DbDataBaseImplementation::isEqual(links[lnk], &test);
    if ( result )   {
      db  = link->dbase;
      cnt = link->container;
      obj = link->object;
      return DbOOMs::DbSuccess;
    }
    // If this does not help, check all other existing links...
    for( std::vector<IDbDataBase::Link*>::const_iterator i=links.begin(); i != links.end(); i++ )    {
      link = (*i);
      if ( isEqual(link, &test) )   {
        db  = link->dbase;
        cnt = link->container;
        obj = link->object;
        return DbOOMs::DbSuccess;
      }
    }
  }
  return DbOOMs::DbError;
}

// Get container implementation from handle
IDbDataBase* DbDataBaseImplementation::getDataBase(const dbHandle<DbDataBase>& dbH)  {
  IDbDataBase* ptr = 0;
  if ( dbH.isValid() )     {
    ptr = dbH.info();
  }
  return ptr;
}

// Standard constructor
DbContainerImplementation::DbContainerImplementation(IOODataBase* idb, 
                                                     IMessageSvc* msg, 
                                                     unsigned char typ)
: DbImplementation(idb, msg, typ)
{
}

// Standard destructor
DbContainerImplementation::~DbContainerImplementation()    {
}

// Release instance (Abstract interfaces do not expose destructor!)
void DbContainerImplementation::release()    {
  delete this;
}

// Remove object from container
DbResult DbContainerImplementation::remove(dbHandle<DbContainer>& cntH, dbHandle<DbObject>& enclosed)    {
  return cntH.remove(enclosed);
}

// Get container implementation from handle
IDbContainer* DbContainerImplementation::getContainer(const dbHandle<DbContainer>& cntH)  {
  IDbContainer* ptr = 0;
  if ( cntH.isValid() )     {
    ptr = cntH.info();
  }
  return ptr;
}

---