Bdb packages | Design docs | Source docs | Guidelines | Recent releases
	Search | Site Map .

                 

---

/CdbBdbShared/CdbBdbSCdb.cc

Go to the documentation of this file.

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

#include "BaBar/BaBar.hh"

#include "CdbBdbShared/CdbBdbSCdb.hh"

#include "CdbBase/CdbDatabase.hh"
#include "CdbBase/CdbEnvironment.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/CdbBdbSReplicaRegistryP.hh"
#include "CdbBdbShared/CdbBdbSTestRegistryP.hh"

#include "BdbTime/BdbTime.hh"

#include "BdbCond/BdbConditions.hh"

#include "BdbApplication/BdbDomain.hh"
#include "BdbApplication/BdbDebug.hh"

#include <assert.h>
#include <iostream.h>

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;
            }

            CdbBdbSReplicaRegistryP replica( "This constructor never gets executed here",
                                              BdbTime::plusInfinity,
                                              BdbTime::plusInfinity );

            BdbRef(CdbBdbSOriginCollectionP) replicaOriginCollRef = replica.originCollection( );
            if( ! BdbIsNull(replicaOriginCollRef)) {

                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: " << replicaOriginCollRef->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( )
    {
        CdbBdbTransaction transaction;

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

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

CdbBdbSCdb::CdbBdbSCdb( ) :
    Cdb( )
{
    COUT1 << "Condition/DB API instantiated for"
          << " TECHNOLOGY=\""     << CdbBdbShared::technology( )     << "\""
          << " IMPLEMENTATION=\"" << CdbBdbShared::implementation( ) << "\""
          << endl;

  // Register itself in the API registry.
  //
  // NOTE: That this operation will also replace the previous instance (if any)
  //       for the same combination of "technology & implementation" keys.

    CdbPtr myPtr = this;
    Cdb::registry( ).set( myPtr );

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

    loadVTables( myPtr );

  // 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( ),
                                    "<default>",
                                    "<local>::<recent>" );
    }
}

CdbBdbSCdb::~CdbBdbSCdb( )
{ }

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

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

std::string
CdbBdbSCdb::defaultDatabase( ) const
{
    std::string dbName = CdbEnvironment::defaultDatabase( technologyName( ),
                                                          implementationName( ));
//    if(( "<default>" == dbName ) || ( "" == dbName )) {
    if( "<default>" == dbName ) {
        dbName = BdbConditions::instance( )->bootName( );
    }
    return dbName;
}

CdbStatus
CdbBdbSCdb::findDatabase( CdbDatabasePtr& thePtr,
                          const char*     theName )
{
    CdbStatus result = CdbStatus::Error;

    thePtr = 0;

    do {

      // Verify and correct parameters if 0 pointer is passed to indicate
      // that default database is needed.

        std::string databaseName = defaultDatabase( );
        if( 0 != theName ) databaseName = theName;

        if( databaseName != defaultDatabase( )) {

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

            break;
        }

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

        CdbPtr selfPtr = registry( ).get( technologyName( ),
                                          implementationName( ));
        thePtr = new CdbBdbSDatabase( selfPtr,
                                      databaseName.c_str( ));
        result = CdbStatus::Success;

    } while( false );

    return result;
}

CdbStatus
CdbBdbSCdb::databaseIterator( CdbDatabaseItr& theItr )
{
  // 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.

    theItr = CdbDatabaseItr( new CdbBdbSDatabaseItr( registry( ).get( technologyName( ),
                                                                      implementationName( ))));

    return CdbStatus::Success;
}

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

 

---

BaBar Public Site | SLAC | News | Links | Who's Who | Contact Us

Page Owner: Jacek Becla
Last Update: October 04, 2002