---

CdbBdbWCondition.cc

Go to the documentation of this file.

// File and Version Information:
//      $Id: CdbBdbWCondition.cc,v 1.33 2005/09/15 05:07:31 gapon Exp $

/// 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 "CdbBase/CdbId.hh"
#include "CdbBase/CdbCompositeName.hh"
#include "CdbBase/CdbDebugStream.hh"

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

#include "CdbBdbWrapper/CdbBdbWRevision.hh"
#include "CdbBdbWrapper/CdbBdbWRevisionIdItr.hh"
#include "CdbBdbWrapper/CdbBdbWRevisionNameItr.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 "ErrLogger/ErrLog.hh"

#include <stdio.h>
using std::endl;

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()
        * 
        * @return the current value the iterator is set on
        */ 
        virtual CdbObjectPtr 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)
    {
        if( theParentPtr.isNull( ))
            ErrMsg(fatal) << "a null pointer instead f a parent object passed into the constructor." << endmsg;
    }
 
    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( ),        // begin of the 'original' interval
                                                            intervalH->endTime( ),          // end   of the 'original' interval
                                                            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;
    }

    CdbObjectPtr
    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->parentDatabase( ),
                                 mySelf->name( ));
}

std::string
CdbBdbWCondition::description( ) const
{
    return std::string( "<not available in this implementation>" );
}

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

CdbCompositeName
CdbBdbWCondition::physicalName( ) const
{
    return CdbCompositeName( "<local>", name( ));
}

CdbId
CdbBdbWCondition::physicalId( ) const
{
    return CdbId( 0, 0 );
}

BdbTime
CdbBdbWCondition::created( ) const
{
    return BdbTime::minusInfinity;
}

BdbTime
CdbBdbWCondition::registered( ) const
{
    return BdbTime::minusInfinity;
}

BdbTime
CdbBdbWCondition::modified( ) const
{
    return BdbTime::minusInfinity;
}

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

        CDB_DEBUG_STREAM << "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( ),    // begin of the 'duration' interval
                                              bdbTransientInterval.endTime( ),      // end   of the 'duration' interval
                                              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 )
{ 
    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 ) {

            ErrMsg(error) << "illegal validity range for the iterator:" << endl
                          << "    DETECTOR   : \"" << detectorName << "\"" << endl
                          << "    CONDITION  : \"" << conditionName << "\"" << endl
                          << "    BEGIN TIME : "   << theBeginValidity << endl
                          << "    END   TIME : "   << theEndValidity << endmsg;
            break;
        }
 
      // Find out the revision information
 
        bool    useTopVersionFlag = true;
        d_ULong revisionId        = BdbCondRevision::BASELINE;
 
        if( BdbcSuccess != BdbCondPath::instance( )->getRevision( detectorName,
                                                                  conditionName,
                                                                  useTopVersionFlag,
                                                                  revisionId )) {

            ErrMsg(error) << "failed to obtain the revision configuration for:" << endl
                          << "    DETECTOR  : \"" << detectorName << "\"" << endl
                          << "    CONDITION : \"" << conditionName << "\"" << endmsg;
            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 ) {
            ErrMsg(error) << "failed to set up the iterator for:" << endl
                          << "    DETECTOR   : \"" << detectorName << "\"" << endl
                          << "    CONDITION  : \"" << conditionName << "\"" << endl
                          << "    BEGIN TIME : "   << theBeginValidity << endmsg;
            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::objectIterator( CdbObjectItr&            theItr,
                                  const CdbRevisionPolicy& thePolicy,
                                  const BdbTime&           theBeginValidity,
                                  const BdbTime&           theEndValidity )
{
    return objectIterator( theItr,
                           theBeginValidity,
                           theEndValidity );
}

CdbStatus
CdbBdbWCondition::originalObjectIterator( CdbObjectItr&        theItr,
                                          const BdbTime&       theBeginInsertion,
                                          const BdbTime&       theEndInsertion,
                                          const unsigned short thePartitionId )
{
    return CdbStatus::NotImplemented;
}

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 != theObjectFactory.create( 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 != theObjectFactory.create( 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 )
{
    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)) {

            ErrMsg(error) << "failed to locate the LastInterval for:" << endl
                          << "    DETECTOR   : \"" << detectorName  << "\"" << endl
                          << "    CONDITION  : \"" << conditionName << "\"" << endmsg;
            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 )) {

                ErrMsg(error) << "failed to split the LastInterval for:" << endl
                              << "    DETECTOR   : \"" << detectorName  << "\"" << endl
                              << "    CONDITION  : \"" << conditionName << "\"" << endl
                              << "    SPLIT TIME : \"" << theTime       << "\"" << endmsg;
                break;
            }
        }

      // Done

        result = CdbStatus::Success;

    } while( false );

    return result;
}

CdbBdbWCondition::CdbBdbWCondition( const CdbFolderPtr&   theFolderPtr,
                                    const CdbDatabasePtr& theDatabasePtr,
                                    const char*           theName ) :
    CdbCondition( theFolderPtr,
                  theDatabasePtr,
                  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::createRevision( CdbRevisionPtr& thePtr,
                                  const BdbTime&  theId,
                                  const char*     theName,
                                  const char*     theDescription,
                                  unsigned short  thePartitionId )
{
    return CdbStatus::NotImplemented;
}

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

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

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 //
/////////////////

---