---

DbContainerObj.cpp

Go to the documentation of this file.

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

// Framework include files
#include "GaudiKernel/System.h"
#include "GaudiKernel/MsgStream.h"
#include "GaudiDb/IOODataBase.h"
#include "GaudiDb/DbHandle.h"
#include "GaudiDb/DbTypeInfo.h"
#include "GaudiDb/DbContainer.h"
#include "DbContainerObj.h"

// Constructor
DbContainer::DbContainer(dbHandle<DbDataBase>& dbH, const std::string& name, const DbTypeInfo& info, DbAccessMode mode)   
: m_info(0), m_typeInfo(info)
{
  m_isOpen    = false;
  m_type      = m_typeInfo.type();
  m_dbOOMs    = dbH.db();
  m_msgSvc    = dbH.msgSvc();
  if ( 0 != m_dbOOMs && dbH.isValid() && m_typeInfo.name().length() > 0 )    {
    if ( dbH.add( name, this) )    {
      m_database = dbH;
      m_name     = name;
      m_mode     = mode;
      if ( mode & DbOOMs::UPDATE ) {
        m_mode |= DbOOMs::CREATE;
      }
      m_info     = m_dbOOMs->createContainer();
      m_database.addRef();
      /*
      MsgStream log(m_msgSvc,dbH.name());
      log << MSG::DEBUG
          << "--> Access   DbContainer  "
          << " Type:" << m_dbOOMs->name() 
          << " Mode:" << DbOOMs::accessMode(m_mode) 
          << "  " << m_name
          << endreq;
      */
      MsgStream log(m_msgSvc, dbH.name());
      log << MSG::DEBUG
          << "--> Access   DbContainer  " << DbOOMs::accessMode(m_mode) << " " << m_name
          << endreq;
      return;
    }
  }
  MsgStream err(m_msgSvc,System::moduleName());
  err << MSG::ERROR
      << "--> Access   DbContainer  "
      << " Mode:" << DbOOMs::accessMode(mode) 
      << "  " << name
      << " impossible. Cannot link to implementation."
      << endreq;
}

// Destructor
DbContainer::~DbContainer()    {
  std::string identifier = m_database.isValid() ? m_database.name() : System::moduleName();
  clearEntries();
  if ( 0 != m_info )    {
    m_info->release();
    m_info = 0;
  }
  DbContainer* p = m_database.find(name());
  if ( p )   {
    m_database.remove ( p );
  }
  m_database.release();
  MsgStream log(m_msgSvc, identifier);
  /*
  std::string dbtyp((m_dbOOMs) ? m_dbOOMs->name() : "UNKNOWN");
  log << MSG::DEBUG
      << "--> Deaccess DbContainer  "
      << " Type:" << dbtyp
      << " Mode:" << DbOOMs::accessMode(m_mode) 
      << "  " << m_name
      << endreq;
  */
  log << MSG::DEBUG
      << "--> Deaccess DbContainer  " << DbOOMs::accessMode(m_mode) << " " << m_name
      << endreq;
}

// Retrieve container size
long DbContainer::size()    const   {
  if ( 0 == m_info )    {
    std::string identifier = m_database.isValid() ? m_database.name() : System::moduleName();
    MsgStream log(m_msgSvc, identifier);
    log << MSG::ERROR
        << "--> Access   DbContainer::size()" 
        << "  " << m_name
        << " impossible - invalid object!"
        << endreq;
    return -1;
  }
  return m_info->size();
}

// Open database container
DbResult DbContainer::open()    const   {
  if ( !m_isOpen )    {
    if ( 0 != m_info )    {
      if ( m_info->open(m_database, m_name, m_typeInfo, m_mode) )   {
        m_isOpen = true;
        return DbOOMs::DbSuccess;
      }
    }
    return DbOOMs::DbError;
  }
  return DbOOMs::DbSuccess;
}

// Close database container
DbResult DbContainer::close()    const   {
  if ( m_isOpen )    {
    if ( 0 != m_info )    {
      //DbContainer* thisPtr = const_cast<DbContainer*>(this);
      //thisPtr->clearEntries();
      //release();
      if ( m_info->close() )   {
        m_isOpen = false;
        DbContainer* p = m_database.find(m_name);
        if ( p )   {
          m_database.remove ( p );
        }
        //std::cout << "internam release:" << m_name << std::endl;
        return DbOOMs::DbSuccess;
      }
    }
    return DbOOMs::DbError;
  }
  else if ( m_database.isValid() )   {
    DbContainer* p = m_database.find(m_name);
    if ( p )   {
      m_database.remove ( p );
    }
  }
  return DbOOMs::DbSuccess;
}

// Add entry to container
DbResult DbContainer::addEntry(const dbHandle<DbObject>& objH)   {
  objH.setType(type());
  if ( m_isOpen && m_info && m_mode != DbOOMs::READ )   {
    if ( m_info->addEntry(objH) )   {
      return m_database.addType(m_name, m_typeInfo);
    }
  }
  return DbOOMs::DbError;
}

// Add entry to container
DbResult DbContainer::updateEntry(const dbHandle<DbObject>& objH)   {
  objH.setType(type());
  if ( m_isOpen && m_info && m_mode != DbOOMs::READ )   {
    return m_info->updateEntry(objH);
  }
  return DbOOMs::DbError;
}

// Find entry in container
DbResult DbContainer::find(const dbHandle<DbContainer>& cntH, dbHandle<DbObject>& objH, const dbHandle<DbLink>& linkH)  const {
  if ( m_isOpen )   {
    objH.setType(m_database.type());
    if ( m_info )   {
      return m_info->find(cntH, objH, linkH);
    }
  }
  return DbOOMs::DbError;
}

DbResult DbContainer::remove(dbHandle<DbObject>& element)   {
  if ( element.isValid() && m_isOpen )    {
    DbObject* it = _Base::find(element.ptr());
    if ( it )    {
      element = dbHandle<DbObject>(m_database.type());
      return _Base::remove(it) ? DbOOMs::DbError : DbOOMs::DbSuccess;
    }
  }
  return DbOOMs::DbError;
}

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

// Reset selection
DbResult DbContainer::unselect()  const   {
  if ( m_info )    {
    return m_info->unselect();
  }
  return DbOOMs::DbError;
}

IDbCursor* DbContainer::makeCursor()  const  {
  if ( m_info )    {
    return m_info->makeCursor();
  }
  return 0;
}

---