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

                 

---

/BdbCond/BdbCondDatabaseMgr.cc

Go to the documentation of this file.

//-----------------------------------------------------------------------------
//
// File and Version Information:
//      $Id: BdbCondDatabaseMgr.cc,v 1.46 2002/08/07 21:45:26 gapon Exp $
//
// Description:
//      Class BdbCondDatabaseMgr
//
// Environment:
//      Software developed for the BaBar Detector at the SLAC B-Factory.
//
// Author List:
//      Igor A. Gaponenko       Original Author
//
// Copyright Information:
//      Copyright (C) 1999      Lawrence Berkeley Laboratory
//
//-----------------------------------------------------------------------------

// -------------------------
// -- This Class's Header --
// -------------------------

#include "BdbCond/BdbCondDatabaseMgr.hh"

// ---------------
// -- C Headers --
// ---------------

extern "C" {
#include <assert.h>
#include <ctype.h>
#include <stddef.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
}

// -----------------
// -- C++ Headers --
// -----------------

#include <string>
using std::string;
#include <vector>
using std::vector;
#include <map>
using std::map;
#include <iostream.h>
#include "BbrStdUtils/String.hh"
// ---------------------------------
// -- Collaborating Class Headers --
// ---------------------------------

#include "BdbApplication/BdbDomain.hh"
#include "BdbApplication/BdbDebug.hh"
#include "BdbAccess/BdbAuth.hh"
#include "BdbAccess/BdbAuthItr.hh"
#include "BdbClustering/BdbCondIndexClusteringHint.hh"
#include "BdbClustering/BdbCondClusteringHint.hh"
#include "BdbCond/BdbCondErrors.hh"
#include "BdbCond/BdbInterval.hh"
#include "BdbCond/BdbIntervalGene.hh"
#include "BdbCond/BdbObject.hh"
#include "BdbCond/BdbCondRevision.hh"
#include "BdbCond/BdbString.hh"
#include "BdbCond/BdbCondHistory.hh"
#include "BdbCond/BdbCondTransientCache.hh"
#include "BdbCond/BdbIntervalItr.hh"
#include "BdbCond/BdbString.hh"
#include "BdbCond/BdbCondContainerLink.hh"
#include "BdbTime/BdbTime.hh"
#include "ErrLogger/ErrLog.hh"


// --------------------------------------------------------------------------
// -- Local Macros, Typedefs, Structures, Unions, and Forward Declarations --
// --------------------------------------------------------------------------

static const char  rcsid[] = "$Id: BdbCondDatabaseMgr.cc,v 1.46 2002/08/07 21:45:26 gapon Exp $";

// -------------------
// -- Error handler --
// -------------------

static ooErrorHandlerPtr oldErrorHandlerPtr;

static ooStatus
vtableWarningsHandler( const ooErrorLevel     errorLevel,
                       const ooError&         errorID,
                       const ooHandle(ooObj)* contextObj,
                       char*                  errorMsg )
{
  // Ignore the warnings #69 and #1132 only.

    if(( errorLevel == oocWarning ) &&
       (( errorID.errorN == 69 ) || ( errorID.errorN == 1132 ))) {

        errorMsg = (char*) 0;

        return oocSuccess;
    }

  // Just forward any other errors further to the regular
  // errors handler.

    return oldErrorHandlerPtr( (ooErrorLevel)     errorLevel,
                               (ooError&)         errorID,
                               (ooHandle(ooObj)*) contextObj,
                                                   errorMsg );
}

// ------------------
// -- Constructors --
// ------------------

BdbCondDatabaseMgr::BdbCondDatabaseMgr( bool supressVTableWarnings ) :
    _supressVTableWarnings(supressVTableWarnings)
{
    if ( _supressVTableWarnings ) {

      // Trap the warnings #69 and #1132 temporarily on the time of copy
      // execution in order to get rid of these noisy messages about
      // missing VTable.
      // The real trapping is controlled by a special flag to be set
      // by the class's constructor.
      //
      //    NOTE: The problem is that ::copy() method is trying to call
      //          a virtual ::ooCopyInit() method in order to perform
      //          user-specific copy operation to follow up the regular
      //          shellow copy.

        oldErrorHandlerPtr = ooGetErrorHandler( );
        ooRegErrorHandler( (ooErrorHandlerPtr) vtableWarningsHandler );
    }
}

// ----------------
// -- Destructor --
// ----------------

BdbCondDatabaseMgr::~BdbCondDatabaseMgr( )
{
    if ( _supressVTableWarnings ) {
        ooRegErrorHandler( oldErrorHandlerPtr );
    }
}

// -----------------------------
// -- Public member Functions --
// -----------------------------

BdbStatus
BdbCondDatabaseMgr::copyIntervalContainer( const char* theInTLA,
                                           const char* theInContName,
                                           const char* theOutTLA,
                                           const char* theOutContName,
                                           LevelType   level,
                                           d_ULong     theRevId,
                                           bool        copyCondObjects,
                                           bool        copyToLocalDb,
                                           const char* theContName )
{
    const char* errorString = "BdbCondDatabaseMgr::copyIntervalContainer() -- error.";

    BdbStatus status = BdbcError;

    assert( theInTLA       != (char*) 0 );
    assert( theInContName  != (char*) 0 );
    assert( theOutTLA      != (char*) 0 );
    assert( theOutContName != (char*) 0 );

  // Open both databases.

    BdbObsoleteDatabase theInDb( theInTLA );
    BdbObsoleteDatabase theOutDb( theOutTLA );

  // Perform operations in a exception-like loop.

    bool operationsLoopWasFailed = true;

    while ( true ) {

      // Prepare the output container.

        status = initOutputContainer( theInDb,
                                      theInContName,
                                      theOutDb,
                                      theOutContName );
        if ( BdbcSuccess != status ) {
            ErrMsg(error) << errorString << endl
                          << "    Failed to initialize the output container." << endmsg;
            break;
        }

      // Choose the desired copy level.

        switch( level ) {

        case LEVEL_DEEP:

            status = deepCopy( theInDb, theOutDb );
            break;

        case LEVEL_TOPMOST:

            status = baselineOrTopmostCopy( theInDb, theOutDb, false );
            break;

        case LEVEL_BASELINE:

            status = baselineOrTopmostCopy( theInDb, theOutDb, true );
            break;

        case LEVEL_REVISION:

            status = revisionCopy( theInDb, theOutDb, theRevId );
            break;

        default:

            status = BdbcError;
            break;
        }

      // Make a further copy of conditions objects itself if required
      // and if the containers belong to two different detectors only.

        if ( BdbcSuccess == status ) {
            if ( copyCondObjects ) {
                if ( strcmp( theInDb.subsystemTLA( ), theOutDb.subsystemTLA( ))) {
                    status = copyObjects( theOutDb, copyToLocalDb, theContName );
                }
            }
        }

      // The loop has been sucessfully completed.

        operationsLoopWasFailed = false;
        break;
    }
    if ( operationsLoopWasFailed ) {
        ErrMsg(error) << "        Input   detector: \"" << theInTLA << "\"" << endl
                      << "               container: \"" << theInContName << "\"" << endl
                      << "        Output  detector: \"" << theOutTLA << "\"" << endl
                      << "               container: \"" << theOutContName << "\"" << endmsg;
        if ( BdbcSuccess == status ) {
            status = BdbcError;
        }
    }

  // Put a record into the History of the output container.

    d_ULong theLastIndex = 0;

    BdbHandle(BdbCondHistory) theInHistoryH;
    theInHistoryH = theInDb.getHistoryH( );

    if ( ! BdbIsNull( theInHistoryH )) {
        theLastIndex = theInHistoryH->numRecords( );
        if ( theLastIndex != 0 ) {
            theLastIndex--;
        }
    }

    theOutDb.historyCCopy( rcsid,
                           theLastIndex,
                           theInTLA,
                           theInContName,
                           level,
                           theRevId,
                           copyCondObjects,
                           copyToLocalDb,
                           theContName );

    return status;
}

BdbStatus
BdbCondDatabaseMgr::removeIntervalContainer( const char* theTLA,
                                             const char* theContName,
                                             bool        removeContainerLinkFlag )
{
    const char* errorString = "BdbCondDatabaseMgr::removeIntervalContainer() -- error.";

    BdbStatus status;

    BdbHandle(BdbContObj) theContH;

    assert ( theTLA      != (char*) 0 );
    assert ( theContName != (char*) 0 );

  // Open the database.

    BdbObsoleteDatabase theDb( theTLA );

  // Perform initializations in a exception-like loop.

    bool theLoopWasFailed = true;

    while ( true ) {

      // Make sure that a proper authorization level is set.

        if ( ! theDb.verifyAuthLevelOnly( theContName )) {
            ErrMsg(error) << errorString << endl
                          << "    Failed to set proper Authorization level." << endmsg;
            break;
        }

      // Check if the container is not write-locked.

        if ( theDb.isWriteLocked( theContName )) {
            ErrMsg(error) << errorString << endl
                          << "    The container is write-locked and can not be deleted in this federation." << endmsg;
            break;
        }

      // Setup cache context by locating the container handle, or handles
      // for both container link and the target interval container.

        status = theDb.findIntervalCont( theContH, theContName );
        if ( BdbcSuccess != status ) {
            ErrMsg(error) << errorString << endl
                          << "    The container does not exist." << endmsg;
            break;
        }

      // If this is the link and the link is also has to be deleted
      // then use the link deletion procedure, which would also
      // delete the interval container itself.

        if( theDb.isLink( ) && removeContainerLinkFlag ) {
            return removeIntervalContainerLink( theTLA, theContName, true );
        }

      // Delete the container with all their contents.

        BdbDelete( theContH ) ;

        theLoopWasFailed = false;
        break;
    }
    if ( theLoopWasFailed ) {
        ErrMsg(error) << "        Detector:  \"" << theTLA << "\"" << endl
                      << "        Container: \"" << theContName << "\"" << endmsg;

        if ( BdbcSuccess == status ) {
            status = BdbcError;
        }

        return status;
    }

    return BdbcSuccess;
}

BdbStatus
BdbCondDatabaseMgr::createIntervalContainerLink( const char* theLinkTLA,
                                                 const char* theLinkContName,
                                                 const char* theOrigin,
                                                 const char* theTLA,
                                                 const char* theContName,
                                                 bool        verifyRealContainer )
{
    const char* errorString = "BdbCondDatabaseMgr::createIntervalContainerLink() -- error.";

  // Verify the parameters.

    assert ( theLinkTLA      != (char*) 0 );
    assert ( theLinkContName != (char*) 0 );
    assert ( theOrigin       != (char*) 0 );
    assert ( theTLA          != (char*) 0 );
    assert ( theContName     != (char*) 0 );

  // Local data structures.

    BdbStatus status;

    BdbHandle(BdbContObj) theLinkContH;
    BdbHandle(BdbContObj) theContH;

    BdbHandle(BdbString) theLinkH;

    BdbCondIndexClusteringHint theHint( theLinkTLA, theLinkContName, "Link" );

    BdbObsoleteDatabase theLinkDb( theLinkTLA );
    BdbObsoleteDatabase theDb( theLinkTLA );

  // Build the link.
  //
  //    NOTE: We will verify the correctness of the link later.

    BdbCondContainerLink theLink( theOrigin, theTLA, theContName );

  // Perform initializations in a exception-like loop.

    bool theLoopWasFailed = true;

    while ( true ) {

      // Ensure a proper authorization level to be set.

        if ( ! theLinkDb.verifyAuthLevelOnly( theLinkContName )) {
            ErrMsg(error) << errorString << endl
                          << "    Failed to set proper Authorization level." << endmsg;
            break;
        }

      // Verify the correctness of the link.

        if ( ! theLink.isValid( )) {
            ErrMsg(error) << errorString << endl
                          << "    Failed to build the link from specified parameters." << endmsg;
            break;
        }

      // Check for the presence of the container with specified link name.
      // It must not exist.

        bool followLinkFlag = false;

        status = theLinkDb.findIntervalCont( theLinkContH, theLinkContName, followLinkFlag );
        if (( BdbcSuccess == status ) && ( ! BdbIsNull( theLinkContH ))) {
             ErrMsg(error) << errorString << endl
                           << "    The link with such name already exist." << endmsg;
             break;
        }

      // Create the link container.

        theLinkContH = theHint.updatedHint( );
        if ( BdbIsNull(theLinkContH) || ( ! theHint.newContainerCreated( ))) {
            ErrMsg(error) << errorString << endl
                          << "    The clustering hint did create new interval contaiiner." << endmsg;
            break;
        }

      // Write the link information into this container.

        theLinkH = new( theLinkContH ) BdbString( theLink.getLinkName().c_str());
        theLinkH.nameObj( theLinkContH, "Link" );

      // Now open the same link container and follow the link in order to make sure
      // if the real container does exist.

        if ( verifyRealContainer ) {
            status = theDb.findIntervalCont( theContH, theLinkContName );
            if ( ! (( BdbcSuccess == status ) && theDb.isLink( ))) {
                ErrMsg(error) << errorString << endl
                              << "    Failed to verify the presence of the real container for this link." << endl
                              << "    The container link would not be created." << endmsg;

              // Remove the newly created container link.

                removeIntervalContainerLink( theLinkTLA, theLinkContName );

                break;
            }
        }

        theLoopWasFailed = false;
        break;
    }
    if ( theLoopWasFailed ) {
        ErrMsg(error) << "        LINK Detector  -> " << theLinkTLA << endl
                      << "        LINK Container -> " << theLinkContName << endl
                      << "            ORIGIN for REAL Container -> " << theOrigin << endl
                      << "            REAL Detector             -> " << theTLA << endl
                      << "            REAL Container            -> " << theContName << endmsg;
        if ( BdbcSuccess == status ) {
            status = BdbcError;
        }
        return status;
    }

    return BdbcSuccess;
}

BdbStatus
BdbCondDatabaseMgr::removeIntervalContainerLink( const char* theLinkTLA,
                                                 const char* theLinkContName,
                                                 bool        removeIntervalContainerFlag )
{
    const char* errorString = "BdbCondDatabaseMgr::removeIntervalContainerLink() -- error.";

  // Verify the parameters.

    assert ( theLinkTLA      != (char*) 0 );
    assert ( theLinkContName != (char*) 0 );

  // Local data structures.

    BdbStatus status;

    BdbHandle(BdbContObj) theContH;
    BdbHandle(BdbContObj) theLinkContH;

    BdbObsoleteDatabase theLinkDb( theLinkTLA );

  // Perform initializations in a exception-like loop.

    bool theLoopWasFailed = true;

    while ( true ) {

      // Ensure a proper authorization level to be set.
      //
      // We don't need to check at this point if the target interval container
      // is write-locked, because deleting the link itself would not require
      // to delete the target interval container.
      // Even more, such a checking procedure (agains write locking) would require
      // the corresponding interval container to exist, which may not be a case.
      //
      // However we may need to perform this test if the optional parameter
      // to this procedure tells us to remove the interval container.

        if ( ! theLinkDb.verifyAuthLevelOnly( theLinkContName )) {
            ErrMsg(error) << errorString << endl
                          << "    Failed to set proper Authorization level." << endmsg;
            break;
        }

      // Check for the presence of the container with specified link name.
      //
      //    NOTE: We don't follow the link in order to avoid the "noise" when
      //          the real container for this link does not exist.
      //
      // The container finding procedure would return us just 

        bool followLinkFlag = false;

        status = theLinkDb.findIntervalCont( theLinkContH, theLinkContName, followLinkFlag );
        if (( BdbcSuccess != status ) || BdbIsNull( theLinkContH )) {
            ErrMsg(error) << errorString << endl
                          << "    The specified link container does not exist." << endmsg;
            break;
        }

      // Locate and destroy the interval container, which is referenced
      // via the link if the third parameter to this procedure require this
      // and if there is no write-lock for this container.
      //
      // NOTE: we are not interested here in the "old" interval containers
      //       which are not referenced through the link.

        if ( removeIntervalContainerFlag ) {

            status = theLinkDb.findIntervalCont( theContH, theLinkContName );
            if (( BdbcSuccess == status ) && ( ! BdbIsNull( theContH )) && theLinkDb.isLink( )) {

              // Check if this container is not write-locked.

                if ( theLinkDb.isWriteLocked( )) {
                    ErrMsg(error) << errorString << endl
                                  << "    The interval container is write-locked and can't be deleted." << endmsg;
                    break;
                }

                BdbDelete(theContH);

            } else {
                ErrMsg(error) << errorString << endl
                              << "    The interval container for specified link does not exist." << endmsg;
                break;
            }
        }

      // Destroy the link container.

        BdbDelete(theLinkContH);

        theLoopWasFailed = false;
        break;
    }
    if ( theLoopWasFailed ) {
        ErrMsg(error) << "        LINK Detector  -> " << theLinkTLA << endl
                      << "        LINK Container -> " << theLinkContName << endmsg;
        if ( BdbcSuccess == status ) {
            status = BdbcError;
        }
        return status;
    }

    return BdbcSuccess;
}

BdbStatus
BdbCondDatabaseMgr::lockIntervalContainerLink( const char* theLinkTLA,
                                               const char* theLinkContName )
{
    const char* errorString = "BdbCondDatabaseMgr::lockIntervalContainerLink() -- error.";

  // Verify the parameters.

    assert ( theLinkTLA      != (char*) 0 );
    assert ( theLinkContName != (char*) 0 );

  // Local data structures.

    BdbStatus status;

    BdbHandle(BdbContObj) theContH;
    BdbHandle(BdbContObj) theLinkContH;

    BdbObsoleteDatabase theLinkDb( theLinkTLA );

  // Perform initializations in a exception-like loop.

    bool theLoopWasFailed = true;

    while ( true ) {

      // Ensure a proper authorization level to be set.
      //
      // We don't need to check at this point if the target interval container
      // is write-locked.

        if ( ! theLinkDb.verifyAuthLevelOnly( theLinkContName )) {
            ErrMsg(error) << errorString << endl
                          << "    Failed to set proper Authorization level." << endmsg;
            break;
        }

      // Check for the presence of the container with specified link name.
      //
      //    NOTE: We don't follow the link in order to avoid the "noise" when
      //          the real container for this link does not exist.
      //
      // The container finding procedure would return us just 

        bool followLinkFlag = false;

        status = theLinkDb.findIntervalCont( theLinkContH, theLinkContName, followLinkFlag );
        if (( BdbcSuccess != status ) || BdbIsNull( theLinkContH )) {
            ErrMsg(error) << errorString << endl
                          << "    The specified link container does not exist." << endmsg;
            break;
        }

      // Try to obtain the lock from the comtainer.

        BdbHandle(BdbString) theWriteLockH;

        theWriteLockH.lookupObj( theLinkContH, "WriteLock" );
        if ( ! BdbIsNull(theWriteLockH)) {
            ErrMsg(error) << errorString << endl
                          << "    The interval container is already write-locked." << endmsg;
            break;
        }

      // Create a new persistent lock for the link.

        theWriteLockH = new( theLinkContH ) BdbString( "Link" );
        theWriteLockH.nameObj( theLinkContH, "WriteLock" );

        theLoopWasFailed = false;
        break;
    }
    if ( theLoopWasFailed ) {
        ErrMsg(error) << "        LINK Detector  -> " << theLinkTLA << endl
                      << "        LINK Container -> " << theLinkContName << endmsg;
        if ( BdbcSuccess == status ) {
            status = BdbcError;
        }
        return status;
    }

    return BdbcSuccess;
}

BdbStatus
BdbCondDatabaseMgr::unlockIntervalContainerLink( const char* theLinkTLA,
                                                 const char* theLinkContName )
{
    const char* errorString = "BdbCondDatabaseMgr::unlockIntervalContainerLink() -- error.";

  // Verify the parameters.

    assert ( theLinkTLA      != (char*) 0 );
    assert ( theLinkContName != (char*) 0 );

  // Local data structures.

    BdbStatus status;

    BdbHandle(BdbContObj) theContH;
    BdbHandle(BdbContObj) theLinkContH;

    BdbObsoleteDatabase theLinkDb( theLinkTLA );

  // Perform initializations in a exception-like loop.

    bool theLoopWasFailed = true;

    while ( true ) {

      // Ensure a proper authorization level to be set.
      //
      // We don't need to check at this point if the target interval container
      // is write-locked.

        if ( ! theLinkDb.verifyAuthLevelOnly( theLinkContName )) {
            ErrMsg(error) << errorString << endl
                          << "    Failed to set proper Authorization level." << endmsg;
            break;
        }

      // Check for the presence of the container with specified link name.
      //
      //    NOTE: We don't follow the link in order to avoid the "noise" when
      //          the real container for this link does not exist.
      //
      // The container finding procedure would return us just 

        bool followLinkFlag = false;

        status = theLinkDb.findIntervalCont( theLinkContH, theLinkContName, followLinkFlag );
        if (( BdbcSuccess != status ) || BdbIsNull( theLinkContH )) {
            ErrMsg(error) << errorString << endl
                          << "    The specified link container does not exist." << endmsg;
            break;
        }

      // Try to obtain the lock from the comtainer.

        BdbHandle(BdbString) theWriteLockH;

        theWriteLockH.lookupObj( theLinkContH, "WriteLock" );
        if ( BdbIsNull(theWriteLockH)) {
            ErrMsg(error) << errorString << endl
                          << "    The interval container is not write-locked." << endmsg;
            break;
        }

      // Just delete a persistent object.

        BdbDelete(theWriteLockH);

        theLoopWasFailed = false;
        break;
    }
    if ( theLoopWasFailed ) {
        ErrMsg(error) << "        LINK Detector  -> " << theLinkTLA << endl
                      << "        LINK Container -> " << theLinkContName << endmsg;
        if ( BdbcSuccess == status ) {
            status = BdbcError;
        }
        return status;
    }

    return BdbcSuccess;
}

