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

                 

---

/CdbBdbWrapper/CdbBdbWCondition.cc

Go to the documentation of this file.

/// The implementation of the CdbBdbWCondition class.
/**
  * @see CdbBdbWCondition
  */

#include "BaBar/BaBar.hh"

#include "CdbBdbWrapper/CdbBdbWCondition.hh"

#include "CdbBase/Cdb.hh"
#include "CdbBase/CdbDatabase.hh"
#include "CdbBase/CdbView.hh"
#include "CdbBase/CdbFolder.hh"
#include "CdbBase/CdbRevisionPolicy.hh"
#include "CdbBase/CdbObject.hh"
#include "CdbBase/CdbObjectItr.hh"
#include "CdbBase/CdbObjectFactoryBase.hh"

#include "CdbBdb/CdbBdbObjectCreator.hh"
#include "CdbBdb/CdbBdbObjectConvertor.hh"

#include "CdbBdbWrapper/CdbBdbWRevision.hh"
#include "CdbBdbWrapper/CdbBdbWRevisionIdItr.hh"
#include "CdbBdbWrapper/CdbBdbWRevisionNameItr.hh"

#include "BdbApplication/BdbDebug.hh"

#include "BdbTime/BdbTime.hh"
#include "BdbTime/BdbIntervalBase.hh"

#include "BdbCond/BdbObject.hh"
#include "BdbCond/BdbObsoleteDatabase.hh"
#include "BdbCond/BdbCondRegistry.hh"
#include "BdbCond/BdbCondRevision.hh"
#include "BdbCond/BdbIntervalItr.hh"

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

namespace {

/////////////////////////////
// Class: CdbBdbWObjectItr //
/////////////////////////////

class CdbBdbWObjectItr : public CdbObjectItr::InterfaceType {
 
private:
 
  /// The default constructor (NOT IMPLEMENTED)
  /**
    * Is disabled...
    */
    CdbBdbWObjectItr( );
 
public:
 
  /// The normal constructor
  /**
    * More details...
    */
    CdbBdbWObjectItr( const CdbConditionPtr& theParentPtr,          /**< a smart pointer onto the parent condition */
                      const BdbIntervalItr&  theInputItr,           /**< the source of information about objects */
                      const BdbTime&         theEndValidityTime     /**< a point beyond which we should stop iteration */
                    );
 
  /// The copy constructor
  /** 
    * More details to come...
    */ 
    CdbBdbWObjectItr( const CdbBdbWObjectItr& theItr );
 
  /// The assignment operator
  /** 
    * More details to come...
    */ 
    CdbBdbWObjectItr& operator=( const CdbBdbWObjectItr& theItr );
 
  /// The destructor
  /** 
    * Details...
    */ 
    virtual ~CdbBdbWObjectItr( );
 
  /// Reset an iterator to its initial state.
  /** 
    * This implements the corresponding method of the base class.
    * 
    * @see CdbIItr::reset
    * @see CdbStatus
    */ 
    virtual CdbStatus reset( );
 
  /// Advance an iterator to the next position.
  /** 
    * This implements the corresponding method of the base class.
    * 
    * @see CdbIItr::next()
    */ 
    virtual bool next( );
 
  /// Obtain the currently reffered value.
  /** 
    * This implements the corresponding method of the base class.
    * 
    * @see CdbIItr::value()
    * @see CdbIItr::ValueType
    * 
    * @return the current value the iterator is set on
    */ 
    virtual ValueType value( );
 
  /// Check if an iterator is valid.
  /** 
    * This implements the corresponding method of the base class.
    * 
    * @see CdbIItr::isValid()
    */ 
    virtual bool isValid( );
 
  /// Make a clone of itself
  /** 
    * @see CdbIItr::clone()
    */ 
    virtual InterfaceType* clone( ) const;
 
private: 
 
  /// Set up current context from specified source
  /** 
    * More details...
    */ 
    void setUpSelf( const CdbBdbWObjectItr& theItr );
 
  /// Try to advance the iterator to the next position
  /** 
    * Return "true" if successful.
    */ 
    bool tryNext( );
 
private: 
 
    bool _isValid;
    bool _hasEverBeenAdvanced;
 
    CdbConditionPtr _myParentPtr;
    BdbIntervalItr  _itr;
    BdbTime         _endTime;
 
