---

CdbBdbWCdb.cc

Go to the documentation of this file.

// File and Version Information:
//      $Id: CdbBdbWCdb.cc,v 1.18 2005/02/02 13:58:08 gapon Exp $

/// The implementation of the CdbBdbWCdb singleton.
/**
  * @see CdbBdbWCdb
  */

#include "BaBar/BaBar.hh"

#include "CdbBdbWrapper/CdbBdbWCdb.hh"

#include "CdbBase/CdbEnvironment.hh"
#include "CdbBase/CdbDatabase.hh"
#include "CdbBase/CdbDebugStream.hh"

#include "CdbBdb/CdbBdbTransaction.hh"

#include "CdbBdbWrapper/CdbBdbWrapper.hh"
#include "CdbBdbWrapper/CdbBdbWDatabase.hh"
#include "CdbBdbWrapper/CdbBdbWDatabaseItr.hh"

#include "BdbCond/BdbConditions.hh"

#include "ErrLogger/ErrLog.hh"

#include <string.h>
#include <assert.h>
using std::endl;

CdbBdbWCdb::CdbBdbWCdb( ) :
    Cdb( ),
    _isInitialized(false)   // For the sake of deffered initialization
{
    CDB_DEBUG_STREAM << "Condition/DB API instantiated for"
                     << " TECHNOLOGY=\"" << CdbBdbWrapper::technology( ) << "\""
                     << " IMPLEMENTATION=\"" << CdbBdbWrapper::implementation( ) << "\""
                     << endl;

  // Try to register itself in the API registry.
  //
  // NOTE: If the registration will fail then we may probably encounter a fatal
  //       unrecoverable problem with implementations of CDB API. One of the possible
  //       reasons of the falure would be if another implementation of the API has already
  //       registered itself in the dictionary under the same names.

    CdbPtr myPtr = this;

    if( CdbStatus::Success != set( myPtr ))
        ErrMsg(fatal) << "failed to register the top level API component in the dictionary." << endmsg;
}

CdbBdbWCdb::~CdbBdbWCdb( )
{ }

const char*
CdbBdbWCdb::technologyName( ) const
{
    return CdbBdbWrapper::technology( );
}

const char*
CdbBdbWCdb::implementationName( ) const
{
    return CdbBdbWrapper::implementation( );
}

void
CdbBdbWCdb::initialize( )
{
    if( !_isInitialized ) {

      // There is nothing else we should do to be initializaed

        _isInitialized = true;
    }
}

bool
CdbBdbWCdb::isInitialized( )
{
    return _isInitialized;
}

CdbStatus
CdbBdbWCdb::getDefaultDatabase( std::string& theDatabase )
{
    assert( isInitialized( ));

    theDatabase = BdbConditions::instance( )->bootName( );

    return CdbStatus::Success;
}

CdbStatus
CdbBdbWCdb::getDefaultView( std::string& theView,
                            const char*  theDatabaseName )
{
    assert( isInitialized( ));

    CdbStatus result = CdbStatus::NotFound;
    do {

      // Verify the database name
      //
      // We only allow the following:
      //
      //   - "<default>"
      //   - the actual BOOT file name of the CDB federation.
      //
      // All these options are treated equally since we only have just one database
      // in the current implementation.

        if( 0 == theDatabaseName ) break;

        if( ! (( 0 == strcmp( theDatabaseName, "<default>" )) ||
               ( 0 == strcmp( theDatabaseName, BdbConditions::instance( )->bootName( ))))) break;

      // The only name we know about is the pseudo name of the most recent view
      // in the local database.

        theView = "<local>::<recent>";

      // Done

        result = CdbStatus::Success;

    } while( false );

    return result; 
}

CdbStatus
CdbBdbWCdb::setDefaultDatabase( const char* theDatabaseName )
{
    assert( isInitialized( ));

  // This is basically "do nothing; method. It just checks for the correctness
  // of the database name.

    CdbStatus result = CdbStatus::NotFound;
    do {

      // Verify the database name
      //
      // We only allow the following:
      //
      //   - "<default>"
      //   - the actual BOOT file name of the CDB federation.
      //
      // All these options are treated equally since we only have just one database
      // in the current implementation.

        if( 0 == theDatabaseName ) break;

        if( ! (( 0 == strcmp( theDatabaseName, "<default>" )) ||
               ( 0 == strcmp( theDatabaseName, BdbConditions::instance( )->bootName( ))))) break;

      // Done

        result = CdbStatus::Success;

    } while( false );

    return result; 
}