BdbStatus
BdbCondDatabaseMgr::deleteObjects( const char* theTLA,
                                   const char* theContName )
{
    const char* errorString = "BdbCondDatabaseMgr::deleteObjects() -- error.";

    BdbHandle(BdbContObj) theContH;

    assert ( theTLA      != (char*) 0 );
    assert ( theContName != (char*) 0 );

  // Open the database.

    BdbObsoleteDatabase theDb( theTLA );

  // Perform initializations in a exception-like loop.

    bool theLoopWasFailed = true;

    while ( true ) {

      // Ensure a proper authorization level to be set.

        if ( ! theDb.verifyAuthLevelOnly( theContName )) {
            ErrMsg(error) << errorString << endl
                          << "    Failed to set proper Authorization level." << endmsg;
            break;
        }

      // Iterate all the BASELINE intervals and recursivly delete objects
      // in each subtree growing from theis interval.

        BdbIntervalItr theItr;
        if( ! theItr.setBaseline( theTLA, theContName )) {
            ErrMsg(error) << errorString << endl
                          << "    Failed to initialize an iterator for BASELINE iintervals." << endmsg;
            break;
        }

        while( theItr.next( )) {
            deleteObjectsInSubTree( theItr );
        }

        theLoopWasFailed = false;
        break;
    }
    if ( theLoopWasFailed ) {
        ErrMsg(error) << "        Detector:  \"" << theTLA << "\"" << endl
                      << "        Container: \"" << theContName << "\"" << endmsg;

        return BdbcError;
    }

    return BdbcSuccess;
}

BdbStatus
BdbCondDatabaseMgr::evaluateIntervalContainer( const char* theTLA,
                                               const char* theContName,
                                               bool&       exists )
{
    const char* errorString = "BdbCondDatabaseMgr::evaluateIntervalContainer() -- error.";

    BdbStatus status;

    BdbHandle(BdbContObj) theContH;

    assert ( theTLA      != (char*) 0 );
    assert ( theContName != (char*) 0 );

  // Set the default status of the container.

    exists = false;

  // Open the database.

    BdbObsoleteDatabase theDb( theTLA );

  // Perform initializations in a exception-like loop.

    bool theLoopWasFailed = true;

    while ( true ) {

      // Here we perform a real verification of the container presence.

        status = theDb.findIntervalCont( theContH, theContName );
        if (( BdbcSuccess == status ) && ( ! BdbIsNull(  theContH ))) {
            exists = true;
        }

        theLoopWasFailed = false;
        break;
    }

    if ( theLoopWasFailed ) {
        ErrMsg(error) << "        Detector:  \"" << theTLA << "\"" << endl
                      << "        Container: \"" << theContName << "\"" << endmsg;

        if ( BdbcSuccess == status ) {
            status = BdbcError;
        }

        return status;
    }

    return BdbcSuccess;
}

BdbStatus
BdbCondDatabaseMgr::createCheckpoint( const char* theTLA,
                                      const char* theContName )
{
    const char* errorString = "BdbCondDatabaseMgr::createCheckpoint() -- error.";

    BdbStatus status = BdbcError;

    assert( theTLA       != (char*) 0 );
    assert( theContName  != (char*) 0 );

    BdbHandle(BdbCondHistory) theHistoryH;

  // Open the database.

    BdbObsoleteDatabase theDb( theTLA );

  // Build the backup container name.
  // The current time would be the checkpoint time.

    BdbTime theTime;

    char theNumber[11];
    sprintf( theNumber, "%.10u", theTime.getGmtSec( ));

    string theBackupContName = string( "_CHECKPOINT_") + string( theNumber ) + string( "_" ) + string( theContName );

  // Perform initializations in a exception-like loop.

    bool theLoopWasFailed = true;

    while ( true ) {

      // Make a copy of the specified container into a backup one without copying the objects.

        status = copyIntervalContainer( theTLA, theContName, theTLA, theBackupContName.c_str() );
        if( BdbcSuccess != status ) {
            ErrMsg(error) << errorString << endl
                          << "    Failed to make a backup copy of specified container." << endmsg;
            break;
        }

      // Initialize the container cache by a simple operation.

        status = theDb.findHistory( theHistoryH, theContName );
        if( BdbcSuccess != status ) {
            ErrMsg(error) << errorString << endl
                          << "    Failed to get the History of the container." << endmsg;
            break;
        }

        theLoopWasFailed = false;
        break;
    }
    if ( theLoopWasFailed ) {
        ErrMsg(error) << "        Input   detector: \"" << theTLA << "\"" << endl
                      << "               container: \"" << theContName << "\"" << endl
                      << "        Backup  detector: \"" << theTLA << "\"" << endl
                      << "               container: \"" << theBackupContName << "\"" << endmsg;

        if ( BdbcSuccess == status ) {
            status = BdbcError;
        }

        return status;
    }

  // Put a record into the History of the original container.

    theDb.historyCPoint( rcsid,
                         theTime,
                         theBackupContName.c_str() );

    return BdbcSuccess;
}

BdbStatus
BdbCondDatabaseMgr::resetRevisions( const char* theTLA,
                                    const char* theContName )
{
    const char* errorString = "BdbCondDatabaseMgr::resetRevisions() -- error.";

    BdbStatus status;

    ErrMsg(error) << errorString << endl
                  << "    The operation is not implemented yet." << endmsg;

    return BdbcError;
}

BdbStatus
BdbCondDatabaseMgr::createHistory( const char* theTLA,
                                   const char* theContName,
                                   bool        makeContainerBackup )
{
    const char* errorString = "BdbCondDatabaseMgr::createHistory() -- error.";

    BdbStatus status;

    BdbHandle(BdbContObj)           theContH;
    BdbHandle(BdbCondHistory)       theHistoryH;
    BdbHandle(BdbCondHistoryRecord) theRecordH;

    assert ( theTLA      != (char*) 0 );
    assert ( theContName != (char*) 0 );

  // Open the database.

    BdbObsoleteDatabase theDb( theTLA );

  // Perform initializations in a exception-like loop.

    bool theLoopWasFailed = true;

    while ( true ) {

      // Ensure a proper authorization level to be set.

        if ( ! theDb.verifyAuthLevelOnly( theContName )) {
            ErrMsg(error) << errorString << endl
                          << "    Failed to set proper Authorization level." << endmsg;
            break;
        }

      // Setup cache context by locating the container handle.

        status = theDb.findIntervalCont( theContH, theContName );
        if ( BdbcSuccess != status ) {
            ErrMsg(error) << errorString << endl
                          << "    The container does not exist." << endmsg;
            break;
        }

      // Try to obtain the History. It should not exist.

        theHistoryH = theDb.getHistoryH( );
        if ( ! BdbIsNull( theHistoryH )) {
            ErrMsg(error) << errorString << endl
                          << "    The History already exist." << endmsg;
            break;
        }

      // Make a container backup in order to reflect a state
      // of the original container.
      //
      // NOTE: The backup is a deep copy of interval container contents
      //       into a special container with prefixed name.

        string theBackupContName;

        if ( makeContainerBackup ) {

          // Build the backup container name.

            theBackupContName = string( "_HISTORY_" ) + string( theContName );

          // Delete existing backup container (if any).

            BdbObsoleteDatabase theBackupDb( theTLA );
            BdbHandle(BdbContObj) theBackupContH;

            status = theBackupDb.findIntervalCont( theBackupContH, theBackupContName.c_str() );
            if (( BdbcSuccess == status ) && ( ! BdbIsNull( theBackupContH ))) {
                BdbDelete(theBackupContH);
            }

            status = copyIntervalContainer( theTLA, theContName, theTLA, theBackupContName.c_str() );
            if ( BdbcSuccess != status ) {
                ErrMsg(error) << errorString << endl
                              << "    Failed to make a deep copy of the container." << endmsg;
                break;
            }
        }

      // Create the History.

        theHistoryH = new( theContH ) BdbCondHistory( );
        theHistoryH.nameObj( theContH, "History" );

     // Reopen the interval container with history.
     // Then put the very first record into the history of container.

        BdbObsoleteDatabase theNewDb( theTLA );

        theHistoryH = 0;

        status = theNewDb.findHistory( theHistoryH, theContName );
        if (( BdbcSuccess != status ) || BdbIsNull( theHistoryH )) {
            ErrMsg(error) << errorString << endl
                          << "    Failed to locate the newly created History in the container." << endmsg;
            break;
        }
        theNewDb.historyHCreate( rcsid, theBackupContName.c_str() );

        theLoopWasFailed = false;
        break;
    }
    if ( theLoopWasFailed ) {
        ErrMsg(error) << "        Detector:  \"" << theTLA << "\"" << endl
                      << "        Container: \"" << theContName << "\"" << endmsg;

        if ( BdbcSuccess == status ) {
            status = BdbcError;
        }
        return status;
    }

    return BdbcSuccess;
}

BdbStatus
BdbCondDatabaseMgr::removeHistory( const char* theTLA,
                                   const char* theContName )
{
    const char* errorString = "BdbCondDatabaseMgr::removeHistory() -- error.";

    BdbStatus status;

    BdbHandle(BdbContObj)     theContH;
    BdbHandle(BdbCondHistory) theHistoryH;

    assert ( theTLA      != (char*) 0 );
    assert ( theContName != (char*) 0 );

  // Open the database.

    BdbObsoleteDatabase theDb( theTLA );

  // Perform initializations in a exception-like loop.

    bool theLoopWasFailed = true;

    while ( true ) {

      // Ensure a proper authorization level to be set.

        if ( ! theDb.verifyAuthLevelOnly( theContName )) {
            ErrMsg(error) << errorString << endl
                          << "    Failed to set proper Authorization level." << endmsg;
            break;
        }

      // Setup cache context by locating the container handle.

        status = theDb.findIntervalCont( theContH, theContName );
        if ( BdbcSuccess != status ) {
            ErrMsg(error) << errorString << endl
                          << "    The container does not exist." << endmsg;
            break;
        }

      // Try to obtain the History. It should exist.

        theHistoryH = theDb.getHistoryH( );
        if ( BdbIsNull( theHistoryH )) {
            ErrMsg(error) << errorString << endl
                          << "    The History does not exist." << endmsg;
            break;
        }

      // Delete the History.

        BdbDelete(theHistoryH);

      // Delete backup container (if any) and corresponding
      // container link (if it's linked container).

        string theBackupContName = string( "_HISTORY_" ) + string( theContName );

        BdbObsoleteDatabase theBackupDb( theTLA );
        BdbHandle(BdbContObj) theBackupContH;
        BdbHandle(BdbContObj) theBackupLinkContH;

        status = theBackupDb.findIntervalCont( theBackupContH, theBackupContName.c_str() );
        if (( BdbcSuccess == status ) && ( ! BdbIsNull( theBackupContH ))) {
            if ( theBackupDb.isLink( )) {
                theBackupDb.getLinkContH( theBackupLinkContH );
                BdbDelete( theBackupLinkContH );
            }
            BdbDelete(theBackupContH);
        }

        theLoopWasFailed = false;
        break;
    }
    if ( theLoopWasFailed ) {
        ErrMsg(error) << "        Detector:  \"" << theTLA << "\"" << endl
                      << "        Container: \"" << theContName << "\"" << endmsg;

        if ( BdbcSuccess == status ) {
            status = BdbcError;
        }
        return status;
    }

    return BdbcSuccess;
}

BdbStatus
BdbCondDatabaseMgr::commentHistory( const char* theTLA,
                                    const char* theContName,
                                    const char* theRcsid,
                                    const char* theComment )
{
    const char* errorString = "BdbCondDatabaseMgr::commentHistory() -- error.";

    BdbStatus status;

    BdbHandle(BdbCondHistory) theHistoryH;

    assert ( theTLA      != (char*) 0 );
    assert ( theContName != (char*) 0 );

  // Open the database.

    BdbObsoleteDatabase theDb( theTLA );

  // Perform initializations in a exception-like loop.

    bool theLoopWasFailed = true;

    while ( true ) {

      // Ensure a proper authorization level to be set.

        if ( ! theDb.verifyAuthLevelOnly( theContName )) {
            ErrMsg(error) << errorString << endl
                          << "    Failed to set proper Authorization level." << endmsg;
            break;
        }

      // Setup cache context by locating the container handle.

        status = theDb.findHistory( theHistoryH, theContName );
        if (( BdbcSuccess != status ) || ( BdbIsNull( theHistoryH ))) {
            ErrMsg(error) << errorString << endl
                          << "    Failed to locate the History in the container." << endmsg;
            break;
        }

      // Make a record for the History

        theDb.historyComment( theRcsid, theComment );

        theLoopWasFailed = false;
        break;
    }
    if ( theLoopWasFailed ) {
        ErrMsg(error) << "        Detector:  \"" << theTLA << "\"" << endl
                      << "        Container: \"" << theContName << "\"" << endmsg;

        if ( BdbcSuccess == status ) {
            status = BdbcError;
        }
        return status;
    }

    return BdbcSuccess;
}

BdbStatus
BdbCondDatabaseMgr::evaluateIntervalDatabase( const char* theTLA,
                                              bool&       exists )
{
    const char* errorString = "BdbCondDatabaseMgr::evaluateIntervalDatabase() -- error.";

    BdbStatus status;

    assert( theTLA != (const char*) 0 );

  // Build the name of the link database.

    BdbObsoleteDatabase theDb( theTLA );
    string dbSysName;

    dbSysName = theDb.linkDatabaseName( theTLA );  
    if ( dbSysName == (char*) 0 ) {
        ErrMsg(error) << errorString << endl
                      << "    Failed to build the link database name from the detector name." << endl
                      << "        DETECTOR: " << theTLA << endmsg;
        return BdbcError;
    }

  // Check the existence of the link database

    BdbHandle(BdbDBObj) theDbH;
    COUT1 << "CONDDBOPEN (exist only): db=" << dbSysName << endl;
    exists = theDbH.exist( BdbApplicationOrDomain::activeInstance()->fd(), dbSysName.c_str(), BdbcNoOpen );

    return BdbcSuccess;
}

BdbStatus
BdbCondDatabaseMgr::getDatabasesForContainer( vector<string>& theList,
                                              const char*                     theTLA,
                                              const char*                     theContName )
{
    const char* errorString = "BdbCondDatabaseMgr::getDatabasesForContainer() -- error.";

    BdbStatus status;

    assert( theTLA      != (const char*) 0 );
    assert( theContName != (const char*) 0 );

    theList.clear( );

  // Prepare the data structures.

    map<string, BdbRef(ooDBObj)>* theDict;
    theDict = new map<string, BdbRef(ooDBObj)>;

    BdbObsoleteDatabase theDb( theTLA );

  // Run the container scanner.

    status = scanContainer( *theDict, theDb, theContName );
    if( BdbcSuccess != status ) {
        ErrMsg(error) << errorString << endl
                      << "    Failed to obtain databases to be referenced through the container." << endl
                      << "        DETECTOR  -> " << theTLA << endl
                      << "        CONTAINER -> " << theContName << endmsg;
        delete theDict;
        return status;
    }

  // Now browse the hash dictionary and get the system name of each database
  // found in there.

    map<string, BdbRef(ooDBObj)>::iterator theDictItr=theDict->begin();
    BdbRef(ooDBObj) theDbRef;

    while( theDictItr!=theDict->end()) {
        theDbRef = theDictItr->second;
        theList.push_back( string( theDbRef.name( )));
        theDictItr++;
    }
    delete theDict;

    return BdbcSuccess;
}

BdbStatus
BdbCondDatabaseMgr::getDatabases( vector<string>&       theList,
                                  const vector<string>& theKeywordsList,
                                  const vector<string>& theDetectorsList,
                                  bool                                  theExcludeFlag )
{
    const char* errorString = "BdbCondDatabaseMgr::getDatabases() -- ERROR.";

    BdbStatus status;

    theList.clear( );

  // Build the list of detectors.

    vector<string> theFinalDetectorsList;

    status = selectDetectors( theFinalDetectorsList, theDetectorsList, theExcludeFlag );
    if( BdbcSuccess != status ) {
        ErrMsg(error) << errorString << endl
                      << "    Failed to build a list of detectors to be scanned." << endmsg;
        return status;
    }

  // Iterate through the final list of detectors.

    vector<string>                     theContainers;
    map<string, BdbRef(ooDBObj)>* theDict;
    theDict = new map<string, BdbRef(ooDBObj)>;

    int detectors = theFinalDetectorsList.size( );
    for( int detectorIndex = 0; detectorIndex < detectors; detectorIndex++ ) {

      // List all the containers in this detector.

        BdbObsoleteDatabase theDb( theFinalDetectorsList[detectorIndex].c_str() );

        theContainers.clear( );
        theDb.listAllClasses( theContainers );

      // Iterate through the list of containers.

        int containers = theContainers.size( );
        for( int containerIndex = 0; containerIndex < containers; containerIndex++ ) {

          // If the list of keywords is non-empty then match the keywords
          // in a container name.

            if( ! theKeywordsList.empty( )) {

              // Just skip a container if it does not have none of specified
              // keywords.

                bool keywordWasFound = false;

                int keywords = theKeywordsList.size( );
                for( int keywordIndex = 0; keywordIndex < keywords; keywordIndex++ ) {
                    if( theContainers[containerIndex].find( theKeywordsList[keywordIndex] )!=string::npos) {
                        keywordWasFound = true;
                        break;
                    }
                }
                if( ! keywordWasFound ) {
                    continue;
                }
            }

          // Run the container scanner.

            status = scanContainer( *theDict, theDb, theContainers[containerIndex].c_str() );
            if( BdbcSuccess != status ) {
                ErrMsg(error) << errorString << endl
                              << "    Failed to obtain databases to be referenced through the container." << endl
                              << "        DETECTOR  -> " << theFinalDetectorsList[detectorIndex] << endl
                              << "        CONTAINER -> " << theContainers[containerIndex] << endmsg;
                delete theDict;
                return status;
            }
        }
    }

  // Now browse the hash dictionary and get the system name of each database
  // found in there.

    map<string, BdbRef(ooDBObj)>::iterator theDictItr=theDict->begin();
    BdbRef(ooDBObj) theDbRef;

    while( theDictItr!=theDict->end( )) {
        theDbRef = theDictItr->second;
        theList.push_back( string( theDbRef.name( )));
        theDictItr++;
    }
    delete theDict;

    return BdbcSuccess;
}

