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

                 

---

/BdbCond/BdbCondDirectAccessor.cc

Go to the documentation of this file.

//-----------------------------------------------------------------------------
//
// File and Version Information:
//      $Id: BdbCondDirectAccessor.cc,v 1.4 2001/03/06 17:50:11 gapon Exp $
//
// Description:
//      This class implements an interface of its base class BdbCondAccessor.
//
//      The current implementation provides direct access to the methadata
//      through Objectivity/API.
//
// Environment:
//      Software developed for the BaBar Detector at the SLAC B-Factory.
//
// Author List:
//      Igor A. Gaponenko       Original Author
//
// Copyright Information:
//      Copyright (C) 2000      Lawrence Berkeley Laboratory
//
//-----------------------------------------------------------------------------

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

#include "BdbCond/BdbCondDirectAccessor.hh"

// -------------------------
// -- Objectivity Headers --
// -------------------------

#include <ooIndex.h>

// -------------------
// -- BaBar Headers --
// -------------------

// ----------------------------
// -- BaBar Database Headers --
// ----------------------------

#include "BdbCond/BdbDatabase.hh"
 
// ---------------
// -- C Headers --
// ---------------

extern "C" {
#include <assert.h>
}

// ---------------------------------
// -- Collaborating Class Headers --
// ---------------------------------

#include "ErrLogger/ErrLog.hh"

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

static const char  rcsid[] = "$Id: BdbCondDirectAccessor.cc,v 1.4 2001/03/06 17:50:11 gapon Exp $";

// --------------------
// -- Static methods --
// --------------------

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

BdbCondDirectAccessor::BdbCondDirectAccessor( ) :
    BdbCondAccessor( )
{
}

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

BdbCondDirectAccessor::~BdbCondDirectAccessor( )
{
}

// ----------------
// -- Operations --
// ----------------

BdbStatus
BdbCondDirectAccessor::findObject( BdbDatabase*          theDatabasePtr,
                                   BdbHandle(BdbObject)& theObjectH,        
                                   const char*           theContainerName,  
                                   const BdbTime&        theTime )
{
  // NOTE: all external comunications of this method go via
  //       its caller for the following two purposes:
  //
  //         - stay in the correct context;
  //         - provide the consistent change in the caller's context.

    assert( 0 != theDatabasePtr );
    assert( 0 != theContainerName );

    BdbStatus status;

    theObjectH = 0;
  
  // Find an appropriate interval.

    BdbHandle(BdbInterval) BdbIntervalH;
    status = theDatabasePtr->findInterval( BdbIntervalH,
                                           theContainerName,
                                           theTime );
    if (( BdbcSuccess != status ) || BdbIsNull(BdbIntervalH)) {
        return BdbcError;
    }

  // Get an object from the interval.

    theObjectH = BdbIntervalH->getObject( );

    return BdbcSuccess;
}

BdbStatus
BdbCondDirectAccessor::findObject( BdbDatabase*          theDatabasePtr,
                                   BdbHandle(BdbObject)& theObjectH, 
                                   BdbIntervalBase&      theIntervalBase,
                                   BdbTime&              theVersionTime,
                                   const char*           theContainerName,
                                   const BdbTime&        theTime )
{
  // NOTE: all external comunications of this method go via
  //       its caller for the following two purposes:
  //
  //         - stay in the correct context;
  //         - provide the consistent change in the caller's context.

    assert( 0 != theDatabasePtr );
    assert( 0 != theContainerName );

    BdbStatus status;

    theObjectH = 0;

    theIntervalBase.setBeginTime( BdbTime::minusInfinity );
    theIntervalBase.setEndTime  ( BdbTime::plusInfinity );
  
  // Find an appropriate interval.

    BdbHandle(BdbInterval) BdbIntervalH;
    status = theDatabasePtr->findInterval( BdbIntervalH,
                                           theContainerName,
                                           theTime );
    if (( BdbcSuccess != status ) || BdbIsNull(BdbIntervalH)) {
        return BdbcError;
    }

  // Get an object, its validity period and its version time from
  // the found interval.

    theObjectH = BdbIntervalH->getObject( );
    theIntervalBase = *BdbIntervalH;

    theVersionTime = BdbIntervalH->getVersionTime( );

    return BdbcSuccess;
}

