---

CdbBdbSTestRegistryP.cc

Go to the documentation of this file.

// File and Version Information:
//      $Id: CdbBdbSTestRegistryP.cc,v 1.4 2004/08/06 05:54:25 bartoldu Exp $

/// Implementation file for the CdbBdbSTestRegistryP class
/**
  * @see CdbBdbSTestRegistryP
  */

#include "BaBar/BaBar.hh"

#include "CdbBdbShared/CdbBdbSTestRegistryP.hh"
#include "CdbBdbShared/CdbBdbSUtils.hh"
#include "CdbBdbShared/CdbBdbSOriginP.hh"

#include "BdbClustering/BdbCondIndexClusteringHint.hh"

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

#include <string>
using std::cout;
using std::endl;

CdbStatus
CdbBdbSTestRegistryP::create( BdbHandle(CdbBdbSRegistryP)& theRegistryH,
                              const char*                  theDescription )
{
    const char* errorStr = "CdbBdbSTestRegistryP::create() -- ERROR";

    theRegistryH = 0;

    CdbStatus result = CdbStatus::Error;
    do {

      // Check if the local registry already exists

        BdbHandle(CdbBdbSRegistryP) localRegistryH;
        if( CdbStatus::Success == findLocal( localRegistryH )) {
            cout << errorStr << endl
                 << "    There local registry already exists in the current Condition/DB." << endl;
            break;
        }

      // Get to the MASTER registry to extract the information about
      // its unique identifier.

        BdbHandle(CdbBdbSRegistryP) masterRegistryH;
        if( CdbStatus::Success != findMaster( masterRegistryH )) {
            cout << errorStr << endl
                 << "    Failed to locate MASTER registry in the current federation." << endl
                 << "    The federation has to be preloaded with at least a partial" << endl
                 << "    snapshot of the MASTER database in order to initialize a TEST one." << endl;
            break;
        }

      // Find the name of the DBID range of the current federation.
      // Make sure this is the right federation.

        std::string localDbIdRangeName;
        if( CdbStatus::Success != CdbBdbSUtils::getLocalDbIdRange( localDbIdRangeName )) {
            cout << errorStr << endl
                 << "    Failed to find the local DBID range." << endl;
            break;
        }
        if( localDbIdRangeName != defaultDbIdRange( )) {
            cout << errorStr << endl
                 << "    The current federation has inappropriate local DBID range, which" << endl
                 << "    can't be used to create a TEST kind of database." << endl
                 << "        LOCAL    RANGE: " << localDbIdRangeName.c_str( ) << endl
                 << "        EXPECTED RANGE: " << defaultDbIdRange( ) << endl;
            break;
        }

      // Generate the hint and create the container

        std::string databaseSuffix = std::string( "database_" ) + localDbIdRangeName;

        BdbCondIndexClusteringHint hint( "cdb",
                                         "System",
                                         databaseSuffix.c_str( ));

        BdbHandle(BdbContObj) contH = hint.updatedHint( );
        if( BdbIsNull(contH)) {
            cout << errorStr << endl
                 << "    Failed to create a container for persistent objects." << endl;
            break;
        }

      // The following check should always be positive, unless we have
      // an unexpected missmatch between ::findIntervalCont() and ::updatedHint()
      // behavior.

        if( ! hint.newContainerCreated( )) {
            cout << errorStr << endl
                 << "    The clustering hint has not created a new persistent container." << endl;
            break;
        }

      // Create the object.

        theRegistryH = new( contH ) CdbBdbSTestRegistryP( theDescription,
                                                          BdbTime::now( ),
                                                          masterRegistryH->id( ));
        if( BdbIsNull(theRegistryH)) {
            cout << errorStr << endl
                 << "    Failed to create a persistent registry object." << endl;
            break;
        }

      // Done

        result = CdbStatus::Success;

    } while( false );

    return result;
}

CdbBdbSTestRegistryP::CdbBdbSTestRegistryP( const char*    theDescription,
                                            const BdbTime& theCreationTime,
                                            const BdbTime& theId ) :
    CdbBdbSRegistryP( CdbBdbSOriginP::TEST_ID,      // origin identifier
                      theDescription,
                      theCreationTime,
                      theId,
                      true )                        // local collections are allowed
{
  // Make sure the code is run against the right federation (DBID range)

    std::string localRangeName;
    {
        CdbStatus result = CdbBdbSUtils::getLocalDbIdRange( localRangeName );
        assert( CdbStatus::Success == result );

      // The TEST kind of databases can only be created in the default
      // space of DBID ranges to be able to import databases from MASTER
      // and SLAVE databases.

        assert( localRangeName == defaultDbIdRange( ));
    }
}

CdbBdbSTestRegistryP::~CdbBdbSTestRegistryP( ) 
{ }

bool
CdbBdbSTestRegistryP::isMaster( ) const
{
    return false;
}

BdbRef(CdbBdbSOriginCollectionP)
CdbBdbSTestRegistryP::originCollection( ) const
{
    return 0;
}

BdbRef(CdbBdbSPartitionsLayoutP)
CdbBdbSTestRegistryP::partitionsLayout( ) const
{
    return 0;
}

BdbRef(CdbBdbSClusterCollectionP)
CdbBdbSTestRegistryP::pClusterCollection( ) const
{
    return 0;
}

BdbRef(CdbBdbSRallocatorP< d_UShort >)
CdbBdbSTestRegistryP::originRallocator( ) const
{
    return 0;
}

BdbRef(CdbBdbSRallocatorP< d_UShort >)
CdbBdbSTestRegistryP::partitionRallocator( ) const
{
    return 0;
}

BdbRef(CdbBdbSRallocatorP< d_UShort >)
CdbBdbSTestRegistryP::pClusterRallocator( ) const
{
    return 0;
}

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

---