BdbStatus
BdbCondDatabaseMgr::getContainers( map<string, vector<string> >& theDict,
                                   const vector<string>&                             theKeywordsList,
                                   const vector<string>&                             theDetectorsList,
                                   bool                                                              theExcludeFlag )
{
    const char* errorString = "BdbCondDatabaseMgr::getContainers() -- error.";

    BdbStatus status;

    theDict.clear( );

  // Build the list of detectors.

    vector<string> theFinalDetectorsList;

    status = selectDetectors( theFinalDetectorsList, theDetectorsList, theExcludeFlag );
    if( BdbcSuccess != status ) {
        ErrMsg(error) << errorString << endl
                      << "    Failed to build a list of detectors to be scanned." << endmsg;
        return status;
    }

  // Iterate through the final list of detectors.
  // Our goal is to build a hash dictionary where the database is a key
  // and list of containers are the values of the dictionary.

    vector<string> theContainers;
    vector<string> theDatabases;

    int detectors = theFinalDetectorsList.size( );
    for( int detectorIndex = 0; detectorIndex < detectors; detectorIndex++ ) {

      // List all the containers in this detector.

        BdbObsoleteDatabase theDb( theFinalDetectorsList[detectorIndex].c_str() );

        theContainers.clear( );

        theDb.listAllClasses( theContainers );

      // Iterate through the list of containers.

        int containers = theContainers.size( );
        for( int containerIndex = 0; containerIndex < containers; containerIndex++ ) {

          // If the list of keywords is non-empty then match the keywords
          // in a container name.

            if( ! theKeywordsList.empty( )) {

              // Just skip a container if it does not have none of specified
              // keywords.

                bool keywordWasFound = false;

                int keywords = theKeywordsList.size( );
                for( int keywordIndex = 0; keywordIndex < keywords; keywordIndex++ ) {
                    if( theContainers[containerIndex].find( theKeywordsList[keywordIndex])!=string::npos ) {
                        keywordWasFound = true;
                        break;
                    }
                }
                if( ! keywordWasFound ) {
                    continue;
                }
            }

          // Get a list of databases for a container.

            status = getDatabasesForContainer( theDatabases,
                                               theFinalDetectorsList[detectorIndex].c_str(),
                                               theContainers[containerIndex].c_str() );
            if( BdbcSuccess != status ) {
                ErrMsg(error) << errorString << endl
                              << "    Failed to obtain a list of databases for specified container." << endmsg;
                return BdbcError;
            }

          // Iterate over all the databases associated to given container,

            int databases = theDatabases.size( );
            for( int databaseIndex = 0; databaseIndex < databases; databaseIndex++ ) {
                theDict[theDatabases[databaseIndex]].push_back( theFinalDetectorsList[detectorIndex] +
                                                             string( " " ) +
                                                             theContainers[containerIndex] );
            }
        }
    }

    return BdbcSuccess;
}

BdbStatus
BdbCondDatabaseMgr::getClasses( map<string, int>& theDict,
                                const char*                           theTLA,
                                const char*                           theContName )
{
    const char* errorString = "BdbCondDatabaseMgr::getClasses() -- error.";

    BdbStatus status;

    assert( theTLA      != (const char*) 0 );
    assert( theContName != (const char*) 0 );

    theDict.clear( );

  // Prepare the data structures.

    BdbObsoleteDatabase theDb( theTLA );

    BdbHandle(BdbInterval) theIntervalH;
    BdbHandle(BdbInterval) theNextIntervalH;
    BdbHandle(BdbObject)   theObjectH;

    string name;

  // Extract the class names from the objects (if they are non-zero)
  // and put them into the hash dictionary as pesistent references.

    status = theDb.firstInterval( theIntervalH, theContName );
    if(( BdbcSuccess != status ) || BdbIsNull(theIntervalH)) {
        ErrMsg(error) << errorString << endl
                      << "    Failed to obtain the FIRST interval from the container." << endl
                      << "        DETECTOR  -> " << theDb.subsystemTLA( ) << endl
                      << "        CONTAINER -> " << theContName << endmsg;
        return BdbcError;
    }

  // Take the version trees one-by-one starting from the very first interval.
  // Each next tree will be accessed following the "next TOPMOST"
  // link until NULL interval is met.

  // Analyze the FIRST interval itself.

    theObjectH = theIntervalH->getObject( );
    if( ! BdbIsNull(theObjectH)) {
        if( theObjectH.isValid( )) {
            name = theObjectH.typeName( );
        } else {
            name = "???";
        }
        if( theDict.find( name )!=theDict.end()) {
            theDict[name]++;
        } else {
            theDict[name] = 1;
        }
    }

  // Then start working with trees.

    vector<BdbHandle(BdbInterval)> theTree;
    int numBranches;

    do {

      // Avoid a problem of "zero" [-oo,-oo] FIRST interval because the next
      // interval would also start from [-oo, *]. And this introduces some
      // ambiguity into the interval locating algorithm.
      // Check also the correct structure of the next interval.

        if( BdbTime::minusInfinity == theIntervalH->endTime( )) {

            theNextIntervalH = theIntervalH->next( );
            theIntervalH     = theNextIntervalH;

            if( theIntervalH->beginTime( ) == theIntervalH->endTime( )) {
                ErrMsg(error) << errorString << endl
                              << "    The invalid interval found in the container." << endl
                              << "        BEGIN TIME -> " << theIntervalH->beginTime( ) << endl
                              << "        END TIME   -> " << theIntervalH->endTime( ) << endl
                              << "        DETECTOR   -> " << theDb.subsystemTLA( ) << endl
                              << "        CONTAINER  -> " << theContName << endmsg;
                return BdbcError;
            }
            status = theDb.getTree( theTree, numBranches, theContName, theIntervalH->beginTime( ) + 1 );
        } else {
            status = theDb.getTree( theTree, numBranches, theContName, theIntervalH->beginTime( ));
        }
        if(( BdbcSuccess != status ) || ( numBranches <= 0 )) {
            ErrMsg(error) << errorString << endl
                          << "    Failed to obtain the version tree from the container." << endl
                          << "        BEGIN TIME -> " << theIntervalH->beginTime( ) << endl
                          << "        DETECTOR   -> " << theDb.subsystemTLA( ) << endl
                          << "        CONTAINER  -> " << theContName << endmsg;
            return BdbcError;
        }

        int entries = theTree.size( );
        for( int i = 0; i < entries; i++ ) {

          // Skip NULL delimiters.

            if( ! BdbIsNull(theTree[i])) {

                theIntervalH = theTree[i];

                theObjectH = theIntervalH->getObject( );
                if( ! BdbIsNull(theObjectH)) {
                    if( theObjectH.isValid( )) {
                        name = theObjectH.typeName( );
                    } else {
                        name = "???";
                    }
                    if( theDict.find( name )!=theDict.end()) {
                        theDict[name]++;
                    } else {
                        theDict[name] = 1;
                    }
                }
            }
        }

        theNextIntervalH = theIntervalH->next( );
        theIntervalH     = theNextIntervalH;

    } while( ! BdbIsNull(theIntervalH));


    return BdbcSuccess;
}

BdbStatus
BdbCondDatabaseMgr::validateContainer( vector<BdbHandle(BdbInterval)>& theList,
                                       const char*                                  theTLA,
                                       const char*                                  theContName )
{
    const char* errorString = "BdbCondDatabaseMgr::getDatabasesForContainer() -- error.";

    BdbStatus status;

    assert( theTLA      != (const char*) 0 );
    assert( theContName != (const char*) 0 );

    theList.clear( );

  // Prepare the data structures.

    BdbObsoleteDatabase theDb( theTLA );
    BdbHandle(BdbInterval) theIntervalH;
    BdbHandle(BdbInterval) theNextIntervalH;
    BdbHandle(BdbObject)   theObjectH;

  // Validate objects (if they are non-zero) and if they are not
  // - put the corresponding interval into the list as pesistent references.

    status = theDb.firstInterval( theIntervalH, theContName );
    if(( BdbcSuccess != status ) || BdbIsNull(theIntervalH)) {
        ErrMsg(error) << errorString << endl
                      << "    Failed to obtain the FIRST interval from the container." << endl
                      << "        DETECTOR  -> " << theDb.subsystemTLA( ) << endl
                      << "        CONTAINER -> " << theContName << endmsg;
        return BdbcError;
    }

  // Take the version trees one-by-one starting from the very first interval.
  //
  // Each next tree will be accessed following the "next TOPMOST"
  // link until NULLinterval is met.

  // Analyze the FIRST interval itself.

    theObjectH = theIntervalH->getObject( );
    if( ! BdbIsNull(theObjectH)) {
        if( ! theObjectH.isValid( )) {
            theList.push_back( theIntervalH );
        }
    }

  // Then start working with trees.

    vector<BdbHandle(BdbInterval)> theTree;
    int numBranches;

    do {

      // Avoid a problem of "zero" [-oo,-oo] FIRST interval because the next
      // interval would also start from [-oo, *]. And this introduces some
      // ambiguity into the interval locating algorithm.
      // Check also the correct structure of the next interval.

        if( BdbTime::minusInfinity == theIntervalH->endTime( )) {

            theNextIntervalH = theIntervalH->next( );
            theIntervalH     = theNextIntervalH;

            if( theIntervalH->beginTime( ) == theIntervalH->endTime( )) {
                ErrMsg(error) << errorString << endl
                              << "    The invalid interval found in the container." << endl
                              << "        BEGIN TIME -> " << theIntervalH->beginTime( ) << endl
                              << "        END TIME   -> " << theIntervalH->endTime( ) << endl
                              << "        DETECTOR   -> " << theDb.subsystemTLA( ) << endl
                              << "        CONTAINER  -> " << theContName << endmsg;
                return BdbcError;
            }
            status = theDb.getTree( theTree, numBranches, theContName, theIntervalH->beginTime( ) + 1 );
        } else {
            status = theDb.getTree( theTree, numBranches, theContName, theIntervalH->beginTime( ));
        }
        if(( BdbcSuccess != status ) || ( numBranches <= 0 )) {
            ErrMsg(error) << errorString << endl
                          << "    Failed to obtain the version tree from the container." << endl
                          << "        BEGIN TIME -> " << theIntervalH->beginTime( ) << endl
                          << "        DETECTOR   -> " << theDb.subsystemTLA( ) << endl
                          << "        CONTAINER  -> " << theContName << endmsg;
            return BdbcError;
        }

        int entries = theTree.size( );
        for( int i = 0; i < entries; i++ ) {

          // Skip NULL delimiters.

            if( ! BdbIsNull(theTree[i])) {

                theIntervalH = theTree[i];

                theObjectH = theIntervalH->getObject( );
                if( ! BdbIsNull(theObjectH)) {
                    if( ! theObjectH.isValid( )) {
                        theList.push_back( theIntervalH );
                    }
                }
            }
        }

        theNextIntervalH = theIntervalH->next( );
        theIntervalH     = theNextIntervalH;

    } while( ! BdbIsNull(theIntervalH));

    return BdbcSuccess;
}

BdbStatus
BdbCondDatabaseMgr::mergeIntervalContainers( const char*    theInTLA,
                                             const char*    theInContName,
                                             const char*    theOutTLA,
                                             const char*    theOutContName,
                                             const BdbTime& theMergeTime,
                                             bool           mergeToLeft,
                                             bool           verifyOnly )
{
    const char* errorString = "BdbCondDatabaseMgr::mergeIntervalContainers() -- error.";

    BdbStatus status = BdbcError;

    assert( theInTLA       != (char*) 0 );
    assert( theInContName  != (char*) 0 );
    assert( theOutTLA      != (char*) 0 );
    assert( theOutContName != (char*) 0 );

  // Open both databases.

    BdbObsoleteDatabase theInDb( theInTLA );
    BdbObsoleteDatabase theOutDb( theOutTLA );

  // Intervals intervals at a merging point. These are obtained during
  // an evaluaton of a merge point/time and then they will be used for
  // merging.

    BdbHandle(BdbIntervalR) theInLeftBaselineIntervalH;
    BdbHandle(BdbIntervalR) theInRightBaselineIntervalH;
    BdbHandle(BdbIntervalR) theOutLeftBaselineIntervalH;
    BdbHandle(BdbIntervalR) theOutRightBaselineIntervalH;

  // Perform operations in a exception-like loop.

    bool operationsLoopWasFailed = true;

    while ( true ) {

      // Locate both containers - they must exist.
      // Check if it's not the same container.

        BdbHandle(BdbContObj) theInContH;
        status = theInDb.findIntervalCont( theInContH, theInContName );
        if (( BdbcSuccess != status ) || ( BdbIsNull( theInContH ))) {
            ErrMsg(error) << errorString << endl
                          << "    The input container does not exist in the database." << endmsg;
            break;
        }

        BdbHandle(BdbContObj) theOutContH;
        status = theOutDb.findIntervalCont( theOutContH, theOutContName );
        if (( BdbcSuccess != status ) || ( BdbIsNull( theOutContH ))) {
            ErrMsg(error) << errorString << endl
                          << "    The output container does not exist in the database." << endmsg;
            break;
        }

        if ( theInContH == theOutContH ) {
            ErrMsg(error) << errorString << endl
                          << "    An attempt to merge a container with itself." << endmsg;
            break;
        }

      // Check if specified merge time meets criteria.
      //
      // NOTE: An essential side effect of this operation is also a set of baseline
      //       intervals in both containers, which correspond to the merging point.

        status = evaluateMergePoint( theInDb,
                                     theOutDb,
                                     theMergeTime,
                                     theInLeftBaselineIntervalH,
                                     theInRightBaselineIntervalH,
                                     theOutLeftBaselineIntervalH,
                                     theOutRightBaselineIntervalH );
        if ( BdbcSuccess != status ) {
            ErrMsg(error) << errorString << endl
                          << "    This time can not be used as the merge point. See detailes above." << endmsg;
            break;
        }

      // Print algorithm DEBUG info if it's just a verification path.

        if ( verifyOnly ) {

            ErrMsg(routine) << "EVALUATE MERGE POINT: most important intervals." << endl
                            << endl
                            << "    theInLeftBaselineIntervalH   = " << getOID( theInLeftBaselineIntervalH ) << endl
                            << "    theInRightBaselineIntervalH  = " << getOID( theInRightBaselineIntervalH ) << endl
                            << endl
                            << "    theOutLeftBaselineIntervalH  = " << getOID( theOutLeftBaselineIntervalH ) << endl
                            << "    theOutRightBaselineIntervalH = " << getOID( theOutRightBaselineIntervalH ) << endl
                            << endmsg;
        }

      // Compare revisions, assuming their partial equivalence (pay attention
      // to the third parameter of the comparision method), which means
      // that the input set of revisions is a true subset of the output one.
      // We also assume that matching revisions must be structurally equivalent
      // (the forth parameter is set to false) rather then have the same contents.

        status = compareRevisions( theInDb, theOutDb, false, false );
        if ( BdbcSuccess != status ) {
            ErrMsg(error) << errorString << endl
                          << "    The revisions are incompatible for merging. See detailes above." << endmsg;
            break;
        }

      // Do not proceed further if it's just a trial (verification) path.

        if ( ! verifyOnly ) {

          // Now we are about to begin the merging...

            if ( mergeToLeft ) {

              // Put a record for the "history" into an output container.

                theOutDb.historyCMerge( rcsid, BdbTime::minusInfinity, theMergeTime );

              // And then begin merging...

                status = mergeLeftFromBaseline( theInDb,
                                                theOutDb,
                                                theInLeftBaselineIntervalH,
                                                theInRightBaselineIntervalH,
                                                theOutLeftBaselineIntervalH,
                                                theOutRightBaselineIntervalH );
                if ( BdbcSuccess != status ) break;

            } else {

              // Yet to be implemented.

                ErrMsg(error) << errorString << endl
                              << "    Merging to the right side of the output container is not" << endl
                              << "    implemented in this code." << endmsg;
                break;
            }
        }

      // The loop has been sucessfully completed.

        operationsLoopWasFailed = false;
        break;
    }
    if ( operationsLoopWasFailed ) {
        ErrMsg(error) << "        INPUT   DETECTOR: \"" << theInTLA << "\"" << endl
                      << "               CONTAINER: \"" << theInContName << "\"" << endl
                      << "        OUTPUT  DETECTOR: \"" << theOutTLA << "\"" << endl
                      << "               CONTAINER: \"" << theOutContName << "\"" << endmsg;
        return BdbcError;
    }

    return BdbcSuccess;
}

BdbStatus
BdbCondDatabaseMgr::mergeIntervalContainers( const char*    theInTLA,
                                             const char*    theInContName,
                                             const char*    theOutTLA,
                                             const char*    theOutContName,
                                             const BdbTime& theBeginMergeTime,
                                             const BdbTime& theEndMergeTime,
                                             bool           mergeInner,
                                             bool           verifyOnly )
{
    const char* errorString = "BdbCondDatabaseMgr::mergeIntervalContainers() -- error.";

    BdbStatus status = BdbcError;

    assert( theInTLA       != (char*) 0 );
    assert( theInContName  != (char*) 0 );
    assert( theOutTLA      != (char*) 0 );
    assert( theOutContName != (char*) 0 );

  // Open both databases.

    BdbObsoleteDatabase theInDb( theInTLA );
    BdbObsoleteDatabase theOutDb( theOutTLA );

  // Intervals intervals at a merging point. These are obtained during
  // an evaluaton of a merge point/time and then they will be used for
  // merging.

    BdbHandle(BdbIntervalR) theInBeginLeftBaselineIntervalH;
    BdbHandle(BdbIntervalR) theInBeginRightBaselineIntervalH;
    BdbHandle(BdbIntervalR) theInEndLeftBaselineIntervalH;
    BdbHandle(BdbIntervalR) theInEndRightBaselineIntervalH;

    BdbHandle(BdbIntervalR) theOutBeginLeftBaselineIntervalH;
    BdbHandle(BdbIntervalR) theOutBeginRightBaselineIntervalH;
    BdbHandle(BdbIntervalR) theOutEndLeftBaselineIntervalH;
    BdbHandle(BdbIntervalR) theOutEndRightBaselineIntervalH;

  // Perform operations in a exception-like loop.

    bool operationsLoopWasFailed = true;

    while ( true ) {

      // Locate both containers - they must exist.
      // Check if it's not the same container.

        BdbHandle(BdbContObj) theInContH;
        status = theInDb.findIntervalCont( theInContH, theInContName );
        if (( BdbcSuccess != status ) || ( BdbIsNull( theInContH ))) {
            ErrMsg(error) << errorString << endl
                          << "    The input container does not exist in the database." << endmsg;
            break;
        }

        BdbHandle(BdbContObj) theOutContH;
        status = theOutDb.findIntervalCont( theOutContH, theOutContName );
        if (( BdbcSuccess != status ) || ( BdbIsNull( theOutContH ))) {
            ErrMsg(error) << errorString << endl
                          << "    The output container does not exist in the database." << endmsg;
            break;
        }

        if ( theInContH == theOutContH ) {
            ErrMsg(error) << errorString << endl
                          << "    An attempt to merge a container with itself." << endmsg;
            break;
        }

        if (( BdbTime::minusInfinity == theBeginMergeTime ) ||
            ( BdbTime::plusInfinity  == theEndMergeTime   ) ||
            ( theBeginMergeTime >= theEndMergeTime )) {
            ErrMsg(error) << errorString << endl
                          << "    Incorrect validity time limits for the merging area were specified ." << endl
                          << "    Neither of these values should equal to (any) \"infinity\"." << endl
                          << "    The begin time must be more than (but not equal to) the end time." << endmsg;
            break;
        }

      // Check if specified merge time points meet criteria.
      //
      // NOTE: An essential side effect of this operation is also a set of baseline
      //       intervals in both containers, which correspond to the merging point.

        status = evaluateMergePoint( theInDb,
                                     theOutDb,
                                     theBeginMergeTime,
                                     theInBeginLeftBaselineIntervalH,
                                     theInBeginRightBaselineIntervalH,
                                     theOutBeginLeftBaselineIntervalH,
                                     theOutBeginRightBaselineIntervalH );
        if ( BdbcSuccess != status ) {
            ErrMsg(error) << errorString << endl
                          << "    The begin merge time can not be used as the merge point. See detailes above." << endmsg;
            break;
        }
        status = evaluateMergePoint( theInDb,
                                     theOutDb,
                                     theEndMergeTime,
                                     theInEndLeftBaselineIntervalH,
                                     theInEndRightBaselineIntervalH,
                                     theOutEndLeftBaselineIntervalH,
                                     theOutEndRightBaselineIntervalH );
        if ( BdbcSuccess != status ) {
            ErrMsg(error) << errorString << endl
                          << "    The end merg time can not be used as the merge point. See detailes above." << endmsg;
            break;
        }

      // Print algorithm DEBUG info if it's just a verification path.

        if ( verifyOnly ) {

            ErrMsg(routine) << "EVALUATE MERGE POINT: most important intervals." << endl
                            << endl
                            << "    theInBeginLeftBaselineIntervalH   = " << getOID( theInBeginLeftBaselineIntervalH ) << endl
                            << "    theInBeginRightBaselineIntervalH  = " << getOID( theInBeginRightBaselineIntervalH ) << endl
                            << "    theInEndLeftBaselineIntervalH     = " << getOID( theInEndLeftBaselineIntervalH ) << endl
                            << "    theInEndRightBaselineIntervalH    = " << getOID( theInEndRightBaselineIntervalH ) << endl
                            << endl
                            << "    theOutBeginLeftBaselineIntervalH  = " << getOID( theOutBeginLeftBaselineIntervalH ) << endl
                            << "    theOutBeginRightBaselineIntervalH = " << getOID( theOutBeginRightBaselineIntervalH ) << endl
                            << "    theOutEndLeftBaselineIntervalH    = " << getOID( theOutEndLeftBaselineIntervalH ) << endl
                            << "    theOutEndRightBaselineIntervalH   = " << getOID( theOutEndRightBaselineIntervalH ) << endl
                            << endmsg;
        }

      // Compare revisions, assuming their partial equivalence (pay attention
      // to the third parameter of the comparision method), which means
      // that the input set of revisions is a true subset of the output one.
      // We also assume that matching revisions must be structurally equivalent
      // (the forth parameter is set to false) rather then have the same contents.

        status = compareRevisions( theInDb, theOutDb, false, false );
        if ( BdbcSuccess != status ) {
            ErrMsg(error) << errorString << endl
                          << "    The revisions are incompatible for merging. See detailes above." << endmsg;
            break;
        }

      // Do not proceed further if it's just a trial (verification) path.

        if ( ! verifyOnly ) {

          // Now we are about to begin the merging...

            if ( mergeInner ) {

              // Put a record for the "history" into an output container.

                theOutDb.historyCMerge( rcsid, theBeginMergeTime, theEndMergeTime );

              // And then begin merging...

                status = mergeInnerFromBaseline( theInDb,
                                                 theOutDb,
                                                 theInBeginLeftBaselineIntervalH,
                                                 theInBeginRightBaselineIntervalH,
                                                 theInEndLeftBaselineIntervalH,
                                                 theInEndRightBaselineIntervalH,
                                                 theOutBeginLeftBaselineIntervalH,
                                                 theOutBeginRightBaselineIntervalH,
                                                 theOutEndLeftBaselineIntervalH,
                                                 theOutEndRightBaselineIntervalH );
                if ( BdbcSuccess != status ) break;

            } else {

              // Yet to be implemented.

                ErrMsg(error) << errorString << endl
                              << "    Merging to the outer part of the output container is not" << endl
                              << "    implemented in this code." << endmsg;
                break;
            }
        }

      // The loop has been sucessfully completed.

        operationsLoopWasFailed = false;
        break;
    }
    if ( operationsLoopWasFailed ) {
        ErrMsg(error) << "        INPUT   DETECTOR: \"" << theInTLA << "\"" << endl
                      << "               CONTAINER: \"" << theInContName << "\"" << endl
                      << "        OUTPUT  DETECTOR: \"" << theOutTLA << "\"" << endl
                      << "               CONTAINER: \"" << theOutContName << "\"" << endmsg;
        return BdbcError;
    }

    return BdbcSuccess;
}

