---

CdbBdbSCdb.cc

Go to the documentation of this file.

// File and Version Information:
//      $Id: CdbBdbSCdb.cc,v 1.17 2005/04/30 02:05:45 gapon Exp $

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

#include "BaBar/BaBar.hh"

#include "CdbBdbShared/CdbBdbSCdb.hh"

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

#include "CdbBdb/CdbBdbTransaction.hh"

#include "CdbBdbShared/CdbBdbShared.hh"
#include "CdbBdbShared/CdbBdbSDatabase.hh"
#include "CdbBdbShared/CdbBdbSDatabaseItr.hh"
#include "CdbBdbShared/CdbBdbSMasterRegistryP.hh"
#include "CdbBdbShared/CdbBdbSSlaveRegistryP.hh"
#include "CdbBdbShared/CdbBdbSTestRegistryP.hh"

#include "BdbTime/BdbTime.hh"

#include "BdbCond/BdbConditions.hh"

#include "BdbApplication/BdbDomain.hh"

#include "ErrLogger/ErrLog.hh"

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

namespace {

  ////////////////////
  // V-table loader //
  ////////////////////

    void
    loadVTables( const CdbPtr& thePtr )
    {
        const char* fatalStr = "CdbBdbSCdb::<anonymous>::loadVTables() -- FATAL ERROR.";

      // The smart pointer passed down to this method should always
      // point to something to avoid crash below.

        if( thePtr.isNull( )) {

          // Except their creation time, the following classes are never used on its
          // own - only through their base classes.
          //
          // NOTE: It's important to call a virtual method to ensure that the corresponding
          //       v-tables are loaded. Just constructing a transient object of a final
          //       persistent class is not going to help for some compilers or optimized
          //       compilation modes.

            CdbBdbSMasterRegistryP master( "This constructor never gets executed here",
                                            BdbTime::plusInfinity );

            BdbRef(CdbBdbSOriginCollectionP) masterOriginCollRef = master.originCollection( );
            if( ! BdbIsNull(masterOriginCollRef)) {

                cout << fatalStr << endl
                     << "    You should never see this message. Still if you do then a nasty" << endl
                     << "    memory corruption is taking place in the current application." << endl
                     << "    Here is a number: " << masterOriginCollRef->elements( ) << endl;
                assert( 0 );

                return;
            }

            CdbBdbSSlaveRegistryP slave( 0,
                                         "This constructor never gets executed here",
                                          BdbTime::plusInfinity,
                                          BdbTime::plusInfinity );

            BdbRef(CdbBdbSOriginCollectionP) slaveOriginCollRef = slave.originCollection( );
            if( ! BdbIsNull(slaveOriginCollRef)) {

                cout << fatalStr << endl
                     << "    You should never see this message. Still if you do then a nasty" << endl
                     << "    memory corruption is taking place in the current application." << endl
                     << "    Here is a number: " << slaveOriginCollRef->elements( ) << endl;
                assert( 0 );

                return;
            }

            CdbBdbSTestRegistryP test( "This constructor never gets executed here",
                                       BdbTime::plusInfinity,
                                       BdbTime::plusInfinity );

            BdbRef(CdbBdbSOriginCollectionP) testOriginCollRef = test.originCollection( );
            if( ! BdbIsNull(testOriginCollRef)) {

                cout << fatalStr << endl
                     << "    You should never see this message. Still if you do then a nasty" << endl
                     << "    memory corruption is taking place in the current application." << endl
                     << "    Here is a number: " << testOriginCollRef->elements( ) << endl;
                assert( 0 );

                return;
            }
        }
    }

  ////////////////////////////////////////////////
  // Check the status of teh current federation //
  ////////////////////////////////////////////////

    bool currentFederationIsInitialized( )
    {
        CdbTransaction transactioni( CdbBdbShared::technology( ),
                                     CdbBdbShared::implementation( ));

        BdbHandle(BdbDBObj) dH;
        return d_True == dH.exist( BdbApplicationOrDomain::activeInstance( )->fd( ),
                                   "con_cdb_database",
                                   BdbcNoOpen );
    }
};

///////////////////////////////
// CdbBdbSCdb implementation //
///////////////////////////////