    CdbObjectPtr _objectPtr;
};

CdbBdbWObjectItr::CdbBdbWObjectItr( const CdbConditionPtr& theParentPtr,
                                    const BdbIntervalItr&  theInputItr,
                                    const BdbTime&         theEndValidityTime ) :
    _isValid            (false),
    _hasEverBeenAdvanced(false),
    _myParentPtr        (theParentPtr),
    _itr                (theInputItr),
    _endTime            (theEndValidityTime),
    _objectPtr          (0)
{
    assert( !theParentPtr.isNull( ));
}
 
CdbBdbWObjectItr::CdbBdbWObjectItr( const CdbBdbWObjectItr& theItr ) :
    _isValid            (theItr._isValid),
    _hasEverBeenAdvanced(theItr._hasEverBeenAdvanced),
    _myParentPtr        (theItr._myParentPtr),
    _itr                (theItr._itr),
    _endTime            (theItr._endTime),
    _objectPtr          (theItr._objectPtr)
{ }
 
CdbBdbWObjectItr::~CdbBdbWObjectItr( )
{ }

CdbBdbWObjectItr&
CdbBdbWObjectItr::operator=( const CdbBdbWObjectItr& theItr )
{ 
    if( this != &theItr ) {
        _isValid             = theItr._isValid;
        _hasEverBeenAdvanced = theItr._hasEverBeenAdvanced;
        _myParentPtr         = theItr._myParentPtr;
        _itr                 = theItr._itr;
        _endTime             = theItr._endTime;
        _objectPtr           = theItr._objectPtr;
    } 
    return *this;
} 
 
CdbStatus 
CdbBdbWObjectItr::reset( )
{ 
    _isValid             = false;
    _hasEverBeenAdvanced = false;
 
    _objectPtr = 0;
 
    _itr.reset( );
 
    return CdbStatus::Success;
}

bool 
CdbBdbWObjectItr::tryNext( )
{ 
    bool result = _itr.next( );
    if( result ) {
 
      // Get to the current handle
 
        BdbHandle(BdbIntervalR) intervalH;
        intervalH = _itr;
 
      // Initialize a generic object
 
        CdbStatus status = CdbBdbObjectCreator::object( _objectPtr,
                                                        _myParentPtr,
                                                        intervalH->beginTime( ),
                                                        intervalH->endTime( ),
                                                        intervalH->getVersionTime( ),   // begin of 'duration' interval
                                                        BdbTime::plusInfinity,          // end   of 'duration' interval
                                                        intervalH->getVersionTime( ),
                                                        intervalH->getObject( ));
        result = ( CdbStatus::Success == status );
    } 
    if( !result ) {
        _objectPtr = 0;
    } 
    return result;
}

bool 
CdbBdbWObjectItr::next( )
{ 
    if( _hasEverBeenAdvanced ) {
        if( _isValid ) {
 
          // Proceed only if the end time of the current object is not beyond the limit
          // passed to the constructor of the current class.
 
            if( _objectPtr->end( ) >= _endTime ) {
 
                _objectPtr = 0;
 
                _isValid = false;
 
            } else {
                _isValid = tryNext( );
            }
 
        } else {
            ;       // leave iterator past the end of the collection
        } 
 
    } else { 
        _hasEverBeenAdvanced = true;
        _isValid             = tryNext( );
    } 
    return _isValid;
}

CdbBdbWObjectItr::ValueType
CdbBdbWObjectItr::value( )
{ 
    return _objectPtr;
} 
 
bool 
CdbBdbWObjectItr::isValid( )
{ 
    return _isValid;
} 
 
CdbBdbWObjectItr::InterfaceType*
CdbBdbWObjectItr::clone( ) const
{ 
    return new CdbBdbWObjectItr( *this );
}

};

/////////////////////////////
// Class: CdbBdbWCondition //
/////////////////////////////

CdbCondition*
CdbBdbWCondition::clone( ) const
{
    CdbBdbWCondition* mySelf = const_cast<CdbBdbWCondition*>( this );
    return new CdbBdbWCondition( mySelf->parent( ),
                                 mySelf->name( ));
}

bool
CdbBdbWCondition::isPartitionable( ) const
{
    return false;
}