BdbStatus
BdbCondDatabaseMgr::evaluateMergePoint( BdbObsoleteDatabase&             theInDb,
                                        BdbObsoleteDatabase&             theOutDb,
                                        const BdbTime&           theMergeTime,
                                        BdbHandle(BdbIntervalR)& theInLeftBaselineIntervalH,
                                        BdbHandle(BdbIntervalR)& theInRightBaselineIntervalH,
                                        BdbHandle(BdbIntervalR)& theOutLeftBaselineIntervalH,
                                        BdbHandle(BdbIntervalR)& theOutRightBaselineIntervalH )
{
    const char* errorString = "BdbCondDatabaseMgr::evaluateMergePoint() -- error.";

    BdbStatus status = BdbcError;

  // NULL-ify results.

    theInLeftBaselineIntervalH   = 0;
    theInRightBaselineIntervalH  = 0;
    theOutLeftBaselineIntervalH  = 0;
    theOutRightBaselineIntervalH = 0;

  // A very trivial check for the merging time.

    if ( theMergeTime <= BdbTime::minusInfinity ||
         theMergeTime >= BdbTime::plusInfinity ) {
        ErrMsg(error) << errorString << endl
                      << "    Incorrect merging time was specified: " << theMergeTime << endl
                      << "    It can not be infinite (either negative or positive)." << endmsg;
        return BdbcError;
    }

  // Locate and verify baseline intervals in both conatiners.

    status = locateBaselineIntervals( theInLeftBaselineIntervalH,
                                      theInRightBaselineIntervalH,
                                      theInDb,
                                      theMergeTime );
    if ( BdbcSuccess != status ) return status;

    status = locateBaselineIntervals( theOutLeftBaselineIntervalH,
                                      theOutRightBaselineIntervalH,
                                      theOutDb,
                                      theMergeTime );
    if ( BdbcSuccess != status ) return status;

  // Evalueate the merge point.
  //
  // The merge point is considered valid if it falls into a border between
  // two baseline intervals at both containers.
  //
  //         the merge time
  //               :
  //               v
  // -----+--------+--------+-----
  //  ... | Left   |  Right | ...
  // -----+--------+--------+-----
  //
  // In this case the handle to the left interval will not be NULL.

    if ( BdbIsNull(theInLeftBaselineIntervalH) || BdbIsNull(theOutLeftBaselineIntervalH)) {
        ErrMsg(error) << errorString << endl
                      << "    PROBLEM:    The merge time does not fall exactly onto a border between" << endl
                      << "                two baseline intervals in one (or both) containers." << endl
                      << "    REASON:     Containers may have different structure of baseline intervals" << endl
                      << "                at a point of merging." << endl
                      << "    CONCLUSION: Merging is not possible." << endmsg;
        return BdbcError;
    }

    return BdbcSuccess;
}

BdbStatus
BdbCondDatabaseMgr::locateBaselineIntervals( BdbHandle(BdbIntervalR)& theLeftBaselineIntervalH,
                                             BdbHandle(BdbIntervalR)& theRightBaselineIntervalH,
                                             BdbObsoleteDatabase&             theDb,
                                             const BdbTime&           theMergeTime )
{
    const char* errorString = "BdbCondDatabaseMgr::locateBaselineIntervals() -- error.";

    BdbStatus status = BdbcError;

    theLeftBaselineIntervalH  = 0;
    theRightBaselineIntervalH = 0;

  // Get the right interval.

    status = theDb.getBaselineInterval( theRightBaselineIntervalH, theDb.containerName( ), theMergeTime );
    if ( BdbcSuccess != status ) {
        ErrMsg(error) << errorString << endl
                      << "    Failed to locate RIGHT baseline interval for the merge time:" << theMergeTime << endmsg;
        return BdbcError;
    }

  // Get the left baseline interval only if the merge time is exactly
  // on the border between baseline intervals.

    theLeftBaselineIntervalH = 0;
    if ( theRightBaselineIntervalH->beginTime( ) == theMergeTime ) {
        theRightBaselineIntervalH->getBaselinePrevious( theLeftBaselineIntervalH );
    }

    return BdbcSuccess;
}

BdbStatus
BdbCondDatabaseMgr::compareRevisions( BdbObsoleteDatabase& theInDb,
                                      BdbObsoleteDatabase& theOutDb,
                                      bool         exactEquivalence,
                                      bool         equalContensVsStructure )
{
    const char* errorString = "BdbCondDatabaseMgr::compareRevisions() -- error.";

    BdbStatus status = BdbcError;

  // Get the handles to Registries, assuming that the proper context
  // of the passed access classes has been properly set.

    BdbHandle(BdbCondRegistry) theInRegistryH;
    BdbHandle(BdbCondRegistry) theOutRegistryH;

    theInDb.getRegistryH( theInRegistryH );
    theOutDb.getRegistryH( theOutRegistryH );

    if ( BdbIsNull(theInRegistryH) || BdbIsNull(theOutRegistryH)) {
        ErrMsg(error) << errorString << endl
                      << "    This function has been called in a proper context." << endl
                      << "    It looks like an internal bug has been encountered." << endmsg;
        return BdbcError;
    }

  // Iterate over all known revisions in both containers and compare
  // them one-by-one.
  //
  // Depending on the comparision mode, we may require either "exact" equivalence
  // (when both Registries have similar revisions) or "partial" equivalence (when
  // the input Registry has a subset of revisions only).
  //
  // NOTE: Two revisions are considered as equal if their contents and the number
  //       its base revisions are equal.

    BdbHandle(BdbCondRevision) theInRevisionH;
    BdbHandle(BdbCondRevision) theOutRevisionH;

    BdbItr(BdbCondRevision) theInItr;
    BdbItr(BdbCondRevision) theOutItr;

    theInRegistryH->setRevisionItr( theInItr );
    theOutRegistryH->setRevisionItr( theOutItr );

    while ( theOutItr.next( )) {

        theOutRevisionH = theOutItr;

        if ( ! theInItr.next( )) {
            if ( exactEquivalence ) {
                ErrMsg(error) << errorString << endl
                              << "    The list of revisions in the INPUT container is shorter" << endl
                              << "    then in the OUTPUT one." << endmsg;
                return BdbcError;
            } else {
                return BdbcSuccess; // Partial equivalence is OK.
            }
        }
        theInRevisionH = theInItr;

      // Compare revisions using specified method.

        if ( equalContensVsStructure ) {
            if ( ! theOutRevisionH->isEqualTo( theInRevisionH )) {
                ErrMsg(error) << errorString << endl
                              << "    The lists of revisions in specified containers have" << endl
                              << "    revisions with non-equal contents." << endmsg;
                return BdbcError;
            }
        } else {
            if ( ! theOutRevisionH->isSimilarTo( theInRevisionH )) {
                ErrMsg(error) << errorString << endl
                              << "    The lists of revisions in specified containers have" << endl
                              << "    revisions which are non structurally equivalent." << endmsg;
                return BdbcError;
            }
        }
    }
    if ( theInItr.next( )) {
        ErrMsg(error) << errorString << endl
                      << "    The list of revisions in the OUTPUT container is shorter" << endl
                      << "    then in the INPUT one." << endmsg;
        return BdbcError;
    }

    return BdbcSuccess;
}

BdbStatus
BdbCondDatabaseMgr::mergeLeftFromBaseline( BdbObsoleteDatabase&             theInDb,
                                           BdbObsoleteDatabase&             theOutDb,
                                           BdbHandle(BdbIntervalR)& theInLeftBaselineIntervalH,
                                           BdbHandle(BdbIntervalR)& theInRightBaselineIntervalH,
                                           BdbHandle(BdbIntervalR)& theOutLeftBaselineIntervalH,
                                           BdbHandle(BdbIntervalR)& theOutRightBaselineIntervalH )
{
    const char* errorString = "BdbCondDatabaseMgr::mergeLeftFromBaseline() -- error.";

    BdbStatus status = BdbcError;

  // Locate the "border" intervals in both containers.

    BdbHandle(BdbIntervalR) theInFirstIntervalH;
    BdbHandle(BdbIntervalR) theInLastIntervalH;
    BdbHandle(BdbIntervalR) theOutFirstIntervalH;
    BdbHandle(BdbIntervalR) theOutLastIntervalH;

    status = locateBorderIntervals( theInDb,
                                    theOutDb,
                                    theInFirstIntervalH,
                                    theInLastIntervalH,
                                    theOutFirstIntervalH,
                                    theOutLastIntervalH );
    if( BdbcSuccess != status ) return status;

  // Get the handles for the output container itself and its baseline
  // revision.
  // We expect that these values are cached by the previous procedure.

    BdbHandle(BdbContObj) theOutContH;
    theOutDb.getIntervalContH( theOutContH );

    BdbHandle(BdbCondRevision) theOutBaselineRevisionH;
    theOutDb.getBaselineRevisionH( theOutBaselineRevisionH );

  // Locate the topmost interval on the left side of the "right" baseline
  // interval of the output container. This will be needed later to connect
  // the last copied interval into there.

    BdbHandle(BdbIntervalR) theOutRightTopmostIntervalH;

    status = theOutDb.getTopmostInterval( theOutRightTopmostIntervalH,
                                          theOutDb.containerName( ),
                                          theOutRightBaselineIntervalH->beginTime( ));
    if ( BdbcSuccess != status ) return status;

  // Step I: Remove old intervals from the left side in the output container.
  //
  //   NOTE: Since a trivial obkectdeletion macro BdbDelete() does not delete
  //         vertical (child) versions of baseline intervals then we are using
  //         a special helper method deleteIntervalsInSubTree() to do this recursivly.
  //
  //         We also tell this deletetion method to delete the genealogy object
  //         as well.

    BdbHandle(BdbIntervalR) theBaselineIntervalH;
    BdbHandle(BdbIntervalR) thePrevBaselineIntervalH;

    theBaselineIntervalH = theOutLeftBaselineIntervalH;
    do {
        theBaselineIntervalH->getBaselinePrevious( thePrevBaselineIntervalH );
        deleteIntervalsInSubTree( theBaselineIntervalH, true );
        theBaselineIntervalH = thePrevBaselineIntervalH;
    } while ( ! BdbIsNull(theBaselineIntervalH));

  // Step II: Make a copy of the FIRST interval. We create this interval separately
  //          just because it's named in a different way (in the scope of the container).

    theOutFirstIntervalH = new( theOutContH ) BdbIntervalR( theInFirstIntervalH->getObject( ),
                                                            theInFirstIntervalH->getBeginTime( ),
                                                            theInFirstIntervalH->getEndTime( ),
                                                            theInFirstIntervalH->getTag( ));
    theOutFirstIntervalH->setVersionTime( theInFirstIntervalH->getVersionTime( ));
    theOutFirstIntervalH->setRevision( theOutBaselineRevisionH );
    theOutFirstIntervalH.nameObj( theOutContH, "FirstInterval" );

  // Step III: Make a copy of remaining baseline intervals until (excluding) the "right"
  //           baseline interval.

    BdbHandle(BdbIntervalR) theInPrevBaselineIntervalH;
    BdbHandle(BdbIntervalR) theInBaselineIntervalH;
    BdbHandle(BdbIntervalR) theOutPrevBaselineIntervalH;
    BdbHandle(BdbIntervalR) theOutBaselineIntervalH;

    theInPrevBaselineIntervalH  = theInFirstIntervalH;
    theOutPrevBaselineIntervalH = theOutFirstIntervalH;

    theInPrevBaselineIntervalH->getBaselineNext( theInBaselineIntervalH );
    while ( theInBaselineIntervalH != theInRightBaselineIntervalH ) {

        theOutBaselineIntervalH = new( theOutContH ) BdbIntervalR( theInBaselineIntervalH->getObject( ),
                                                                   theInBaselineIntervalH->getBeginTime( ),
                                                                   theInBaselineIntervalH->getEndTime( ),
                                                                   theInBaselineIntervalH->getTag( ));

        theOutBaselineIntervalH->setVersionTime( theInBaselineIntervalH->getVersionTime( ));
        theOutBaselineIntervalH->setRevision( theOutBaselineRevisionH );

        theOutPrevBaselineIntervalH->setTopNext( theOutBaselineIntervalH );
        theOutPrevBaselineIntervalH->setBaselineNext( theOutBaselineIntervalH );

        theOutBaselineIntervalH->setTopPrevious( theOutPrevBaselineIntervalH );
        theOutBaselineIntervalH->setBaselinePrevious( theOutPrevBaselineIntervalH );

        theOutPrevBaselineIntervalH = theOutBaselineIntervalH;

        theInPrevBaselineIntervalH = theInBaselineIntervalH;
        theInPrevBaselineIntervalH->getBaselineNext( theInBaselineIntervalH );
    }

    theOutPrevBaselineIntervalH->setTopNext( theOutRightTopmostIntervalH );
    theOutPrevBaselineIntervalH->setBaselineNext( theOutRightBaselineIntervalH );

    theOutRightTopmostIntervalH->setTopPrevious( theOutPrevBaselineIntervalH );
    theOutRightBaselineIntervalH->setBaselinePrevious( theOutPrevBaselineIntervalH );

  // Step IV: traverse baseline intervals and build the version trees.
  //          Copy information from the input intervals into output ones.
  //
  //    NOTE: the pointers (handles) in both containers advance
  //          along containers synchronosly (pay attention to the check
  //          after the "while" loop ends.
  //
  //          This operation lasts until (excluding) the "right" baseline interval.

    BdbHandle(BdbIntervalR) theInIntervalH;
    BdbHandle(BdbIntervalR) theInNextIntervalH;
    BdbHandle(BdbIntervalR) theOutIntervalH;
    BdbHandle(BdbIntervalR) theOutNextIntervalH;

    theInFirstIntervalH->getBaselineNext( theInIntervalH );
    theOutFirstIntervalH->getBaselineNext( theOutIntervalH );

    while( theInIntervalH != theInRightBaselineIntervalH ) {

        status = copySubTree( theInIntervalH,
                              theOutDb,
                              theOutIntervalH );
        if( BdbcSuccess != status ) {
            ErrMsg(error) << errorString << endl
                          << "    Failed to copy the next tree of versions." << endmsg;
            return status;
        }

        theInIntervalH->getBaselineNext( theInNextIntervalH );
        theInIntervalH = theInNextIntervalH;

        theOutIntervalH->getBaselineNext( theOutNextIntervalH );
        theOutIntervalH = theOutNextIntervalH;
    }
    if ( theOutIntervalH != theOutRightBaselineIntervalH ) {
        ErrMsg(error) << errorString << endl
                      << "    The output container has incorrect internal structure." << endmsg;
        return status;
    }

  // Step V: Connect the topmost intervals into the double linked list.

    BdbHandle(BdbIntervalR) theOutPreviousIntervalH;

    theOutPreviousIntervalH = theOutFirstIntervalH;
    theOutPreviousIntervalH->getBaselineNext( theOutIntervalH );

    while( theOutIntervalH != theOutRightBaselineIntervalH ) {

        status = linkTopIntervalsInSubTree( theOutIntervalH,
                                            theOutPreviousIntervalH );
        if( BdbcSuccess != status ) {
            ErrMsg(error) << errorString << endl
                          << "    Failed to process the next tree of versions." << endmsg;
            return status;
        }

        theOutIntervalH->getBaselineNext( theOutNextIntervalH );
        theOutIntervalH = theOutNextIntervalH;
    }

    theOutPreviousIntervalH->setTopNext( theOutRightTopmostIntervalH );
    theOutRightTopmostIntervalH->setTopPrevious( theOutPreviousIntervalH );
   
    return BdbcSuccess;
}

