---

DbDataBase.cpp

Go to the documentation of this file.

//====================================================================
//      DbDataBase handle implementation
//--------------------------------------------------------------------
//
//      Package    : System ( The LHCb Offline System)
//
//  Description: Generic data persistency
//
//      Author     : M.Frank
//  History    :
// +---------+----------------------------------------------+---------
// |    Date |                 Comment                      | Who     
// +---------+----------------------------------------------+---------
// | 11/07/99| Initial version                              | MF
// +---------+----------------------------------------------+---------
//====================================================================
#define DBCNV_DBDATABASE_CPP

#include "GaudiDb/DbDataBase.h"
#include "GaudiDb/DbObject.h"
#include "GaudiDb/DbHandle.h"
#include "DbContainerObj.h"
#include "DbDataBaseObj.h"

dbHandle<DbDataBase>::dbHandle(DbDataBase* obj)    {
  switchPtr( obj );
  if ( m_ptr )    {
    m_name = m_ptr->name();
    m_mode = m_ptr->mode();
    m_type = m_ptr->type();
  }
}

long dbHandle<DbDataBase>::addRef()  const  {
  if ( isValid() )    {
    return m_ptr->addRef();
  }
  return -1;
}

// Decrease reference count on object; if 0, invalidate handle
long dbHandle<DbDataBase>::release()  const  {
  if ( isValid() )    {
    long cnt = m_ptr->release();
    if ( 0 >= cnt )  {
      m_ptr = 0;
    }
    return cnt;
  }
  return -1;
}

dbHandle<DbFederation> dbHandle<DbDataBase>::containedIn()    const   {
  dbHandle<DbFederation> handle;
  return (0 == m_ptr) ? handle : m_ptr->federation();
}

void dbHandle<DbDataBase>::switchPtr(DbDataBase* obj)  const  {
  if (   obj ) obj->addRef();
  if ( m_ptr ) m_ptr->release();
  m_ptr = obj;
  if ( m_ptr )  {
    setType(obj->type());
  }
}

// Check if database exisst within scope of federation
bool dbHandle<DbDataBase>::exist(const dbHandle<DbFederation>& fedH, const std::string& name)  const   {
  if ( fedH.isValid() )   {
    return fedH.existsDbase(name);
  }
  return false;
}

// Open database
DbResult dbHandle<DbDataBase>::open(const dbHandle<DbFederation>& fedH, const std::string& name, DbAccessMode mode)  const  {
  if ( fedH.isValid() )   {
    dbHandle<DbDataBase> db = fedH.find(name);
    if ( !db.isValid() )   {
      db = new DbDataBase(fedH, name, mode);
      if ( DbOOMs::DbSuccess != db->open() )    {
        switchPtr(0);
        db.switchPtr(0);
        return DbOOMs::DbError;
      }
    }
    switchPtr(db.ptr());
    m_mode = db.openMode();
    m_name = name;
    m_type = fedH.type();
    return DbOOMs::DbSuccess;
  }
  return DbOOMs::DbError;
}

// Close database
DbResult dbHandle<DbDataBase>::close()  const  {
  if ( isValid() )    {
    m_ptr->close();
  }
  switchPtr(0);  
  return DbOOMs::DbSuccess;
}

// Add federation to session
DbResult dbHandle<DbDataBase>::add(const std::string& name, DbContainer* cnt)  const    {
  if ( isValid() && cnt )    {
    return m_ptr->add(name, cnt);
  }
  return DbOOMs::DbError;
}

// Find federation in session
DbContainer* dbHandle<DbDataBase>::find(const std::string& name)  const    {
  if ( isValid() )    {
    return m_ptr->find(name);
  }
  return 0;
}

// Find federation in session
DbResult dbHandle<DbDataBase>::remove( DbContainer* cnt)   {
  if ( isValid() )    {
    return m_ptr->remove(cnt);
  }
  return DbOOMs::DbError;
}

DbResult dbHandle<DbDataBase>::addType (const std::string& cntName, const DbTypeInfo& refType)   {
  if ( isValid() )    {
    return m_ptr->addType(cntName, refType);
  }
  return DbOOMs::DbError;
}

const DbTypeInfo* dbHandle<DbDataBase>::objType(const std::string& name) const    {
  if ( isValid() )    {
    return m_ptr->objType(name);
  }
  return 0;
}

// Add association link to link container
DbResult dbHandle<DbDataBase>::addAssocEntry(const std::string& db, const std::string& cnt, const std::string& obj, dbHandle<DbLink>& to)   {
  if ( isValid() )    {
    return m_ptr->addAssocEntry(db, cnt, obj, to);
  }
  return DbOOMs::DbError;
}

// Retrieve the number of all contained object types
long dbHandle<DbDataBase>::numAssocEntries()  const     {
  if ( isValid() )    {
    return m_ptr->numAssocEntries();
  }
  return -1;
}

// Retrieve association link from link container
DbResult dbHandle<DbDataBase>::assocEntry(const dbHandle<DbLink>& which, std::string& db, std::string& cnt, std::string& obj)  const   {
  if ( isValid() )    {
    return m_ptr->assocEntry(which, db, cnt, obj);
  }
  return DbOOMs::DbError;
}

// Retrieve association link from link container
DbResult dbHandle<DbDataBase>::assocEntry(long id, dbHandle<DbLink>& which, std::string& db, std::string& cnt, std::string& obj)  const   {
  if ( isValid() )    {
    return m_ptr->assocEntry(id, which, db, cnt, obj);
  }
  return DbOOMs::DbError;
}

// Access implementation internals
IDbDataBase* dbHandle<DbDataBase>::info()   const   {
  if ( isValid() )    {
    return m_ptr->info();
  }
  return 0;
}

// Allow access to the database implementation
IOODataBase* dbHandle<DbDataBase>::db()    {
  if ( isValid() )    {
    return m_ptr->db();
  }
  return 0;
}

// Allow access to the message service
IMessageSvc* dbHandle<DbDataBase>::msgSvc()    {
  if ( isValid() )    {
    return m_ptr->msgSvc();
  }
  return 0;
}

---