CdbStatus
CdbBdbWCondition::findObject( CdbObjectPtr&  theObjectPtr,
                              const BdbTime& theValidityTime,
                              const BdbTime& theInsertionTime )
{
/******************************************************************
 *
 * IMPLEMENTATION NOTES:
 *
 * - THIS METHOD IGNORSE THE INSERTION TIME PASSED AS THE PARAMETER
 * - IT RELIES ON THE CURRENT REVISION PATH CONFIGURATION
 *
 ******************************************************************
 */
    CdbStatus result = CdbStatus::Error;

    theObjectPtr = 0;

    do {

      // Find the corresponding object and its parameters in the database.
      //
      // NOTE: We always rely on the revision configuration in
      //        the BdbCondRevisionPath.

        BdbObsoleteDatabase            db( parent( )->name( ));
        BdbHandle(BdbInterval) intervalH;
        BdbHandle(BdbObject)   objectH;
        BdbIntervalBase        bdbTransientInterval;
        BdbTime                bdbInsertionTime( 0 );

        COUT1 << "CDB_FETCH_: detector=" << parent( )->name( ) << " container=" << name( ) << " fetch_time=" << theValidityTime << endl;

        BdbStatus bdbStatus = db.fetch( objectH,
                                        bdbTransientInterval,
                                        bdbInsertionTime,
                                        name( ),
                                        theValidityTime );
        if( BdbcSuccess != bdbStatus ) break;

      // Create a transient object through the creator factory.
      //
      // DESIGN NOTE: We need to construct a smart pointer against a clone since
      //              we don't know a smart pointer pointing to the current
      //              instance, therefore we can't guarantee the lifetime
      //              of the current instance.

        CdbConditionPtr myPtr( this->clone( ));
        result = CdbBdbObjectCreator::object( theObjectPtr,
                                              myPtr,
                                              bdbTransientInterval.beginTime( ),
                                              bdbTransientInterval.endTime( ),
                                              bdbInsertionTime,         // begin of the 'duration' interval
                                              BdbTime::plusInfinity,    // end   of the 'duration' interval
                                              bdbInsertionTime,
                                              objectH );

    } while( false );

    return result;
}

CdbStatus
CdbBdbWCondition::findObject( CdbObjectPtr&            theObjectPtr,
                              const CdbRevisionPolicy& thePolicy,
                              const BdbTime&           theValidityTime,
                              const BdbTime&           theInsertionTime )
{
    return findObject( theObjectPtr,
                       theValidityTime,
                       theInsertionTime );
}

CdbStatus
CdbBdbWCondition::objectIterator( CdbObjectItr&  theItr,
                                  const BdbTime& theBeginValidity,
                                  const BdbTime& theEndValidity )
{
    const char* errorStr = "CdbBdbWCondition::objectIterator() -- ERROR.";
 
    CdbStatus result = CdbStatus::Error;
 
    do {
 
        const char* detectorName  = parent( )->name( );
        const char* conditionName = name( );
 
      // Verify parameters to make sure that at least one point of the validity
      // timeline is in the specified interval.
 
        if( theBeginValidity > theEndValidity ) {
            cout << errorStr << endl
                 << "    Illegal validity range for the iterator:" << endl
                 << "        DETECTOR   : \"" << detectorName << "\"" << endl
                 << "        CONDITION  : \"" << conditionName << "\"" << endl
                 << "        BEGIN TIME : "   << theBeginValidity << endl
                 << "        END   TIME : "   << theEndValidity << endl;
            break;
        }
 
      // Find out the revision information
 
        bool    useTopVersionFlag = true;
        d_ULong revisionId        = BdbCondRevision::BASELINE;
 
        if( BdbcSuccess != BdbCondPath::instance( )->getRevision( detectorName,
                                                                  conditionName,
                                                                  useTopVersionFlag,
                                                                  revisionId )) {
            cout << errorStr << endl
                 << "    Failed to obtain the revision configuration for:" << endl
                 << "        DETECTOR  : \"" << detectorName << "\"" << endl
                 << "        CONDITION : \"" << conditionName << "\"" << endl;
            break;
        }

      // Set up the iterator
 
        BdbIntervalItr itr;
        bool           itrWasSetup = false;
 
        if( useTopVersionFlag ) {
 
            itrWasSetup = itr.setTopmost( detectorName,
                                          conditionName,
                                          theBeginValidity );
        } else {
 
            if( BdbCondRevision::BASELINE == revisionId ) {
 
                itrWasSetup = itr.setBaseline( detectorName,
                                               conditionName,
                                               theBeginValidity );
            } else {
 
                itrWasSetup = itr.setRevision( detectorName,
                                               conditionName,
                                               revisionId,
                                               theBeginValidity );
            }
        } 
        if( !itrWasSetup ) {
            cout << errorStr << endl
                 << "    Failed to set up the iterator for:" << endl
                 << "        DETECTOR   : \"" << detectorName << "\"" << endl
                 << "        CONDITION  : \"" << conditionName << "\"" << endl
                 << "        BEGIN TIME : "   << theBeginValidity << endl;
            break;
        }

      // ATTENTION: This is not a memory leak - the created object
      //            will be destroyed by the iterator.
 
        CdbConditionPtr myPtr( this->clone( ));
        theItr = CdbObjectItr( new CdbBdbWObjectItr( myPtr,
                                                     itr,
                                                     theEndValidity ));
 
      // Done.
 
        result = CdbStatus::Success;
 
    } while( false );
 
    return result;
}