BdbStatus
BdbCondDatabaseMgr::mergeInnerFromBaseline( BdbObsoleteDatabase&             theInDb,
                                            BdbObsoleteDatabase&             theOutDb,
                                            BdbHandle(BdbIntervalR)& theInBeginLeftBaselineIntervalH,
                                            BdbHandle(BdbIntervalR)& theInBeginRightBaselineIntervalH,
                                            BdbHandle(BdbIntervalR)& theInEndLeftBaselineIntervalH,
                                            BdbHandle(BdbIntervalR)& theInEndRightBaselineIntervalH,
                                            BdbHandle(BdbIntervalR)& theOutBeginLeftBaselineIntervalH,
                                            BdbHandle(BdbIntervalR)& theOutBeginRightBaselineIntervalH,
                                            BdbHandle(BdbIntervalR)& theOutEndLeftBaselineIntervalH,
                                            BdbHandle(BdbIntervalR)& theOutEndRightBaselineIntervalH )
{
    const char* errorString = "BdbCondDatabaseMgr::mergeInnerFromBaseline() -- error.";

    BdbStatus status = BdbcError;

  // Locate the "border" intervals in both containers.

    BdbHandle(BdbIntervalR) theInFirstIntervalH;
    BdbHandle(BdbIntervalR) theInLastIntervalH;
    BdbHandle(BdbIntervalR) theOutFirstIntervalH;
    BdbHandle(BdbIntervalR) theOutLastIntervalH;

    status = locateBorderIntervals( theInDb,
                                    theOutDb,
                                    theInFirstIntervalH,
                                    theInLastIntervalH,
                                    theOutFirstIntervalH,
                                    theOutLastIntervalH );
    if( BdbcSuccess != status ) return status;

  // Get the handles for the output container itself and its baseline
  // revision.
  // We expect that these values are cached by the previous procedure.

    BdbHandle(BdbContObj) theOutContH;
    theOutDb.getIntervalContH( theOutContH );

    BdbHandle(BdbCondRevision) theOutBaselineRevisionH;
    theOutDb.getBaselineRevisionH( theOutBaselineRevisionH );

  // Locate the topmost intervals on:
  //
  //    - the right side of the left  outer part
  //    - the left  side of the right outer part
  //
  // of the output containers. This will be needed later to connect
  // the leftmost and rightmost topmost intervals of the copied innner
  // part.
  //
  //         this is what we are
  //           looking for
  //              :   :
  //          +...+   +...+
  //          :           :
  //          v           v
  //        +---+       +---+
  //        | * |.......| * |
  //    ----+---+.......+---+----
  //    .........................
  //    --------+.......+--------
  //                ^
  //                :
  //              Inner
  //
  // NOTE: the techniques we are using to locate the interval on the left -  we are
  //       locating the first topmost interval in the inner side and then are taking
  //       one step back in the topmost link to the rightmost topmost interval
  //       from the left outer part.

    BdbHandle(BdbIntervalR) theIntervalH;
    BdbHandle(BdbIntervalR) theOutBeginLeftTopmostIntervalH;
    BdbHandle(BdbIntervalR) theOutEndRightTopmostIntervalH;

    status = theOutDb.getTopmostInterval( theIntervalH,
                                          theOutDb.containerName( ),
                                          theOutBeginRightBaselineIntervalH->beginTime( ));
    if ( BdbcSuccess != status ) return status;
    theIntervalH->getTopPrevious( theOutBeginLeftTopmostIntervalH );

    status = theOutDb.getTopmostInterval( theOutEndRightTopmostIntervalH,
                                          theOutDb.containerName( ),
                                          theOutEndRightBaselineIntervalH->beginTime( ));
    if ( BdbcSuccess != status ) return status;

  // Step I: Remove old intervals from the left side in the output container.
  //
  //   NOTE: Since a trivial obkectdeletion macro BdbDelete() does not delete
  //         vertical (child) versions of baseline intervals then we are using
  //         a special helper method deleteIntervalsInSubTree() to do this recursivly.
  //
  //         We also tell this deletetion method to delete the genealogy object
  //         as well.

    BdbHandle(BdbIntervalR) theBaselineIntervalH;
    BdbHandle(BdbIntervalR) theNextBaselineIntervalH;

    theBaselineIntervalH = theOutBeginRightBaselineIntervalH;   // This interval will be deleted first.
    do {
        theBaselineIntervalH->getBaselineNext( theNextBaselineIntervalH );
        deleteIntervalsInSubTree( theBaselineIntervalH, true );
        theBaselineIntervalH = theNextBaselineIntervalH;
    } while ( theBaselineIntervalH != theOutEndRightBaselineIntervalH );

  // Step II: Make a copy of baseline intervals until (excluding) the "right"
  //          baseline interval.

    BdbHandle(BdbIntervalR) theInPrevBaselineIntervalH;
    BdbHandle(BdbIntervalR) theInBaselineIntervalH;
    BdbHandle(BdbIntervalR) theOutPrevBaselineIntervalH;
    BdbHandle(BdbIntervalR) theOutBaselineIntervalH;

    theInPrevBaselineIntervalH  = theInBeginLeftBaselineIntervalH;
    theOutPrevBaselineIntervalH = theOutBeginLeftBaselineIntervalH;

    theInPrevBaselineIntervalH->getBaselineNext( theInBaselineIntervalH );
    while ( theInBaselineIntervalH != theInEndRightBaselineIntervalH ) {

        theOutBaselineIntervalH = new( theOutContH ) BdbIntervalR( theInBaselineIntervalH->getObject( ),
                                                                   theInBaselineIntervalH->getBeginTime( ),
                                                                   theInBaselineIntervalH->getEndTime( ),
                                                                   theInBaselineIntervalH->getTag( ));

        theOutBaselineIntervalH->setVersionTime( theInBaselineIntervalH->getVersionTime( ));
        theOutBaselineIntervalH->setRevision( theOutBaselineRevisionH );

        theOutPrevBaselineIntervalH->setTopNext( theOutBaselineIntervalH );
        theOutPrevBaselineIntervalH->setBaselineNext( theOutBaselineIntervalH );

        theOutBaselineIntervalH->setTopPrevious( theOutPrevBaselineIntervalH );
        theOutBaselineIntervalH->setBaselinePrevious( theOutPrevBaselineIntervalH );

        theOutPrevBaselineIntervalH = theOutBaselineIntervalH;

        theInPrevBaselineIntervalH = theInBaselineIntervalH;
        theInPrevBaselineIntervalH->getBaselineNext( theInBaselineIntervalH );
    }

    theOutPrevBaselineIntervalH->setTopNext( theOutEndRightTopmostIntervalH );
    theOutPrevBaselineIntervalH->setBaselineNext( theOutEndRightBaselineIntervalH );

    theOutEndRightTopmostIntervalH->setTopPrevious( theOutPrevBaselineIntervalH );
    theOutEndRightBaselineIntervalH->setBaselinePrevious( theOutPrevBaselineIntervalH );

  // Step III: traverse baseline intervals and build the version trees.
  //           Copy information from the input intervals into output ones.
  //
  //    NOTE: the pointers (handles) in both containers advance
  //          along containers synchronosly (pay attention to the check
  //          after the "while" loop ends.
  //
  //          This operation lasts until (excluding) the "right" baseline interval.

    BdbHandle(BdbIntervalR) theInIntervalH;
    BdbHandle(BdbIntervalR) theInNextIntervalH;
    BdbHandle(BdbIntervalR) theOutIntervalH;
    BdbHandle(BdbIntervalR) theOutNextIntervalH;

    theInBeginLeftBaselineIntervalH->getBaselineNext( theInIntervalH );
    theOutBeginLeftBaselineIntervalH->getBaselineNext( theOutIntervalH );

    while( theInIntervalH != theInEndRightBaselineIntervalH ) {

        status = copySubTree( theInIntervalH,
                              theOutDb,
                              theOutIntervalH );
        if( BdbcSuccess != status ) {
            ErrMsg(error) << errorString << endl
                          << "    Failed to copy the next tree of versions." << endmsg;
            return status;
        }

        theInIntervalH->getBaselineNext( theInNextIntervalH );
        theInIntervalH = theInNextIntervalH;

        theOutIntervalH->getBaselineNext( theOutNextIntervalH );
        theOutIntervalH = theOutNextIntervalH;
    }
    if ( theOutIntervalH != theOutEndRightBaselineIntervalH ) {
        ErrMsg(error) << errorString << endl
                      << "    The output container has incorrect internal structure." << endmsg;
        return status;
    }

  // Step IV: Connect the topmost intervals into the double linked list.

    BdbHandle(BdbIntervalR) theOutPreviousIntervalH;

    theOutPreviousIntervalH = theOutBeginLeftTopmostIntervalH;
    theOutBeginLeftBaselineIntervalH->getBaselineNext( theOutIntervalH );

    while( theOutIntervalH != theOutEndRightBaselineIntervalH ) {

        status = linkTopIntervalsInSubTree( theOutIntervalH,
                                            theOutPreviousIntervalH );
        if( BdbcSuccess != status ) {
            ErrMsg(error) << errorString << endl
                          << "    Failed to process the next tree of versions." << endmsg;
            return status;
        }

        theOutIntervalH->getBaselineNext( theOutNextIntervalH );
        theOutIntervalH = theOutNextIntervalH;
    }

    theOutPreviousIntervalH->setTopNext( theOutEndRightTopmostIntervalH );
    theOutEndRightTopmostIntervalH->setTopPrevious( theOutPreviousIntervalH );

    return BdbcSuccess;
}

BdbStatus
BdbCondDatabaseMgr::purgeIntervalContainer( const char*    theTLA,
                                            const char*    theContName,
                                            const BdbTime& theBeginTime,
                                            const BdbTime& theEndTime,
                                            bool           keepRevisedIntervals,
                                            d_ULong        maxNumOfTopLayers,
                                            d_ULong        maxNumOfLayersUnderRevisedInterval )
{
    const char* errorString = "BdbCondDatabaseMgr::purgeIntervalContainer() -- error.";

    BdbStatus status = BdbcSuccess;

    assert( theTLA       != (char*) 0 );
    assert( theContName  != (char*) 0 );
    assert( theBeginTime <= theEndTime );

  // Open the database.

    BdbObsoleteDatabase theDb( theTLA );

    BdbHandle(BdbIntervalR) theFirstIntervalH;
    BdbHandle(BdbIntervalR) theLastIntervalH;

    BdbHandle(BdbIntervalR) theInBeginBaselineIntervalH;
    BdbHandle(BdbIntervalR) theInEndBaselineIntervalH;
    BdbHandle(BdbIntervalR) theInBaselineIntervalH;
    BdbHandle(BdbIntervalR) theInPreviousBaselineIntervalH;
    BdbHandle(BdbIntervalR) theInNextBaselineIntervalH;

    BdbHandle(BdbIntervalR) theBeginTopIntervalH;
    BdbHandle(BdbIntervalR) theEndTopIntervalH;
    BdbHandle(BdbIntervalR) theTopIntervalH;

    BdbHandle(BdbIntervalR) theOutBeginBaselineIntervalH;
    BdbHandle(BdbIntervalR) theOutEndBaselineIntervalH;
    BdbHandle(BdbIntervalR) theOutBaselineIntervalH;
    BdbHandle(BdbIntervalR) theOutNextBaselineIntervalH;

  // Perform firther operations in a exception-like loop.

    bool operationsLoopWasFailed = true;

    while( true ) {

      // Make sure that both begin and end time were correctly specified.

        if ( theBeginTime > theEndTime ) {
            ErrMsg(error) << errorString << endl
                          << "    Wrong values of the procedure's parameters - the begin time" << endl
                          << "    must be less or equal to the end time." << endmsg;
            break;
        }

      // Get the FIRST and the LAST intervals.

        status = theDb.firstInterval( theFirstIntervalH, theContName );
        if ( BdbcSuccess != status ) {
            ErrMsg(error) << errorString << endl
                          << "    Failed to locate the FIRST interval in the specified container." << endmsg;
            break;
        }
        status = theDb.lastInterval( theLastIntervalH, theContName );
        if ( BdbcSuccess != status ) {
            ErrMsg(error) << errorString << endl
                          << "    Failed to locate the LAST interval in the specified container." << endmsg;
            break;
        }

      // Get the baseline intervals corresponding to specified begin and end times.
      // These intervals will be included into the processing.
      //
      // NOTE: A trivial optimization in case if one (or both) of specified time(s)
      //       goes (go) into either infinity has been done.

        if ( BdbTime::minusInfinity == theBeginTime ) {
            theInBeginBaselineIntervalH = theFirstIntervalH;
        } else {
            status = theDb.getBaselineInterval( theInBeginBaselineIntervalH, theContName, theBeginTime );
            if ( BdbcSuccess != status ) {
                ErrMsg(error) << errorString << endl
                              << "    Failed to locate a baseline interval for specified begin time." << endmsg;
                break;
            }
        }
        if ( BdbTime::plusInfinity == theEndTime ) {
            theInEndBaselineIntervalH = theLastIntervalH;
        } else {
            status = theDb.getBaselineInterval( theInEndBaselineIntervalH, theContName, theEndTime );
            if ( BdbcSuccess != status ) {
                ErrMsg(error) << errorString << endl
                              << "    Failed to locate a baseline interval for specified end time." << endmsg;
                break;
            }
        }

      // Just skip the processing of the FIRST and LAST intervals.
      //
      // NOTE: the adjusted intervals could be NULL in the following cases:
      //
      //       ================================================
      //       CASE I: both times fall into the FIRST interval.
      //       ================================================
      //
      //         beginTime   endTime
      //              :         :
      //              +...+  +..+
      //                  :  :
      //                  V  V
      //                [ FIRST )...
      //
      //       ================================================
      //       CASE II: both times fall into the LAST interval.
      //       ================================================
      //
      //         beginTime   endTime
      //              :         :
      //              +...+  +..+
      //                  :  :
      //                  V  V
      //             ...[ LAST )
      //
      //       ======================================================
      //       CASE III: just FIST and LAST intervals in a container.
      //       ======================================================
      //
      //         beginTime      endTime
      //              :            :
      //              +...+    +...+
      //                  :    :
      //                  V    V
      //            [ FIRST )[ LAST )
      //

        if ( theInBeginBaselineIntervalH == theFirstIntervalH ) {
            theFirstIntervalH->getBaselineNext( theInBeginBaselineIntervalH );
        }
        if ( theInBeginBaselineIntervalH == theLastIntervalH ) {
            theInBeginBaselineIntervalH = 0;    // CASE: I or III.
        }
        if ( theInEndBaselineIntervalH == theLastIntervalH ) {
            theLastIntervalH->getBaselinePrevious( theInEndBaselineIntervalH );
        }
        if ( theInEndBaselineIntervalH == theFirstIntervalH ) {
            theInEndBaselineIntervalH = 0;      // CASE: II or III.
        }

      // Proceed if there are other intervals in between the begin
      // and the end ones.

        if (( ! BdbIsNull(theInBeginBaselineIntervalH)) &&
            ( ! BdbIsNull(theInEndBaselineIntervalH))) {

          // Get the nearest topmost intervals left and right from the found
          // baseline intervals.
          // These intervals will be used later when drawing the topmost path
          // over the newely created sub-sequence.
          //
          // NOTE: That we are doing this operation _before_ we create any new intervals
          //       in this container. Otherwise the Objectivity's index will supply us
          //       a list of wrong intervals.
          //
          // Here is a picture of what we are looking for:
          //
          // ----------------------+                                                               +--------------------+
          //  theBeginTopIntervalH |                                                               | theEndTopIntervalH |
          // ----------------------+                                                               +--------------------+
          //                       :                                                               :
          // ----------------------+-----------------------------+     +---------------------------+---------------------
          //                       | theInBeginBaselineIntervalH | ... | theInEndBaselineIntervalH |
          // ----------------------+-----------------------------+     +---------------------------+---------------------
          //  

            status = theDb.getTopmostInterval( theTopIntervalH,
                                               theContName,
                                               theInBeginBaselineIntervalH->getBeginTime( ));
            if( BdbcSuccess != status ) {
                ErrMsg(error) << errorString << endl
                              << "    Failed to locate a topmost interval interval at: " << theInBeginBaselineIntervalH->getBeginTime( ) << endmsg;
                break;
            }
            theTopIntervalH->getTopPrevious( theBeginTopIntervalH );


            status = theDb.getTopmostInterval( theEndTopIntervalH,
                                               theContName,
                                               theInEndBaselineIntervalH->getEndTime( ));
            if( BdbcSuccess != status ) {
                ErrMsg(error) << errorString << endl
                              << "    Failed to locate a topmost interval interval at: " << theInEndBaselineIntervalH->getEndTime( ) << endmsg;
                break;
            }

          // Put a record for the "history" of this container.

            theDb.historyCPurge( rcsid,
                                 theBeginTime,
                                 theEndTime,
                                 keepRevisedIntervals,
                                 maxNumOfTopLayers,
                                 maxNumOfLayersUnderRevisedInterval );

          // And then begin merging...

          // Copy baseline intervals. Then replace this new sequence instead of
          // of the old one.
          //
          // NOTE; that after these operations we will still have the incomplete
          //       topmost layer. We'll do it later after we copy the required
          //       fraction of vertical versions.

            status = copySubSequenceOfBaselineIntervals( theDb,
                                                         theInBeginBaselineIntervalH,
                                                         theInEndBaselineIntervalH,
                                                         theDb,
                                                         theOutBeginBaselineIntervalH,
                                                         theOutEndBaselineIntervalH );
            if ( BdbcSuccess != status ) {
                ErrMsg(error) << errorString << endl
                              << "    Failed to copy a sub-sequence of original baseline intervals." << endmsg;
                break;
            }

            theInBeginBaselineIntervalH->getBaselinePrevious( theInPreviousBaselineIntervalH );
            theInPreviousBaselineIntervalH->setBaselineNext( theOutBeginBaselineIntervalH );
            theOutBeginBaselineIntervalH->setBaselinePrevious( theInPreviousBaselineIntervalH );

            theInEndBaselineIntervalH->getBaselineNext( theInNextBaselineIntervalH );
            theOutEndBaselineIntervalH->setBaselineNext( theInNextBaselineIntervalH );
            theInNextBaselineIntervalH->setBaselinePrevious( theOutEndBaselineIntervalH );

          // The enclosed (into "if") list of actions makes a sense if specified number of top intervals
          // to keep is more then 0. If it's equal to 0 then we are copying just baseline intervals.

            if ( keepRevisedIntervals || ( maxNumOfTopLayers > 0 )) {

              // Copy the top fractions of the subtrees for all baseline intervals
              // starting from the found begin and end ones.

                theInNextBaselineIntervalH  = theInBeginBaselineIntervalH;
                theOutNextBaselineIntervalH = theOutBeginBaselineIntervalH;

                do {

                    theInBaselineIntervalH  = theInNextBaselineIntervalH;
                    theOutBaselineIntervalH = theOutNextBaselineIntervalH;


                  // Correct the copying conditions if the revised intervals should
                  // be kept and if the current versioning tree has at least one
                  // such interval.
                  //
                  // NOTE: The BASELINE intervals do not count.

                    if (( 0 == maxNumOfTopLayers ) &&
                          keepRevisedIntervals     &&
                          hasRevisedIntervalInSubTree( theInBaselineIntervalH )) {

                      // Since we have at least one revised interval in this tree then
                      // we would need the topmost layer to be copied as well in order to fill
                      // potential gaps after explicit copying of the revised interval(s).

                        status = copyTopIntervalsInSubTree( theDb,
                                                            theInBaselineIntervalH,
                                                            theOutBaselineIntervalH,
                                                            keepRevisedIntervals,
                                                            1,
                                                            maxNumOfLayersUnderRevisedInterval );
                    } else {

                        status = copyTopIntervalsInSubTree( theDb,
                                                            theInBaselineIntervalH,
                                                            theOutBaselineIntervalH,
                                                            keepRevisedIntervals,
                                                            maxNumOfTopLayers,
                                                            maxNumOfLayersUnderRevisedInterval );
                    }
                    if ( BdbcSuccess != status ) {
                        ErrMsg(error) << errorString << endl
                                      << "    Failed to copy a top slice of intervals for a version tree staring" << endl
                                      << "    at: " << theInBaselineIntervalH->beginTime( ) << endmsg;
                        break;
                    }

                    theInBaselineIntervalH->getBaselineNext( theInNextBaselineIntervalH );
                    theOutBaselineIntervalH->getBaselineNext( theOutNextBaselineIntervalH );

                } while ( theInBaselineIntervalH != theInEndBaselineIntervalH );

                if ( BdbcSuccess != status ) break;
            }

          // Connect new topmost intervals into a linked list.
          // We do this operation in 2 steps:
          //
          //    1. Routinly link the intervals in cycle up to (including) the last
          //       cluster of newely created intervals.
          //    2. Connect the rightmost top interval of the last cluster with the rest
          //       of the container.
          //
          // IMPORTANT NOTE: In all these steps we are using the same
          //    interval "theBeginTopIntervalH" as a link to the previous topmost interval.
          //    Due to a way the "::linkTopIntervalsInSubTree()" method works, the value
          //    of this back link is always modified upon the completion of the method.


            theOutNextBaselineIntervalH = theOutBeginBaselineIntervalH;

            do {

                theOutBaselineIntervalH = theOutNextBaselineIntervalH;

                status = linkTopIntervalsInSubTree( theOutBaselineIntervalH,
                                                    theBeginTopIntervalH );
                if( BdbcSuccess != status ) {
                    ErrMsg(error) << errorString << endl
                                  << "    Failed to draw the topmost line at: " << theOutBaselineIntervalH->getBeginTime( ) << endmsg;
                    break;
                }

                theOutBaselineIntervalH->getBaselineNext( theOutNextBaselineIntervalH );

            } while ( theOutBaselineIntervalH != theOutEndBaselineIntervalH );

            if ( BdbcSuccess != status ) break;

            theBeginTopIntervalH->setTopNext( theEndTopIntervalH );
            theEndTopIntervalH->setTopPrevious( theBeginTopIntervalH );

          // Delete the old clusters of intervals.
          //
          // NOTE: There is one very important assumption which we bear in mind
          //       when running the following algorithm - when the object pointed by
          //       a handle is deleted then the OID in this handle is not destroyed.
          //       This assumption is in a base of the check at the end of the loop.

            theInNextBaselineIntervalH = theInBeginBaselineIntervalH;

            do {

                theInBaselineIntervalH = theInNextBaselineIntervalH;
                theInBaselineIntervalH->getBaselineNext( theInNextBaselineIntervalH );

                deleteIntervalsInSubTree( theInBaselineIntervalH, true );

            } while ( theInBaselineIntervalH != theInEndBaselineIntervalH );
        }

      // The processing has been sucessfully completed.

        operationsLoopWasFailed = false;
        break;
    }
    if ( operationsLoopWasFailed ) {
        ErrMsg(error) << "        DETECTOR:   " << theTLA << endl
                      << "        CONTAINER:  " << theContName << endl
                      << "        BEGIN TIME: " << theBeginTime << endl
                      << "        END TIME:   " << theEndTime << endmsg;
        return BdbcError;
    }

    return BdbcSuccess;
}

