---

DbContainer.cpp

Go to the documentation of this file.

//====================================================================
//      DbContainer handle implementation
//--------------------------------------------------------------------
//
//      Package    : DbCnv ( The LHCb Offline System)
//
//  Description: Generic data persistency
//
//      Author     : M.Frank
//====================================================================
#define DBCNV_DBCONTAINER_CPP

// Framework include files
#include "GaudiDb/DbHandle.h"
#include "GaudiDb/DbContainer.h"
#include "DbContainerObj.h"
#include "DbDataBaseObj.h"

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


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

long dbHandle<DbContainer>::release()  const  {
  if ( isValid() )    {
    long cnt = m_ptr->release();
    if ( 0 >= cnt )  {
      m_ptr = 0;
    }
    return cnt;
  }
  return -1;
}

// Open container from handle
DbResult dbHandle<DbContainer>::open(dbHandle<DbDataBase>& dbH, const std::string& name, const DbTypeInfo& info, DbAccessMode mode)  const   {
  m_name = name;
  m_mode = mode;
  if ( 0 == m_ptr )   {
    if ( dbH.isValid() )    {
      if ( !(dbH.openMode() == DbOOMs::READ && m_mode != DbOOMs::READ) )    {
        DbContainer* q = dbH->find(m_name);
        if ( q )   {
          switchPtr( q );
        }
        else  {
          switchPtr( new DbContainer(dbH, m_name, info, m_mode) );
        }
        return m_ptr->open();
      }
    }
    return DbOOMs::DbError;
  }
  return DbOOMs::DbSuccess;
}

// Open container from handle in READ mode
DbResult dbHandle<DbContainer>::open(dbHandle<DbDataBase>& dbH, const std::string& name)  const   {
  if ( dbH.isValid() )    {
    const DbTypeInfo* info = dbH.objType(name);
    if ( 0 != info )    {
      return open(dbH, name, *info, DbOOMs::READ);
    }
  }
  return DbOOMs::DbError;
}

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


dbHandle<DbDataBase> dbHandle<DbContainer>::containedIn()    const   {
  if ( isValid() )   {
    return m_ptr->database();
  }
  dbHandle<DbDataBase> dbH(type());
  return dbH;
}

long dbHandle<DbContainer>::size()   const {
  if ( isValid() )    {
    return m_ptr->size();
  }
  return 0;
}

DbResult dbHandle<DbContainer>::i_addEntry(const dbHandle<DbObject>& objH)  {
  if ( isValid() )  {
    return m_ptr->addEntry(objH);
  }
  return DbOOMs::DbError;
}

DbResult dbHandle<DbContainer>::i_updateEntry(const dbHandle<DbObject>& objH)  {
  if ( isValid() )  {
    return m_ptr->updateEntry(objH);
  }
  return DbOOMs::DbError;
}

dbHandle<DbObject> dbHandle<DbContainer>::find(const dbHandle<DbLink>& link)    const   {
  dbHandle<DbObject> objH(type());
  if ( isValid() )  {
    m_ptr->find(*this, objH, link);
  }
  return objH;
}

// Close container object if handle is valid
DbResult dbHandle<DbContainer>::close()    const   {
  if ( isValid() )  {
    DbResult res = m_ptr->close();
    switchPtr(0);
    return res;
  }
  return DbOOMs::DbError;
}

// Create iterator to loop over container elements
IDbCursor* dbHandle<DbContainer>::makeCursor()  const  {
  if ( isValid() )    {
    return m_ptr->makeCursor();
  }
  return 0;
}

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

// Perform selection
DbResult dbHandle<DbContainer>::select(ISelectStatement* sel)  const   {
  if ( isValid() )    {
    return m_ptr->select(sel);
  }
  return DbOOMs::DbError;
}

// Reset selection
DbResult dbHandle<DbContainer>::unselect()  const   {
  if ( isValid() )    {
    return m_ptr->unselect();
  }
  return DbOOMs::DbError;
}

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

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

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

// Allow access to the type information
const DbTypeInfo* dbHandle<DbContainer>::typeInfo()  const  {
  if ( isValid() )    {
    return m_ptr->typeInfo();
  }
  return 0;
}

---