CdbStatus
CdbBdbWCondition::storeObject( CdbObjectFactoryBase& theObjectFactory,
                               const BdbTime&        theBegin,
                               const BdbTime&        theEnd,
                               CdbObjectPtr&         theObjectPtr )
{
    CdbStatus result = CdbStatus::Error;

    theObjectPtr = 0;

    do {

      // Invoke the object creator first.

        CdbConditionPtr myPtr( this->clone( ));

        if( CdbStatus::Success != create( theObjectFactory, theObjectPtr, myPtr, theBegin, theEnd )) break;
        if( theObjectPtr.isNull( )) break;

      // Get object handle

        BdbHandle(BdbObject) objectH;

        if( CdbStatus::Success != CdbBdbObjectConvertor::narrow( objectH, theObjectPtr )) break;
        if( BdbIsNull(objectH)) break;

      // Store the persistent object in the database.

        BdbObsoleteDatabase db( parent( )->name( ));

        if( BdbcSuccess != db.store( objectH, name( ), theBegin, theEnd )) break;

      // Done

        result = CdbStatus::Success;

    } while( false );

    return result;
}

CdbStatus
CdbBdbWCondition::storeAndTruncateObject( CdbObjectFactoryBase& theObjectFactory,
                                          const BdbTime&        theStoreTime,
                                          const BdbTime&        theTruncateTime,
                                          CdbObjectPtr&         theObjectPtr )
{
    CdbStatus result = CdbStatus::Error;

    theObjectPtr = 0;

    do {

      // Invoke the object creator first.
      //
      // NOTE: We're passing +Infinity instead of the "truncate" time because
      //       the newely created object can (if applied to teh LastInterval) be valid
      //       to +Infinity.

        CdbConditionPtr myPtr( this->clone( ));

        if( CdbStatus::Success != create( theObjectFactory, theObjectPtr, myPtr, theStoreTime, BdbTime::plusInfinity )) break;
        if( theObjectPtr.isNull( )) break;

      // Get object handle

        BdbHandle(BdbObject) objectH;

        if( CdbStatus::Success != CdbBdbObjectConvertor::narrow( objectH, theObjectPtr )) break;
        if( BdbIsNull(objectH)) break;

      // Store the persistent object in the database.

        BdbObsoleteDatabase db( parent( )->name( ));

        if( BdbcSuccess != db.storeAndTruncate( objectH, name( ), theStoreTime, theTruncateTime )) break;

      // Done

        result = CdbStatus::Success;

    } while( false );

    return result;
}

CdbStatus
CdbBdbWCondition::split( const BdbTime& theTime )
{
    const char* errorStr = "CdbBdbWCondition::split() -- ERROR.";

    CdbStatus result = CdbStatus::Error;

    do {

        const char* detectorName  = parent( )->name( );
        const char* conditionName = name( );

      // Find the LastInterval

        BdbObsoleteDatabase db( detectorName );

        BdbStatus status;
        BdbHandle(BdbIntervalR) lastIntervalH;

        status = db.lastInterval( lastIntervalH, conditionName ); 
        if( BdbcSuccess != status || BdbIsNull(lastIntervalH)) {
            cout << errorStr << endl
                 << "    Failed to locate the LastInterval for:" << endl
                 << "        DETECTOR   : \"" << detectorName  << "\"" << endl
                 << "        CONDITION  : \"" << conditionName << "\"" << endl;
            break;
        }

      // Do the actual split only if the specified time falls inside the last interval,
      // excluding its begin and end (+Infinity).

        if(( lastIntervalH->beginTime( ) < theTime ) && ( theTime < lastIntervalH->endTime( ))) {
            if( BdbcSuccess != db.split( conditionName, theTime )) {
                cout << errorStr << endl
                     << "    Failed to split the LastInterval for:" << endl
                     << "        DETECTOR   : \"" << detectorName  << "\"" << endl
                     << "        CONDITION  : \"" << conditionName << "\"" << endl
                     << "        SPLIT TIME : \"" << theTime       << "\"" << endl;
                break;
            }
        }

      // Done

        result = CdbStatus::Success;

    } while( false );

    return result;
}