BdbStatus
BdbCondDatabaseMgr::nanoCorrection( const char*                 theTLA,
                                    const char*                 theContName,
                                    const BdbTime&              theBeginTime,
                                    const BdbTime&              theEndTime,
                                    vector<ooId>&  theFoundIntervalsList,
                                    bool                        verifyOnly )
{
    const char* errorString = "BdbCondDatabaseMgr::nanoCorrection() -- error.";

    BdbStatus status = BdbcSuccess;

    assert( theTLA       != (char*) 0 );
    assert( theContName  != (char*) 0 );
    assert( theBeginTime <= theEndTime );

    theFoundIntervalsList.clear( );

  // Correct the input times to be sure that we are working in a proper range
  // of validity time.

    BdbTime theCorrectedBeginTime( theBeginTime.getGmtSec( ));
    BdbTime theCorrectedEndTime  ( theEndTime.getGmtSec  ( ));

  // Open the database.

    BdbObsoleteDatabase theDb( theTLA );

    BdbHandle(BdbIntervalR) theFirstIntervalH;
    BdbHandle(BdbIntervalR) theLastIntervalH;

  // Perform initializations in a exception-like loop.

    BdbHandle(BdbIntervalR) theIntervalH;

    bool theLoopWasFailed = true;

    while ( true ) {

      // Get the FIRST and the LAST intervals.
      //
      // NOTE: These operations are useless in the current context, but they
      //       would bring in the cache of the BdbObsoleteDatabase object which would
      //       be needed for a subsequent "non-verify-only" operation mode.

        status = theDb.firstInterval( theFirstIntervalH, theContName );
        if ( BdbcSuccess != status ) {
            ErrMsg(error) << errorString << endl
                          << "    Failed to locate the FIRST interval in the specified container." << endmsg;
            break;
        }
        status = theDb.lastInterval( theLastIntervalH, theContName );
        if ( BdbcSuccess != status ) {
            ErrMsg(error) << errorString << endl
                          << "    Failed to locate the LAST interval in the specified container." << endmsg;
            break;
        }

      // Ensure a proper authorization level to be set if we are not
      // running in the "verify" mode.

        if( ! verifyOnly ) {
            if ( ! theDb.verifyAuthLevelOnly( theContName )) {
                ErrMsg(error) << errorString << endl
                              << "    Failed to set proper Authorization level." << endmsg;
                break;
            }
        }

      // Iterate all the BASELINE intervals and recursivly process
      // in each subtree growing from these intervals.

        BdbIntervalItr theItr;
        if( ! theItr.setBaseline( theTLA, theContName, theCorrectedBeginTime )) {
            ErrMsg(error) << errorString << endl
                          << "    Failed to initialize an iterator for BASELINE iintervals." << endmsg;
            break;
        }

      // Put a record for the "history" of this container if we are not
      // running in the "verify" mode.

        if( ! verifyOnly ) {
            theDb.historyNCorrection( rcsid,
                                      theBeginTime,
                                      theEndTime );
        }
        while( theItr.next( )) {

            theIntervalH = (BdbHandle(BdbIntervalR)&) theItr;
            if( theIntervalH->beginTime( ) >= theCorrectedEndTime ) break;

             nanoCorrectionInSubTree( theIntervalH, theFoundIntervalsList, verifyOnly );
        }
        if( BdbcSuccess != status ) break;

        theLoopWasFailed = false;
        break;
    }
    if ( theLoopWasFailed ) {
        ErrMsg(error) << "        Detector:  \"" << theTLA << "\"" << endl
                      << "        Container: \"" << theContName << "\"" << endmsg;

        return BdbcError;
    }

    return BdbcSuccess;
}

void
BdbCondDatabaseMgr::nanoCorrectionInSubTree( const BdbHandle(BdbIntervalR)& theBaseIntervalH,
                                             vector<ooId>&     theFoundIntervalsList,
                                             bool                           verifyOnly )
{
  // Check the base interval first.

    const BdbTime& theBeginTime = theBaseIntervalH->beginTime( );
    const BdbTime& theEndTime   = theBaseIntervalH->endTime  ( );

    ooId id = theBaseIntervalH;

    if(( 0 != theBeginTime.getGmtNsec( )) || ( 0 != theEndTime.getGmtNsec( ))) {

        BdbRef(BdbIntervalR) theIntervalRef( theBaseIntervalH );
        ooId theId = theIntervalRef;

        theFoundIntervalsList.push_back( theId );

        if( ! verifyOnly ) {
            theBaseIntervalH->ooUpdate( );
            theBaseIntervalH->setBeginTime( BdbTime( theBeginTime.getGmtSec( )));
            theBaseIntervalH->setEndTime  ( BdbTime( theEndTime.getGmtSec  ( )));
        }
    }

  // Proceed to the child versions (if any).

    BdbHandle(BdbIntervalR) theIntervalH;
    BdbItr(BdbPersObj)      theItr;

    theBaseIntervalH->nextVers( theItr );
    while ( theItr.next( )) {
        theIntervalH = (BdbHandle(BdbIntervalR)&) theItr;
        nanoCorrectionInSubTree( theIntervalH, theFoundIntervalsList, verifyOnly );
    }

    return;
}

BdbStatus
BdbCondDatabaseMgr::initOutputContainer( BdbObsoleteDatabase& theInDb,
                                         const char*  theInContName,
                                         BdbObsoleteDatabase& theOutDb,
                                         const char*  theOutContName )
{
    const char* errorString = "BdbCondDatabaseMgr::initOutputContainer() -- error.";

    BdbStatus status;

    BdbHandle(BdbContObj) theInContH;
    BdbHandle(BdbContObj) theOutContH;

    BdbHandle(BdbInterval) theInFirstIntervalH;

  // Perform initializations in a exception-like loop.

    bool initLoopWasFailed = true;

    while( true ) {

      // Open the input container. The container must exist.

        status = theInDb.findIntervalCont( theInContH, theInContName );
        if (( BdbcSuccess != status ) || ( BdbIsNull( theInContH ))) {
            ErrMsg(error) << errorString << endl
                          << "    The input container does not exist in the database." << endmsg;
            break;
        }

      // Locate the FIRST interval in the input container:

        theInFirstIntervalH.lookupObj( theInContH, "FirstInterval", BdbcRead );
        if ( BdbIsNull( theInFirstIntervalH )) {
            ErrMsg(error) << errorString << endl
                          << "    The FIRST was not found in the input container." << endl
                          << "    The container may have incorrect internal structure." << endmsg;
            break;
        }

      // First of all we want to make sure that no conainer link with such name exists
      // in the link database.
      //
      // We don't care about "non-link"-ed containers at all, because new containers
      // are always created in the link database.

        status = theOutDb.findIntervalCont( theOutContH, theOutContName );
        if( BdbcSuccess == status ) {
            if( theOutDb.isLink( )) {
                ErrMsg(error) << errorString << endl
                              << "    The output container link with such name already exist." << endl
                              << "    You may want to delete the link before to perform this operation." << endmsg;
                break;
            }
        }

      // Ensure the proper context to be set.

        if ( ! theOutDb.verifyIndexMode( ))             break;
        if ( ! theOutDb.setAuthLevel( theOutContName )) break;

      // Create the output container.

        status = theOutDb.createIntervalCont( theOutContName,
                                              0,
                                              theInFirstIntervalH->getEndTime( ));
        if( BdbcSuccess != status ) {
            ErrMsg(error) << errorString << endl
                          << "    Failed to create the output container." << endmsg;
            break;
        }

      // Copy all revisions relevant information from the input container
      // to the output one.

        BdbHandle(BdbCondRegistry) theInRegistryH;
        BdbHandle(BdbCondRegistry) theOutRegistryH;

        theInDb.getRegistryH (theInRegistryH );
        theOutDb.getRegistryH( theOutRegistryH );

        status = copyRevisions( theInRegistryH, theOutRegistryH );
        if( BdbcSuccess != status ) {
            ErrMsg(error) << errorString << endl
                          << "    Failed to make a copy of revision infromation from the input" << endl
                          << "    container to the output one." << endmsg;
            break;
        }

      // The initialization has been sucessfully completed.

        initLoopWasFailed = false;
        break;
    }
    if( initLoopWasFailed ) {

        if( BdbcSuccess == status ) {
            status = BdbcError;
        }

        return status;
    }
 
    return BdbcSuccess;
}

BdbStatus
BdbCondDatabaseMgr::copyRevisions( const BdbHandle(BdbCondRegistry)& theInRegistryH,
                                   const BdbHandle(BdbCondRegistry)& theOutRegistryH )
{
    const char* errorString = "BdbCondDatabaseMgr::copyRevisions() -- error.";

    BdbStatus status = BdbcError;

    assert( ! BdbIsNull( theInRegistryH ));
    assert( ! BdbIsNull( theOutRegistryH ));

  // The operation is disable d for the same container.

    if ( theInRegistryH == theOutRegistryH ) {
        ErrMsg(error) << errorString << endl
                      << "    Unabled to perform the operation within the same container." << endmsg;
        return BdbcError;
    }

  // Locate baseline revisions for both containers. They must exist
  // if the containers were properly intialized.

    BdbHandle(BdbCondRevision) theInBaselineRevisionH;
    BdbHandle(BdbCondRevision) theOutBaselineRevisionH;

    theInRegistryH->getRevision( theInBaselineRevisionH, BdbCondRevision::BASELINE );
    if ( BdbIsNull( theInBaselineRevisionH )) {
        ErrMsg(error) << errorString << endl
                      << "    The baseline revision can't be located at the input container." << endl
                      << "    The container may have inconsistent internal structure due" << endl
                      << "    to unproper initialization." << endmsg;
        return BdbcError;
    }

    theOutRegistryH->getRevision( theOutBaselineRevisionH, BdbCondRevision::BASELINE );
    if ( BdbIsNull( theOutBaselineRevisionH )) {
        ErrMsg(error) << errorString << endl
                      << "    The baseline revision can't be located at the output container." << endl
                      << "    The container may have inconsistent internal structure due" << endl
                      << "    to unproper initialization." << endmsg;
        return BdbcError;
    }

  // Update baseline revision description in the output container
  // with the information taken from the input one.

    theOutBaselineRevisionH->setCreationTime( theInBaselineRevisionH->creationTime( ));
    theOutBaselineRevisionH->setSite(         theInBaselineRevisionH->site( ));
    theOutBaselineRevisionH->setDescription(  theInBaselineRevisionH->description( ));

  // Locate all the revisions connected to the output registry
  // and destroy all of them except the baseline one.
  // This operation does not destroy intervals connected to these
  // revisions although these intervals will have NULL references
  // with revisions.

    BdbItr(BdbCondRevision) theItr;

    theOutRegistryH->setRevisionItr( theItr );
    while ( theItr.next( )) {
        if ( theItr != theOutBaselineRevisionH ) {
            BdbDelete( theItr );
        }
    }

  // Iterate all the known revisions (except the baseline one) in the input
  // registry and copy them to the output one.

    BdbHandle(BdbCondRevision) theRevisionH;

    theInRegistryH->setRevisionItr( theItr );
    while ( theItr.next( )) {
        if ( theItr != theInBaselineRevisionH ) {

            theRevisionH = new( theOutRegistryH ) BdbCondRevision( theItr->id( ),
                                                                   theItr->creationTime( ),
                                                                   theItr->site( ),
                                                                   theItr->description( ));
            theOutRegistryH->addRevision( theRevisionH );
        }
    }

  // The second path. Set the same "base" relationships for all the revision
  // in the output container as in the input one.
  // NOTE: The baseline revision is ignored.

    BdbHandle(BdbCondRevision) theBaseRevisionH;

    theOutRegistryH->setRevisionItr( theItr );
    while ( theItr.next( )) {
        if ( theItr != theOutBaselineRevisionH ) {

            d_ULong theRevId = theItr->id( );
            theInRegistryH->getRevision( theRevisionH, theRevId );
            if( BdbIsNull( theRevisionH )) {
                ErrMsg(error) << errorString << endl
                              << "    Failed to locate revision with ID = " << theRevId << " in input container." << endl
                              << "    The containers have inconsistent revisions." << endmsg;
                return BdbcError;
            }

            theRevisionH->getBaseRevision( theBaseRevisionH );
            if( BdbIsNull( theBaseRevisionH )) {
                ErrMsg(error) << errorString << endl
                              << "    Failed to locate base revision for a revision with ID = " << theRevId << endl
                              << "    in input container." << endl
                              << "    The containers have inconsistent revisions." << endmsg;
                return BdbcError;
            }

            d_ULong theBaseRevId = theBaseRevisionH->id( );
            theOutRegistryH->getRevision( theRevisionH, theBaseRevId );
            if( BdbIsNull( theRevisionH )) {
                ErrMsg(error) << errorString << endl
                              << "    Failed to locate revision with ID = " << theBaseRevId << " in output container." << endl
                              << "    The containers have inconsistent revisions." << endmsg;
                return BdbcError;
            }

            status = theItr->setBaseRevision( theRevisionH );
            if( BdbcSuccess != status ) {
                ErrMsg(error) << errorString << endl
                              << "    Failed to set base revision in output container." << endmsg;
                return BdbcError;
            }
        }
    }

    return BdbcSuccess;
}

BdbStatus
BdbCondDatabaseMgr::deepCopy( BdbObsoleteDatabase& theInDb,
                              BdbObsoleteDatabase& theOutDb )
{
    const char* errorString = "BdbCondDatabaseMgr::deepCopy() -- error.";

    BdbStatus status = BdbcError;

    BdbHandle(BdbIntervalR) theInFirstIntervalH;
    BdbHandle(BdbIntervalR) theInPreviousIntervalH;
    BdbHandle(BdbIntervalR) theInIntervalH;
    BdbHandle(BdbIntervalR) theInNextIntervalH;
    BdbHandle(BdbIntervalR) theInLastIntervalH;

    BdbHandle(BdbIntervalR) theOutFirstIntervalH;
    BdbHandle(BdbIntervalR) theOutPreviousIntervalH;
    BdbHandle(BdbIntervalR) theOutIntervalH;
    BdbHandle(BdbIntervalR) theOutNextIntervalH;
    BdbHandle(BdbIntervalR) theOutLastIntervalH;

  // Step I: make a copy of baseline intervals.

    status = baselineOrTopmostCopy( theInDb, theOutDb, true );
    if ( BdbcSuccess != status ) {
        ErrMsg(error) << errorString << endl
                      << "    Failed to copy baseline intervals." << endmsg;
        return status;
    }

  // Locate the "border" intervals in both containers.

    status = locateBorderIntervals( theInDb,
                                    theOutDb,
                                    theInFirstIntervalH,
                                    theInLastIntervalH,
                                    theOutFirstIntervalH,
                                    theOutLastIntervalH );
    if( BdbcSuccess != status ) {
        return status;
    }

  // Step II: traverse baseline intervals and build the version trees.
  //          Copy information from the input intervals into output ones.
  //
  //    NOTE: the pointers (handles) in both containers advance
  //          along containers synchronosly.
  //          (pay attention to the check after the "while" loop ends.

    theInFirstIntervalH->getBaselineNext( theInIntervalH );
    theOutFirstIntervalH->getBaselineNext( theOutIntervalH );

    while( theInIntervalH != theInLastIntervalH ) {

        status = copySubTree( theInIntervalH,
                              theOutDb,
                              theOutIntervalH );
        if( BdbcSuccess != status ) {
            ErrMsg(error) << errorString << endl
                          << "    Failed to copy the next tree of versions." << endmsg;
            return status;
        }

        theInIntervalH->getBaselineNext( theInNextIntervalH );
        theInIntervalH = theInNextIntervalH;

        theOutIntervalH->getBaselineNext( theOutNextIntervalH );
        theOutIntervalH = theOutNextIntervalH;
    }
    if ( theOutIntervalH != theOutLastIntervalH ) {
        ErrMsg(error) << errorString << endl
                      << "    The output container has incorrect internal structure." << endmsg;
        return status;
    }

  // Step III: Connect the topmost intervals into the double linked list.

    theOutPreviousIntervalH = theOutFirstIntervalH;
    theOutPreviousIntervalH->getBaselineNext( theOutIntervalH );

    while( theOutIntervalH != theOutLastIntervalH ) {

        status = linkTopIntervalsInSubTree( theOutIntervalH,
                                            theOutPreviousIntervalH );
        if( BdbcSuccess != status ) {
            ErrMsg(error) << errorString << endl
                          << "    Failed to process the next tree of versions." << endmsg;
            return status;
        }

        theOutIntervalH->getBaselineNext( theOutNextIntervalH );
        theOutIntervalH = theOutNextIntervalH;
    }

    theOutPreviousIntervalH->setTopNext( theOutLastIntervalH );
    theOutLastIntervalH->setTopPrevious( theOutPreviousIntervalH );

    return BdbcSuccess;
}

BdbStatus
BdbCondDatabaseMgr::baselineOrTopmostCopy( BdbObsoleteDatabase& theInDb,
                                           BdbObsoleteDatabase& theOutDb,
                                           bool         baselineFlag )
{
    const char* errorString = "BdbCondDatabaseMgr::baselineOrTopmostCopy() -- error.";

    BdbStatus status = BdbcError;

    BdbHandle(BdbIntervalR) theInFirstIntervalH;
    BdbHandle(BdbIntervalR) theInPreviousIntervalH;
    BdbHandle(BdbIntervalR) theInIntervalH;
    BdbHandle(BdbIntervalR) theInNextIntervalH;
    BdbHandle(BdbIntervalR) theInLastIntervalH;

    BdbHandle(BdbIntervalR) theOutFirstIntervalH;
    BdbHandle(BdbIntervalR) theOutPreviousIntervalH;
    BdbHandle(BdbIntervalR) theOutIntervalH;
    BdbHandle(BdbIntervalR) theOutLastIntervalH;

  // Locate the "border" intervals in both containers.

    status = locateBorderIntervals( theInDb,
                                    theOutDb,
                                    theInFirstIntervalH,
                                    theInLastIntervalH,
                                    theOutFirstIntervalH,
                                    theOutLastIntervalH );
    if( BdbcSuccess != status ) {
        return status;
    }

  // Get the handles for the output container itself and its baseline
  // revision.
  // We expect that these values are cached by the previous procedure.

    BdbHandle(BdbContObj) theOutContH;
    theOutDb.getIntervalContH( theOutContH );

    BdbHandle(BdbCondRevision) theOutBaselineRevisionH;
    theOutDb.getBaselineRevisionH( theOutBaselineRevisionH );

  // Delete the LAST interval from the output container.
  // This interval was created temporarily.

    theOutFirstIntervalH->getBaselineNext( theOutIntervalH );
    if( theOutIntervalH != theOutLastIntervalH ) {
        ErrMsg(error) << errorString << endl
                      << "    The output container has incorrect initial structure." << endmsg;
        return BdbcError;
    }
    BdbDelete( theOutLastIntervalH );

  // Locate the FIRST->NEXT interval from the input container.
  // This interval must exist.

    if( baselineFlag ) {
        theInFirstIntervalH->getBaselineNext( theInIntervalH );
    } else {
        theInFirstIntervalH->getTopNext( theInIntervalH );
    }
    if( BdbIsNull( theInIntervalH )) {
        ErrMsg(error) << errorString << endl
                      << "    The input container has incorrect structure." << endmsg;
        return BdbcError;
    }

  // Iterate over the list of baseline intervals and create duplicates
  // in the corresponding places.

    theOutFirstIntervalH->setObject          ( theInFirstIntervalH->getObject( ));
    theOutFirstIntervalH->setVersionTime     ( theInFirstIntervalH->getVersionTime( ));
    theOutFirstIntervalH->setTag             ( theInFirstIntervalH->getTag( ));
    theOutFirstIntervalH->setTopPrevious     ( NULL );
    theOutFirstIntervalH->setTopNext         ( NULL );
    theOutFirstIntervalH->setBaselinePrevious( NULL );
    theOutFirstIntervalH->setBaselineNext    ( NULL );
    theOutFirstIntervalH->setRevision        ( theOutBaselineRevisionH );

    theOutPreviousIntervalH = theOutFirstIntervalH;

    do {

      // Make a copy of an input interval within the output container.

        theOutIntervalH = new( theOutContH ) BdbIntervalR( theInIntervalH->getObject( ),
                                                           theInIntervalH->getBeginTime( ),
                                                           theInIntervalH->getEndTime( ),
                                                           theInIntervalH->getTag( ));

        theOutIntervalH->setVersionTime( theInIntervalH->getVersionTime( ));

      // Always connect interval to the baseline revision.

        theOutIntervalH->setRevision( theOutBaselineRevisionH );

      // Include this interval into the list 

        theOutPreviousIntervalH->setTopNext(      theOutIntervalH );
        theOutPreviousIntervalH->setBaselineNext( theOutIntervalH );

        theOutIntervalH->setTopPrevious(      theOutPreviousIntervalH );
        theOutIntervalH->setTopNext(          NULL );
        theOutIntervalH->setBaselinePrevious( theOutPreviousIntervalH );
        theOutIntervalH->setBaselineNext(     NULL );

      // Advance pointers for both containers.

        if( baselineFlag ) {
            theInIntervalH->getBaselineNext( theInNextIntervalH );
        } else {
            theInIntervalH->getTopNext( theInNextIntervalH );
        }
        theInIntervalH = theInNextIntervalH;

        theOutPreviousIntervalH = theOutIntervalH;
        theOutLastIntervalH     = theOutIntervalH;

    } while( ! BdbIsNull( theInIntervalH ));

  // Set the proper scope name to the LAST interval in the output container.

    theOutLastIntervalH.nameObj( theOutContH, "LastInterval" );

    return BdbcSuccess;
}