BdbStatus
BdbCondDirectAccessor::findInterval( BdbDatabase*            theDatabasePtr,
                                     BdbHandle(BdbInterval)& theIntervalH,
                                     const char*             theContainerName,
                                     const BdbTime&          theTime )
{
  // NOTE: all external comunications of this method go via
  //       its caller for the following two purposes:
  //
  //         - stay in the correct context;
  //         - provide the consistent change in the caller's context.

    const char* errorString = "BdbCondDirectAccessor::findInterval() -- ERROR.";

    BdbStatus status;

    assert( 0 != theDatabasePtr );
    assert( 0 != theContainerName );

    theIntervalH = 0;

  // Get a handle to the interval container

    BdbHandle(BdbContObj) intervalContH;

    status = theDatabasePtr->findIntervalCont( intervalContH, theContainerName );
    if (( BdbcSuccess != status ) || BdbIsNull(intervalContH)) {
        return BdbcError;
    }

  // A simplest optimization: check the FIRST and LAST intervals.

    status = theDatabasePtr->firstInterval( theIntervalH, theContainerName );
    if ( BdbcSuccess != status )              return status;
    if ( theIntervalH->inInterval( theTime )) return BdbcSuccess;

    status = theDatabasePtr->lastInterval( theIntervalH, theContainerName );
    if ( BdbcSuccess != status )              return status;
    if ( theIntervalH->inInterval( theTime )) return BdbcSuccess;

  // look up the interval

    d_ULong gmtTheTime = theTime.getGmtSec( );

    ooLookupKey lookupKey( ooTypeN(BdbInterval), 2 );
              
    ooLessThanEqualLookupField lessThanEqual( ooTypeN(BdbInterval),
                                              "_beginTime._gmtSec",
                                              & gmtTheTime );
    lookupKey.addField( lessThanEqual );

    ooGreaterThanLookupField greaterThan( ooTypeN(BdbInterval),
                                          "_endTime._gmtSec",
                                          & gmtTheTime );
    lookupKey.addField( greaterThan );

    BdbItr(BdbInterval) theIntervalItr;
    theIntervalItr.scan( intervalContH, lookupKey, BdbcRead );

  // Select an interval search method. We use a revision description
  // path in order to do make a decision.
  //
  // NOTE: We always use both the original TLA and the original container
  //       name as lookup keys for the revision ID enquiry.

    bool    useTopVersionFlag;
    d_ULong theRevisionId;

    status = theDatabasePtr->_revisionPath->getRevision( theDatabasePtr->subsystemTLA( ),
                                                         theContainerName,
                                                         useTopVersionFlag,
                                                         theRevisionId );
    if ( BdbcSuccess != status ) {
        ErrMsg(error) << errorString << endl
                      << "    Failed to determine a revision number." << endl
                      << "        DETECTOR  -> " << theDatabasePtr->subsystemTLA( ) << endl
                      << "        CONTAINER -> " << theContainerName << endmsg;
        return status;
    }

  // Call appropriate search algorithm.

    if ( useTopVersionFlag ) {
    
        status = theDatabasePtr->findTopInterval( theIntervalH,
                                                  theIntervalItr );
    } else {

        status = theDatabasePtr->findRevisedInterval( theIntervalH,
                                                      theIntervalItr,
                                                      theRevisionId );
    }

    return status;
}

BdbStatus
BdbCondDirectAccessor::firstInterval( BdbDatabase*            theDatabasePtr,
                                      BdbHandle(BdbInterval)& theIntervalH,
                                      const char*             theContainerName )
{
  // NOTE: all external comunications of this method go via
  //       its caller for the following two purposes:
  //
  //         - stay in the correct context;
  //         - provide the consistent change in the caller's context.

    const char* errorString = "BdbCondDirectAccessor::firstInterval() -- ERROR.";

    BdbStatus status;

    assert( 0 != theDatabasePtr );
    assert( 0 != theContainerName );

    theIntervalH = 0;

  // Locate the interval container.

    BdbHandle(BdbContObj) intervalContH;

    status = theDatabasePtr->findIntervalCont( intervalContH, theContainerName );
    if (( BdbcSuccess != status ) || BdbIsNull(intervalContH)) {
        ErrMsg(error) << errorString << endl
                      << "    Can not find the interval container." << endl
                      << "        DETECTOR ->  " << theDatabasePtr->subsystemTLA( ) << endl
                      << "        CONTAINER -> " << theContainerName << endmsg;
        return BdbcError;
    }

  // Locate the FIRST interval in the container.

    theIntervalH.lookupObj( intervalContH, "FirstInterval" );
    if ( BdbIsNull(theIntervalH)) {
        ErrMsg(error) << errorString << endl
                      << "    Can not find the FIRST interval in this container." << endl
                      << "        DETECTOR ->  " << theDatabasePtr->subsystemTLA( ) << endl
                      << "        CONTAINER -> " << theContainerName << endmsg;
        return BdbcError;
    }

    return BdbcSuccess;
}

BdbStatus
BdbCondDirectAccessor::lastInterval(  BdbDatabase*            theDatabasePtr,
                                      BdbHandle(BdbInterval)& theIntervalH,
                                      const char*             theContainerName )
{
  // NOTE: all external comunications of this method go via
  //       its caller for the following two purposes:
  //
  //         - stay in the correct context;
  //         - provide the consistent change in the caller's context.

    const char* errorString = "BdbCondDirectAccessor::lastInterval() -- ERROR.";

    BdbStatus status;

    assert( 0 != theDatabasePtr );
    assert( 0 != theContainerName );

    theIntervalH = 0;

  // Locate the interval container.

    BdbHandle(BdbContObj) intervalContH;

    status = theDatabasePtr->findIntervalCont( intervalContH, theContainerName );
    if (( BdbcSuccess != status ) || BdbIsNull(intervalContH)) {
        ErrMsg(error) << errorString << endl
                      << "    Can not find the interval container." << endl
                      << "        DETECTOR ->  " << theDatabasePtr->subsystemTLA( ) << endl
                      << "        CONTAINER -> " << theContainerName << endmsg;
        return BdbcError;
    }

  // Locate the LAST interval in the container.

    theIntervalH.lookupObj( intervalContH, "LastInterval" );
    if ( BdbIsNull(theIntervalH)) {
        ErrMsg(error) << errorString << endl
                      << "    Can not find the LAST interval in this container." << endl
                      << "        DETECTOR ->  " << theDatabasePtr->subsystemTLA( ) << endl
                      << "        CONTAINER -> " << theContainerName << endmsg;
        return BdbcError;
    }

    return BdbcSuccess;
}

void
BdbCondDirectAccessor::reset( )
{
  // We have nothing to clear in this brand of accessor.
}

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

 

---

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

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