CdbBdbWCondition::CdbBdbWCondition( const CdbFolderPtr& theFolderPtr,
                                    const char*         theName ) :
    CdbCondition( theFolderPtr,
                  theName )
{ }

CdbBdbWCondition::~CdbBdbWCondition( )
{ }

bool
CdbBdbWCondition::isValid( )
{
    return true;
}

bool
CdbBdbWCondition::isOpen( )
{
    return true;
}

CdbStatus
CdbBdbWCondition::open( )
{
    return CdbStatus::Success;
}

CdbStatus
CdbBdbWCondition::close( )
{
    return CdbStatus::Success;
}

CdbStatus
CdbBdbWCondition::findRevision( CdbRevisionPtr& thePtr,
                                const BdbTime&  theId,
                                unsigned short  thePartitionId )
{
    CdbStatus result = CdbStatus::Error;

    thePtr = 0;

    do {

      // Shortcat for the "TOPMOST" revision ID.

        if( BdbTime::plusInfinity == theId ) {

          // DESIGN NOTE: We need to construct a smart pointer against a clone since
          //              we don't know a smart pointer pointing to the current
          //              instance, therefore we can't guarantee the lifetime
          //              of the current instance.

            CdbConditionPtr myPtr( this->clone( ));
            thePtr = new CdbBdbWRevision( myPtr,
                                          theId,
                                          "<topmost>",
                                          BdbTime::plusInfinity,        // creation time
                                          "It's TOPMOST layer",         // description
                                          BdbCondRevision::ILLEGAL );   // "old" revision id

            result = CdbStatus::Success;
            break;
        }

      // Real revisions require to get to the persistent store.

      // Get to the Registry.

        BdbObsoleteDatabase                db( parent( )->name( ));
        BdbHandle(BdbCondRegistry) registryH;

        BdbStatus bdbStatus = db.findRegistry( registryH,
                                               name( ));
        if(( BdbcSuccess != bdbStatus ) || BdbIsNull(registryH)) break;

      // Check every single persistent revision if it matches
      // specified parameters.

        BdbItr(BdbCondRevision)    revisionItr;
        BdbHandle(BdbCondRevision) revisionH;

        registryH->setRevisionItr( revisionItr );
        while( revisionItr.next( )) {

            revisionH = revisionItr;

            BdbTime revisionCreationTime( revisionH->creationTime( ));

            char revisionIdName[11];
            sprintf( revisionIdName, "%u", (unsigned) revisionH->id( ));

          // "OLD" -> "NEW" mapping rules for revisions:
          //
          //    - We treat the creation time of the "old" revisions
          //      as the identifiers of the "new" ones.
          //
          //    - We also use the textual representation of the "old"
          //      revisions as the names of "new" revisions.

            if( theId == revisionCreationTime ) {

              // DESIGN NOTE: We need to construct a smart pointer against a clone since
              //              we don't know a smart pointer pointing to the current
              //              instance, therefore we can't guarantee the lifetime
              //              of the current instance.

                CdbConditionPtr myPtr( this->clone( ));
                thePtr = new CdbBdbWRevision( myPtr,
                                              theId,
                                              revisionIdName,
                                              revisionH->creationTime( ),
                                              revisionH->description( ),
                                              revisionH->id( ));

                result = CdbStatus::Success;
                break;
            }
        }

    } while( false );

    return result;
}