BdbStatus
BdbCondDatabaseMgr::revisionCopy( BdbObsoleteDatabase& theInDb,
                                  BdbObsoleteDatabase& theOutDb,
                                  d_ULong      theRevId )
{
    const char* errorString = "BdbCondDatabaseMgr::revisionCopy() -- error.";

    BdbStatus status = BdbcError;

  // A minor optimizaton of the baseline revision ID has
  // been specified.

    if( BdbCondRevision::BASELINE == theRevId ) {
        return baselineOrTopmostCopy( theInDb, theOutDb, true );
    }

  // For any other revision this operation is not implemented yet.

    ErrMsg(error) << errorString << endl
                  << "    The operation is not implemented yet." << endmsg;

    return BdbcError;
}

BdbStatus
BdbCondDatabaseMgr::locateBorderIntervals( BdbObsoleteDatabase&            theInDb,
                                           BdbObsoleteDatabase&            theOutDb,
                                           BdbHandle(BdbInterval)& theInFirstIntervalH,
                                           BdbHandle(BdbInterval)& theInLastIntervalH,
                                           BdbHandle(BdbInterval)& theOutFirstIntervalH,
                                           BdbHandle(BdbInterval)& theOutLastIntervalH )
{
    const char* errorString = "BdbCondDatabaseMgr::locateBorderIntervals() -- error.";

    BdbStatus status = BdbcError;

    status = theInDb.firstInterval( theInFirstIntervalH, theInDb.containerName( ));
    if(( BdbcSuccess != status ) || ( BdbIsNull( theInFirstIntervalH ))) {
        ErrMsg(error) << errorString << endl
                      << "    Failed to locate the FIRST interval in the input container." << endmsg;
        return BdbcError;
    }

    status = theInDb.lastInterval( theInLastIntervalH, theInDb.containerName( ));
    if(( BdbcSuccess != status ) || ( BdbIsNull( theInLastIntervalH ))) {
        ErrMsg(error) << errorString << endl
                      << "    Failed to locate the LAST interval in the input container." << endmsg;
        return BdbcError;
    }

    status = theOutDb.firstInterval( theOutFirstIntervalH, theOutDb.containerName( ));
    if(( BdbcSuccess != status ) || ( BdbIsNull( theOutFirstIntervalH ))) {
        ErrMsg(error) << errorString << endl
                      << "    Failed to locate the FIRST interval in the output container." << endmsg;
        return BdbcError;
    }

    status = theOutDb.lastInterval( theOutLastIntervalH, theOutDb.containerName( ));
    if(( BdbcSuccess != status ) || ( BdbIsNull( theOutLastIntervalH ))) {
        ErrMsg(error) << errorString << endl
                      << "    Failed to locate the LAST interval in the output container." << endmsg;
        return BdbcError;
    }

    return BdbcSuccess;
}

BdbStatus
BdbCondDatabaseMgr::matchRevision( const BdbHandle(BdbIntervalR)& theInNextIntervalH,
                                   BdbObsoleteDatabase&                   theOutDb,
                                   BdbHandle(BdbCondRevision)&    theOutRevisionH )
{
    BdbStatus status = BdbcSuccess;
    BdbHandle(BdbCondRevision) theInRevisionH;

    theInNextIntervalH->getRevision( theInRevisionH );
    if( BdbIsNull( theInRevisionH )) {
        theOutRevisionH = NULL;
        status = BdbcSuccess;
    } else {

        BdbHandle(BdbCondRegistry) theOutRegistryH;
        theOutDb.getRegistryH( theOutRegistryH );

        theOutRegistryH->getRevision( theOutRevisionH,
                                      theInRevisionH->id( ));
        if( BdbIsNull( theOutRevisionH )) {
            status = BdbcError;
        }
    }

    return status;
}

BdbStatus
BdbCondDatabaseMgr::linkTopIntervalsInSubTree( const BdbHandle(BdbIntervalR)& theIntervalH,
                                               BdbHandle(BdbIntervalR)&       thePreviousIntervalH )
{
    const char* errorString = "BdbCondDatabaseMgr::linkTopIntervalsInSubTree() -- error.";

    BdbStatus status = BdbcError;

  // This check will prevent us from accidental crashing.

    if( BdbIsNull( theIntervalH ) || BdbIsNull( thePreviousIntervalH )) {
        ErrMsg(error) << errorString << endl
                      << "    NULL handles have been detected." << endl
                      << "    The output container may have incorrect internal structure." << endmsg;
        return BdbcError;
    }

  // Iterate over sub-tree(s) (if any).

    bool subTreeFound = false;

    BdbItr(BdbPersObj) theItr;

    theIntervalH->nextVers( theItr );
    while( theItr.next( )) {

        status = linkTopIntervalsInSubTree( (BdbHandle(BdbIntervalR)&) theItr,
                                            thePreviousIntervalH );
        if( BdbcSuccess != status ) {
            return status;
        }

        subTreeFound = true;
    }

  // If the subtree was not found this means that the current interval
  // is the TOPMOST one and must be included into the list.

    if ( ! subTreeFound ) {

        thePreviousIntervalH->setTopNext( theIntervalH );
        theIntervalH->setTopPrevious( thePreviousIntervalH );

        thePreviousIntervalH = theIntervalH;
    }

    return BdbcSuccess;
}

BdbStatus
BdbCondDatabaseMgr::copySubTree( const BdbHandle(BdbIntervalR)& theInIntervalH,
                                 BdbObsoleteDatabase&                   theOutDb,
                                 BdbHandle(BdbIntervalR)&       theOutIntervalH )
{
    const char* errorString = "BdbCondDatabaseMgr::copySubTree() -- error.";

    BdbStatus status = BdbcError;
    
    int i;

  // This check will prevent us from accidental crashing.

    if( BdbIsNull( theInIntervalH ) || BdbIsNull( theOutIntervalH )) {
        ErrMsg(error) << errorString << endl
                      << "    NULL handles have been detected." << endl
                      << "    The output container may have incorrect internal structure." << endmsg;
        return BdbcError;
    }

  // Get sub-trees (if any).

    vector<BdbHandle(BdbIntervalR)> theInNextIntervalH;
    BdbItr(BdbPersObj)                           theItr;

    theInIntervalH->nextVers( theItr );
    while( theItr.next( )) {
        theInNextIntervalH.push_back((BdbHandle(BdbIntervalR)&) theItr );
    }

  // Create duplicate sub-trees in the output container if at leas one
  // sub-tree was found in the input one.

    int numSubTrees = theInNextIntervalH.size( );

    if( numSubTrees > 0 ) {

      // Enable linear/branch versioning on the original interval object.

        if( numSubTrees == 1 ) {
            theOutIntervalH.setVersStatus( oocLinearVers );
        } else {
            theOutIntervalH.setVersStatus( oocBranchVers );
        }

      // Create as many linear/branch version(s) for the output interval
      // as it were found for the input interval.

        BdbHandle(BdbIntervalR)                      theOutNewIntervalH;
        vector<BdbHandle(BdbIntervalR)> theOutNextIntervalH;

        for( i = 0; i < numSubTrees; i++ ) {
            theOutDb.createVersion( theOutIntervalH, theOutNewIntervalH );
            theOutNextIntervalH.push_back( theOutNewIntervalH );
        }

      // Disable versioning of the current interval.

        theOutIntervalH.setVersStatus( oocNoVers );

      // Copy the interval name in the scope of the genealogy object
      // with the following steps:
      //
      //    1. Locate a genealogy object for the input version tree (must exist).
      //    2. Locate or create the genealogy object for the output tree.
      //    3. Copy the version name of the input branch interval into the output one.
      //    4. Copy the last known (to the input genealogy object) into
      //       output genealogy object.

        BdbHandle(BdbIntervalGene) theInGeneH;
        if( ! theInIntervalH->exist_geneObj( )) {
            ErrMsg(error) << errorString << endl
                          << "    The genealogy object does not exist for an interval." << endl
                          << "    The input container may have incorrect internal structure." << endmsg;
            return BdbcError;
        }
        theInGeneH = (const BdbHandle(BdbIntervalGene)&) theInIntervalH->geneObj( );

        BdbHandle(BdbIntervalGene) theOutGeneH;
        if( theOutIntervalH->exist_geneObj( )) {

          // Use existing genealogy object.

            theOutGeneH = (const BdbHandle(BdbIntervalGene)&) theOutIntervalH->geneObj( );

        } else {

          // Crate new genealogy object. Name the current version (which is expected
          // to be a BASELINE interval) in the scope of ths ngenealogy object.

            theOutGeneH = new( theOutIntervalH ) BdbIntervalGene( );

            theOutIntervalH.nameObj( theOutGeneH, theInIntervalH.getObjName( theInGeneH ));

            theOutGeneH->set_defaultVers( theOutIntervalH );
            theOutGeneH->add_allVers(     theOutIntervalH );
        }

      // Attach newely created versions to the Genealogy object and name
      // these versions.

        for( i = 0; i < numSubTrees; i++ ) {
            theOutGeneH->add_allVers( theOutNextIntervalH[i] );
            theOutNextIntervalH[i].nameObj( theOutGeneH, theInNextIntervalH[i].getObjName( theInGeneH ));
            theOutGeneH->setVersionName( theInGeneH->getVersionName( ));
        }

      // Copy information from the input intervals into the output ones.

        for( i = 0; i < numSubTrees; i++ ) {

          // Copy the basic characteristics.

            theOutNextIntervalH[i]->setObject(      theInNextIntervalH[i]->getObject( ));
            theOutNextIntervalH[i]->setBeginTime(   theInNextIntervalH[i]->getBeginTime( ));
            theOutNextIntervalH[i]->setEndTime(     theInNextIntervalH[i]->getEndTime( ));
            theOutNextIntervalH[i]->setVersionTime( theInNextIntervalH[i]->getVersionTime( ));
            theOutNextIntervalH[i]->setTag(         theInNextIntervalH[i]->getTag( ));

          // Copy a revision.

            BdbHandle(BdbCondRevision) theOutRevisionH;

            status = matchRevision( theInNextIntervalH[i],
                                    theOutDb,
                                    theOutRevisionH );
            if( BdbcSuccess != status ) {
                ErrMsg(error) << errorString << endl
                              << "    Failed to locate a matching revision for an interval." << endl
                              << "    The output container may have incorrect internal structure." << endmsg;
                return status;
            }
            theOutNextIntervalH[i]->setRevision( theOutRevisionH );
        }

      // Proceed alongside the version tree.

        for( i = 0; i < numSubTrees; i++ ) {

            status = copySubTree( theInNextIntervalH[i],
                                  theOutDb,
                                  theOutNextIntervalH[i] );
            if( BdbcSuccess != status ) {
                ErrMsg(error) << errorString << endl
                              << "    Failed to copy the next tree of versions." << endmsg;
                return status;
            }
        }
    }

    return BdbcSuccess;
}

BdbStatus
BdbCondDatabaseMgr::copyObjects( BdbObsoleteDatabase& theDb,
                                 bool         copyToLocalDb,
                                 const char*  theContName )
{
    const char* errorString = "BdbCondDatabaseMgr::copyObjects() -- error.";

    BdbStatus status = BdbcError;

  // Locate the FIRST interval in the container to start with.

    BdbHandle(BdbIntervalR) theIntervalH;
    BdbHandle(BdbIntervalR) theNextIntervalH;

    status = theDb.firstInterval( theIntervalH, theDb.containerName( ));
    if(( BdbcSuccess != status ) || ( BdbIsNull( theIntervalH ))) {
        ErrMsg(error) << errorString << endl
                      << "    Failed to locate the FIRST interval in the output container." << endmsg;
        return BdbcError;
    }

  // If the copy to local Db is required then we shall open/create
  // a container with a predefined name within the same interval database
  // and to use this container as a handle for the copied of Conditions objects.
  //
  //    NOTE_1: We allow to put data in different containers of the same
  //            database because of the addressing limitation of an individual
  //            container.
  //            A container is able to keep up to 64K pages. Currently the page
  //            size is set to 16KB. This would imply just 1GB limit onto the amount
  //            of data to be stored in a single container.
  //
  //    NOTE_2: In some future more sophisticated container handling logic could
  //            be implemented. For example, when specified container is full
  //            then anbother one with incremented suffix will be created.
  //
  //                _DATA_0
  //                _DATA_1
  //                _DATA_2
  //
  //            to increase the available space without

    BdbHandle(BdbContObj) theLocalContH;

    if( copyToLocalDb ) {

        if( theContName == (char*) 0 ) {
            ErrMsg(error) << errorString << endl
                          << "    Zero container name has been specified for the local container." << endl
                          << "    The local container is ment to keep local copies of Conditions data" << endl
                          << "    whihin the same interval database." << endmsg;
            return BdbcError;
        }

      // Try to locate if the container already exist.

        BdbHandle(BdbDBObj) theIntervalDBH;
        theDb.getIntervalDBH( theIntervalDBH );

        if( d_True == theLocalContH.exist( theIntervalDBH, theContName, BdbcNoOpen )) {
            status = theLocalContH.open( theIntervalDBH, theContName, BdbcUpdate );
            if(( BdbcSuccess != status ) || BdbIsNull(theLocalContH)) {
                ErrMsg(error) << errorString << endl
                              << "    Failed to open existing container \"" << theContName << "\""<< endl
                              << "    in the output database in UPDATE mode." << endl
                              << "    The container is ment to keep local copies of Conditions objects." << endmsg;
               return BdbcError;
            }
        }
        if( BdbIsNull( theLocalContH )) {

          // Create a new container.

            theLocalContH = new( theContName, 1, 4, 10, theIntervalDBH ) BdbContObj( );
            if( BdbIsNull( theLocalContH )) {
                ErrMsg(error) << errorString << endl
                              << "    Failed to create a container container \"" << theContName << "\""<< endl
                              << "    in the output database. The container is ment to keep local copies" << endl
                              << "    of Conditions objects." << endmsg;
                    return BdbcError;
            }
        }
    }

  // Process the container as a sequence of sub-trees growing
  // from baseline intervals.

    BdbCondCache<BdbRefAny>* theCache = new BdbCondTransientCache( );

    ooCheckVTablePointer( d_True );

    do {

        status = copyObjectsInSubTree( theIntervalH,
                                       copyToLocalDb,
                                       theLocalContH,
                                       theDb._myHint,
                                       theCache );
        if( BdbcSuccess != status ) {
            ErrMsg(error) << errorString << endl
                          << "    Failed to copy objects for the next sub-tree." << endmsg;
            delete theCache;
            return BdbcError;
        }

        theIntervalH->getBaselineNext( theNextIntervalH );
        theIntervalH = theNextIntervalH;

    } while( ! BdbIsNull( theIntervalH ));

    delete theCache;

    return BdbcSuccess;
}

BdbStatus
BdbCondDatabaseMgr::copyObjectsInSubTree( BdbHandle(BdbInterval)&          theIntervalH,
                                          bool                             copyToLocalDb,
                                          const BdbHandle(BdbContObj)&     theLocalContH,
                                          BdbCondClusteringHint*           theHint,
                                          BdbCondCache<BdbRefAny>* theCache )
{
    const char* errorString = "BdbCondDatabaseMgr::copyObjectsInSubTree() -- error.";

    BdbStatus status = BdbcError;

  // Copy object for current handle.

    BdbRef(BdbObject) theOldObjectR;
    BdbRef(BdbObject) theNewObjectR;

    theIntervalH->getObject( theOldObjectR );
    if( ! BdbIsNull( theOldObjectR )) {

      // Make a copy of the persistent object.
      //
      //     NOTE: We are passing a pointer to the cache object
      //           to the ::clone() method. So the object itself
      //           would be responsible for the cache maintainance.
      //
      //     NOTE: The following code may crash if the corresponding virtual
      //           table for the real persistent classes is not loaded.

        if( copyToLocalDb ) {
            theNewObjectR = theOldObjectR->clone( theLocalContH, theCache );
        } else {
            theNewObjectR = theOldObjectR->clone( theHint->updatedHint( ), theCache );
        }

      // Replace an object for the current interval.

        theIntervalH->setObject( theNewObjectR );
    }

  // Propagate along the branches (if any).

    BdbItr(BdbPersObj) theItr;

    if( theIntervalH->exist_geneObj( )) {
        theIntervalH->nextVers( theItr );
        while( theItr.next( )) {
            status = copyObjectsInSubTree((BdbHandle(BdbInterval)&) theItr,
                                           copyToLocalDb,
                                           theLocalContH,
                                           theHint,
                                           theCache );
            if( BdbcSuccess != status ) {
                return status;
            }
        }
    }

    return BdbcSuccess;
}

void
BdbCondDatabaseMgr::deleteIntervalsInSubTree( BdbHandle(BdbIntervalR)& theIntervalH,
                                              bool                     deleteGeneObject )
{
  // First of all we propagate recursively along the branches (if any)
  // and delete intervals there.

    BdbItr(BdbPersObj) theItr;

    if( theIntervalH->exist_geneObj( )) {
        theIntervalH->nextVers( theItr );
        while( theItr.next( )) {
            deleteIntervalsInSubTree((BdbHandle(BdbIntervalR)&) theItr );
        }
    }

  // Then we delete the genealogy object if required.

    if( deleteGeneObject && theIntervalH->exist_geneObj( )) {

        BdbHandle(BdbIntervalGene) theGeneObjH;
        theGeneObjH = (const BdbHandle(BdbIntervalGene)&) theIntervalH->geneObj( );

        BdbDelete(theGeneObjH);
    }

  // And finally we delete current interval itself.

    BdbDelete( theIntervalH );

    return;
}

void
BdbCondDatabaseMgr::deleteObjectsInSubTree( BdbHandle(BdbInterval)& theIntervalH )
{
  // Delete object for current handle and delete it with NULL handle.

    BdbRef(BdbObject) theNullObjectRef;
    BdbRef(BdbObject) theObjectRef;

    theIntervalH->getObject( theObjectRef );
    if(( ! BdbIsNull( theObjectRef )) && theObjectRef.isValid( )) {
        BdbDelete( theObjectRef );
        theIntervalH->setObject( theNullObjectRef );
    }

  // Propagate along the branches (if any).

    BdbItr(BdbPersObj) theItr;

    if( theIntervalH->exist_geneObj( )) {
        theIntervalH->nextVers( theItr );
        while( theItr.next( )) {
            deleteObjectsInSubTree((BdbHandle(BdbInterval)&) theItr );
        }
    }

    return;
}

BdbStatus
BdbCondDatabaseMgr::selectDetectors( vector<string>&       theFinalDetectorsList,
                                     const vector<string>& theDetectorsList,
                                     bool                                  theExcludeFlag )
{
    const char* errorString = "BdbCondDatabaseMgr::selectDetectors() -- ERROR.";

  // Build the list of detectors to look into using either Authorization database
  // or a list of detectors supplied by a user, depending on whether the specified
  // list is empty or not.
  // If the list is not empty, but the  "exclude" flag was specified then we also
  // take a list of detectors from the Conditions domain of the Authorization database
  // and then will exclude these databases from the list.

    if( theDetectorsList.empty( ) || ( true == theExcludeFlag )) {

      // Obtain the list of all known detectors from the Authorization database.

        BdbAuthItr* itr = BdbAuth::instance( )->createGroupsItr( BdbDomain::Conditions );
        {
            if(( 0 == itr ) || !itr->isValid( )) {

                ErrMsg(error) << errorString << endl
                              << "    Failed to obtain a list of detectors in Conditions domain." << endl
                              << "    See detailed error report from Authorization code." << endmsg;

                delete itr;

                return BdbcError;
            }

          // Browse the list and filter out special groups and those detectors
          // which were found in the user supplied list (if any).

            while( itr->next( )) {

              // Just skip this special group

                if( 0 == strcmp( "Global", itr->current( ))) {
                    continue;
                }

              // Then match for any user supplied detector name if required.

                if( theExcludeFlag ) {

                    bool detectorWasFound = false;

                    int detectors = theDetectorsList.size( );
                    for( int detectorIndex = 0; detectorIndex < detectors; detectorIndex++ ) {
                        if( 0 == strcmp( theDetectorsList[detectorIndex].c_str(), itr->current( ))) {
                            detectorWasFound = true;
                            break;
                        }
                    }
                    if( ! detectorWasFound ) {

                      // The detector was not found - then just include this detector
                      // into the final list.

                        theFinalDetectorsList.push_back( itr->current( ));
                    }

                } else {

                  // Just include the current group as is without verification.

                    theFinalDetectorsList.push_back( itr->current( ));
                }
            }
        }
        delete itr;

    } else {

      // Just copy all of these groups into the final list.
      // It would be up to the user to provide the correct list.

        theFinalDetectorsList = theDetectorsList;
    }

    return BdbcSuccess;
}

