---

DbFederation.cpp

Go to the documentation of this file.

//====================================================================
//      DbFederation handle implementation
//--------------------------------------------------------------------
//
//      Package    : DbCnv ( The LHCb Offline System)
//      Author     : M.Frank
//====================================================================
#define DBCNV_DBFEDERATION_CPP

// Framework include files
#include "GaudiDb/DbFederation.h"
#include "GaudiDb/DbObject.h"
#include "DbDataBaseObj.h"
#include "DbContainerObj.h"
#include "DbFederationObj.h"

// friend's constructor
dbHandle<DbFederation>::dbHandle(DbFederation* fed)   {
  switchPtr( fed );
  if ( fed )    {
    m_name = fed->name();
    m_mode = fed->mode();
    m_type = fed->type();
  }
}

// Add reference count to object if present
long dbHandle<DbFederation>::addRef()  const   {
  if ( isValid() )    {
    return m_ptr->addRef();
  }
  return -1;
}

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

const char* dbHandle<DbFederation>::typeName()    const  {
  return "DbFederation";
}

DbResult dbHandle<DbFederation>::open(const dbHandle<DbSession>& sessionH, const std::string& name, DbAccessMode mode)  const  {
  if ( sessionH.isValid() )    {
    DbFederation* fed = sessionH.find(name);
    m_mode = mode;
    if ( !fed )   {
      fed = new DbFederation(sessionH, name, m_mode);
    }
    switchPtr(fed);
    m_name = name;
    return fed->open();
  }
  close();
  return DbOOMs::DbError;
}

DbResult dbHandle<DbFederation>::close()   const    {
  if ( isValid() )    {
    m_ptr->close();
  }
  m_name = "";
  m_mode = DbOOMs::READ;
  switchPtr(0);
  return DbOOMs::DbSuccess;
}

bool dbHandle<DbFederation>::exist(const dbHandle<DbSession>& sessionH, const std::string& name)  const    {
  if ( sessionH.isValid() )    {
    dbHandle<DbFederation> p = sessionH.find(name);
    return p.isValid();
  }
  return false;
}

dbHandle<DbSession> dbHandle<DbFederation>::containedIn()    const   {
  if ( isValid() )   {
    return m_ptr->session();
  }
  dbHandle<DbSession> handle(type());
  return handle;
}

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

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

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

// Find federation in session
DbResult dbHandle<DbFederation>::remove(DbDataBase* dbH)  const   {
  if ( isValid() )   {
    return m_ptr->remove(dbH) ? DbOOMs::DbSuccess : DbOOMs::DbError;
  }
  return DbOOMs::DbError;
}

bool dbHandle<DbFederation>::existsDbase( const std::string& name )   const   {
  if ( isValid() )    {
    return m_ptr->existsDbase(name);
  }
  return false;
}

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

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

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

---