CdbStatus
CdbBdbWCondition::findRevision( CdbRevisionPtr& thePtr,
                                const char*     theName,
                                unsigned short  thePartitionId )
{
    CdbStatus result = CdbStatus::Error;

    thePtr = 0;

    do {

      // Shortcat for the "TOPMOST" revision ID.

        if( 0 == strcmp( "<topmost>", theName )) {

          // DESIGN NOTE: We need to construct a smart pointer against a clone since
          //              we don't know a smart pointer pointing to the current
          //              instance, therefore we can't guarantee the lifetime
          //              of the current instance.

            CdbConditionPtr myPtr( this->clone( ));
            thePtr = new CdbBdbWRevision( myPtr,
                                          BdbTime::plusInfinity,
                                          theName,
                                          BdbTime::plusInfinity,        // creation time
                                          "It's TOPMOST layer",         // description
                                          BdbCondRevision::ILLEGAL );   // "old" revision id

            result = CdbStatus::Success;
            break;
        }

      // Real revisions require to get to the persistent store.

      // Get to the Registry.

        BdbObsoleteDatabase                db( parent( )->name( ));
        BdbHandle(BdbCondRegistry) registryH;

        BdbStatus bdbStatus = db.findRegistry( registryH,
                                               name( ));
        if(( BdbcSuccess != bdbStatus ) || BdbIsNull(registryH)) break;

      // Check every single persistent revision if it matches
      // specified parameters.

        BdbItr(BdbCondRevision)    revisionItr;
        BdbHandle(BdbCondRevision) revisionH;

        registryH->setRevisionItr( revisionItr );
        while( revisionItr.next( )) {

            revisionH = revisionItr;

            BdbTime revisionCreationTime( revisionH->creationTime( ));

            char revisionIdName[11];
            sprintf( revisionIdName, "%u", (unsigned) revisionH->id( ));

          // "OLD" -> "NEW" mapping rules for revisions:
          //
          //    - We treat the creation time of the "old" revisions
          //      as the identifiers of the "new" ones.
          //
          //    - We also use the textual representation of the "old"
          //      revisions as the names of "new" revisions.

            if( 0 == strcmp( revisionIdName, theName )) {

              // DESIGN NOTE: We need to construct a smart pointer against a clone since
              //              we don't know a smart pointer pointing to the current
              //              instance, therefore we can't guarantee the lifetime
              //              of the current instance.

                CdbConditionPtr myPtr( this->clone( ));
                thePtr = new CdbBdbWRevision( myPtr,
                                              revisionH->creationTime( ),
                                              theName,
                                              revisionH->creationTime( ),
                                              revisionH->description( ),
                                              revisionH->id( ));

                result = CdbStatus::Success;
                break;
            }
        }

    } while( false );

    return result;
}

CdbStatus
CdbBdbWCondition::revisionIdIterator( CdbItr<BdbTime>& theItr,
                                      unsigned short   thePartitionId )
{
    CdbConditionPtr myPtr( this->clone( ));

  // ATTENTION: This is not a memory leak - the created object
  //            will be destroyed by the iterator.

    theItr = CdbItr<BdbTime>( new CdbBdbWRevisionIdItr( myPtr ));

    return CdbStatus::Success;
}

CdbStatus
CdbBdbWCondition::revisionNameIterator( CdbItr<const char*>& theItr,
                                        unsigned short       thePartitionId )
{
    CdbConditionPtr myPtr( this->clone( ));

  // ATTENTION: This is not a memory leak - the created object
  //            will be destroyed by the iterator.

    theItr = CdbItr<const char*>( new CdbBdbWRevisionNameItr( myPtr ));

    return CdbStatus::Success;
}

CdbStatus
CdbBdbWCondition::historyEventIterator( CdbHistoryEventItr& theItr,
                                        const BdbTime&      theBeginTime,
                                        const BdbTime&      theEndTime,
                                        const char**        theEventsToSelect )
{
    return CdbStatus::Error;
}

CdbStatus
CdbBdbWCondition::historyEventTypeIterator( CdbHistoryEventTypeItr& theItr )
{
    return CdbStatus::Error;
}

CdbStatus
CdbBdbWCondition::hint( BdbRefAny&     theHint,
                        const BdbTime& theBegin,
                        const BdbTime& theEnd )
{
  // Ignore tha validity range and condition name and get the hint
  // in the scope of the curren detector

    BdbObsoleteDatabase db( parent( )->name( ));

    theHint = db.updatedHint( );

    return CdbStatus::Success;
}

CdbStatus
CdbBdbWCondition::verify( const BdbRefAny&         theHint,
                          const BdbRef(BdbObject)& theObjectRef )
{
    CdbStatus result = CdbStatus::Error;

    do {

      // All we're going to check is to see if both the hint and
      // the objects are located in the same container.

        if( BdbIsNull( theHint ))      break;
        if( BdbIsNull( theObjectRef )) break;

        BdbRef(BdbContObj) hintContRef;
        BdbRef(BdbContObj) objectContRef;

        theHint.containedIn( hintContRef );
        theObjectRef.containedIn( objectContRef );

        if( BdbIsNull( hintContRef ))   break;
        if( BdbIsNull( objectContRef )) break;

        if( hintContRef == objectContRef ) result = CdbStatus::Success;

    } while( false );

    return result;
}

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

 

---

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

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