---

DbSession.cpp

Go to the documentation of this file.

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

#include "GaudiDb/DbSession.h"
#include "GaudiDb/DbObject.h"
#include "DbDataBaseObj.h"
#include "DbContainerObj.h"
#include "DbFederationObj.h"
#include "DbSessionObj.h"

// Attach session to handle
void dbHandle<DbSession>::switchPtr(_DataType* obj)  const  {
  if (   obj ) obj->addRef();
  if ( m_ptr ) m_ptr->release();
  m_ptr = obj;
  if ( m_ptr )   {
    setType(m_ptr->type());
  }
}

// Handle constructor
dbHandle<DbSession>::dbHandle<DbSession>(unsigned char type)    {
  m_mode = DbOOMs::READ;
  setType(type);
}

// Copy constructor
dbHandle<DbSession>::dbHandle(const dbHandle<DbSession>& copy)     
: dbHandleBase<DbSession>()
{
  *this = copy;
}

// Standard Destructor
dbHandle<DbSession>::~dbHandle()     {
  switchPtr( 0 );
}

// Assignment operator
dbHandle<DbSession>& dbHandle<DbSession>::operator=(const dbHandle<DbSession>& copy)   {
  switchPtr( copy.m_ptr );
  m_mode = copy.m_mode;
  setType(copy.type());
  return *this;
}

// type name of session
const char* dbHandle<DbSession>::typeName()    const  {
  return "DbSession";
}

// Access Session mode
DbAccessMode dbHandle<DbSession>::openMode()   const   {
  return m_mode;
}

// Open session by handle
DbResult dbHandle<DbSession>::open(IOODataBase* db, IMessageSvc* msg, DbAccessMode mode)   {
  m_mode = mode;
  if ( !m_ptr )   {
    switchPtr(new DbSession(db, msg, type()));
  }
  return (isValid()) ? m_ptr->open(m_mode) : DbOOMs::DbError;
}

// Close session by handle
DbResult dbHandle<DbSession>::close()   const   {
  if ( m_ptr )     {
    m_ptr->clearEntries();
    m_ptr->close();
  }
  switchPtr(0);
  m_mode = DbOOMs::NOT_OPEN;
  return DbOOMs::DbSuccess;
}

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

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

// Remove federation from current session
DbResult dbHandle<DbSession>::remove(DbFederation* fed)   {
  if ( isValid() )    {
    return m_ptr->remove(fed);
  }
  return DbOOMs::DbError;
}

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

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

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

---