CdbStatus
CdbBdbWCdb::setDefaultView( const char* theViewName,
                            const char* theDatabaseName )
{
    assert( isInitialized( ));

  // This is basically "do nothing; method. It just checks for the correctness
  // of the database name.

    CdbStatus result = CdbStatus::NotFound;
    do {

      // Verify the database name
      //
      // We only allow the following:
      //
      //   - "<default>"
      //   - the actual BOOT file name of the CDB federation.
      //
      // All these options are treated equally since we only have just one database
      // in the current implementation.

        if( 0 == theDatabaseName ) break;

        if( ! (( 0 == strcmp( theDatabaseName, "<default>" )) ||
               ( 0 == strcmp( theDatabaseName, BdbConditions::instance( )->bootName( ))))) break;


      // Verify the database name
      //
      // The only name we know about is the pseudo name of the most recent view
      // in the local database.

        if( 0 == theViewName ) break;

        if( 0 != strcmp( theViewName, "<local>::<recent>" )) break;

      // Done

        result = CdbStatus::Success;

    } while( false );

    return result; 
}

CdbStatus
CdbBdbWCdb::findDatabase( CdbDatabasePtr& thePtr,
                          const char*     theName )
{
    assert( isInitialized( ));

    CdbStatus result = CdbStatus::Error;

    thePtr = 0;

    do {

      // Verify and correct parameters if 0 pointer is passed to indicate
      // that default database is needed. The "<default>" string is also allowed
      // since the current implementation maps it onto the boot file name.

        std::string defaultDatabaseName;
        if( CdbStatus::Success != getDefaultDatabase( defaultDatabaseName )) break;

        std::string databaseName = defaultDatabaseName;
        if( 0 != theName ) {
            if( 0 != strcmp( "<default>", theName )) {

              // This is a special keyword to be mapped onto whatever default
              // bootfile name we have.

                ;

            } else {
                databaseName = theName;
            }
        }
        if( databaseName != defaultDatabaseName ) {

            ErrMsg(error) << "no such database in this implementation: \"" << databaseName << "\"" << endl
                          << "The only name allowed is the default one: \"" << defaultDatabaseName << "\"" << endmsg;

            break;
        }

      // NOTE: - the above corrected parameters object is used.
      //       - a smart pointer onto itself is found through the registry.

        CdbPtr selfPtr;
        if( CdbStatus::Success != get( selfPtr,
                                       technologyName( ),
                                       implementationName( ))) {

            ErrMsg(fatal) << "failed to recover its own instance of the CDB API." << endl
                          << "    TECHNOLOGY     : \"" << technologyName( ) << "\"" << endl
                          << "    IMPLEMENTATION : \"" << implementationName( ) << "\"" << endmsg;
        }
        thePtr = new CdbBdbWDatabase( selfPtr,
                                      databaseName.c_str( ));
        result = CdbStatus::Success;

    } while( false );

    return result;
}

CdbStatus
CdbBdbWCdb::databaseIterator( CdbDatabaseItr& theItr )
{
    assert( isInitialized( ));

  // Note, that we find its own smart pointer through the Registry

  // ATTENTION: This is not a memory leak - the created object
  //            will be destroyed by the iterator.

    CdbPtr selfPtr;
    if( CdbStatus::Success != get( selfPtr,
                                   technologyName( ),
                                   implementationName( ))) {

        ErrMsg(fatal) << "failed to recover its own instance of the CDB API." << endl
                      << "    TECHNOLOGY     : \"" << technologyName( ) << "\"" << endl
                      << "    IMPLEMENTATION : \"" << implementationName( ) << "\"" << endmsg;
    }
    theItr = CdbDatabaseItr( new CdbBdbWDatabaseItr( selfPtr ));

    return CdbStatus::Success;
}

CdbTransactionBase*
CdbBdbWCdb::transaction( CdbTransaction::Mode theMode ) const
{
  // Translate the transaction mode from "Bdb"-specific enum into
  // the corresponding technology-neutral one.

    switch( theMode ) {
    case CdbTransaction::Read:   return new CdbBdbTransaction( BdbcRead );
    case CdbTransaction::Update: return new CdbBdbTransaction( BdbcUpdate );
    };

  // For unknown mode complain report the problem, try to crash the application,
  // and if this doesn't help then return 0.

    ErrMsg(fatal) << "CdbBdbWCdb::transaction( ) -- FATAL ERROR" << endl
                  << "    Unssuported transaction mode: " << theMode << endl
                  << "    The implementation of the current method doesn't seem to follow changes" << endl
                  << "    in the technology-neutral CDB API." << endmsg;
    return 0;
}

/////////////////
// End Of File //
/////////////////

---