CdbBdbSCdb::CdbBdbSCdb( ) :
    Cdb( ),
    _isInitialized(false),                  // For the sake of deffered initialization
    _defaultViewName("<local>::<recent>")
{
    CDB_DEBUG_STREAM
        << "Condition/DB API instantiated for"
        << " TECHNOLOGY=\""     << CdbBdbShared::technology( )     << "\""
        << " IMPLEMENTATION=\"" << CdbBdbShared::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;

    CdbStatus status = set( myPtr );
    assert( CdbStatus::Success == status );

  // Make sure that v-tables for persistent classes are loaded

    loadVTables( myPtr );
}

CdbBdbSCdb::~CdbBdbSCdb( )
{ }

const char*
CdbBdbSCdb::technologyName( ) const
{
    return CdbBdbShared::technology( );
}

const char*
CdbBdbSCdb::implementationName( ) const
{
    return CdbBdbShared::implementation( );
}

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

      // IMPORTANT: This flag has to be set up first before doing any actual
      //            operations with the persistent store since we may have
      //            indirect recursion when setting default (the defaults setting
      //            algorithm may request initialization).

        _isInitialized = true;

      // Check for the presense of the "Shared" databases in the federation and
      // if they are found setup the proper default.

        if( currentFederationIsInitialized( )) {
            CdbEnvironment::setDefault( CdbBdbShared::technology( ),
                                        CdbBdbShared::implementation( ),
                                        BdbConditions::instance( )->bootName( ),
                                        "<local>::<recent>" );
        }
    }
}

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

CdbStatus
CdbBdbSCdb::getDefaultDatabase( std::string& theDatabaseName )
{
    assert( isInitialized( ));

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

    return CdbStatus::Success;
}

CdbStatus
CdbBdbSCdb::getDefaultView( std::string& theViewName,
                            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;

      // Return the current default.

        theViewName = _defaultViewName;

      // Done

        result = CdbStatus::Success;

    } while( false );

    return result; 
}

CdbStatus
CdbBdbSCdb::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
CdbBdbSCdb::setDefaultView( const char* theViewName,
                            const char* theDatabaseName )
{
    assert( isInitialized( ));

  // This method will checks for the correctness of the database and view names.
  //
  // IMPLEMENTATION NOTE: It will NOT check if specified view is present in the database.
  //                      The reason is that certain operations with CDB may be permitted
  //                      without having finally established database.

    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

        if( 0 == theViewName ) break;
/**
 ** IMPLEMENTATION NOTE: The following code is disabled to allow operations with
 **                      incomplete CDB.
 **
      // Try open the database and the view to check if they both exist.

        CdbDatabasePtr databasePtr;
        if( CdbStatus::Success != findDatabase( databasePtr )) break;

        CdbViewPtr viewPtr;
        if( CdbStatus::Success != databasePtr->findView( viewPtr, theViewName  )) break;
 **
 **/
      // Done

        _defaultViewName = theViewName;

        result = CdbStatus::Success;

    } while( false );

    return result; 
}

CdbStatus
CdbBdbSCdb::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 ) {

            cout << "CdbBdbSCdb::findDatabase( ) -- ERROR" << endl
                 << "    No such database in this implementation:  \"" << databaseName.c_str( )        << "\"" << endl
                 << "    The only name allowed is the default one: \"" << defaultDatabaseName.c_str( ) << "\"" << endl;

            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( ))) {
            cout << "CdbBdbSCdb::findDatabase( ) -- FATAL ERROR" << endl
                 << "    Failed to recover its own instance of the CDB API." << endl
                 << "        TECHNOLOGY     : \"" << technologyName( ) << "\"" << endl
                 << "        IMPLEMENTATION : \"" << implementationName( ) << "\"" << endl;

            assert( 0 );

            break;
        }
        thePtr = new CdbBdbSDatabase( selfPtr,
                                      databaseName.c_str( ));
        result = CdbStatus::Success;

    } while( false );

    return result;
}

CdbStatus
CdbBdbSCdb::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( ))) {
        cout << "CdbBdbSCdb::databaseIterator( ) -- FATAL ERROR" << endl
             << "    Failed to recover its own instance of the CDB API." << endl
             << "        TECHNOLOGY     : \"" << technologyName( ) << "\"" << endl
             << "        IMPLEMENTATION : \"" << implementationName( ) << "\"" << endl;

        assert( 0 );

        return CdbStatus::Error;
    }
    theItr = CdbDatabaseItr( new CdbBdbSDatabaseItr( selfPtr ));

    return CdbStatus::Success;
}

CdbTransactionBase*
CdbBdbSCdb::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) << "CdbBdbSCdb::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 //
/////////////////

---