BdbStatus
BdbCondDatabaseMgr::scanContainer( map<string, BdbRef(ooDBObj)>& theDict,
                                   BdbObsoleteDatabase&                                      theDb,
                                   const char*                                       theContName )
{
    const char* errorString = "BdbCondDatabaseMgr::scanContainer( ) -- ERROR.";

    BdbStatus status;
    BdbHandle(BdbInterval) theIntervalH;
    BdbHandle(BdbInterval) theNextIntervalH;
    BdbHandle(BdbObject)   theObjectH;

    char buf[255];

  // Extract the DBs from the objects (if they are non-zero)
  // and put them into the hash dictionary as pesistent references.

    status = theDb.firstInterval( theIntervalH, theContName );
    if(( BdbcSuccess != status ) || BdbIsNull(theIntervalH)) {
        ErrMsg(error) << errorString << endl
                      << "    Failed to obtain the FIRST interval from the container." << endl
                      << "        DETECTOR  -> " << theDb.subsystemTLA( ) << endl
                      << "        CONTAINER -> " << theContName << endmsg;
        return BdbcError;
    }

  // Take the version trees one-by-one starting from the very first interval.
  // Each next tree will be accessed following the "next TOPMOST"
  // link until NULLinterval is met.

  // Analyze the FIRST interval itself.

    theObjectH = theIntervalH->getObject( );
    if( ! BdbIsNull(theObjectH)) {
        ooId theId = theObjectH;
        int theDb = theId.get_DB( );
        sprintf( buf, "%d", theDb );
        theDict[string( buf )].set_DB( theDb );
    }

  // Then start working with trees.

    vector<BdbHandle(BdbInterval)> theTree;
    int numBranches;

    do {

      // Avoid a problem of "zero" [-oo,-oo] FIRST interval because the next
      // interval would also start from [-oo, *]. And this introduces some
      // ambiguity into the interval locating algorithm.
      // Check also the correct structure of the next interval.

        if( BdbTime::minusInfinity == theIntervalH->endTime( )) {

            theNextIntervalH = theIntervalH->next( );
            theIntervalH     = theNextIntervalH;

            if( theIntervalH->beginTime( ) == theIntervalH->endTime( )) {
                ErrMsg(error) << errorString << endl
                              << "    The invalid interval found in the container." << endl
                              << "        BEGIN TIME -> " << theIntervalH->beginTime( ) << endl
                              << "        END TIME   -> " << theIntervalH->endTime( ) << endl
                              << "        DETECTOR   -> " << theDb.subsystemTLA( ) << endl
                              << "        CONTAINER  -> " << theContName << endmsg;
                return BdbcError;
            }
            status = theDb.getTree( theTree, numBranches, theContName, theIntervalH->beginTime( ) + 1 );
        } else {
            status = theDb.getTree( theTree, numBranches, theContName, theIntervalH->beginTime( ));
        }
        if(( BdbcSuccess != status ) || ( numBranches <= 0 )) {
            ErrMsg(error) << errorString << endl
                          << "    Failed to obtain the version tree from the container." << endl
                          << "        BEGIN TIME -> " << theIntervalH->beginTime( ) << endl
                          << "        DETECTOR   -> " << theDb.subsystemTLA( ) << endl
                          << "        CONTAINER  -> " << theContName << endmsg;
            return BdbcError;
        }

        int entries = theTree.size( );
        for( int i = 0; i < entries; i++ ) {

          // Skip NULL delimiters.

            if( ! BdbIsNull(theTree[i])) {

                theIntervalH = theTree[i];

                theObjectH = theIntervalH->getObject( );
                if( ! BdbIsNull(theObjectH)) {
                    ooId theId = theObjectH;
                    int theDb = theId.get_DB( );
                    sprintf( buf, "%d", theDb );
                    theDict[string( buf )].set_DB( theDb );
                }
            }
        }

        theNextIntervalH = theIntervalH->next( );
        theIntervalH     = theNextIntervalH;

    } while( ! BdbIsNull(theIntervalH));

    return BdbcSuccess;
}

BdbStatus
BdbCondDatabaseMgr::copySubSequenceOfBaselineIntervals( BdbObsoleteDatabase&                   theInDb,
                                                        const BdbHandle(BdbIntervalR)& theInBeginBaselineIntervalH,
                                                        const BdbHandle(BdbIntervalR)& theInEndBaselineIntervalH,
                                                        BdbObsoleteDatabase&                   theOutDb,
                                                        BdbHandle(BdbIntervalR)&       theOutBeginBaselineIntervalH,
                                                        BdbHandle(BdbIntervalR)&       theOutEndBaselineIntervalH )
{
    const char* errorString = "BdbCondDatabaseMgr::copySubSequenceOfBaselineIntervals( ) -- ERROR.";

    BdbStatus status;

  // NOTES:
  //
  //    1. This procedure is not meant to copy the FIRST and LAST intervals.
  //    2. It's expected that the context of the "BdbObsoleteDatabase" objects has already
  //       been set.
  //    3. The algorithm may also work well if both the input and the output
  //       subsequences belong to the same interval container.
  //    4. This procedure does not connect the newly created leftmost and rightmost
  //       intervals correctly. It's being assumed a task of the caller.
  //    5. The topmost links for the new sub-sequence are not set. It's being assuming
  //       a prerogative of the caller.

  // These parameters will be set to correct values upon the completion
  // of the procedure.

    theOutBeginBaselineIntervalH = 0;
    theOutEndBaselineIntervalH   = 0;

  // Get handles of the output container and a baseline revision in it.
  // We are going to use these handles as a clustering hint for the newely
  // created objects and as their baseline revision respectivly.

    BdbHandle(BdbContObj)      theOutContH;
    BdbHandle(BdbCondRevision) theOutBaselineRevisionH;

    theOutDb.getIntervalContH( theOutContH );
    if ( BdbIsNull(theOutContH)) {
        ErrMsg(error) << errorString << endl
                      << "    Unable to obtain a handle for the output container." << endl
                      << "    The context of the transient BdbObsoleteDatabase object for this interval container" << endl
                      << "    has not been set properly before calling the procedure" << endmsg;
        return BdbcError;
    }

    theOutDb.getBaselineRevisionH( theOutBaselineRevisionH );
    if ( BdbIsNull(theOutBaselineRevisionH)) {
        ErrMsg(error) << errorString << endl
                      << "    Unable to obtain a handle for the baseline revision of the output container." << endl
                      << "    The context of the transient BdbObsoleteDatabase object for this interval container" << endl
                      << "    has not been set properly before calling the procedure" << endmsg;
        return BdbcError;
    }

  // Iterate over the input list of baseline intervals and copy these
  // intervals into an output baseline sub-sequence.

    BdbHandle(BdbIntervalR) theInNextBaselineIntervalH;
    BdbHandle(BdbIntervalR) theInBaselineIntervalH;

    BdbHandle(BdbIntervalR) theOutPreviousBaselineIntervalH;
    BdbHandle(BdbIntervalR) theOutBaselineIntervalH;

    theInNextBaselineIntervalH      = theInBeginBaselineIntervalH;
    theOutPreviousBaselineIntervalH = 0;

    do {

        theInBaselineIntervalH = theInNextBaselineIntervalH;

      // Make a copy of an input interval within the output container.

        theOutBaselineIntervalH = new(theOutContH) BdbIntervalR( theInBaselineIntervalH->getObject( ),
                                                                 theInBaselineIntervalH->getBeginTime( ),
                                                                 theInBaselineIntervalH->getEndTime( ),
                                                                 theInBaselineIntervalH->getTag( ));

        theOutBaselineIntervalH->setVersionTime( theInBaselineIntervalH->getVersionTime( ));
        theOutBaselineIntervalH->setRevision( theOutBaselineRevisionH );

      // Include this interval into the BASELINE list only.

        if ( ! BdbIsNull(theOutPreviousBaselineIntervalH))  {
            theOutPreviousBaselineIntervalH->setBaselineNext( theOutBaselineIntervalH );
        }
        theOutBaselineIntervalH->setBaselinePrevious( theOutPreviousBaselineIntervalH );

      // Advance pointers in both containers.

        theInBaselineIntervalH->getBaselineNext( theInNextBaselineIntervalH );
        theOutPreviousBaselineIntervalH = theOutBaselineIntervalH;

      // Set un-initialized output handle for the very first output interval
      // if it's not been set. This has been done for the very first handle
      // in the sub-sequence.

        if ( BdbIsNull(theOutBeginBaselineIntervalH)) {
            theOutBeginBaselineIntervalH = theOutBaselineIntervalH;
        }

    } while( theInBaselineIntervalH != theInEndBaselineIntervalH );

  // Set the un-initialized output handle for the very last output interval
  // using the most recently created handle.

    theOutEndBaselineIntervalH = theOutBaselineIntervalH;

    return BdbcSuccess;
}

BdbStatus
BdbCondDatabaseMgr::copyTopIntervalsInSubTree( BdbObsoleteDatabase&                   theDb,
                                               const BdbHandle(BdbIntervalR)& theInBaseIntervalH,
                                               BdbHandle(BdbIntervalR)&       theOutBaseIntervalH,
                                               bool                           keepRevisedIntervals,
                                               d_ULong                        maxNumOfTopLayers,
                                               d_ULong                        maxNumOfLayersUnderRevisedInterval )
{
    const char* errorString = "BdbCondDatabaseMgr::copyTopIntervalsInSubTree( ) -- ERROR.";

    BdbStatus status;

  // Just return if no Genealogy object exist for specified base interval.
  // This is a case when specified base interval is a baseline one without
  // any versions above.

    if ( ! theInBaseIntervalH->exist_geneObj( )) {
        return BdbcSuccess;
    }

  // Always set the versioning status of specified _output_ base interval as "multiple".
  // We will correct this later, when all the input versions are analysed and
  // sufficient output versions are created.

    theOutBaseIntervalH.setVersStatus( oocBranchVers );

  // Now we are about to run two iterations over the lists of child intervals
  // of the current baseline one.
  //
  // NOTE: We could optimize this part of code if we stored the results of
  //       the first iteration in a RW vector.

    BdbHandle(BdbIntervalR) theInIntervalH;
    BdbHandle(BdbIntervalR) theOutIntervalH;
    BdbRef(BdbCondRevision) theRevisionRef;
    BdbItr(BdbPersObj)      theInItr;

  // ITERATION I: (optional)
  //
  //    If the revisions must be kept then iterate over the list of versions of
  //    specified base interval and check if there is at least one explicitly revised
  //    interval. If so then all the children of the current base interval should
  //    be unconditionally copied.
  //
  //    NOTE: This algorithm works till the very first revised interval is met.

    bool copyAnyway = false;

    if ( keepRevisedIntervals ) {

        theInBaseIntervalH->nextVers( theInItr );
        while ( theInItr.next( )) {

            theInIntervalH = (BdbHandle(BdbIntervalR)&) theInItr;
            theRevisionRef = theInIntervalH->getRevision( );
            if ( ! BdbIsNull(theRevisionRef)) {
                copyAnyway = true;
                break;
            }
        }
    }

  // ITERATION II: (mandatory)
  //
  //    Now we've got all missing corrections before to proceed processing intervals
  //    at the current layer.

    theInBaseIntervalH->nextVers( theInItr );
    while ( theInItr.next( )) {

        theInIntervalH = (BdbHandle(BdbIntervalR)&) theInItr;
        theRevisionRef = theInIntervalH->getRevision( );

      // Check if any of the following conditions is true:
      //
      //    - the input interval version is meant to fill the "revision hole" ("copyAnyway");
      //    - the interval is explicitly connected to a revision (if this is required);
      //    - the interval is "close enough" to the revised interval (if required);
      //    - the interval is "close enough" to the top of the versioning tree.

        if ( copyAnyway ||
             ( keepRevisedIntervals && ( ! BdbIsNull(theRevisionRef))) ||
             ( keepRevisedIntervals && hasAnyRevisedIntervalAsCloaseAs( theInIntervalH, maxNumOfLayersUnderRevisedInterval )) ||
             hasAnyTopIntervalAsCloaseAs( theInIntervalH, maxNumOfTopLayers )) {

          // Since we have either an explicit revision for this interval (if this was required)
          // or we can see a top withing specified distance then we should
          // make a copy of this input interval and to attach it as a version
          // to the current output base.

            theDb.createVersion( theOutBaseIntervalH, theOutIntervalH );
            theDb.nameVersion( theOutBaseIntervalH, theOutIntervalH );

            theOutIntervalH->setObject(      theInIntervalH->getObject( ));
            theOutIntervalH->setBeginTime(   theInIntervalH->getBeginTime( ));
            theOutIntervalH->setEndTime(     theInIntervalH->getEndTime( ));
            theOutIntervalH->setVersionTime( theInIntervalH->getVersionTime( ));
            theOutIntervalH->setTag(         theInIntervalH->getTag( ));
            theOutIntervalH->setRevision(    theRevisionRef );

          // Proceed along the versioning tree with the new _output_ base.

            status = copyTopIntervalsInSubTree( theDb,
                                                theInIntervalH,
                                                theOutIntervalH,
                                                keepRevisedIntervals,
                                                maxNumOfTopLayers,
                                                maxNumOfLayersUnderRevisedInterval );
            if ( BdbcSuccess != status ) return status;

        } else {

          // Just ignore this interval, because it's located too deep inside
          // the versioning tree and does not respresent any particular interesnt.

          // Proceed along the versioning tree with the current _output_ base.

            status = copyTopIntervalsInSubTree( theDb,
                                                theInIntervalH,
                                                theOutBaseIntervalH,
                                                keepRevisedIntervals,
                                                maxNumOfTopLayers,
                                                maxNumOfLayersUnderRevisedInterval );
            if ( BdbcSuccess != status ) return status;
        }
    }

  // Count the number of versions of the _output_ base and set the branching
  // to a proper number.

    d_ULong numBranches = 0;

    BdbItr(BdbPersObj) theOutItr;
    theOutBaseIntervalH->nextVers( theOutItr );

    while ( theOutItr.next( )) {
        ++numBranches;
    }

    switch ( numBranches ) {
    case 0:
        theOutBaseIntervalH.setVersStatus( oocNoVers  );
        break;
    case 1:
        theOutBaseIntervalH.setVersStatus( oocLinearVers  );
        break;
    default:
        theOutBaseIntervalH.setVersStatus( oocBranchVers  );
        break;
    }

  // Ok. We've done it at this layer.

    return BdbcSuccess;
}

bool
BdbCondDatabaseMgr::hasAnyTopIntervalAsCloaseAs( const BdbHandle(BdbIntervalR)& theIntervalH,
                                                 d_ULong                        maxNumOfTopLayers )
{
  // This method is meant to check if specified interval itself is being the topmost one
  // or its vertical child versions are within specified range of muximum number of top layers.
  //
  // NOTE: If the specified number is 0 then we do not check anything at all
  //       If it's equal to 1 then we check the specified interval only.
  //       If it > 1 then we check specified interval, and its children (if any).
  //
  // IMPORTANT: We are assuming that the genealogy tree for this interval already
  //            exists, and that this method was not called against the baseline interval.

    BdbItr(BdbPersObj) theItr;

    switch( maxNumOfTopLayers ) {

    case 0:

        {
          // If the radius of visibility is zero then we don't even try
          // to continue further checks.

            return false;
        }

    case 1:

        {
            theIntervalH->nextVers( theItr );
            while( theItr.next( )) {

              // Oops. The current interval has at least one vertical version, which means
              //       that this interval is not the TOPMOST one.

                return false;
            }

          // Ok. No versions. The current interval is the TOPMOST one.

            return true;
        }

    default:

        {
            d_ULong numVersions = 0;

            theIntervalH->nextVers( theItr );
            while( theItr.next( )) {

                numVersions++;

                if( hasAnyTopIntervalAsCloaseAs((BdbHandle(BdbIntervalR)&) theItr,
                                                 maxNumOfTopLayers - 1 )) {

                  // Ok. The TOPMOST layer is close enough and is seen by the child
                  //     interval within specified radius.

                    return true;
                }
            }

            if( 0 == numVersions ) {

              // Ok. No versions. The current interval is the TOPMOST one.

                return true;
            }

            break;
        }
    }

  // Oops. We are still too far from the top of the genealogy.

    return false;
}

bool
BdbCondDatabaseMgr::hasAnyRevisedIntervalAsCloaseAs( const BdbHandle(BdbIntervalR)& theIntervalH,
                                                     d_ULong                        maxNumOfLayersUnderRevisedInterval )
{
  // This method is meant to check if specified interval itself is being the revised one
  // or its vertical child versions are within specified range of muximum number of layers
  // to another revised interval.
  //
  // NOTE: If the specified number is 0 then we do not check anything at all
  //       If it's equal to 1 then we check the children of the specified interval only.
  //       If it > 1 then we check both the children of specified interval, and further.
  //
  // IMPORTANT: We are assuming that the genealogy tree for this interval already
  //            exists, and that this method was not called against the baseline interval.

    BdbHandle(BdbIntervalR) theNextIntervalH;
    BdbRef(BdbCondRevision) theRevisionRef;

    BdbItr(BdbPersObj) theItr;

    switch( maxNumOfLayersUnderRevisedInterval ) {

    case 0:

        {
          // If the radius of visibility is zero then we don't even try
          // to continue further checks.

            return false;
        }

    case 1:

        {
            theIntervalH->nextVers( theItr );
            while( theItr.next( )) {

                theNextIntervalH = (BdbHandle(BdbIntervalR)&) theItr;

                theRevisionRef = theNextIntervalH->getRevision( );
                if ( ! BdbIsNull(theRevisionRef)) {

                  // Ok. The current interval has at least one revised child.

                    return true;
                }
            }

          // Oops. No revised intervals among children.

            return false;
        }

    default:

        {
            theIntervalH->nextVers( theItr );
            while( theItr.next( )) {

                theNextIntervalH = (BdbHandle(BdbIntervalR)&) theItr;

                theRevisionRef = theNextIntervalH->getRevision( );
                if ( ! BdbIsNull(theRevisionRef)) {

                  // Ok. The current interval has at least one revised child.

                    return true;
                }
                if( hasAnyRevisedIntervalAsCloaseAs( theNextIntervalH,
                                                     maxNumOfLayersUnderRevisedInterval - 1 )) {

                  // Ok. There is a revised interval which is close enough and is seen by the child
                  //     interval within specified radius.

                    return true;
                }
            }

            break;
        }
    }

  // Oops. We are still too far from a revised interval in this sub-branch
  //       of the genealogy.

    return false;
}

bool
BdbCondDatabaseMgr::hasRevisedIntervalInSubTree( const BdbHandle(BdbIntervalR)& theIntervalH )
{
  // This method is meant to check if there is at least one revised interval
  // in the versioning tree.
  //
  // NOTE: This test does not count the baseline interval (since we are checking
  //       only the children of specified interval then the baseline interval would
  //       not be counted automatically).

    if ( theIntervalH->exist_geneObj( )) {

        BdbHandle(BdbIntervalR) theNextIntervalH;
        BdbRef(BdbCondRevision) theRevisionRef;

        BdbItr(BdbPersObj) theItr;
        theIntervalH->nextVers( theItr );

        while( theItr.next( )) {

            theNextIntervalH = (BdbHandle(BdbIntervalR)&) theItr;

            theRevisionRef = theNextIntervalH->getRevision( );
            if ( ! BdbIsNull(theRevisionRef)) {
                return true;
            } else {
                if( hasRevisedIntervalInSubTree( theNextIntervalH )) {
                    return true;
                }
            }
        }
    }

    return false;
}

const char*
BdbCondDatabaseMgr::getOID( const BdbHandle(BdbPersObj)& thePersObjH )
{
    static char buf[255];

    ooId id = thePersObjH;
    
    int db   = id.get_DB();
    int cont = id.get_OC();
    int page = id.get_page();
    int slot = id.get_slot();
    
    sprintf( buf, "#%d-%d-%d-%d", db, cont, page, slot );

    return buf;
}
/////////////////
// End Of File //
/////////////////

 

---

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

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