---

CdbRooRoCondition.cc

Go to the documentation of this file.

// File and Version Information:
//      $Id: CdbRooRoCondition.cc,v 1.7 2005/06/23 23:44:43 gapon Exp $
#include "BaBar/BaBar.hh"

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

#include "CdbRooReadonly/CdbRooRoCondition.hh"

#include "CdbBase/Cdb.hh"
#include "CdbBase/CdbEnvironment.hh"
#include "CdbBase/CdbFolder.hh"
#include "CdbBase/CdbRevision.hh"
#include "CdbBase/CdbRevisionPolicy.hh"
#include "CdbBase/CdbObject.hh"
#include "CdbBase/CdbObjectFactoryBase.hh"
#include "CdbBase/CdbItr.hh"
#include "CdbBase/CdbId.hh"
#include "CdbBase/CdbCompositeName.hh"
#include "CdbBase/CdbTimeUtils.hh"
#include "CdbBase/CdbDebugStream.hh"

#include "CdbRooReadonly/CdbRooRoFolderR.hh"
#include "CdbRooReadonly/CdbRooRoViewR.hh"
#include "CdbRooReadonly/CdbRooRoView.hh"
#include "CdbRooReadonly/CdbRooRoConditionAtFolderR.hh"
#include "CdbRooReadonly/CdbRooRoPartitionR.hh"
#include "CdbRooReadonly/CdbRooRoPartitionsLayoutR.hh"
#include "CdbRooReadonly/CdbRooRoMetaDataR.hh"
#include "CdbRooReadonly/CdbRooRoConfigCollectionR.hh"
#include "CdbRooReadonly/CdbRooRoOriginR.hh"
#include "CdbRooReadonly/CdbRooRoOriginCollectionR.hh"
#include "CdbRooReadonly/CdbRooRoRevision.hh"
#include "CdbRooReadonly/CdbRooRoOiCollectionR.hh"
#include "CdbRooReadonly/CdbRooRoFileUtils.hh"
#include "CdbRooReadonly/CdbRooRoOiR.hh"
#include "CdbRooReadonly/CdbRooRoSimpleConfigIterator.hh"
#include "CdbRooReadonly/CdbRooRoCi.hh"
#include "CdbRooReadonly/CdbRooRoObject.hh"
#include "CdbRooReadonly/CdbRooRoRClusterR.hh"
#include "CdbRooReadonly/CdbRooRoRClusterCollectionR.hh"
#include "CdbRooReadonly/CdbRooRoConditionCollectionR.hh"

#include "BdbTime/BdbTime.hh"

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

#include <vector>
#include <stack>
using std::cout;
using std::cerr;
using std::endl;
using std::ends;

namespace {

  /// Calculate the full path for the condition
  /**
    * The path would include all preceeding folders and the specified condition
    * itself.
    *
    * The method will return an empty path containing "" in case of any problem met
    * while calculating the path.
    *
    * NOTE: For conditions found via their 'physical' names or addresses the nethod
    *       will return that empty path since their (CdbCondition) API objects
    *       do not have any parent folders or views.
    * 
    * @see class CdbCondition
    */ 
    std::string fullPathName( const CdbRooRoCondition* theConditionPtr );

  /// Find MetaData object(s) for specified condition
  /**
    * DESIGN NOTE:
    *
    *   This operation is put out of the current class's context to make it usable by other classes
    *   defined in the scope of the current implementation file.
    *
    * The contence of the output vector varies depending on the values of flags
    * passed to the function.
    *
    *     - if "allIncrementsFlag" is set (true) then metadata objects will be
    *       found for all increments. Then the increments numbers can be used to
    *       as the vector's indexes to fet to tyhe corresponding meta-data.
    *       The subsequent parameters are ignored in this case.
    *
    *     - else if "recentIncrementFlag" is set then the output vector will only
    *       containe the metadata reference for the most recently created increment.
    *
    *     - else the specified increment number will be used to locate the corresponding
    *       metadata object.
    *
    * The partition identifier is only used if the corresponding condition
    * is the partitionable.
    *
    * IMPORTANT NOTE: The procedure will use the condition's creation time
    *                 when looking for a subset of increments including or newer
    *                 than that time. The reason is that conditions could be created
    *                 later on when a number of increments for a cluster/partition may
    *                 already exist.
    */
    CdbStatus findMetaData( std::vector< CdbCPtr< CdbRooRoMetaDataR > >& theVectorOfPtrs,
                            const CdbCPtr< CdbRooRoRegistry >&           theMasterRegistryPtr,
                            const CdbCPtr< CdbRooRoRegistry >&           theLocalRegistryPtr,
                            const CdbId&                                 theExtendedConditionId,
                            UShort_t                                     thePartitionId,
                            bool                                         allIncrementsFlag   = true,
                            bool                                         recentIncrementFlag = true,
                            UShort_t                                     theIncrementNumber  = 0 );

  /// An implementation class for the iterator of revision identifiers
  /**
    * @see class CdbItr
    */
    class RevisionIdIterator : public CdbItr<BdbTime>::InterfaceType {

    private:

        RevisionIdIterator( );

        RevisionIdIterator& operator=( const RevisionIdIterator& theItr );

    protected:

        RevisionIdIterator( const RevisionIdIterator& theItr ) :
            _metaDataPtrs       (theItr._metaDataPtrs),
            _isValid            (theItr._isValid),
            _hasEverBeenAdvanced(theItr._hasEverBeenAdvanced),
            _value              (theItr._value),
            _itr                (theItr._itr),
            _revItr             (theItr._revItr)
        { }

    public:


        RevisionIdIterator( const std::vector< CdbCPtr< CdbRooRoMetaDataR > >& theMetaDataPtrs ) :
            _metaDataPtrs       (theMetaDataPtrs),
            _isValid            (false),
            _hasEverBeenAdvanced(false)
        { }

        virtual ~RevisionIdIterator( )
        { }

        virtual CdbStatus reset( )
        {
            _isValid             = false;
            _hasEverBeenAdvanced = false;

            return CdbStatus::Success;
        }

        bool tryNext( )
        {
            if( _revItr.next( )) {
                return true;
            } else {

              // Switch to the next metaData (if any)

                ++_itr;
                if( _metaDataPtrs.end( ) != _itr ) {

                    CdbCPtr< CdbRooRoMetaDataR > mdPtr = (*_itr);
                    if( CdbStatus::Success != mdPtr->revisionIdIterator( _revItr )) {
                        return false;
                    }
                    return tryNext( );
                }
            }
            return false;
        }

        virtual bool next( )
        {
            if( _hasEverBeenAdvanced && !_isValid ) {
                return _isValid;        // stay in "past the last element" state
            }

            if( !_hasEverBeenAdvanced ) {
                _hasEverBeenAdvanced = true;

                _itr = _metaDataPtrs.begin( );
                if( _metaDataPtrs.end( ) == _itr ) {
                    _isValid = false;
                    return _isValid;    // go into the "past the last element" state      
                }
                CdbCPtr< CdbRooRoMetaDataR > mdPtr = (*_itr);

                if( CdbStatus::Success != mdPtr->revisionIdIterator( _revItr )) {
                    _isValid = false;
                    return _isValid;    // go into the "past the last element" state      
                }

              // At this point _itr points onto the very first MetaData in the vector
              // and _revItr is just before the very first revision of this metadata.
            }

          // At this point _itr points onto some MetaDat ain the vector
          // and _revItr is before the next element we're intrested in (if still there
          // is some in this MetaData).

            if( tryNext( )) {
                _value = _revItr.value( );
                _isValid = true;
            } else {
                _isValid = false;   // go into the "past the last element" state
            }
            return _isValid;
        }

        virtual ValueType value( )
        {
            if( _isValid ) {
                return _value;
            }
            return BdbTime::minusInfinity;
        }

        virtual bool isValid( )
        {
            return _isValid;
        }

        virtual InterfaceType* clone( ) const
        {
            return new RevisionIdIterator( *this );
        }

    private:

        std::vector< CdbCPtr< CdbRooRoMetaDataR > > _metaDataPtrs;

        bool _isValid;
        bool _hasEverBeenAdvanced;

        BdbTime _value;

      // A pointer onto the current element at the above defined vector of
      // metadata references.

        std::vector< CdbCPtr< CdbRooRoMetaDataR > >::const_iterator _itr;

      // The current iterator for the currently indexed metadata reference.

        CdbItr<BdbTime> _revItr;
    };

  /// An implementation class for the iterator of revision names
  /**
    * @see class CdbItr
    */
    class RevisionNameIterator : public CdbItr<const char*>::InterfaceType {

    private:

        RevisionNameIterator( );

        RevisionNameIterator& operator=( const RevisionNameIterator& theItr );

    protected:

        RevisionNameIterator( const RevisionNameIterator& theItr ) :
            _metaDataPtrs       (theItr._metaDataPtrs),
            _isValid            (theItr._isValid),
            _hasEverBeenAdvanced(theItr._hasEverBeenAdvanced),
            _value              (theItr._value),
            _itr                (theItr._itr),
            _revItr             (theItr._revItr)
        { }

    public:

        RevisionNameIterator( const std::vector< CdbCPtr< CdbRooRoMetaDataR > >& theMetaDataPtrs ) :
            _metaDataPtrs       (theMetaDataPtrs),
            _isValid            (false),
            _hasEverBeenAdvanced(false),
            _value("")
        { }

        virtual ~RevisionNameIterator( )
        { }

        virtual CdbStatus reset( )
        {
            _isValid             = false;
            _hasEverBeenAdvanced = false;

            return CdbStatus::Success;
        }

        bool tryNext( )
        {
            if( _revItr.next( )) {
                return true;
            } else {

              // Switch to the next metaData (if any)

                ++_itr;
                if( _metaDataPtrs.end( ) != _itr ) {

                    CdbCPtr< CdbRooRoMetaDataR > mdPtr = (*_itr);
                    if( CdbStatus::Success != mdPtr->revisionNameIterator( _revItr )) {
                        return false;
                    }
                    return tryNext( );
                }
            }
            return false;
        }

        virtual bool next( )
        {
            if( _hasEverBeenAdvanced && !_isValid ) {
                return _isValid;        // stay in "past the last element" state
            }

            if( !_hasEverBeenAdvanced ) {
                _hasEverBeenAdvanced = true;

                _itr = _metaDataPtrs.begin( );
                if( _metaDataPtrs.end( ) == _itr ) {
                    _isValid = false;
                    return _isValid;    // go into the "past the last element" state      
                }
                CdbCPtr< CdbRooRoMetaDataR > mdPtr = (*_itr);

                if( CdbStatus::Success != mdPtr->revisionNameIterator( _revItr )) {
                    _isValid = false;
                    return _isValid;    // go into the "past the last element" state      
                }

              // At this point _itr points onto the very first MetaData in the vector
              // and _revItr is just before the very first revision of this metadata.
            }

          // At this point _itr points onto some MetaDat ain the vector
          // and _revItr is before the next element we're intrested in (if still there
          // is some in this MetaData).

            if( tryNext( )) {
                _value = _revItr.value( );
                _isValid = true;
            } else {
                _isValid = false;   // go into the "past the last element" state
            }
            return _isValid;
        }

        virtual ValueType value( )
        {
            if( _isValid ) {
                return _value.c_str( );
            }
            return 0;
        }

        virtual bool isValid( )
        {
            return _isValid;
        }

        virtual InterfaceType* clone( ) const
        {
            return new RevisionNameIterator( *this );
        }

    private:

        std::vector< CdbCPtr< CdbRooRoMetaDataR > > _metaDataPtrs;

        bool _isValid;
        bool _hasEverBeenAdvanced;

        std::string _value;

      // A pointer onto the current element at the above defined vector of
      // metadata references.

        std::vector< CdbCPtr< CdbRooRoMetaDataR > >::const_iterator _itr;

      // The current iterator for the currently indexed metadata reference.

        CdbItr<const char*> _revItr;
    };

  ////////////////////////////////////////
  // Class: PartitionableObjectIterator //
  ////////////////////////////////////////

    class PartitionableObjectIterator : public CdbObjectItr::InterfaceType {

    private:

      // These forms of object construction are not implemented

        PartitionableObjectIterator( );

        PartitionableObjectIterator& operator=( const PartitionableObjectIterator& theItr );

    protected:

      // This form of the constructor is only used by the clone operation

        PartitionableObjectIterator( const PartitionableObjectIterator& theItr );

    public:

      /// Normal constructor
      /**
        * If the configuration collection parameter is pointing onto a zero object
        * then the revision policy must be used.
        */
        PartitionableObjectIterator( const CdbConditionPtr&             theParentPtr,
                                     const BdbTime&                     theBegin,
                                     const BdbTime&                     theEnd,
                                     const CdbItr< CdbConfigElement >&  theConfigItr,
                                     const CdbCPtr< CdbRooRoRegistry >& theMasterRegistryPtr,
                                     const CdbCPtr< CdbRooRoRegistry >& theLocalRegistryPtr,
                                     const CdbId&                       theExtendedConditionId,
                                     const BdbTime&                     theConditionCreationTime );

        virtual ~PartitionableObjectIterator( );

      // Methods implementing public interface of the geneic iterator

        virtual CdbStatus reset( );

        virtual bool next( );

        virtual ValueType value( );

        virtual bool isValid( );

        virtual InterfaceType* clone( ) const;

    private:

      // Helpers

        bool tryNextObject( );

        bool tryNextPartition( const BdbTime& theBeginTime,
                               const BdbTime& theEndTime );

        bool tryNextConfigElement( );

        bool findPartition( CdbCPtr< CdbRooRoPartitionR >& thePersistentPartitionPtr,
                            UShort_t                       thePartitionId );

    private:

      // Parameters

        CdbConditionPtr _parent;

        BdbTime _begin;
        BdbTime _end;

        CdbItr< CdbConfigElement > _configItr;

        CdbCPtr< CdbRooRoRegistry > _masterRegistryPtr;
        CdbCPtr< CdbRooRoRegistry > _localRegistryPtr;

        CdbId _extendedConditionId;

        BdbTime _conditionCreationTime;

      // The current state

        bool _isValid;
        bool _hasEverBeenAdvanced;

        CdbObjectPtr _value;

      // The context : configuration element

        BdbTime _beginConfig;
        BdbTime _endConfig;
        BdbTime _revisionId;

      // Other contexts to follow as a hierarchy of objects of two nested
      // classes MD and PARTITION. These classes are also used by the iterator
      // set up and next element location algorithms.
      //
      // DESIGN NOTES: In the current design the PARTITION object contains
      //               objects of the MD class. MD objects describe MetaData
      //               for the container PARTITION.
      //               There is one PARTITION descrybing the current context
      //               (a data member of _cxt defined below) in which the iterator
      //               is. The previous contexts (if any) are put into the stack
      //               of PARTITION-s.

    public:

      // NOTE: This class lives in the public scope since it's used
      //       by the PARTITION class defined below

        class MD {

        public:

            MD( );

            MD( const CdbCPtr< CdbRooRoMetaDataR >& theMetaDataPtr,
                const BdbTime&                      theRevisionId );

            MD( const CdbCPtr< CdbRooRoMetaDataR >& theMetaDataPtr,
                const CdbItr<CdbRooRoCi>&           theObjectItr,
                const BdbTime&                      theRevisionId,
                const BdbTime&                      theBeginTime,
                const BdbTime&                      theEndTime );

            MD( const MD& theMd );

            ~MD( );

            MD& operator=( const MD& theMd );

        public:

            CdbCPtr< CdbRooRoMetaDataR > mdPtr;

            CdbItr<CdbRooRoCi> itr;

            BdbTime revision;
            BdbTime begin;
            BdbTime end;

            bool inHole;

            CdbItr< CdbRooRoPartitionIntervalR > pItr;
        };

    private:

        class PARTITION {

          // We need this definition in order to comply with C++ requirements
          // on the scope resolution. The problem is that MD and PARTITION
          // can't see each other since they are defined independently
          // inside the host class.

            typedef PartitionableObjectIterator::MD MD;

        public:

            PARTITION( );

            PARTITION( UShort_t                           thePartitionId,
                       const BdbTime&                     theBeginTime,
                       const BdbTime&                     theEndTime,
                       const std::vector< MD >&           theMd,
                       const std::vector< MD >::size_type theMdCurrent );

            PARTITION( const PARTITION& thePartition  );

            ~PARTITION( );

            PARTITION& operator=( const PARTITION& thePartition );

        public:

            UShort_t _partitionId;

            BdbTime _begin;
            BdbTime _end;

            std::vector< MD >            _md;
            std::vector< MD >::size_type _mdCurrent;
        };

    private:

      // The context : partition & metadata

        PARTITION             _cxt;
        std::stack<PARTITION> _previousCxt;
    };

  /////////////////////////////////////////////////////////////////
  // Implementation of the PartitionableObjectIterator::MD class //
  /////////////////////////////////////////////////////////////////

    PartitionableObjectIterator::MD::MD( )
    { }

    PartitionableObjectIterator::MD::MD( const CdbCPtr< CdbRooRoMetaDataR >& theMetaDataPtr,
                                         const BdbTime&                      theRevisionId ) :
        mdPtr   (theMetaDataPtr),
        revision(theRevisionId ),
        inHole  (false         )
    { }

    PartitionableObjectIterator::MD::MD( const CdbCPtr< CdbRooRoMetaDataR >& theMetaDataPtr,
                                         const CdbItr<CdbRooRoCi>&           theObjectItr,
                                         const BdbTime&                      theRevisionId,
                                         const BdbTime&                      theBeginTime,
                                         const BdbTime&                      theEndTime ) :
        mdPtr   (theMetaDataPtr),
        itr     (theObjectItr  ),
        revision(theRevisionId ),
        begin   (theBeginTime  ),
        end     (theEndTime    ),
        inHole  (false         )
    { }

    PartitionableObjectIterator::MD::MD( const PartitionableObjectIterator::MD& theMd ) :
        mdPtr   (theMd.mdPtr   ),
        itr     (theMd.itr     ),
        revision(theMd.revision),
        begin   (theMd.begin   ),
        end     (theMd.end     ),
        inHole  (theMd.inHole  ),
        pItr    (theMd.pItr    ) { }

    PartitionableObjectIterator::MD::~MD( )
    { }

    PartitionableObjectIterator::MD&
    PartitionableObjectIterator::MD::operator=( const PartitionableObjectIterator::MD& theMd )
    {
        if( this != &theMd ) {
            mdPtr    = theMd.mdPtr;
            itr      = theMd.itr;
            revision = theMd.revision;
            begin    = theMd.begin;
            end      = theMd.end;
            inHole   = theMd.inHole;
            pItr     = theMd.pItr;
        }
        return *this;
    }

  ////////////////////////////////////////////////////////////////////////
  // Implementation of the PartitionableObjectIterator::PARTITION class //
  ////////////////////////////////////////////////////////////////////////

    PartitionableObjectIterator::PARTITION::PARTITION( )
    { }

    PartitionableObjectIterator::PARTITION::PARTITION( UShort_t                           thePartitionId,
                                                       const BdbTime&                     theBeginTime,
                                                       const BdbTime&                     theEndTime,
                                                       const std::vector< MD >&           theMd,
                                                       const std::vector< MD >::size_type theMdCurrent ) :
        _partitionId(thePartitionId),
        _begin      (theBeginTime  ),
        _end        (theEndTime    ),
        _md         (theMd         ),
        _mdCurrent  (theMdCurrent  )
    { }

    PartitionableObjectIterator::PARTITION::PARTITION( const PartitionableObjectIterator::PARTITION& thePartition  ) :
        _partitionId(thePartition._partitionId),
        _begin      (thePartition._begin      ),
        _end        (thePartition._end        ),
        _md         (thePartition._md         ),
        _mdCurrent  (thePartition._mdCurrent  )
    { }

    PartitionableObjectIterator::PARTITION::~PARTITION( )
    { }

    PartitionableObjectIterator::PARTITION&
    PartitionableObjectIterator::PARTITION::operator=( const PartitionableObjectIterator::PARTITION& thePartition )
    {
        if( this != &thePartition ) {
            _partitionId = thePartition._partitionId;
            _begin       = thePartition._begin;
            _end         = thePartition._end;
            _md          = thePartition._md;
            _mdCurrent   = thePartition._mdCurrent;
        }
        return *this;
    }

  /////////////////////////////////////////////////////////////
  // Implementation of the PartitionableObjectIterator class //
  /////////////////////////////////////////////////////////////

    PartitionableObjectIterator::PartitionableObjectIterator( const PartitionableObjectIterator& theItr ) :

        _parent               (theItr._parent),
        _begin                (theItr._begin),
        _end                  (theItr._end),
        _configItr            (theItr._configItr),
        _masterRegistryPtr    (theItr._masterRegistryPtr),
        _localRegistryPtr     (theItr._localRegistryPtr),
        _extendedConditionId  (theItr._extendedConditionId),
        _conditionCreationTime(theItr._conditionCreationTime),

        _isValid              (theItr._isValid),
        _hasEverBeenAdvanced  (theItr._hasEverBeenAdvanced),
        _value                (theItr._value),

        _beginConfig          (theItr._beginConfig),
        _endConfig            (theItr._endConfig),
        _revisionId           (theItr._revisionId),

        _cxt                  (theItr._cxt),
        _previousCxt          (theItr._previousCxt)
    { }

    PartitionableObjectIterator::PartitionableObjectIterator( const CdbConditionPtr&             theParentPtr,
                                                              const BdbTime&                     theBegin,
                                                              const BdbTime&                     theEnd,
                                                              const CdbItr< CdbConfigElement >&  theConfigItr,
                                                              const CdbCPtr< CdbRooRoRegistry >& theMasterRegistryPtr,
                                                              const CdbCPtr< CdbRooRoRegistry >& theLocalRegistryPtr,
                                                              const CdbId&                       theExtendedConditionId,
                                                              const BdbTime&                     theConditionCreationTime ) :
        _parent               (theParentPtr),
        _begin                (theBegin),
        _end                  (theEnd),
        _configItr            (theConfigItr),
        _masterRegistryPtr    (theMasterRegistryPtr),
        _localRegistryPtr     (theLocalRegistryPtr),
        _extendedConditionId  (theExtendedConditionId),
        _conditionCreationTime(theConditionCreationTime),
        _isValid              (false),
        _hasEverBeenAdvanced  (false)
    { }

    PartitionableObjectIterator::~PartitionableObjectIterator( )
    { }

    CdbStatus
    PartitionableObjectIterator::reset( )
    {
        _isValid             = false;
        _hasEverBeenAdvanced = false;

        return CdbStatus::Success;
    }

    bool
    PartitionableObjectIterator::next( )
    {
        if( _hasEverBeenAdvanced ) {
            if( ! _isValid ) {

              // Stay at BEYOND_PAST_ELEMENT state

                ;

            } else {

              // Try to get next object...

                _isValid = tryNextObject( );
            }

        } else {

          // Set up initial context of the iterator. Then proceed down
          // to the first object of the collection starting from the configuration.

            _configItr.reset( );

            _hasEverBeenAdvanced = true;
            _isValid             = tryNextConfigElement( );
        }
        return _isValid;
    }

    PartitionableObjectIterator::ValueType
    PartitionableObjectIterator::value( )
    {
        if( ! _isValid ) {
            assert( 0 );
        }
        return _value;
    }

    bool
    PartitionableObjectIterator::isValid( )
    {
        return _isValid;
    }

    PartitionableObjectIterator::InterfaceType*
    PartitionableObjectIterator::PartitionableObjectIterator::clone( ) const
    {
        return new PartitionableObjectIterator( *this );
    }

    bool
    PartitionableObjectIterator::tryNextPartition( const BdbTime& theBeginTime,
                                                   const BdbTime& theEndTime )
    {
        const char* debugStr = "CdbRooRoCondition::PartitionableObjectIterator::tryNextPartition()";
        const char* errorStr = "CdbRooRoCondition::PartitionableObjectIterator::tryNextPartition() -- ERROR";

/*********************************************************************************************/
if( CdbEnvironment::getDebugMode( ) != 0 )
    cout << debugStr << endl
         << "{" << endl
         << "    Trying to set up partition iterator below the 'hole' at the bottom MD" << endl
         << "    of the current partition." << endl
         << "        _cxt._partitionId = " << _cxt._partitionId << endl
         << "        theBeginTime      = " << CdbTimeUtils::time2string( theBeginTime ) << endl
         << "        theEndTime        = " << CdbTimeUtils::time2string( theEndTime   ) << endl
         << "}" << endl;
/*********************************************************************************************/

      // Find the bottom insertion time of the current partition.

        CdbCPtr< CdbRooRoPartitionR > persistentPartitionPtr;

        if( CdbStatus::Success != _masterRegistryPtr->partitionsLayout( )->find( _cxt._partitionId,
                                                                                 persistentPartitionPtr )) {
            cerr << errorStr << endl
                 << "    The database could be corrupted or be in an inconsistent state." << endl;
            assert( 0 );
            return false;
        }

      // Set up the iterator of partitions below the found bottom time
      // and withing the limits of a hole passed as parameters to the current method.

        _cxt._md[_cxt._mdCurrent].pItr = _masterRegistryPtr->partitionsLayout( )->iterator( persistentPartitionPtr->cell( ).beginInsertion( ),
                                                                                            theBeginTime,
                                                                                            theEndTime );

      // Set up special flag to engage the partition iterator when
      // calling the "tryNextObject()" method below.

        _cxt._md[_cxt._mdCurrent].inHole = true;

        return tryNextObject( );
    }

    bool
    PartitionableObjectIterator::tryNextObject( )
    {
        const char* debugStr = "CdbRooRoCondition::PartitionableObjectIterator::tryNextObject()";
        const char* errorStr = "CdbRooRoCondition::PartitionableObjectIterator::tryNextObject() -- ERROR";

        assert( _cxt._md.size( ) > 0 );
        assert( _cxt._mdCurrent < _cxt._md.size( ));

/******************************************************************/
if( CdbEnvironment::getDebugMode( ) != 0 )
    cout << debugStr << endl
         << "{" << endl
         << "    ENTERING THE METHOD..." << endl
         << "}" << endl;
/******************************************************************/

      // Check if we're running in the 'hole'. Then we'd need to try advancing
      // the partition iterator one step forward and get the whole stack of metada data
      // of this partition. Then we push current context into the stack and proceed as usually.
      //
      // NOTE: If we find "closed" partitions, whose upper "insertion" time boundry is older
      //       than the creation time of the condition then we do not jump down into these partitions
      //       and skip them and go to the next element of the partitions iterator.

        if( _cxt._md[_cxt._mdCurrent].inHole ) {

            bool found = false;

            while( _cxt._md[_cxt._mdCurrent].pItr.next( )) {

              // We're staying in this loop till the end of the iterator of partitions
              // because this iterator was supposed to be set up exactly for the duration of
              // the current "hole" we're in.

                CdbRooRoPartitionIntervalR iVal = _cxt._md[_cxt._mdCurrent].pItr.value( );

                if( !iVal.isEmpty( )) {

                  // Make this test before switching context. It's meant to reassure
                  // that partitions iterator delivers correct partitions.

                    assert( _cxt._md[_cxt._mdCurrent].begin <= iVal.begin( ));
                    assert( iVal.end( ) <= _cxt._md[_cxt._mdCurrent].end );

                  // Find out the partition to see if it's in the "closed" state. If so then we need
                  // to check if its upper "insertion" time boundry is not older than the creation
                  // time of the condition. If it happens that the condition is newer than the partition
                  // closeout time then we just bail out since there should not be any MetaData information
                  // in this partition for our current condition. Then we skip this partition.

                    {
                        UShort_t partitionId = iVal.id( );

                        CdbCPtr< CdbRooRoPartitionR > persistentPartitionPtr;
                        if( !findPartition( persistentPartitionPtr,
                                            partitionId )) {
                            cerr << errorStr << endl
                                 << "    Failed to locate the partition with ID=" << partitionId << endl;
                            return false;
                        }

/******************************************************************/
if( CdbEnvironment::getDebugMode( ) != 0 )
    cout << debugStr << endl
         << "{" << endl
         << "    Found partition ID=" << persistentPartitionPtr->id( ) << endl
         << "}" << endl;
/******************************************************************/

                        if( persistentPartitionPtr->isClosed( )) {
                            CdbRooRoCellR pCell = persistentPartitionPtr->cell( );
                            if( pCell.endInsertion( ) <= _conditionCreationTime ) {

/**********************************************************************************************************************/
if( CdbEnvironment::getDebugMode( ) != 0 )
    cout << debugStr << endl
         << "{" << endl
         << "    The above found partition required by the current configuration interval is already 'closed'" << endl
         << "    and its upper 'insertion' time limit is older than the creation time of the current condition." << endl
         << "    Skipping the current configuration interval." << endl
         << "        partitionId            : " << partitionId << endl
         << "        _conditionCreationTime : " << _conditionCreationTime << endl
         << "        pCell.endInsertion     : " << pCell.endInsertion( ) << endl
         << "}" << endl;
/**********************************************************************************************************************/

                                continue;
                            }
                        }
                    }

                  // Okay. This partition is fine. Dive into the partition.

                  // ATTENTION:
                  //
                  //   Before diving we should reset the current iterator of objects
                  //   to begin where the just found partition ends. We need it to resume
                  //   iteration of objects from that time after we'll return from this partition.
                  //
                  //     [ Otherwise we may miss the rest of the current context, which can easily happen
                  //       for example of the current hole is longer than a partition we're going
                  //       to dive in. If we didn't do this then we would just miss any information
                  //       between the end of the partition we're diving in and the end of the current 'hole'. ]
                  //
                  //    NOTE_1: In fact we have a similar (although not the same) problem when diving into
                  //            MetaData within the same partition. However this problem is already solved below.
                  //            These two cases are not equal because when we're diving into MetaDate only then
                  //            we always reset its parameters (begin, end and iterator) since we use this MD object
                  //            for the 'hole' only. Meanwhile in the current (diving into another partition case)
                  //            we are not modifying the end time of the MD context, which we're going to reuse. Therefore we
                  //            just can't modify the limits (begin, end) of the current context, just the iterator.
                  //
                  //    NOTE_2: Pay attention that iterator is reset only if the partition interval's where
                  //            we're going to dive into does not last till +Infinity. In this specific case
                  //            it does not make any sense to reset the iterator and also the iterator initialization
                  //            operatio will simply fail to set up the iterator for the interval: [+Infinity,+Infinity).
                  //
                  //    NOTE_3: A similar to the previous NOTE_2 comment is that we'll reset the iterator
                  //            only if the partition below wher we're going to dive into ends strictly
                  //            _before_ the current one does. Otherwise we will wrongfully try to set up
                  //            an iterator with 0 length, which will cause complains from the iterator.

                    if(( BdbTime::plusInfinity != iVal.end( )) && ( iVal.end( ) < _cxt._md[_cxt._mdCurrent].end )) {

                        _cxt._md[_cxt._mdCurrent].begin = iVal.end( );

/**************************************************************************************************************************************/
if( CdbEnvironment::getDebugMode( ) != 0 )
    cout << debugStr << endl
         << "{" << endl
         << "    Resetting object iterator before to diving into a partition below the 'hole'." << endl
         << "    _cxt._md[" << _cxt._mdCurrent << "].begin    = " << CdbTimeUtils::time2string( _cxt._md[_cxt._mdCurrent].begin    ) << endl
         << "    _cxt._md[" << _cxt._mdCurrent << "].end      = " << CdbTimeUtils::time2string( _cxt._md[_cxt._mdCurrent].end      ) << endl
         << "    _cxt._md[" << _cxt._mdCurrent << "].revision = " << CdbTimeUtils::time2string( _cxt._md[_cxt._mdCurrent].revision ) << endl
         << "}" << endl;
/**************************************************************************************************************************************/

                        if( CdbStatus::Success != _cxt._md[_cxt._mdCurrent].mdPtr->objectIterator( _cxt._md[_cxt._mdCurrent].itr,
                                                                                                   _cxt._md[_cxt._mdCurrent].revision,
                                                                                                   _cxt._md[_cxt._mdCurrent].begin,
                                                                                                   _cxt._md[_cxt._mdCurrent].end )) {
                            cerr << errorStr << endl
                                 << "    Failed to reset the iterator of objects to begin where the partition we're" << endl
                                 << "    diving in ends up." << endl;
                            return false;
                        }
                    }

                  // Save curent context

                    _previousCxt.push( _cxt );

                  // Prepare new current context
                  //
                  // NOTE: Unlike the very topmost context we're accepting all MetaData
                  //       objects. Besides we're alway using "modification" time of each
                  //       of these MD objects to determine their highest revisions.

                    _cxt._partitionId = iVal.id   ( );
                    _cxt._begin       = iVal.begin( );
                    _cxt._end         = iVal.end  ( );

/*******************************************************************************************/
if( CdbEnvironment::getDebugMode( ) != 0 )
    cout << debugStr << endl
         << "{" << endl
         << "    Diving into a partition below the 'hole'." << endl
         << "        _previousCxt.size( ) = " << _previousCxt.size( ) << endl
         << "        _cxt._partitionId    = " << _cxt._partitionId << endl
         << "        _cxt._begin          = " << CdbTimeUtils::time2string( _cxt._begin ) << endl
         << "        _cxt._end            = " << CdbTimeUtils::time2string( _cxt._end ) << endl
         << "}" << endl;

/*******************************************************************************************/

                    std::vector< CdbCPtr< CdbRooRoMetaDataR > > vectorOfMdPtrs;

                    bool allIncrementsFlag = true;

                    if( CdbStatus::Success != findMetaData( vectorOfMdPtrs,
                                                            _masterRegistryPtr,
                                                            _localRegistryPtr,
                                                            _extendedConditionId,
                                                            _cxt._partitionId,
                                                            allIncrementsFlag )) {
                        cerr << errorStr << endl
                             << "    Failed to locate the MetaData objects for the current condition/partition." << endl;
                        break;
                    }

                    _cxt._md.clear( );

                    std::vector< CdbCPtr< CdbRooRoMetaDataR > >::size_type i;
                    std::vector< CdbCPtr< CdbRooRoMetaDataR > >::size_type num = vectorOfMdPtrs.size( );

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

                        CdbCPtr< CdbRooRoMetaDataR > mdPtr;
                        mdPtr = vectorOfMdPtrs[i];

                        BdbTime modified = mdPtr->modified( );
                        assert( BdbTime::plusInfinity != modified );

                      // Check for special case of the topmost element of the stack of MD. We're going
                      // to set up both the iterator and the limits of this element since we have
                      // sufficient information for this.

                        if(( i + 1 ) >= num ) {

                          // Set up an iterator matching the revision.

                            CdbItr<CdbRooRoCi> itr;
                            if( CdbStatus::Success != mdPtr->objectIterator( itr,
                                                                             modified,
                                                                             _cxt._begin,
                                                                             _cxt._end )) {
                                cerr << errorStr << endl
                                     << "    Failed to set up the iterator." << endl;
                                return false;
                            }

                          // Top element of the stack

                            _cxt._md.push_back( MD( mdPtr,
                                                    itr,
                                                    modified,
                                                    _cxt._begin,
                                                    _cxt._end ));

                        } else {

                          // This is a MetaData object below the top

                          // We're not establishing the composite objects iterator now
                          // because we don't know yet which validity range
                          // we're going to use this iterator for. This range will be defined
                          // by a "hole" in a MD above. Setting up the iterator now would
                          // also be very inefficient since we might never use it or we would need
                          // to skip many intervals in it due to ongoing development at above
                          // iterators.

                            _cxt._md.push_back( MD( mdPtr,
                                                    modified ));
                        }
                   }

                  // Switch to the topmost MD of the prepared context

                    if( 0 == _cxt._md.size( )) {
                        cerr << errorStr << endl
                             << "    The database could be corrupted or be in an inconsistent state." << endl;
                        assert( 0 );
                        return false;
                    }
                    _cxt._mdCurrent = _cxt._md.size( ) - 1;

                  // Done with context switch

                    found = true;
                    break;
                }
            }
            if( !found ) {

              // No more partitions below current one or the hole has ended. Then just proceed
              // with the next element at the bottom of the stack trying to hit a non-empty
              // one object or reach the end of the current MetaData object.

                _cxt._md[_cxt._mdCurrent].inHole = false;
            }
        }

      // Proceed within current PARTITION context and MD

        do {

            while( _cxt._md[_cxt._mdCurrent].itr.next( )) {

                CdbRooRoCi ci = _cxt._md[_cxt._mdCurrent].itr.value( );

/**************************************************************************************************************************************/
if( CdbEnvironment::getDebugMode( ) != 0 )
    cout << debugStr << endl
         << "{" << endl
         << "    _cxt._md[" << _cxt._mdCurrent << "].begin    = " << CdbTimeUtils::time2string( _cxt._md[_cxt._mdCurrent].begin    ) << endl
         << "    _cxt._md[" << _cxt._mdCurrent << "].end      = " << CdbTimeUtils::time2string( _cxt._md[_cxt._mdCurrent].end      ) << endl
         << "    _cxt._md[" << _cxt._mdCurrent << "].revision = " << CdbTimeUtils::time2string( _cxt._md[_cxt._mdCurrent].revision ) << endl
         << "    ci = " << ci << endl
         << "}" << endl;
/**************************************************************************************************************************************/

              // Make adjustments for the validity time of the found interval if it's needed.

                BdbTime begin = ci.begin( );
                BdbTime end   = ci.end  ( );

                if( begin < _cxt._md[_cxt._mdCurrent].begin ) begin = _cxt._md[_cxt._mdCurrent].begin;
                if( end   > _cxt._md[_cxt._mdCurrent].end   ) end   = _cxt._md[_cxt._mdCurrent].end;

                assert( end >= begin );

              // Check if the validity of the found object is still within
              // the limits of the "md" entry at this level. If not then we should
              // back off to let the upper level (another "md" or "partition" or "configuration"
              // or the iterator ) to take further actions.

                if( begin >= _cxt._md[_cxt._mdCurrent].end ) {

                    _cxt._mdCurrent++;
                    if( _cxt._mdCurrent >= _cxt._md.size( )) {

                        if( _previousCxt.empty( )) return tryNextConfigElement( );

                      // One step up to previous partition

                        _cxt = _previousCxt.top( );
                        _previousCxt.pop( );

                      // Remove "inHole" flag from the previous partition's MD

                        _cxt._md[_cxt._mdCurrent].inHole = false;

                      // And proceed with next attemp to locate an object below.

                    }
                    return tryNextObject( );

                } else {

                  // Check for a "hole". If there is one then we need to go down
                  // the stack of MetaData.

                    if( ci.isEmpty( )) {

                      // If we're at the bottom of the stack then we'll try to set up
                      // an iterator for partitions below the current one to see if we
                      // could proceed down.

                        if( 0 == _cxt._mdCurrent ) {
                            return tryNextPartition( begin, end );
                        }
                        _cxt._mdCurrent--;

                      // Prepare the MD object, including its validity limits and the iterator.

                        _cxt._md[_cxt._mdCurrent].begin = begin;
                        _cxt._md[_cxt._mdCurrent].end   = end;

                        if( CdbStatus::Success != _cxt._md[_cxt._mdCurrent].mdPtr->objectIterator( _cxt._md[_cxt._mdCurrent].itr,
                                                                                                   _cxt._md[_cxt._mdCurrent].revision,
                                                                                                   _cxt._md[_cxt._mdCurrent].begin,
                                                                                                   _cxt._md[_cxt._mdCurrent].end )) {
                            cerr << errorStr << endl
                                 << "    Failed to set up the iterator." << endl;
                            return false;
                        }

                        return tryNextObject( );

                    } else {

                      // Construct the current value of the iterator and return with success.

                        _value = new CdbRooRoObject( _parent,
                                                     ci.original( ).begin( ),       // begin of "original" period
                                                     ci.original( ).end  ( ),       // begin of "original" period
                                                     begin,
                                                     end,
                                                     ci.original( ).inserted( ),    // begin of "duration" period
                                                     BdbTime::plusInfinity,         // end   of "duration" period
                                                     ci.original( ).inserted( ),
                                                     ci.original( ).object( ),
                                                     ci.original( ).legacyObjectAddress( ));
                        return true;
                    }
                }

            }

          // We may get here only if the iterator in the loop above got
          // beyond its last element while iterating over the bottom-most layer
          // of MD. So now we need either back off to the upper
          // MD object (if any), or previous partition (if any). Otherwise we back off to
          // the configuration.

            _cxt._mdCurrent++;
            if( _cxt._mdCurrent >= _cxt._md.size( )) {

                if( _previousCxt.empty( )) return tryNextConfigElement( );

              // One step up to previous partition

                _cxt = _previousCxt.top( );
                _previousCxt.pop( );

              // Remove "inHole" flag from the previous partition's MD

                _cxt._md[_cxt._mdCurrent].inHole = false;

              // And proceed with next attemp to locate an object withing the current method
              // but in the just "pop"-ped previous context.
            }

        } while( true );

        return false;
    }

    bool
    PartitionableObjectIterator::findPartition( CdbCPtr< CdbRooRoPartitionR >& thePersistentPartitionPtr,
                                                UShort_t                       thePartitionId )
    {
        const char* errorStr = "CdbRooRoCondition::PartitionableObjectIterator::findPartition() -- ERROR";

        bool result = false;
        do {

          // The temporary partition reference required by some interfaces.

            CdbCPtr< CdbRooRoPartitionR > persistentPartitionPtr;

          // The partition location can be a two-stage process, First we look for general
          // partition information at the MASTER registry. Then we need to verify if the
          // found partition belongs to the local registry. If so then we reload
          // partition information from the local registry since this partition
          // is supposed to be modified locally.

            if( CdbStatus::Success != _masterRegistryPtr->partitionsLayout( )->find( thePartitionId,
                                                                                     persistentPartitionPtr )) {
                cerr << errorStr << endl
                         << "    Failed to find a partition #" << thePartitionId << " at the master registry." << endl;
                break;
            }

            if(( _localRegistryPtr->originId( ) == persistentPartitionPtr->originId( )) &&
               ( _localRegistryPtr->originId( ) != _masterRegistryPtr->originId( ))) {

                if( CdbStatus::Success != _localRegistryPtr->partitionsLayout( )->find( thePartitionId,
                                                                                        persistentPartitionPtr )) {
                    cerr << errorStr << endl
                         << "    Failed to find a partition #" << thePartitionId << " at the local registry." << endl;
                    break;
                }
            }

          // Done.

            thePersistentPartitionPtr = persistentPartitionPtr;
            result                    = true;

        } while( false );

        return result;
    }

    bool
    PartitionableObjectIterator::tryNextConfigElement( )
    {
        const char* debugStr = "CdbRooRoCondition::PartitionableObjectIterator::tryNextConfigElement()";
        const char* errorStr = "CdbRooRoCondition::PartitionableObjectIterator::tryNextConfigElement() -- ERROR";

/******************************************************************/
if( CdbEnvironment::getDebugMode( ) != 0 )
    cout << debugStr << endl
         << "{" << endl
         << "    ENTERING THE METHOD..." << endl
         << "}" << endl;
/******************************************************************/

        while( _configItr.next( )) {

          // Get rid of any previous contexts of partitions

            _previousCxt = std::stack<PARTITION>( );

          // Get next element
          //
          // Skip the whole configuration interval if the found
          // configuration element will say so.
          //
          // ATTENTION: If the config element says "do not use revisions"
          //            then we just ignore this statement and replace it
          //            with "use topmost revisiono instead."

            CdbConfigElement in = _configItr.value( );
            if( !in.accessIsAllowed ) continue;

            _beginConfig = in.begin;
            _endConfig   = in.end;

            if( in.policy.useRevision( )) _revisionId = in.policy.revisionId( );
            else                          _revisionId = BdbTime::plusInfinity;

            _cxt._partitionId = in.policy.partitionId( );

          // Check if we need to skip or shorten this configuration element
          // because the specified iterator's range:
          //
          //     _begin   _end       ACTION:
          //          :   :
          //      [---)   :          1: skip
          //      [---:---)          2: cut on the left only
          //      [---:---:---)      3: cut on the left and on the right
          //          [---)          4: none
          //          [---:---)      5: cut on the right only
          //          :   [---)      6: finish (not found)

            if( _endConfig   <= _begin ) continue;              // #1
            if( _beginConfig >= _end   ) break;                 // #6
            if( _beginConfig < _begin  ) _beginConfig = _begin; // #2, #3
            if( _endConfig   > _end    ) _endConfig   = _end;   // #3, #5

            _cxt._begin = _beginConfig;
            _cxt._end   = _endConfig;

          // Find out the partition to see if it's in the "closed" state. If so then we need
          // to check if its upper "insertion" time boundry is not older than the creation
          // time of the condition. If it happens that the condition is newer than the partition
          // closeout time then we just bail out since there should not be any MetaData information
          // in this partition for our current condition. Then we skip this config element.

            {
                CdbCPtr< CdbRooRoPartitionR > persistentPartitionPtr;
                if( ! findPartition( persistentPartitionPtr,
                                     _cxt._partitionId )) {
                    cerr << errorStr << endl
                         << "    Failed to locate the partition with ID=" << _cxt._partitionId << endl;
                    break;
                }

/******************************************************************/
if( CdbEnvironment::getDebugMode( ) != 0 )
    cout << debugStr << endl
         << "{" << endl
         << "    Found partition ID=" << persistentPartitionPtr->id( ) << endl
         << "}" << endl;
/******************************************************************/

                if( persistentPartitionPtr->isClosed( )) {
                    CdbRooRoCellR pCell = persistentPartitionPtr->cell( );
                    if( pCell.endInsertion( ) <= _conditionCreationTime ) {

/**********************************************************************************************************************/
if( CdbEnvironment::getDebugMode( ) != 0 )
    cout << debugStr << endl
         << "{" << endl
         << "    The above found partition required by the current configuration interval is already 'closed'" << endl
         << "    and its upper 'insertion' time limit is older than the creation time of the current condition." << endl
         << "    Skipping the current configuration interval." << endl
         << "        _cxt._partitionId      : " << _cxt._partitionId << endl
         << "        _conditionCreationTime : " << _conditionCreationTime << endl
         << "        pCell.endInsertion     : " << pCell.endInsertion( ) << endl
         << "}" << endl;
/**********************************************************************************************************************/

                        continue;
                    }
                }
            }

          // Build a stack of MetaData for the found element. This operation is done
          // in the folowing steps:
          //
          //   1) Get a list of all MetaData objects for specified condition/partition.
          //
          //   2) Find the MetaData corresponding to specified revision.
          //
          //   3) Discard any MetaData-s above the one containing specified revision
          //      and keep the others.
          //
          //   4) Create a vector of objects of the nested MD class. The rules for these
          //      objects differ for the top element in the vector and thoses below it:
          //
          //      - top element always gets the original revision ID established above.
          //        Its composite objects iterator is also set up for a validity
          //        interval of the current configuration element.
          //
          //      - other elements are set up with their most recent revisions
          //        corresponding to the "modified" time of these MD objects.
          //        Their composite objects iterators are not set.

            std::vector< CdbCPtr< CdbRooRoMetaDataR > > vectorOfMdPtrs;

            bool allIncrementsFlag = true;

            if( CdbStatus::Success !=  findMetaData( vectorOfMdPtrs,
                                                     _masterRegistryPtr,
                                                     _localRegistryPtr,
                                                     _extendedConditionId,
                                                     _cxt._partitionId,
                                                     allIncrementsFlag )) {
                cerr << errorStr << endl
                     << "    Failed to locate the MetaData objects for the current condition/partition." << endl;
                break;
            }

            const std::vector< CdbCPtr< CdbRooRoMetaDataR > >::size_type numPart = vectorOfMdPtrs.size( );
            if( 0 == numPart ) {
                cerr << errorStr << endl
                     << "    There is no MetaData objects for the current condition/partition." << endl
                     << "    The condition/partition could not be properly initialized/loaded." << endl;
                break;
            }

            _cxt._md.clear( );

            for( std::vector< CdbCPtr< CdbRooRoMetaDataR > >::size_type i = 0; i < numPart; ++i ) {

                CdbCPtr< CdbRooRoMetaDataR > mdPtr;
                mdPtr = vectorOfMdPtrs[i];

                if( _revisionId >= mdPtr->minInsertion( )) {

                  // Three ways to set up the MD at the context:
                  //
                  //   1: This is for a top MD element (not nessesarily the top at the input
                  //      vector) only. This is the last MD including specified revision.
                  //
                  //        1.1: We also cover the case of the topmost revision at
                  //             "open" partitions.
                  //
                  //   2: This is a variation of the 1.1 case above for "closed" partitions.
                  //      The reason why we put it into a special case is that "closed" partitions
                  //      do not have the topmost revision. HOwever we still need to provide
                  //      backward compatibility for teh old views configured for the topmost
                  //      revision in the same way it's done for regular conditions.
                  //      Here we map the topmost revision onto the final revision of the MD object
                  //      whose actual revision iD corresponds to the revision modification timestamp.
                  //
                  //   3. In the final case of the non-top MD objects we use the modification
                  //      timestamp of the MD object as the revision identifier.

                    if((( BdbTime::plusInfinity == _revisionId ) && ( BdbTime::plusInfinity == mdPtr->maxInsertion( ))) ||
                       ( _revisionId < mdPtr->maxInsertion( ))) {

                      // -1-

                      // Set up an iterator matching the exact revision.

                        CdbItr<CdbRooRoCi> itr;
                        if( CdbStatus::Success != mdPtr->objectIterator( itr,
                                                                         _revisionId,
                                                                         _beginConfig,
                                                                         _endConfig )) {
                            cerr << errorStr << endl
                                 << "    Failed to set up the iterator." << endl;
                            return false;
                        }

                      // Top element of the stack

                        _cxt._md.push_back( MD( mdPtr,
                                                itr,
                                                _revisionId,
                                                _cxt._begin,
                                                _cxt._end ));

/**************************************************************************************************************************************/
if( CdbEnvironment::getDebugMode( ) != 0 )
    cout << debugStr << endl
         << "{" << endl
         << "    Case #1: Regular top MetaData/Increment object which has exactly the required" << endl
         << "             revision. This use case also include 'open' partition and 'topmost' revision." << endl
         << "    {" << endl
         << "        _cxt._partitionId      = " << _cxt._partitionId << endl
         << "        _cxt._begin            = " << CdbTimeUtils::time2string( _cxt._begin ) << endl
         << "        _cxt._end              = " << CdbTimeUtils::time2string( _cxt._end ) << endl
         << "        mdPtr->minInsertion( ) = " << CdbTimeUtils::time2string( mdPtr->minInsertion( )) << endl
         << "        mdPtr->maxInsertion( ) = " << CdbTimeUtils::time2string( mdPtr->maxInsertion( )) << endl
         << "        _revisionId            = " << CdbTimeUtils::time2string( _revisionId ) << endl
         << "    }" << endl
         << "}" << endl;
/**************************************************************************************************************************************/

                      // Since we found the top MD objects so we need to stop here.

                        break;

                    } else if((( numPart - 1 ) == i ) &&
                              ( BdbTime::plusInfinity == _revisionId ) &&
                              ( BdbTime::plusInfinity != mdPtr->maxInsertion( ))){

                      // -2-

                      // Set up an iterator matching the final revision of the MD object.

                        BdbTime modified = mdPtr->modified( );

                        CdbItr<CdbRooRoCi> itr;
                        if( CdbStatus::Success != mdPtr->objectIterator( itr,
                                                                         modified,
                                                                         _beginConfig,
                                                                         _endConfig )) {
                            cerr << errorStr << endl
                                 << "    Failed to set up the iterator." << endl;
                            return false;
                        }

                      // Top element of the stack

                        _cxt._md.push_back( MD( mdPtr,
                                                itr,
                                                modified,
                                                _cxt._begin,
                                                _cxt._end ));

/**************************************************************************************************************************************/
if( CdbEnvironment::getDebugMode( ) != 0 )
    cout << debugStr << endl
         << "{" << endl
         << "    Case #2. Special case of a 'closed' partition when the 'topmost' (+Infinity)" << endl
         << "             revision identifier is required by the view configuration." << endl
         << "             The solution in this case is to find out the most recent reveision in this" << endl
         << "             partition and to treat it as the topmost one. The identifier of this most" << endl
         << "             recent revision is equal to the 'modified' time of the top MetaData/Increment" << endl
         << "             object of the partition." << endl
         << "    {" << endl
         << "        _cxt._partitionId      = " << _cxt._partitionId << endl
         << "        _cxt._begin            = " << CdbTimeUtils::time2string( _cxt._begin ) << endl
         << "        _cxt._end              = " << CdbTimeUtils::time2string( _cxt._end ) << endl
         << "        mdPtr->minInsertion( ) = " << CdbTimeUtils::time2string( mdPtr->minInsertion( )) << endl
         << "        mdPtr->maxInsertion( ) = " << CdbTimeUtils::time2string( mdPtr->maxInsertion( )) << endl
         << "        modified               = " << CdbTimeUtils::time2string( modified ) << endl
         << "    }" << endl
         << "}" << endl;
/**************************************************************************************************************************************/

                    } else {

                      // -3-

                      // It will use the MetaData object's modification time
                      // time to set up the composite object iterator. We're not establishing
                      // this iterator now because we don't know yet which validity range
                      // we're going to use this iterator for. This range will be defined
                      // by a "hole" in a revision above. Setting up the iterator now would
                      // also be veru inefficient since we might never use it or we would need
                      // to skip many intervals in it due to ongoing development at above
                      // iterators.

                        BdbTime modified = mdPtr->modified( );
                        assert( BdbTime::plusInfinity != modified );

                        _cxt._md.push_back( MD( mdPtr,
                                            modified ));

/**************************************************************************************************************************************/
if( CdbEnvironment::getDebugMode( ) != 0 )
    cout << debugStr << endl
         << "{" << endl
         << "    Case #3: MetaData/Increment object below the topmost one for this partition." << endl
         << "             We should use the 'modified' time of this MetaData/Increment object as an actual" << endl
         << "             revision identifier." << endl
         << "    {" << endl
         << "        _cxt._partitionId      = " << _cxt._partitionId << endl
         << "        _cxt._begin            = " << CdbTimeUtils::time2string( _cxt._begin ) << endl
         << "        _cxt._end              = " << CdbTimeUtils::time2string( _cxt._end ) << endl
         << "        mdPtr->minInsertion( ) = " << CdbTimeUtils::time2string( mdPtr->minInsertion( )) << endl
         << "        mdPtr->maxInsertion( ) = " << CdbTimeUtils::time2string( mdPtr->maxInsertion( )) << endl
         << "        modified               = " << CdbTimeUtils::time2string( modified ) << endl
         << "    }" << endl
         << "}" << endl;
/**************************************************************************************************************************************/

                    }

                } else {

                  // We're above specified revision.

                    break;
                }
            }
            if( 0 == _cxt._md.size( )) {
                cerr << errorStr << endl
                     << "    The database could be corrupted or be in an inconsistent state." << endl;
                assert( 0 );
                return false;
            }
            _cxt._mdCurrent = _cxt._md.size( ) - 1;

/***************************************************************/
if( CdbEnvironment::getDebugMode( ) != 0 )
    cout << debugStr << endl
         << "{" << endl
         << "    _cxt._mdCurrent = " << _cxt._mdCurrent << endl
         << "}" << endl;
/***************************************************************/

          // Proceed down to the first element in the stack

            if( tryNextObject( )) return true;
        }

        return false;
    }

  //////////////////////////////////
  // Class: RegularObjectIterator //
  //////////////////////////////////

    class RegularObjectIterator : public CdbObjectItr::InterfaceType {

    private:

        RegularObjectIterator( );

        RegularObjectIterator& operator=( const RegularObjectIterator& theItr );

    protected:

        RegularObjectIterator( const RegularObjectIterator& theItr ) :

            _parent             (theItr._parent),
            _begin              (theItr._begin),
            _end                (theItr._end),
            _configItr          (theItr._configItr),
            _masterRegistryPtr  (theItr._masterRegistryPtr),
            _localRegistryPtr   (theItr._localRegistryPtr),
            _extendedConditionId(theItr._extendedConditionId),

            _isValid            (theItr._isValid),
            _hasEverBeenAdvanced(theItr._hasEverBeenAdvanced),
            _value              (theItr._value),

            _beginConfig        (theItr._beginConfig),
            _endConfig          (theItr._endConfig),
            _revisionId         (theItr._revisionId),
            _partitionId        (theItr._partitionId),

            _md                 (theItr._md),
            _mdCurrent          (theItr._mdCurrent)
        { }

    public:

      /// Normal constructor
      /**
        * If the configuration collection parameter is pointing onto a zero object
        * then the revision policy must be used.
        */
        RegularObjectIterator( const CdbConditionPtr&             theParentPtr,
                               const BdbTime&                     theBegin,
                               const BdbTime&                     theEnd,
                               const CdbItr< CdbConfigElement >&  theConfigItr,
                               const CdbCPtr< CdbRooRoRegistry >& theMasterRegistryPtr,
                               const CdbCPtr< CdbRooRoRegistry >& theLocalRegistryPtr,
                               const CdbId&                       theExtendedConditionId ) :
            _parent             (theParentPtr),
            _begin              (theBegin),
            _end                (theEnd),
            _configItr          (theConfigItr),
            _masterRegistryPtr  (theMasterRegistryPtr),
            _localRegistryPtr   (theLocalRegistryPtr),
            _extendedConditionId(theExtendedConditionId),
            _isValid            (false),
            _hasEverBeenAdvanced(false)
        { }

        virtual ~RegularObjectIterator( )
        { }

        virtual CdbStatus reset( )
        {
            _isValid             = false;
            _hasEverBeenAdvanced = false;

            return CdbStatus::Success;
        }

        bool tryNextObject( );
        bool tryNextConfigElement( );

        virtual bool next( )
        {
            if( _hasEverBeenAdvanced ) {
                if( ! _isValid ) {

                  // Stay at BEYOND_PAST_ELEMENT state

                    ;

                } else {

                  // Try to get next object...

                    _isValid = tryNextObject( );
                }

            } else {

              // Set up initial context of the iterator. Then proceed down
              // to the first object of the collection starting from the configuration.

                _configItr.reset( );

                _hasEverBeenAdvanced = true;
                _isValid             = tryNextConfigElement( );
            }
            return _isValid;
        }

        virtual ValueType value( )
        {
            if( ! _isValid ) {
                assert( 0 );
            }
            return _value;
        }

        virtual bool isValid( )
        {
            return _isValid;
        }

        virtual InterfaceType* clone( ) const
        {
            return new RegularObjectIterator( *this );
        }

    private:

      // Parameters

        CdbConditionPtr _parent;

        BdbTime _begin;
        BdbTime _end;

        CdbItr< CdbConfigElement > _configItr;

        CdbCPtr< CdbRooRoRegistry > _masterRegistryPtr;
        CdbCPtr< CdbRooRoRegistry > _localRegistryPtr;

        CdbId _extendedConditionId;

      // The current state

        bool _isValid;
        bool _hasEverBeenAdvanced;

        CdbObjectPtr _value;

      // The context : configuration element

        BdbTime _beginConfig;
        BdbTime _endConfig;
        BdbTime _revisionId;

        UShort_t _partitionId;

      // The context : meta-data

        class MD {

        public:

            MD( ) { }

            MD( const CdbCPtr< CdbRooRoMetaDataR >& theMetaDataPtr,
                const BdbTime&                      theRevisionId ) :
                mdPtr   (theMetaDataPtr),
                revision(theRevisionId ) { }

            MD( const CdbCPtr< CdbRooRoMetaDataR >& theMetaDataPtr,
                const CdbItr<CdbRooRoCi>&           theObjectItr,
                const BdbTime&                      theRevisionId,
                const BdbTime&                      theBeginTime,
                const BdbTime&                      theEndTime ) :
                mdPtr   (theMetaDataPtr),
                itr     (theObjectItr  ),
                revision(theRevisionId ),
                begin   (theBeginTime  ),
                end     (theEndTime    ) { }

            MD( const MD& theMd ) :
                mdPtr   (theMd.mdPtr   ),
                itr     (theMd.itr     ),
                revision(theMd.revision),
                begin   (theMd.begin   ),
                end     (theMd.end     ) { }

            ~MD( ) { }

            MD& operator=( const MD& theMd )
            {
                if( this != &theMd ) {
                    mdPtr    = theMd.mdPtr;
                    itr      = theMd.itr;
                    revision = theMd.revision;
                    begin    = theMd.begin;
                    end      = theMd.end;
                }
                return *this;
            }

        public:

            CdbCPtr< CdbRooRoMetaDataR > mdPtr;

            CdbItr<CdbRooRoCi> itr;

            BdbTime revision;
            BdbTime begin;
            BdbTime end;
        };
        std::vector< MD >            _md;
        std::vector< MD >::size_type _mdCurrent;

      // The context : object
    };

  ///////////////////////////////////////////////////////
  // Implementation of the RegularObjectIterator class //
  ///////////////////////////////////////////////////////

    bool
    RegularObjectIterator::tryNextObject( )
    {
        const char* debugStr = "CdbRooRoCondition::RegularObjectIterator::tryNextObject()";
        const char* errorStr = "CdbRooRoCondition::RegularObjectIterator::tryNextObject() -- ERROR";

        assert( _md.size( ) > 0 );
        assert( _mdCurrent < _md.size( ));

        do {

            while( _md[_mdCurrent].itr.next( )) {

                CdbRooRoCi ci = _md[_mdCurrent].itr.value( );

/**************************************************************************************************************/
if( CdbEnvironment::getDebugMode( ) != 0 )
    cout << debugStr << endl
         << "{" << endl
         << "    _md[" << _mdCurrent << "].begin    = " << CdbTimeUtils::time2string( _md[_mdCurrent].begin    ) << endl
         << "    _md[" << _mdCurrent << "].end      = " << CdbTimeUtils::time2string( _md[_mdCurrent].end      ) << endl
         << "    _md[" << _mdCurrent << "].revision = " << CdbTimeUtils::time2string( _md[_mdCurrent].revision ) << endl
         << "    ci = " << ci << endl
         << "}" << endl;
/**************************************************************************************************************/

              // Make adjustments for the validity time of the found interval if it's needed.

                BdbTime begin = ci.begin( );
                BdbTime end   = ci.end  ( );

                if( begin < _md[_mdCurrent].begin ) begin = _md[_mdCurrent].begin;
                if( end   > _md[_mdCurrent].end   ) end   = _md[_mdCurrent].end;

                assert( end >= begin );

              // Check if the validity of the found object is still within
              // the limits of the "md" entry at this level. If not then we should
              // back off to let the upper level (another "md" or "configuration"
              // or the iterator ) to take further actions.

                if( begin >= _md[_mdCurrent].end ) {

                    _mdCurrent++;
                    if( _mdCurrent >= _md.size( )) return tryNextConfigElement( );

                    return tryNextObject( );

                } else {

                  // Check for a "hole". If there is one then we need to go down
                  // the stack of MetaData.

                    if( ci.isEmpty( )) {

                      // If we're at the bottom of the stack then we have nowhere
                      // else to look for intervals. So we'll try to proceed down along
                      // the validity time dimension hoping to hit a non-zero object.

                        if( 0 == _mdCurrent ) continue;
                        _mdCurrent--;

                      // Prepare the MD object, including its validity limits and the iterator.

                        _md[_mdCurrent].begin = begin;
                        _md[_mdCurrent].end   = end;

                        if( CdbStatus::Success != _md[_mdCurrent].mdPtr->objectIterator( _md[_mdCurrent].itr,
                                                                                         _md[_mdCurrent].revision,
                                                                                         _md[_mdCurrent].begin,
                                                                                         _md[_mdCurrent].end )) {
                            cerr << errorStr << endl
                                 << "    Failed to set up the iterator." << endl;
                            return false;
                        }

                        return tryNextObject( );

                    } else {

                      // Construct the current value of the iterator and return with success.

                        _value = new CdbRooRoObject( _parent,
                                                     ci.original( ).begin( ),       // begin of "original" period
                                                     ci.original( ).end( ),         // begin of "original" period
                                                     begin,
                                                     end,
                                                     ci.original( ).inserted( ),    // begin of "duration" period
                                                     BdbTime::plusInfinity,         // end   of "duration" period
                                                     ci.original( ).inserted( ),
                                                     ci.original( ).object( ),
                                                     ci.original( ).legacyObjectAddress( ));
                        return true;
                    }
                }

            }

          // We may gete here only of the iterator in the loop above got
          // beyond its last element while iterating over the bottom-most layer
          // of MD. So now we need either back off to the upper
          // MD object (if any). Otherwise we back off to the configuration.

            _mdCurrent++;
            if( _mdCurrent >= _md.size( )) return tryNextConfigElement( );

        } while( true );

        return false;
    }

    bool
    RegularObjectIterator::tryNextConfigElement( )
    {
        const char* debugStr = "CdbRooRoCondition::RegularObjectIterator::tryNextConfigElement()";
        const char* errorStr = "CdbRooRoCondition::RegularObjectIterator::tryNextConfigElement() -- ERROR";

        while( _configItr.next( )) {

          // Get next element
          //
          // Skip the whole configuration interval if the found
          // configuration element will say so.
          //
          // ATTENTION: If the config element says "do not use revisions"
          //            then we just ignore this statement and replace it
          //            with "use topmost revisiono instead."

            CdbConfigElement in = _configItr.value( );
            if( ! in.accessIsAllowed ) continue;

            _beginConfig = in.begin;
            _endConfig   = in.end;

            if( in.policy.useRevision( )) _revisionId = in.policy.revisionId( );
            else                          _revisionId = BdbTime::plusInfinity;

            _partitionId = in.policy.partitionId( );

          // Check if we need to skip or shorten this configuration element
          // because the specified iterator's range:
          //
          //     _begin   _end       ACTION:
          //          :   :
          //      [---)   :          1: skip
          //      [---:---)          2: cut on the left only
          //      [---:---:---)      3: cut on the left and on the right
          //          [---)          4: none
          //          [---:---)      5: cut on the right only
          //          :   [---)      6: finish (not found)

            if( _endConfig   <= _begin ) continue;              // #1
            if( _beginConfig >= _end   ) break;                 // #6
            if( _beginConfig < _begin  ) _beginConfig = _begin; // #2, #3
            if( _endConfig   > _end    ) _endConfig   = _end;   // #3, #5

          // Build a stack of MetaData for the found element. This operation is done
          // in the folowing steps:
          //
          //   1) Get a list of all MetaData objects for specified condition/partition.
          //
          //   2) Find the MetaData corresponding to specified revision.
          //
          //   3) Discard any MetaData-s above the one containing specified revision
          //      and keep the others.
          //
          //   4) Create a vector of objects of the nested MD class. The rules for these
          //      objects differ for the top element in the vector and thoses below it:
          //
          //      - top element always gets the original revision ID established above.
          //        Its composite objects iterator is also set up for a validity
          //        interval of the current configuration element.
          //
          //      - other elements are set up with their most recent revisions
          //        corresponding to the "modified" time of these MD objects.
          //        Their composite objects iterators are not set.

            std::vector< CdbCPtr< CdbRooRoMetaDataR > > vectorOfMdPtrs;

            bool allIncrementsFlag = true;

            if( CdbStatus::Success !=  findMetaData( vectorOfMdPtrs,
                                                     _masterRegistryPtr,
                                                     _localRegistryPtr,
                                                     _extendedConditionId,
                                                     _partitionId,
                                                     allIncrementsFlag )) {
                cerr << errorStr << endl
                     << "    Failed to locate the MetaData objects for the current condition/partition." << endl;
                break;
            }

            _md.clear( );

            for( std::vector< CdbCPtr< CdbRooRoMetaDataR > >::size_type i = 0; i < vectorOfMdPtrs.size( ); ++i ) {

                CdbCPtr< CdbRooRoMetaDataR > mdPtr;
                mdPtr = vectorOfMdPtrs[i];

                if( _revisionId >= mdPtr->minInsertion( )) {

                  // Check for a separate case of the top element in the stack. Don't forget
                  // about a special case when we have the topmost revision since this require
                  // more relaxing check on the upper border of the MetaData object.

                    if((( BdbTime::plusInfinity == _revisionId ) && ( BdbTime::plusInfinity == mdPtr->maxInsertion( )))
                        ||
                        ( _revisionId < mdPtr->maxInsertion( ))) {

                      // Set up an iterator matching the revision.

                        CdbItr<CdbRooRoCi> itr;
                        if( CdbStatus::Success != mdPtr->objectIterator( itr,
                                                                         _revisionId,
                                                                         _beginConfig,
                                                                         _endConfig )) {
                            cerr << errorStr << endl
                                 << "    Failed to set up the iterator." << endl;
                            return false;
                        }

                      // Top element of the stack

                        _md.push_back( MD( mdPtr,
                                           itr,
                                           _revisionId,
                                           _beginConfig,
                                           _endConfig ));

                      // At the next step we'll be above specified revision.

                        break;

                    } else {

                      // This is a MetaData object below the top

                      // It will use the MetaData object's modification time
                      // time to set up the composite object iterator. We're not establishing
                      // this iterator now because we don't know yet which validity range
                      // we're going to use this iterator for. This range will be defined
                      // by a "hole" in a revision above. Setting up the iterator now would
                      // also be veru inefficient since we might never use it or we would need
                      // to skip many intervals in it due to ongoing development at above
                      // iterators.

                        BdbTime modified = mdPtr->modified( );
                        assert( BdbTime::plusInfinity != modified );

                        _md.push_back( MD( mdPtr,
                                           modified ));
                    }

                } else {

                  // We're above specified revision.

                    break;
                }
            }
            if( 0 == _md.size( )) {
                cerr << errorStr << endl
                     << "    The database could be corrupted or be in an inconsistent state." << endl;
                assert( 0 );
                return false;
            }
            _mdCurrent = _md.size( ) - 1;

/*****************************************************/
if( CdbEnvironment::getDebugMode( ) != 0 )
    cout << debugStr << endl
         << "{" << endl
         << "    _mdCurrent = " << _mdCurrent << endl
         << "}" << endl;
/*****************************************************/

          // Proceed down to the first element in the stack

            if( tryNextObject( )) return true;
        }

        return false;
    }

  /// An implementation class for the iterator of original objects
  /**
    * @see class CdbItr
    */
    class OriginalObjectIterator : public CdbObjectItr::InterfaceType {

    private:

        OriginalObjectIterator( );

        OriginalObjectIterator& operator=( const OriginalObjectIterator& theItr );

    protected:

        OriginalObjectIterator( const OriginalObjectIterator& theItr ) :

            _parent                  (theItr._parent),
            _begin                   (theItr._begin),
            _end                     (theItr._end),
            _masterRegistryPtr       (theItr._masterRegistryPtr),
            _localRegistryPtr        (theItr._localRegistryPtr),
            _extendedConditionId     (theItr._extendedConditionId),
            _partitionId             (theItr._partitionId),
            _isValid                 (theItr._isValid),
            _hasEverBeenAdvanced     (theItr._hasEverBeenAdvanced),
            _value                   (theItr._value),
            _md                      (theItr._md),
            _mdCurrent               (theItr._mdCurrent),
            _mdCurrentOiCollectionPtr(theItr._mdCurrentOiCollectionPtr),
            _mdCurrentOi             (theItr._mdCurrentOi)
        { }

    public:

        OriginalObjectIterator( const CdbConditionPtr&             theParentPtr,
                                const BdbTime&                     theBegin,
                                const BdbTime&                     theEnd,
                                const CdbCPtr< CdbRooRoRegistry >& theMasterRegistryPtr,
                                const CdbCPtr< CdbRooRoRegistry >& theLocalRegistryPtr,
                                const CdbId&                       theExtendedConditionId,
                                const UShort_t                     thePartitionId ) :
            _parent             (theParentPtr),
            _begin              (theBegin),
            _end                (theEnd),
            _masterRegistryPtr  (theMasterRegistryPtr),
            _localRegistryPtr   (theLocalRegistryPtr),
            _extendedConditionId(theExtendedConditionId),
            _partitionId        (thePartitionId),
            _isValid            (false),
            _hasEverBeenAdvanced(false)
        { }

        virtual ~OriginalObjectIterator( )
        { }

        virtual CdbStatus reset( )
        {
            _isValid             = false;
            _hasEverBeenAdvanced = false;

            return CdbStatus::Success;
        }

        bool tryNextMetaData( );
        bool tryNextObject( );

        virtual bool next( )
        {
            const char* errorStr = "CdbRooRoCondition::OriginalObjectIterator::next() -- ERROR";

            if( _hasEverBeenAdvanced ) {
                if( ! _isValid ) {

                  // Stay at BEYOND_PAST_ELEMENT state

                    ;

                } else {

                  // Try to get next object...

                    _isValid = tryNextObject( );
                }

            } else {

                _hasEverBeenAdvanced = true;

              // Set up initial context of the iterator. Then proceed down
              // to the first object of the collection starting from the configuration.

                bool allIncrementsFlag = true;

                if( CdbStatus::Success !=  ::findMetaData( _md,
                                                           _masterRegistryPtr,
                                                           _localRegistryPtr,
                                                           _extendedConditionId,
                                                           _partitionId,
                                                           allIncrementsFlag )) {
                    cerr << errorStr << endl
                         << "    Failed to locate the MetaData objects for the current condition/partition." << endl;

                     _isValid = false;

                } else {

                    _mdCurrent = 0;     // This is the very bottom increment to begin with.

                    _mdCurrentOiCollectionPtr = _md[_mdCurrent]->originalIntervalsCollection( );

                    _mdCurrentOi = 0;   // This number will _always_ get incremented by ::tryNextObject()
                                        // method. Therefore we're safe to put 0 (which is a special
                                        // index in the cllections of 'original' intervals) into here.

                    _isValid = tryNextObject( );
                }
            }
            return _isValid;
        }

        virtual ValueType value( )
        {
            if( ! _isValid ) {
                assert( 0 );
            }
            return _value;
        }

        virtual bool isValid( )
        {
            return _isValid;
        }

        virtual InterfaceType* clone( ) const
        {
            return new OriginalObjectIterator( *this );
        }

    private:

      // Parameters

        CdbConditionPtr _parent;

        BdbTime _begin;
        BdbTime _end;

        CdbCPtr< CdbRooRoRegistry > _masterRegistryPtr;
        CdbCPtr< CdbRooRoRegistry > _localRegistryPtr;

        CdbId _extendedConditionId;

        UShort_t _partitionId;

      // The current state

        bool _isValid;
        bool _hasEverBeenAdvanced;

        CdbObjectPtr _value;

      // The context : meta-data

        std::vector< CdbCPtr< CdbRooRoMetaDataR > >            _md;
        std::vector< CdbCPtr< CdbRooRoMetaDataR > >::size_type _mdCurrent;

      // Have this pointer for the sake of optimization when traversing intervals
      // within the same MetaData.

        CdbCPtr< CdbRooRoOiCollectionR > _mdCurrentOiCollectionPtr;

        UInt_t _mdCurrentOi;    // The current index of the original intyerval in
                                // the corresponding collection of the current metadata object.
    };

    bool
    OriginalObjectIterator::tryNextMetaData( )
    {
      // Try to switch to another MetaData (if any)

        ++_mdCurrent;
        if( _mdCurrent >= _md.size( )) {

          // No more MetaData. We've reached the end.

            return false;
        }

      // Proceed to the next increment

        _mdCurrentOiCollectionPtr = _md[_mdCurrent]->originalIntervalsCollection( );
        _mdCurrentOi = 0;

        return tryNextObject( );    // This number will _always_ get incremented by ::tryNextObject()
                                    // method. Therefore we're safe to put 0 (which is a special
                                    // index in the cllections of 'original' intervals) into here.
    }

    bool
    OriginalObjectIterator::tryNextObject( )
    {
        const char* errorStr = "CdbRooRoCondition::OriginalObjectIterator::tryNextObject() -- ERROR";

        assert( _md.size( ) > 0 );
        assert( _mdCurrent < _md.size( ));
        assert( !_mdCurrentOiCollectionPtr.isNull( ));
        assert( _mdCurrentOi < _mdCurrentOiCollectionPtr->size( ));

      // Try to look for the next interval in the current MetaData or proceed
      // to the next one if the current one got exausted.

        ++_mdCurrentOi;
        if( _mdCurrentOi >= _mdCurrentOiCollectionPtr->size( )) return tryNextMetaData( );

      // Get the next 'original' interval and its 'duration' in the 'insertion' time dimension
      // then check if this interval falls into the specified 'duration' window.
      // If not then proceed to the next interval till an appropriate one would be found
      // or we'll run out of available MetaData.
      //
      // NOTE: The algorithm used below is just partially recursive. It uses plain cycle
      //       when iterating over intervals within the same MetaData and it uses
      //       recursive calls to switch to another MetaData. This's done for the sake
      //       of optimization.

        CdbRooRoOiR oi;

        BdbTime beginDuration;
        BdbTime endDuration;

        do {

            if( CdbStatus::Success != _mdCurrentOiCollectionPtr->find( _mdCurrentOi,
                                                                       oi,
                                                                       beginDuration,
                                                                       endDuration )) {
                cerr << errorStr << endl
                     << "    Failed to obtain the next 'original' interval from the current MetaData." << endl;
                return false;
            }
            if(( _begin <= oi.inserted( )) && ( oi.inserted( ) < _end )) {

              // We've found the right interval. Proceed to form the result.

                break;
            }

          // Try to look for the next interval in the current MetaData or proceed
          // to the next one if the current one got exausted.

            ++_mdCurrentOi;
            if( _mdCurrentOi >= _mdCurrentOiCollectionPtr->size( )) return tryNextMetaData( );

        } while( true );

      // Finally, convert this information into a technology & implementation transparent object.

        _value = new CdbRooRoObject( _parent,
                                     oi.begin( ),       // begin of "original" period
                                     oi.end( ),         // end   of "original" period
                                     oi.begin( ),       // begin of "visible" period (same as "original" in this context)
                                     oi.end( ),         // end   of "visible" period (same as "original" in this context)
                                     beginDuration,     // begin of "duration" period
                                     endDuration,       // end   of "duration" period
                                     oi.inserted( ),
                                     oi.object( ),
                                     oi.legacyObjectAddress( ));
        return true;
    }

  ////////////////////////////////////
  // End Of The Anonymous Namespace //
  ////////////////////////////////////
}

CdbCondition*
CdbRooRoCondition::clone( ) const
{
    return new CdbRooRoCondition( *this );
}

CdbRooRoCondition::CdbRooRoCondition( const CdbFolderPtr&                  theFolderPtr,
                                      const CdbDatabasePtr&                theDatabasePtr,
                                      const char*                          theName,
                                      const CdbId&                         thePhysicalAddress,
                                      CdbRooRoConditionAtFolderR*          thePersistentConditionAtFolderPtr,
                                      const CdbCPtr< CdbRooRoConditionR >& thePersistentConditionPtr,
                                      const CdbCPtr< CdbRooRoRegistry >&   theMasterRegistryPtr,
                                      const CdbCPtr< CdbRooRoRegistry >&   theLocalRegistryPtr ) :
    CdbCondition( theFolderPtr,
                  theDatabasePtr,
                  theName ),
    _physicalAddress               (thePhysicalAddress),
    _persistentConditionAtFolderPtr(thePersistentConditionAtFolderPtr),
    _persistentConditionPtr        (thePersistentConditionPtr),
    _masterRegistryPtr             (theMasterRegistryPtr),
    _localRegistryPtr              (theLocalRegistryPtr)
{ }

CdbRooRoCondition::CdbRooRoCondition( const CdbRooRoCondition& theCondition ) :
    CdbCondition( theCondition ),
    _physicalAddress               (theCondition._physicalAddress),
    _persistentConditionAtFolderPtr(theCondition._persistentConditionAtFolderPtr),
    _persistentConditionPtr        (theCondition._persistentConditionPtr),
    _masterRegistryPtr             (theCondition._masterRegistryPtr),
    _localRegistryPtr              (theCondition._localRegistryPtr)
{ }

CdbRooRoCondition::~CdbRooRoCondition( )
{ }

std::string
CdbRooRoCondition::description( ) const
{
    if( 0 == _persistentConditionAtFolderPtr ) return _persistentConditionPtr->description( );
    return _persistentConditionAtFolderPtr->description( );
}

bool
CdbRooRoCondition::isPartitionable( ) const
{
    return _persistentConditionPtr->isPartitionable( );
}

CdbCompositeName
CdbRooRoCondition::physicalName( ) const
{
    const char* errorStr = "CdbRooRoCondition::physicalName() -- ERROR.";

  // Get to the origin first by its identifier. We need it to get the name
  // of the origin.

    CdbCPtr< CdbRooRoOriginR > persistentOriginPtr;

    if( CdbStatus::Success != _masterRegistryPtr->originCollection( )->find( _physicalAddress.origin,
                                                                             persistentOriginPtr )) {
        cerr << errorStr << endl
             << "    Failed to obtain a persistent object describing the 'origin' for" << endl
             << "    the following ID=" << _physicalAddress.origin << endl;

        return CdbCompositeName( ); // object in the "non-valid" state
    }

  // Construct a valid object

    return  CdbCompositeName( persistentOriginPtr->name( ).c_str( ),
                              _persistentConditionPtr->name( ).c_str( ));

}

CdbId
CdbRooRoCondition::physicalId( ) const
{
    return _physicalAddress;
}

BdbTime
CdbRooRoCondition::created( ) const
{
    return _persistentConditionPtr->created( );
}

BdbTime
CdbRooRoCondition::registered( ) const
{
    if( 0 == _persistentConditionAtFolderPtr ) return _persistentConditionPtr->created( );
    return _persistentConditionAtFolderPtr->created( );
}

BdbTime
CdbRooRoCondition::modified( ) const
{
    const char* errorStr = "CdbRooRoCondition::modified() -- ERROR";

  // CONTRACT NOTE:
  //
  //    The method will always return "BdbTime::minusInfinity" in case of any failure
  //    to calculate the modification time.

    BdbTime defaultResultInCaseOfFailure = BdbTime::minusInfinity;

  /*
   * =================
   * EXECUTION PATH I: 'physical address' conditions only
   * =================
   *
   * This path is not currently implemented. A complicated algorithm to iterate
   * over a validity timeline of the "topmost" partitions would be needed for
   * PARTITIONABLE conditions. Things are trivial for REGULAR conditions though.
   * However to avoid an incomplete implementation of this part of the code let's just
   * postpone it as a whole.
   *
   * AN IDEA: Having a super-iterator composed of elementary iterators for individual
   *          "topmost" partitions would be a good idea. That would require to extend
   *          the API of P-Layout to deliver an iterator of "topmost" partitions. The
   *          one currently available does not respect non-instantiated partitions.
   */

    if( 0 == _persistentConditionAtFolderPtr ) return defaultResultInCaseOfFailure;

  /*
   * ==================
   * EXECUTION PATH II: 'view/folder/config' conditions only
   * ==================
   */

    BdbTime modificationTime = defaultResultInCaseOfFailure;
    {

      // Use the specific configuration of the condition.

        const CdbRooRoConfigCollectionR* configCollPtr = _persistentConditionAtFolderPtr->config( );
        if( 0 == configCollPtr ) {

            cerr << errorStr << endl
                 << "    The current condition has no configuration in the default view." << endl
                 << "    The application may be misconfigured." << endl
                 << "    The condition name is \"" << name( ) << "\"" << endl;

            return defaultResultInCaseOfFailure;
        }

      // Iterate through the configuration intervals to determine the result.

        CdbRooRoConfigCollectionR::IteratorOfIntervals itr = configCollPtr->iterator( );
        while( itr.next( )) {

            CdbRooRoConfigInterval configInterval = itr.value( );
            CdbRooRoConfigElementR configElement  = configInterval.value( );

          // Skeep the found element if it tells us that the corresponding range of the validity
          // timeline is not accessible for the current application.

            if( !configElement.accessIsAllowed( )) continue;

          // If we're supposed to use revisions and if this is not the 'topmost' one
          // then then we use that revision ID as the modification time.

            BdbTime cModificationTime = BdbTime::minusInfinity;
            if( configElement.useRevision( ) && ( BdbTime::plusInfinity != configElement.revision( ))) {
                cModificationTime = configElement.revision( );
            } else {

              // Otherwise we use the modification time of the most recent Meta-Data object.

                std::vector< CdbCPtr< CdbRooRoMetaDataR > > mdPtrs;

                bool allIncrementsFlag   = false;
                bool recentIncrementFlag = true;

                if( CdbStatus::Success != findMetaData( mdPtrs,
                                                        _masterRegistryPtr,
                                                        _localRegistryPtr,
                                                        _physicalAddress,
                                                        configElement.partition( ),
                                                        allIncrementsFlag,
                                                        recentIncrementFlag )) {
                    cerr << errorStr << endl
                         << "    Failed to find the most recent MetaData objects for the current condition." << endl
                         << "    The database may not be properly initialized/loaded." << endl
                         << "    The condition name is \"" << name( ) << "\"" << endl;

                    return defaultResultInCaseOfFailure;
                }
                assert( 1 == mdPtrs.size( ));

                cModificationTime = mdPtrs[0]->modified( );
            }
            assert( BdbTime::minusInfinity != cModificationTime );
            assert( BdbTime::plusInfinity  != cModificationTime );

          // Check if the found time is newer than the one we have now.

            if( cModificationTime > modificationTime ) modificationTime = cModificationTime;
        }
    }
    return modificationTime;
}

CdbStatus
CdbRooRoCondition::findObject( CdbObjectPtr&  theObjectPtr,
                               const BdbTime& theValidityTime,
                               const BdbTime& theInsertionTime )
{
    const char* errorStr = "CdbRooRoCondition::findObject() -- ERROR";

  /*
   * =================
   * EXECUTION PATH I: 'physical address' conditions only
   * =================
   *
   * If the condition is available by its 'physical address' only
   * then we don't have any asociation with views & folders, therefore no such things
   * as condition configurations are available. The "insertion" time will play a role
   * of the secondary (in addition to the validity time) key. Here are the rules
   * for different values of the insertion time and condition types
   *
   *   o if the insertion time is +Infinity then:
   *
   *     REGULAR       : the TOPMOST revision will always be used
   *
   *     PARTITIONABLE : the most recent revision of the "topmost" (at given validity time)
   *                     partition will be used. In case if this is an "open" partition
   *                     then its TOPMOST revision will be used.
   *
   *   o for any other values of the insertion time:
   *
   *     REGULAR       : the specified insertion time would be used
   *
   *     PARTITIONABLE : the specified insertion time would be used
   */

    if( 0 == _persistentConditionAtFolderPtr ) {

      // The default constructor of the policy would assume that we're going
      // to use the actual insertion time rather than any explicitly found revision.

        CdbRevisionPolicy rPolicy;

        if( BdbTime::plusInfinity == theInsertionTime ) {

          // Okay, we need to find the most recent partition & revision

            if( _persistentConditionPtr->isPartitionable( )) {

              // Find an appropriate partition for the specified validity and insertion
              // timestamps.
              //
              // @see CdbRooRoCondition::findInitialPartition()

                UShort_t partitionId = 0;
                {
                    CdbCPtr< CdbRooRoPartitionR > persistentPartitionPtr;

                    if( CdbStatus::Success != findInitialPartition( theValidityTime,
                                                                    theInsertionTime,
                                                                    persistentPartitionPtr )) {
                        cerr << errorStr << endl
                             << "    Failed to find an initial partition for the specified validity and insertion" << endl
                             << "    for a condition found by its 'physical address'." << endl
                             << "        PHYSICAL CONDITION ADDRESS : " << _physicalAddress << endl
                             << "        VALIDITY TIME              : " << CdbTimeUtils::time2string( theValidityTime )  << " : " << theValidityTime  << endl
                             << "        INSERTION TIME             : " << CdbTimeUtils::time2string( theInsertionTime ) << " : " << theInsertionTime << endl;

                        return CdbStatus::Error;
                    }
                    partitionId = persistentPartitionPtr->id( );
                }

              // Find the most recent (can be "<topmost>" if the partition is in the "open"
              // state) revision in the partition.
              //
              // NOTE: The default value for the revision is -Infinity, which we'll
              //       also use as a flag indicationg whether any revision is found
              //       or not.

                BdbTime rId = BdbTime::minusInfinity;
                {
                   // Find the most recent metadata object for the specified condition/partition

                    std::vector< CdbCPtr< CdbRooRoMetaDataR > > vectorOfMdPtrs;

                    bool allIncrementsFlag   = false;
                    bool recentIncrementFlag = true;


                    if( CdbStatus::Success != findMetaData( vectorOfMdPtrs,
                                                            _masterRegistryPtr,
                                                            _localRegistryPtr,
                                                            _physicalAddress,
                                                            partitionId,
                                                            allIncrementsFlag,
                                                            recentIncrementFlag )) {
                        cerr << errorStr << endl
                             << "    Failed to locate the most recent MetaData objects for" << endl
                             << "    the current condition/partition." << endl
                             << "        PARTITION                  : " << partitionId << endl
                             << "        PHYSICAL CONDITION ADDRESS : " << _physicalAddress << endl
                             << "        VALIDITY TIME              : " << CdbTimeUtils::time2string( theValidityTime )  << " : " << theValidityTime  << endl
                             << "        INSERTION TIME             : " << CdbTimeUtils::time2string( theInsertionTime ) << " : " << theInsertionTime << endl;

                        return CdbStatus::Error;
                    }

                  // Make sure just one metadata found. If not then something is broken
                  // in the current implementation.

                    assert( 1 == vectorOfMdPtrs.size( ));

                  // Find the most recent revision

                    CdbCPtr< CdbRooRoMetaDataR > mdPtr = vectorOfMdPtrs[0];

                    CdbItr<BdbTime> rItr;

                    if( CdbStatus::Success != mdPtr->revisionIdIterator( rItr )) {

                        cerr << errorStr << endl
                             << "    Failed to setup an iterator of revision identifiers in" << endl
                             << "    the most recent MetaData objects for the current condition/partition." << endl
                             << "        PARTITION                  : " << partitionId << endl
                             << "        PHYSICAL CONDITION ADDRESS : " << _physicalAddress << endl
                             << "        VALIDITY TIME              : " << CdbTimeUtils::time2string( theValidityTime )  << " : " << theValidityTime  << endl
                             << "        INSERTION TIME             : " << CdbTimeUtils::time2string( theInsertionTime ) << " : " << theInsertionTime << endl;

                        return CdbStatus::Error;
                    }
                    while( rItr.next( )) {
                        if( rItr.value( ) > rId ) {
                            rId = rItr.value( );
                        }
                    }

                  // Make sure we've found what we wanted to find. If not then something
                  // is broken in persistent data structures. So we don't even bother to complain
                  // in verbose form.

                    assert( BdbTime::minusInfinity != rId );
                }

            } else {

              // Just use TOPMOST revision for REGULAR conditions.

                rPolicy = CdbRevisionPolicy( BdbTime::plusInfinity, 0 );
            }
        }

      // Proceed with the policy driven search.

        return findObject( theObjectPtr,
                           rPolicy,
                           theValidityTime,
                           theInsertionTime );
    }

  /*
   * ==================
   * EXECUTION PATH II: 'view/folder/config' conditions only
   * ==================
   */

    CDB_DEBUG_STREAM
        << "CDB_FIND_OBJECT_1: condition=" << name( )
        << " validity_time=" << CdbTimeUtils::time2string( theValidityTime )
        << " insertion_time=" << CdbTimeUtils::time2string( theInsertionTime ) << endl;

    theObjectPtr = 0;

    CdbRooRoObjectIdR foundObjectId;
    CdbStatus         result = CdbStatus::Error;
    do {

      // Check if specified validity time is covered by the validity
      // interval of the current view.

        if(( theValidityTime <  parent( )->parentView( )->minValidity( )) ||
           ( theValidityTime >= parent( )->parentView( )->maxValidity( ))) {

            cerr << errorStr << endl
                 << "    Specified validity time does not fit into the validity range" << endl
                 << "    of the current view." << endl
                 << "        VIEW NAME:   \"" << parent( )->parentView( )->name( ) << "\"" << endl
                 << "        PASSED TIME: " << CdbTimeUtils::time2string( theValidityTime ) << " : " << theValidityTime << endl;
            break;
        }

      // For the specified validity time, find a configuration element which would tell
      // us how we're going to proceed with a further interval mining.
      //
      // NOTE: That we're using the default view the current application
      //       is configured with.
      //
      // ROOT I/O IMPLEMENTATION NOTE:
      //
      //    The persistentcy specific configuration element/interval
      //    has been replacd with technology neutral way of finding the default configuration.
      //    This needs to be tested well before deploying! Otherwise it's safer to revert back
      //    to the original approach.

        CdbConfigElement configElement;
        if( CdbStatus::Success != parent( )->parentView( )->get( ::fullPathName( this ).c_str( ),
                                                                 theValidityTime,
                                                                 configElement )) {
            cerr << errorStr << endl
                 << "    Failed to find the configuration element for specified validity time" << endl
                 << "    at the condition description of the  the current view." << endl
                 << "    The view may be inproperly configured." << endl
                 << "        PASSED TIME:    " << CdbTimeUtils::time2string( theValidityTime ) << " : " << theValidityTime << endl
                 << "        CONDITION NAME: \"" << name( ) << "\"" << endl
                 << "        VIEW NAME:      \"" << parent( )->parentView( )->name( ) << "\"" << endl;
            break;
        }
        if( !configElement.accessIsAllowed ) {
            cerr << errorStr << endl
                 << "    The current view prohibits accessing conditions at specified" << endl
                 << "    point of the validity timeline." << endl
                 << "        VIEW NAME:   \"" << parent( )->parentView( )->name( ) << "\"" << endl
                 << "        PASSED TIME: " << CdbTimeUtils::time2string( theValidityTime ) << " : " << theValidityTime << endl;
            break;
        }

      // Given the found policy, propagate the call down to the next
      // method requiring explicit policy to be specified among
      // the method's parameters.

        CdbRooRoOiR originalInterval;

        BdbTime beginOfVisiblePeriod ( 0 );
        BdbTime endOfVisiblePeriod   ( 0 );
        BdbTime beginOfDurationPeriod( 0 );
        BdbTime endOfDurationPeriod  ( 0 );

        if( _persistentConditionPtr->isPartitionable( )) {

            if( CdbStatus::Success != doFindObjectAtPartition( configElement.policy,
                                                               theValidityTime,
                                                               theInsertionTime,
                                                               originalInterval, 
                                                               beginOfVisiblePeriod,
                                                               endOfVisiblePeriod,
                                                               beginOfDurationPeriod,
                                                               endOfDurationPeriod )) break;
        } else {

            if( CdbStatus::Success != doFindObject( configElement.policy,
                                                    theValidityTime,
                                                    theInsertionTime,
                                                    originalInterval, 
                                                    beginOfVisiblePeriod,
                                                    endOfVisiblePeriod,
                                                    beginOfDurationPeriod,
                                                    endOfDurationPeriod )) break;
        }

      // Now we should check if the found visible validity interval must be
      // narrowed down to the limits enforced by the current policy interval.

        if( configElement.begin > beginOfVisiblePeriod ) beginOfVisiblePeriod = configElement.begin;
        if( configElement.end   < endOfVisiblePeriod   ) endOfVisiblePeriod   = configElement.end;

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

        theObjectPtr = new CdbRooRoObject( CdbConditionPtr( this->clone( )),
                                           originalInterval.begin( ),
                                           originalInterval.end( ),
                                           beginOfVisiblePeriod,
                                           endOfVisiblePeriod,
                                           beginOfDurationPeriod,
                                           endOfDurationPeriod,
                                           originalInterval.inserted( ),
                                           originalInterval.object( ),
                                           originalInterval.legacyObjectAddress( ));

     // Done

       foundObjectId = originalInterval.object( );
       result        = CdbStatus::Success;

    } while( false );

    CDB_DEBUG_STREAM << "CDB_FIND_OBJECT_1: " << foundObjectId << endl;

    return result;
}

CdbStatus
CdbRooRoCondition::findObject( CdbObjectPtr&            theObjectPtr,
                               const CdbRevisionPolicy& thePolicy,
                               const BdbTime&           theValidityTime,
                               const BdbTime&           theInsertionTime )
{
    theObjectPtr = 0;

    CDB_DEBUG_STREAM
        << "CDB_FIND_OBJECT_2: condition=" << name( ) 
        << " validity_time=" << CdbTimeUtils::time2string( theValidityTime ) 
        << " insertion_time=" << CdbTimeUtils::time2string( theInsertionTime ) << endl;

    CdbRooRoObjectIdR foundObjectId;
    CdbStatus         result = CdbStatus::Error;
    do {

      // Given the found policy, propagate the call down to the next
      // method requiring explicit policy to be specified among
      // the method's parameters.

        CdbRooRoOiR originalInterval;

        BdbTime beginOfVisiblePeriod ( 0 );
        BdbTime endOfVisiblePeriod   ( 0 );
        BdbTime beginOfDurationPeriod( 0 );
        BdbTime endOfDurationPeriod  ( 0 );

        if( _persistentConditionPtr->isPartitionable( )) {

            if( CdbStatus::Success != doFindObjectAtPartition( thePolicy,
                                                               theValidityTime,
                                                               theInsertionTime,
                                                               originalInterval, 
                                                               beginOfVisiblePeriod,
                                                               endOfVisiblePeriod,
                                                               beginOfDurationPeriod,
                                                               endOfDurationPeriod )) break;
        } else {

            if( CdbStatus::Success != doFindObject( thePolicy,
                                                    theValidityTime,
                                                    theInsertionTime,
                                                    originalInterval, 
                                                    beginOfVisiblePeriod,
                                                    endOfVisiblePeriod,
                                                    beginOfDurationPeriod,
                                                    endOfDurationPeriod )) 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.

        theObjectPtr = new CdbRooRoObject( CdbConditionPtr( this->clone( )),
                                           originalInterval.begin( ),
                                           originalInterval.end( ),
                                           beginOfVisiblePeriod,
                                           endOfVisiblePeriod,
                                           beginOfDurationPeriod,
                                           endOfDurationPeriod,
                                           originalInterval.inserted( ),
                                           originalInterval.object( ),
                                           originalInterval.legacyObjectAddress( ));

     // Done
 
       foundObjectId = originalInterval.object( );
       result        = CdbStatus::Success;
 
    } while( false );
 
    CDB_DEBUG_STREAM << "CDB_FIND_OBJECT_2: " << foundObjectId << endl; 

    return result;
}

CdbStatus
CdbRooRoCondition::objectIterator( CdbObjectItr&  theItr,
                                   const BdbTime& theBeginValidity,
                                   const BdbTime& theEndValidity )
{
    const char* errorStr = "CdbRooRoCondition::objectIterator() -- ERROR";

  /*
   * =================
   * EXECUTION PATH I: 'physical address' conditions only
   * =================
   *
   * This path is not currently implemented. A complicated algorithm to iterate
   * over a validity timeline of the "topmost" partitions would be needed for
   * PARTITIONABLE conditions. Things are trivial for REGULAR conditions though.
   * However to avoid an incomplete implementation of this part of the code let's just
   * postpone it as a whole.
   *
   * AN IDEA: Having a super-iterator composed of elementary iterators for individual
   *          "topmost" partitions would be a good idea. That would require to extend
   *          the API of P-Layout to deliver an iterator of "topmost" partitions. The
   *          one currently available does not respect non-instantiated partitions.
   */

    if( 0 == _persistentConditionAtFolderPtr ) return CdbStatus::NotImplemented;

  /*
   * ==================
   * EXECUTION PATH II: 'view/folder/config' conditions only
   * ==================
   */

    CdbStatus result = CdbStatus::NotFound;
    do {

      // Verify parameters

        if( theEndValidity <= theBeginValidity ) {
            cerr << errorStr << endl
                 << "    Invalid validity interval range passed to the method." << endl
                 << "    The end time should be greater or equal than the begin one." << endl
                 << "        PASSED BEGIN TIME : " << theBeginValidity << endl
                 << "        PASSED END   TIME : " << theEndValidity << endl
                 << "        CONDITION         : \"" << name( ) << "\"" << endl;
            break;
        }

        BdbTime minValidity = parent( )->parentView( )->minValidity( );
        BdbTime maxValidity = parent( )->parentView( )->maxValidity( );

        if(( theBeginValidity >= maxValidity ) || ( theEndValidity <= minValidity )) {
            cerr << errorStr << endl
                 << "    Invalid validity interval range passed to the method." << endl
                 << "    This interval does not fit into the validity range" << endl
                 << "    allowed by the current view." << endl
                 << "        PASSED BEGIN TIME : " << theBeginValidity << endl
                 << "        PASSED END   TIME : " << theEndValidity << endl
                 << "        VIEW'S BEGIN TIME : " << minValidity << endl
                 << "        VIEW'S END   TIME : " << maxValidity << endl
                 << "        VIEW              : \"" << parent( )->parentView( )->name( ) << "\"" << endl
                 << "        CONDITION         : \"" << name( ) << "\"" << endl;
            break;
        }

      // Find an iterator for the right configuration. This is going to be either specific one
      // at the level of the condition, or the default one at the level of the view.
      //
      // NOTE: That we're using the default view the current application
      //       is configured with.
      //
      // ROOT I/O IMPLEMENTATION NOTE:
      //
      //    The persistentcy specific configuration
      //    has been replacd with technology neutral way of finding the default configuration.
      //    This needs to be tested well before deploying! Otherwise it's safer to revert back
      //    to the original approach.

        CdbItr<CdbConfigElement> configItr;
        if( CdbStatus::Success != parent( )->parentView( )->configIterator( ::fullPathName( this ).c_str( ),
                                                                            configItr )) {
            cerr << errorStr << endl
                 << "    Failed to find the configuration iterator" << endl
                 << "    at the condition description of the  the current view." << endl
                 << "    The view may be inproperly configured." << endl
                 << "        CONDITION NAME: \"" << name( ) << "\"" << endl
                 << "        VIEW NAME:      \"" << parent( )->parentView( )->name( ) << "\"" << endl;
            break;
        }

      // Now pick up the right iterator and let it to do the rest...

        if( _persistentConditionPtr->isPartitionable( )) {

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

            theItr = CdbObjectItr( new PartitionableObjectIterator( CdbConditionPtr( this->clone( )),
                                                                    theBeginValidity,
                                                                    theEndValidity,
                                                                    configItr,
                                                                    _masterRegistryPtr,
                                                                    _localRegistryPtr,
                                                                    _physicalAddress,
                                                                    _persistentConditionPtr->created( )));
        } else {

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

            theItr = CdbObjectItr( new RegularObjectIterator( CdbConditionPtr( this->clone( )),
                                                              theBeginValidity,
                                                              theEndValidity,
                                                              configItr,
                                                              _masterRegistryPtr,
                                                              _localRegistryPtr,
                                                              _physicalAddress));
        }

      // Done
 
       result = CdbStatus::Success;
 
    } while( false );

    return result;
}

CdbStatus
CdbRooRoCondition::objectIterator( CdbObjectItr&            theItr,
                                   const CdbRevisionPolicy& thePolicy,
                                   const BdbTime&           theBeginValidity,
                                   const BdbTime&           theEndValidity )
{
    const char* errorStr = "CdbRooRoCondition::objectIterator(by policy) -- ERROR";

    CdbStatus result = CdbStatus::NotFound;
    do {

      // Verify parameters

        if( theEndValidity <= theBeginValidity ) {
            cerr << errorStr << endl
                 << "    Invalid validity interval range passed to the method." << endl
                 << "    The end time should be greater or equal than the begin one." << endl
                 << "        PASSED BEGIN TIME : " << theBeginValidity << endl
                 << "        PASSED END   TIME : " << theEndValidity << endl
                 << "        CONDITION         : \"" << name( ) << "\"" << endl;
            break;
        }

      // Prepare a special iterator to serve single configuration record
      //
      // ATTENTION: This is not a memory leak - the created object
      //            will be destroyed by the iterator.

        CdbItr<CdbConfigElement> configItr( new CdbRooRoSimpleConfigIterator( CdbConfigElement( thePolicy,
                                                                                                theBeginValidity,
                                                                                                theEndValidity )));

      // Now pick up the right iterator and let it to do the rest...

        if( _persistentConditionPtr->isPartitionable( )) {

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

            theItr = CdbObjectItr( new PartitionableObjectIterator( CdbConditionPtr( this->clone( )),
                                                                    theBeginValidity,
                                                                    theEndValidity,
                                                                    configItr,
                                                                    _masterRegistryPtr,
                                                                    _localRegistryPtr,
                                                                    _physicalAddress,
                                                                    _persistentConditionPtr->created( )));
        } else {

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

            theItr = CdbObjectItr( new RegularObjectIterator( CdbConditionPtr( this->clone( )),
                                                              theBeginValidity,
                                                              theEndValidity,
                                                              configItr,
                                                              _masterRegistryPtr,
                                                              _localRegistryPtr,
                                                              _physicalAddress ));
        }

      // Done
 
       result = CdbStatus::Success;
 
    } while( false );

    return result;
}

CdbStatus
CdbRooRoCondition::originalObjectIterator( CdbObjectItr&        theItr,
                                           const BdbTime&       theBeginInsertion,
                                           const BdbTime&       theEndInsertion,
                                           const unsigned short thePartitionId )
{
    const char* errorStr = "CdbRooRoCondition::originalObjectIterator() -- ERROR";

    CdbStatus result = CdbStatus::NotFound;
    do {

      // Verify parameters

        if( theBeginInsertion >= theEndInsertion ) {
            cerr << errorStr << endl
                 << "    Invalid 'insertion' interval range passed to the method." << endl
                 << "    The end time should be greater or equal than the begin one." << endl
                 << "        PASSED BEGIN TIME : " << theBeginInsertion << endl
                 << "        PASSED END   TIME : " << theEndInsertion << endl
                 << "        CONDITION         : \"" << name( ) << "\"" << endl;
            break;
        }

      // Now pick up the right iterator and let it to do the rest...
      //
      // ATTENTION: This is not a memory leak - the created object
      //            will be destroyed by the iterator.

        theItr = CdbObjectItr( new OriginalObjectIterator( CdbConditionPtr( this->clone( )),
                                                           theBeginInsertion,
                                                           theEndInsertion,
                                                           _masterRegistryPtr,
                                                           _localRegistryPtr,
                                                           _physicalAddress,
                                                           thePartitionId ));

      // Done
 
       result = CdbStatus::Success;
 
    } while( false );

    return result;
}

CdbStatus
CdbRooRoCondition::storeObject( CdbObjectFactoryBase& theObjectFactory,
                                const BdbTime&        theBegin,
                                const BdbTime&        theEnd,
                                CdbObjectPtr&         theObjectPtr )
{
    return CdbStatus::NotImplemented;
}

CdbStatus
CdbRooRoCondition::storeAndTruncateObject( CdbObjectFactoryBase& theObjectFactory,
                                           const BdbTime&        theStoreTime,
                                           const BdbTime&        theTruncateTime,
                                           CdbObjectPtr&         theObjectPtr )
{
    return CdbStatus::NotImplemented;
}

CdbStatus
CdbRooRoCondition::split( const BdbTime& theTime )
{
    return CdbStatus::NotImplemented;
}

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

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

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

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

CdbStatus
CdbRooRoCondition::findRevision( CdbRevisionPtr& thePtr,
                                 const BdbTime&  theId,
                                 unsigned short  thePartitionId )
{
    const char* errorStr = "CdbRooRoCondition::findRevision(id) -- ERROR";

    CdbStatus result = CdbStatus::NotFound;
    do {

       // Find all metadata objects corresponding to current condition/partition.

        std::vector< CdbCPtr< CdbRooRoMetaDataR > > vectorOfMdPtrs;

        bool allIncrementsFlag = true;

        if( CdbStatus::Success !=  findMetaData( vectorOfMdPtrs,
                                                 _masterRegistryPtr,
                                                 _localRegistryPtr,
                                                 _physicalAddress,
                                                 thePartitionId,
                                                 allIncrementsFlag )) {
            cerr << errorStr << endl
                 << "    Failed to locate the MetaData objects for the current condition/partition." << endl;
            break;
        }

      // Find an appropriate one

        CdbCPtr< CdbRooRoRevisionR > persistentRevisionPtr;
        {
            bool found = false;

            std::vector< CdbCPtr< CdbRooRoMetaDataR > >::const_iterator itr;
            for( itr = vectorOfMdPtrs.begin( ); itr < vectorOfMdPtrs.end( ); ++itr ) {

                CdbCPtr< CdbRooRoMetaDataR > mdPtr = (*itr);
                if( CdbStatus::Success == mdPtr->findRevision( theId,
                                                               persistentRevisionPtr )) {
                    found = true;
                    break;
                }
            }
            if( !found ) break;
        }

      // Construct the transient revision object.
      //
      // 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.

        thePtr = new CdbRooRoRevision( CdbConditionPtr( this->clone( )),
                                       persistentRevisionPtr );

      // Done

        result = CdbStatus::Success;

    } while( false );

    return result;
}

CdbStatus
CdbRooRoCondition::findRevision( CdbRevisionPtr& thePtr,
                                 const char*     theName,
                                 unsigned short  thePartitionId )
{
    const char* errorStr = "CdbRooRoCondition::findRevision(name) -- ERROR";

    CdbStatus result = CdbStatus::NotFound;
    do {

       // Find all metadata objects corresponding to current condition/partition.

        std::vector< CdbCPtr< CdbRooRoMetaDataR > > vectorOfMdPtrs;

        bool allIncrementsFlag = true;

        if( CdbStatus::Success !=  findMetaData( vectorOfMdPtrs,
                                                 _masterRegistryPtr,
                                                 _localRegistryPtr,
                                                 _physicalAddress,
                                                 thePartitionId,
                                                 allIncrementsFlag )) {
            cerr << errorStr << endl
                 << "    Failed to locate the MetaData objects for the current condition/partition." << endl;
            break;
        }

      // Find an appropriate one

        CdbCPtr< CdbRooRoRevisionR > persistentRevisionPtr;
        {
            bool found = false;

            std::vector< CdbCPtr< CdbRooRoMetaDataR > >::const_iterator itr;
            for( itr = vectorOfMdPtrs.begin( ); itr < vectorOfMdPtrs.end( ); ++itr ) {

                CdbCPtr< CdbRooRoMetaDataR > mdPtr = (*itr);
                if( CdbStatus::Success == mdPtr->findRevision( theName,
                                                               persistentRevisionPtr )) {
                    found = true;
                    break;
                }
            }
            if( !found ) break;
        }

      // Construct the transient revision object.
      //
      // 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.

        thePtr = new CdbRooRoRevision( CdbConditionPtr( this->clone( )),
                                       persistentRevisionPtr );

      // Done

        result = CdbStatus::Success;

    } while( false );

    return result;
}

CdbStatus
CdbRooRoCondition::revisionIdIterator( CdbItr<BdbTime>& theItr,
                                       unsigned short   thePartitionId )
{
    const char* errorStr = "CdbRooRoCondition::revisionIdIterator() -- ERROR";

    CdbStatus result = CdbStatus::Error;
    do {

      // Find all metadata objects corresponding to current condition/partition.

        std::vector< CdbCPtr< CdbRooRoMetaDataR > > vectorOfMdPtrs;

        bool allIncrementsFlag = true;

        if( CdbStatus::Success !=  findMetaData( vectorOfMdPtrs,
                                                 _masterRegistryPtr,
                                                 _localRegistryPtr,
                                                 _physicalAddress,
                                                 thePartitionId,
                                                 allIncrementsFlag )) {
            cerr << errorStr << endl
                 << "    Failed to locate the MetaData objects for the current condition/partition." << endl;
            break;
        }

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

        theItr = CdbItr<BdbTime>( new RevisionIdIterator( vectorOfMdPtrs ));

      // Done

        result = CdbStatus::Success;

    } while( false );

    return result;
}

CdbStatus
CdbRooRoCondition::revisionNameIterator( CdbItr<const char*>& theItr,
                                         unsigned short       thePartitionId )
{
    const char* errorStr = "CdbRooRoCondition::revisionNameIterator() -- ERROR";

    CdbStatus result = CdbStatus::Error;
    do {

      // Find all metadata objects corresponding to current condition/partition.

        std::vector< CdbCPtr< CdbRooRoMetaDataR > > vectorOfMdPtrs;

        bool allIncrementsFlag = true;

        if( CdbStatus::Success !=  findMetaData( vectorOfMdPtrs,
                                                 _masterRegistryPtr,
                                                 _localRegistryPtr,
                                                 _physicalAddress,
                                                 thePartitionId,
                                                 allIncrementsFlag )) {
            cerr << errorStr << endl
                 << "    Failed to locate the MetaData objects for the current condition/partition." << endl;
            break;
        }

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

        theItr = CdbItr<const char*>( new RevisionNameIterator( vectorOfMdPtrs ));

      // Done

        result = CdbStatus::Success;

    } while( false );

    return result;
}

CdbStatus
CdbRooRoCondition::createRevision( CdbRevisionPtr& thePtr,
                                   const BdbTime&  theId,
                                   const char*     theName,
                                   const char*     theDescription,
                                   unsigned short  thePartitionId )
{
    return CdbStatus::NotImplemented;
}

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

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

CdbStatus
CdbRooRoCondition::findPartition( CdbCPtr< CdbRooRoPartitionR >& thePtr,
                                  UShort_t                       thePartitonId ) const
{
    const char* errorStr = "CdbRooRoCondition::findPartition() -- ERROR";

    CdbStatus result = CdbStatus::Error;

    do {

      // The partition location can be a two-stage process, First we look for general
      // partition information at the MASTER registry. Then we need to verify if the
      // found partition belongs to the local registry. If so then we reload
      // partition information from the local registry since this partition
      // is supposed to be modified locally.

        CdbCPtr< CdbRooRoPartitionR > persistentPartitionPtr;

        if( CdbStatus::Success != _masterRegistryPtr->partitionsLayout( )->find( thePartitonId,
                                                                                 persistentPartitionPtr )) {
            cerr << errorStr << endl
                 << "    Failed to find a partition #" << thePartitonId << " at the MASTER registry." << endl;
            break;
        }

        if(( _localRegistryPtr->originId( ) == persistentPartitionPtr->originId( )) &&
           ( _localRegistryPtr->originId( ) != _masterRegistryPtr->originId( ))) {

            if( CdbStatus::Success != _localRegistryPtr->partitionsLayout( )->find( thePartitonId,
                                                                                    persistentPartitionPtr )) {
                cerr << errorStr << endl
                     << "    Failed to find a partition #" << thePartitonId << " at the local registry." << endl
                     << "    Perhaps the partition has not been 'instantiated' yet in the local" << endl
                     << "    database after being created by MASTER CDB." << endl;
                break;
            }
        }

      // Done

        thePtr = persistentPartitionPtr;
        result = CdbStatus::Success;

    } while( false );

    return result;
}

CdbStatus
CdbRooRoCondition::findInitialPartition( const BdbTime&                 theValidityTime,
                                         const BdbTime&                 theInsertionTime,
                                         CdbCPtr< CdbRooRoPartitionR >& thePersistentPartitionPtr ) const
{
    const char* errorStr = "CdbRooRoCondition::findInitialPartition() -- ERROR";

    CdbStatus result = CdbStatus::Error;

    do {

      // The temporary partition reference required by some interfaces.

        CdbCPtr< CdbRooRoPartitionR > persistentPartitionPtr;

      // The partition location can be a two-stage process, First we look for general
      // partition information at the MASTER registry. Then we need to verify if the
      // found partition belongs to the local registry. If so then we reload
      // partition information from the local registry since this partition
      // is supposed to be modified locally.

        if( BdbTime::plusInfinity == theInsertionTime ) {

            if( CdbStatus::Success != _masterRegistryPtr->partitionsLayout( )->topmost( theValidityTime,
                                                                                        persistentPartitionPtr )) {
                cerr << errorStr << endl
                     << "    Failed to find a 'topmost' partition for specified validity time" << endl
                     << "    at the master registry." << endl
                     << "        VALIDITY TIME: " << theValidityTime << endl;
                break;
            }

        } else {

            if( CdbStatus::Success != _masterRegistryPtr->partitionsLayout( )->find( theValidityTime,
                                                                                     theInsertionTime,
                                                                                     persistentPartitionPtr )) {
                cerr << errorStr << endl
                     << "    Failed to find a partition at specified point of 2-D timespace" << endl
                     << "    at the master registry." << endl
                     << "        VALIDITY  TIME: " << theValidityTime << endl
                     << "        INSERTION TIME: " << theInsertionTime << endl;
                break;
            }
        }

        UShort_t partitionId = persistentPartitionPtr->id( );

        if(( _localRegistryPtr->originId( ) == persistentPartitionPtr->originId( )) &&
           ( _localRegistryPtr->originId( ) != _masterRegistryPtr->originId( ))) {

            if( CdbStatus::Success != _localRegistryPtr->partitionsLayout( )->find( partitionId,
                                                                                    persistentPartitionPtr )) {
                cerr << errorStr << endl
                     << "    Failed to find a partition #" << partitionId << " at the local registry." << endl;
                break;
            }
        }

      // Done

        thePersistentPartitionPtr = persistentPartitionPtr;

        result = CdbStatus::Success;

    } while( false );

    return result;
}

CdbStatus
CdbRooRoCondition::findNextPartition( const BdbTime&                 theValidityTime,
                                      CdbCPtr< CdbRooRoPartitionR >& thePersistentPartitionPtr ) const
{
    const char* errorStr = "CdbRooRoCondition::findNextPartition() -- ERROR";

    assert( !thePersistentPartitionPtr.isNull( ));

    CdbStatus result = CdbStatus::Error;

    do {

      // The partition location can be a tree-stage process,
      //
      //  (1) First we look for general partition information corresponding to the old
      //      partition at the MASTER registry. We need this step since the "next" operation
      //      could be based on comparision of references rather than partitions identifiers.
      //      So we need to obtain the right reference to succeed.
      //
      //  (2) Then we're trying to locate the information about the next partition from
      //      the same master registry.
      //
      //  (3) And finally we need to verify if the found partition belongs to the local registry.
      //      If so then we reload partition information from the local registry since this partition
      //      is supposed to be modified locally.

      // -1-

        UShort_t prevPartitionId = thePersistentPartitionPtr->id( );

        CdbCPtr< CdbRooRoPartitionR > prevPartPtr;

        if( CdbStatus::Success != _masterRegistryPtr->partitionsLayout( )->find( prevPartitionId,
                                                                                 prevPartPtr )) {
            cerr << errorStr << endl
                     << "    Failed to find a partition #" << prevPartitionId << " at the master registry." << endl;
            break;
        }

      // -2-

        CdbCPtr< CdbRooRoPartitionR > nextPartPtr = prevPartPtr;

        CdbStatus tmpResult = _masterRegistryPtr->partitionsLayout( )->next( theValidityTime,
                                                                             nextPartPtr );
        if( CdbStatus::Success == tmpResult ) {
            ;
        } else {
            if( CdbStatus::NotFound == tmpResult ) {
                result = tmpResult;
            } else {
                cerr << errorStr << endl
                     << "    Failed to find a 'next' partition for specified validity time" << endl
                     << "    at the master registry." << endl
                     << "        VALIDITY TIME:       " << theValidityTime << endl
                     << "        PREVIOUS PARTITION: #" << prevPartitionId << endl;
            }
            break;
        }

      // -3-

        UShort_t partitionId = nextPartPtr->id( );

        if(( _localRegistryPtr->originId( ) == nextPartPtr->originId( )) &&
           ( _localRegistryPtr->originId( ) != _masterRegistryPtr->originId( ))) {

            if( CdbStatus::Success != _localRegistryPtr->partitionsLayout( )->find( partitionId,
                                                                                    nextPartPtr )) {
                cerr << errorStr << endl
                     << "    Failed to find a partition #" << partitionId << " at the local registry." << endl;
                break;
            }
        }

      // Done

        thePersistentPartitionPtr = nextPartPtr;
        result                    = CdbStatus::Success;

    } while( false );

    return result;
}

CdbStatus
CdbRooRoCondition::doFindObjectAtPartition( const CdbRevisionPolicy& thePolicy,
                                            const BdbTime&           theValidityTime,
                                            const BdbTime&           theInsertionTime,
                                            CdbRooRoOiR&             theOriginalInterval,
                                            BdbTime&                 theBeginOfVisiblePeriod,
                                            BdbTime&                 theEndOfVisiblePeriod,
                                            BdbTime&                 theBeginOfDurationPeriod,
                                            BdbTime&                 theEndOfDurationPeriod ) const
{
    const char* debugStr = "CdbRooRoCondition::doFindObjectAtPartition()";
    const char* errorStr = "CdbRooRoCondition::doFindObjectAtPartition() -- ERROR";

    CdbStatus result = CdbStatus::Error;

    do {

      // Make sure this is a proper use of the algorithm. Just in case...

        assert( _persistentConditionPtr->isPartitionable( ));

      // Verify parameters and extract revision to begin with

        bool    useRevisions = thePolicy.useRevision( );
        BdbTime rId          = thePolicy.revisionId( );

        if( useRevisions ) {

            ;   // Nothing more to say

        } else if( BdbTime::plusInfinity == theInsertionTime ) {

            useRevisions = true;                    // Need this for the topmost revision
            rId          = BdbTime::plusInfinity;   // TOPMOST revision

        } else {

            rId = theInsertionTime;     // Still, no revisions
        }

      // Get the condition creation time.
      //
      // IMPORTANT NOTE:
      //
      //     We would need this information to see which increments (MetaData)
      //     to include into the search,
      //     The reason why we're doing this check is that conditions
      //     may be created (put into a cluster) when the correspodning clusters
      //     already have more than 1 increment. Therefore some earlier partitions or increments
      //     may just not have any MetaData fore newer conditions.

        BdbTime creationTime = _persistentConditionPtr->created( );

        if( rId < creationTime ) {
            cerr << errorStr << endl
                 << "    Specified revision identifier / insertion time is older" << endl
                 << "    than the time when the condition was created." << endl
                 << "    The current view may be inproperly configured for the condition." << endl
                 << "        REVISION ID / INSERTION TIME : " << rId << endl
                 << "        CONDITION CREATION TIME      : " << creationTime << endl
                 << "        CONDITION NAME               : \"" << name( ) << "\"" << endl
                 << "        PARENT FOLDER NAME           : \"" << parent( )->name( ) << "\"" << endl
                 << "        VIEW NAME                    : \"" << parent( )->parentView( )->name( ) << "\"" << endl;
            break;
        }

      // Find the initial <partition> to begin with.
      //
      // NOTE: We're going to check if the partion is closed. If so if its
      //       upper "insertion" time boundry is strictly above the condition
      //       creation time. Otherwise we just quit here since no MetaData
      //       for the recently created condition should exist in his partition.

        CdbCPtr< CdbRooRoPartitionR > persistentPartitionPtr;

        if( CdbStatus::Success != findInitialPartition( theValidityTime,
                                                        rId,
                                                        persistentPartitionPtr )) {
            break;
        }

/******************************************************************/
if( CdbEnvironment::getDebugMode( ) != 0 )
    cout << debugStr << endl
         << "{" << endl
         << "    Found initial partition ID=" << persistentPartitionPtr->id( ) << endl
         << "}" << endl;
/******************************************************************/

        if( persistentPartitionPtr->isClosed( )) {

            CdbRooRoCellR pCell = persistentPartitionPtr->cell( );

            if( pCell.endInsertion( ) <= creationTime ) {

/***************************************************************/
if( CdbEnvironment::getDebugMode( ) != 0 )
cout << debugStr << endl
 << "{" << endl
 << "    The just found partition is already 'closed' and its upper 'insertion'" << endl
 << "    time limit is older than the creation time of the current condition." << endl
 << "    So no object has been found." << endl
 << "        creationTime       : " << creationTime << endl
 << "        pCell.endInsertion : " << pCell.endInsertion( ) << endl
 << "}" << endl;
/***************************************************************/

                result = CdbStatus::NotFound;
                break;
            }
        }

      //  Then find the increments range for specified revision time.

        UShort_t firstIncrement = 0;
        UShort_t lastIncrement  = 0;
        {
            UShort_t numIncrements = persistentPartitionPtr->numIncrements( );
            assert( numIncrements > 0 );

          // Find the very first increment including the creation time
          // of the condition.

            {
                bool failed = true;

                for( UShort_t i = 0; i < numIncrements; ++i ) {

                    CdbRooRoIncrementR iVal;
                    if( CdbStatus::Success != persistentPartitionPtr->increment( i,
                                                                                 iVal )) {
                        break;
                    }
                    if( creationTime < iVal.end( )) {

                        firstIncrement = i;

                        failed = false;
                        break;
                    }
                }
                if( failed ) {
                    cerr << errorStr << endl
                         << "    Failed to find the smallest increment number at a partition #" << persistentPartitionPtr->id( ) << endl
                         << "    The current federation may not be properly initialized/loaded." << endl;
                    break;
                }
            }

          // Find the very last increment including specified revision
          //
          // NOTE: This search begins with the above found very first
          //       increment number.

            if( BdbTime::plusInfinity == rId ) {
                lastIncrement = numIncrements - 1;
            } else {

                bool failed = true;

                for( UShort_t i = firstIncrement; i < numIncrements; ++i ) {

                    CdbRooRoIncrementR iVal;
                    if( CdbStatus::Success != persistentPartitionPtr->increment( i,
                                                                                 iVal )) {
                        break;
                    }
                    if(( rId >= iVal.begin( )) && ( rId <  iVal.end( ))) {

                        lastIncrement = i;

                        failed = false;
                        break;
                    }
                }
                if( failed ) {
                    cerr << errorStr << endl
                         << "    Failed to find the biggest increment number at a partition #" << persistentPartitionPtr->id( ) << endl
                         << "    The current federation may not be properly initialized/loaded." << endl;
                    break;
                }
            }
        }

/*********************************************************************/
if( CdbEnvironment::getDebugMode( ) != 0 )
    cout << debugStr << endl
         << "{" << endl
         << "    Initial firstIncrement : " << firstIncrement << endl
         << "            lastIncrement  : " << lastIncrement  << endl
         << "}" << endl;
/*********************************************************************/

      // Now we're ready to begin seraching for condition objects through
      // the sequence of partitions & increments.
      //
      // == ALGORITHM DESCRIPTION ==
      //
      //  (1) The search algorithm begins with the specified revision/insertion time
      //      of the initially found partition & increment and it will proceed down
      //      to final revisions of previous increments of the this partition until
      //      either the desired interval is found or the bottom of the increments
      //      stack is met. The bottom is defined as the lowest increment including
      //      the condition's creation time.
      //
      //  (2) If the bottom of the initial partition is met and desired interval
      //      is still not found then we switch to the next partition below
      //      the initial one and proceed with the search begining with the final
      //      revision of that partition.
      //
      //  (3) We proceed with step (2) until either we find desired interval or
      //      we reach the bottom of the condition. Note, that definition of
      //      the "bottom" given at (1) above.
      //
      // This algorithm is used for both states of the "useRevisions" flag
      // calculated above. The only difference is that in case of "!useRevisions"
      // we're only given one chance to try the above calculated initial partition & increment
      // where the answer for specified insertionTime should be.
      // See the details at the implementation of the CdbRooRoMetaDataR::findByInsertion()
      // method.
      //
      // Here is a pseudo-graphical representation of this process:
      //
      //           <validity time>
      //                   |
      //                   |
      // ..................|..............................................
      // :Partition M      |                                             :
      // : ................|............................................ :
      // : :Increment MAX  |                                           : :
      // : :               |                              ============ : :
      // : :               |                         ================= : :
      // : + + + + + + + + X + + + + + + + + + + + + + + + + + + + + + + +  Rev.M/insertion time
      // : :               |                   ======================= : :
      // : :               |              ============================ : :
      // : :               |        ================================== : :
      // : ................|............................................ :
      // : ................|............................................ :
      // : :Increment 0    |                                           : :
      // : + + + + + + + + X + + + + + + + + + + + + + + + + + + + + + + +  Rev.Final
      // : :               |                     ===================== : :
      // : :               |                 ========================= : :
      // : ................|............................................ :
      // ..................|..............................................
      //                   |
      // ..................|............................
      // :Partition L      |                           :
      // : ................|.......................... :
      // : :Increment MAX  |                         : :
      // : + + + + + + + + X + + + + + + + + + + + + + +  Rev.Final
      // : :               |     =================== : :
      // : :               | ======================= : :
      // : :               X======================== : :
      // : :         =============================== : :
      // : ........................................... :
      // ...............................................
      //
      // This algorithm can be optimized in the future by caching all the relevant
      // information in the virtual memory of an application to avoid expensive
      // operations with peristsent store.
      //
      // NOT IMPLEMENTED: Will be implemented after the special failure test will
      //                  be done.
      //
      // == CALCULATING THE VISIBLE VALIDITY INTERVAL OF FOUND OBJECT ==
      //
      // The basic idea is that the visible validity interval is the shortest interval
      // of any of the following validity intervals met by the above described
      // algorithm:
      //
      // - the validity range of any partition explored
      // - the validity range of any failed as CdbStatus::NotFound attempts
      //   to find desired object at any MetaData object of partitions & increments explored
      // - the visibke validity for a successfully found object
      //
      // IMPORTANT: This algorithm needs thorough testing before deploying it.

        CdbRooRoCellR pCell = persistentPartitionPtr->cell( );

        theBeginOfVisiblePeriod = pCell.beginValidity( );
        theEndOfVisiblePeriod   = pCell.endValidity  ( );

        assert( theBeginOfVisiblePeriod < theEndOfVisiblePeriod );

      // Begin the algorithm...

        bool isFirstPath = true;

        do {

/**************************************************************************/
if( CdbEnvironment::getDebugMode( ) != 0 )
    cout << debugStr << endl
         << "{" << endl
         << "    isFirstPath : " << ( isFirstPath ? "Yes" : "No" ) << endl
         << "}" << endl;
/**************************************************************************/

            if( !isFirstPath ) {

              // Reload <partition>
              //
              // NOTE: We're going to check if the partion is closed. If so if its
              //       upper "insertion" time boundry is strictly above the condition
              //       creation time. Otherwise we just quit here since no MetaData
              //       for the recently created condition should exist in his partition.

                if( CdbStatus::Success != findNextPartition( theValidityTime,
                                                             persistentPartitionPtr )) {
                    break;
                }

/***************************************************************/
if( CdbEnvironment::getDebugMode( ) != 0 )
    cout << debugStr << endl
         << "{" << endl
         << "    Found next partition ID=" << persistentPartitionPtr->id( ) << endl
         << "}" << endl;
/***************************************************************/

                if( persistentPartitionPtr->isClosed( )) {

                    CdbRooRoCellR pCell = persistentPartitionPtr->cell( );

                    if( pCell.endInsertion( ) <= creationTime ) {

/***************************************************************/
if( CdbEnvironment::getDebugMode( ) != 0 )
    cout << debugStr << endl
         << "{" << endl
         << "    The just found partition is already 'closed' and its upper 'insertion'" << endl
         << "    time limit is older than the creation time of the current condition." << endl
         << "    So no object has been found." << endl
         << "        creationTime       : " << creationTime << endl
         << "        pCell.endInsertion : " << pCell.endInsertion( ) << endl
         << "}" << endl;
/***************************************************************/

                        result = CdbStatus::NotFound;
                        break;
                    }
                }

              // ...and <increment>
              //
              // NOTE: We're going to recalculate the first and last increment numbers
              //       of the partition taking into accound the condition creation time.

                {
                    UShort_t numIncrements = persistentPartitionPtr->numIncrements( );
                    assert( numIncrements > 0 );

/*******************************************************************************************************************/
if( CdbEnvironment::getDebugMode( ) != 0 )
    cout << debugStr << endl
         << "{" << endl
         << "    num increments : " << numIncrements << " at partition ID=" << persistentPartitionPtr->id( ) << endl
         << "}" << endl;
/*******************************************************************************************************************/

                  // Find the first increment first

                    bool found  = false;
                    bool failed = true;

                    for( UShort_t i = 0; i < numIncrements; ++i ) {

                        CdbRooRoIncrementR iVal;
                        if( CdbStatus::Success != persistentPartitionPtr->increment( i,
                                                                                     iVal )) {
                            cerr << errorStr << endl
                                 << "    Failed to find the increment #" << i << " at the partition #" << persistentPartitionPtr->id( ) << endl
                                 << "    The current federation may not be properly initialized/loaded." << endl;
                            break;
                        }

/*********************************************************/
if( CdbEnvironment::getDebugMode( ) != 0 )
    cout << debugStr << endl
         << "{" << endl
         << "    creation time : " << creationTime << endl
         << "    iVal.end      : " << iVal.end( ) << endl
         << "}" << endl;
/*********************************************************/

                        if( creationTime < iVal.end( )) {

                            firstIncrement = i;

                            found  = true;
                            failed = false;

                            break;
                        }
                    }
                    if( failed ) {
                        break;
                    }
                    if( !found ) {
                        result = CdbStatus::NotFound;
                        break;
                    }

                  // The last increment is alway the biggest one since we're
                  // already below the revision/insertion time

                    lastIncrement = numIncrements - 1;
                }

/******************************************************************/
if( CdbEnvironment::getDebugMode( ) != 0 )
    cout << debugStr << endl
         << "{" << endl
         << "    next firstIncrement : " << firstIncrement << endl
         << "         lastIncrement  : " << lastIncrement  << endl
         << "}" << endl;
/******************************************************************/

              // Narrow down the visible interval to the partition limits

                pCell = persistentPartitionPtr->cell( );

                if( pCell.beginValidity( ) > theBeginOfVisiblePeriod ) theBeginOfVisiblePeriod = pCell.beginValidity( );
                if( pCell.endValidity  ( ) < theEndOfVisiblePeriod   ) theEndOfVisiblePeriod   = pCell.endValidity  ( );

                assert( theBeginOfVisiblePeriod < theEndOfVisiblePeriod );
            }

            bool isBreaking  = false;

            for( int i = lastIncrement; i >= firstIncrement; --i ) {

              // Find out the meta-data object.

                CdbCPtr< CdbRooRoMetaDataR > mdPtr;

                if( CdbStatus::Success != CdbRooRoFileUtils::instance( ).findMetaData( mdPtr,
                                                                                       _physicalAddress.local,                     // theConditionId
                                                                                       true,                                       // isPartitionableFlag
                                                                                       persistentPartitionPtr->id( ),              // thePartitionId
                                                                                       _persistentConditionPtr->clusterId( ),      // theClusterId
                                                                                       i,                                          // theIncrementId
                                                                                       persistentPartitionPtr->originId( ))) {     // theOriginId (of the partition)
                    cerr << errorStr << endl
                         << "    Failed to find a MetaData object." << endl
                         << "        CONDITION 'PHYSICAL' ADDRESS : " << _physicalAddress << endl
                         << "        IS PARTITIONABLE             : " << "Yes" << endl
                         << "        PARTITION ID                 : " << persistentPartitionPtr->id( ) << endl
                         << "        CLUSTER   ID                 : " << _persistentConditionPtr->clusterId( ) << endl
                         << "        INCREMENT ID                 : " << i << endl
                         << "        PARTITION'S ORIGIN ID        : " << persistentPartitionPtr->originId( ) << endl;

                    isBreaking = true;
                    break;
                }

              // If this is not the very first step in the <partition> & <increment> loop
              // then we need to switch to the "final" revision of the just found metadata object.
              //
              // NOTE: The "final" revision of a metadata object is the one corresponding
              //       to its most recent "modification" time.
              //
              //       @see CdbRooRoMetaDataR::modified()

                if( isFirstPath && ( i == lastIncrement )) {
                    ;
                } else {
                    rId = mdPtr->modified( );
                }

              // Try finding the persistent object in the meta-data object of
              // the current increment.
              //
              // NOTE: We do only one attemp for "useRevisions == false".

                BdbTime beginOfVisiblePeriod( 0 );
                BdbTime endOfVisiblePeriod  ( 0 );

                if( useRevisions ) {

/*************************************************************************************************/
if( CdbEnvironment::getDebugMode( ) != 0 )
    cout << debugStr << endl
         << "{" << endl
         << "    Find by revision" << endl
         << "       next    curent increment number : " << i << endl
         << "               rId                     : " << rId << endl
         << "               theValidityTime         : " << theValidityTime << endl
         << "}" << endl;
/*************************************************************************************************/

                    result = mdPtr->findByRevision( rId,
                                                    theValidityTime,
                                                    theOriginalInterval,
                                                    beginOfVisiblePeriod,
                                                    endOfVisiblePeriod );

/************************************************/
if( CdbEnvironment::getDebugMode( ) != 0 )
    cout << debugStr << endl
         << "{" << endl
         << "    result : " << result << endl
         << "}" << endl;
/************************************************/

                    if( beginOfVisiblePeriod > theBeginOfVisiblePeriod ) theBeginOfVisiblePeriod = beginOfVisiblePeriod;
                    if( endOfVisiblePeriod   < theEndOfVisiblePeriod   ) theEndOfVisiblePeriod   = endOfVisiblePeriod;

                    assert( theBeginOfVisiblePeriod < theEndOfVisiblePeriod );

                    if( CdbStatus::NotFound != result ) {

                      // The duration of this object begins with its insertion time up
                      // to +Infinity

                        theBeginOfDurationPeriod = theOriginalInterval.inserted( );
                        theEndOfDurationPeriod   = BdbTime::plusInfinity;

                      // No matter if it's success or anything else except "NotFound".

                        isBreaking = true;
                        break;
                    }

                } else {

                    result = mdPtr->findByInsertion( rId,
                                                     theValidityTime,
                                                     theOriginalInterval,
                                                     theBeginOfDurationPeriod,
                                                     theEndOfDurationPeriod );

                  // Special situation when an 'original' interval becomes the 'visible' one

                    theBeginOfVisiblePeriod = theOriginalInterval.begin( );
                    theEndOfVisiblePeriod   = theOriginalInterval.end  ( );

                  // No more attempts.

                    isBreaking = true;
                    break;
                }
            }
            if( isBreaking ) break;

            isFirstPath = false;

        } while( true );    // Should be broken by the logic above.

    } while( false );

    return result;
}

CdbStatus
CdbRooRoCondition::doFindObject( const CdbRevisionPolicy& thePolicy,
                                 const BdbTime&           theValidityTime,
                                 const BdbTime&           theInsertionTime,
                                 CdbRooRoOiR&             theOriginalInterval, 
                                 BdbTime&                 theBeginOfVisiblePeriod,
                                 BdbTime&                 theEndOfVisiblePeriod,
                                 BdbTime&                 theBeginOfDurationPeriod,
                                 BdbTime&                 theEndOfDurationPeriod ) const
{
    const char* debugStr = "CdbRooRoCondition::doFindObject()";
    const char* errorStr = "CdbRooRoCondition::doFindObject() -- ERROR";

    CdbStatus result = CdbStatus::Error;

    do {

      // Make sure this is a proper use of the algorithm. Just in case...

        assert( !_persistentConditionPtr->isPartitionable( ));

      // Verify parameters and extract revision to begin with

        bool    useRevisions = thePolicy.useRevision( );
        BdbTime rId          = thePolicy.revisionId( );

        if( useRevisions ) {

            ;   // Nothing more to say

        } else if( BdbTime::plusInfinity == theInsertionTime ) {

            useRevisions = true;                    // Need this for the topmost revision
            rId          = BdbTime::plusInfinity;   // TOPMOST revision

        } else {

            rId = theInsertionTime;     // Still, no revisions
        }

      // Set up some initial "visible" validity period. This window will be corrected
      // by the condition lookup algorithm.

        theBeginOfVisiblePeriod = BdbTime::minusInfinity;
        theEndOfVisiblePeriod   = BdbTime::plusInfinity;

      // Get the condition creation time.
      //
      // IMPORTANT NOTE:
      //
      //     We would need this information to see which increments (MetaData)
      //     to include into the search,
      //     The reason why we're doing this check is that conditions
      //     may be created (put into a cluster) when the correspodning clusters
      //     already have more than 1 increment. Therefore some earlier increments
      //     may just not have any MetaData fore newer conditions.

        BdbTime creationTime = _persistentConditionPtr->created( );

        if( rId < creationTime ) {
            cerr << errorStr << endl
                 << "    Specified revision identifier / insertion time is older" << endl
                 << "    than the time when the condition was created." << endl
                 << "    The current view may be inproperly configured for the condition." << endl
                 << "        REVISION ID / INSERTION TIME : " << rId << endl
                 << "        CONDITION CREATION TIME      : " << creationTime << endl
                 << "        CONDITION NAME               : \"" << name( ) << "\"" << endl
                 << "        PARENT FOLDER NAME           : \"" << parent( )->name( ) << "\"" << endl
                 << "        VIEW NAME                    : \"" << parent( )->parentView( )->name( ) << "\"" << endl;
            break;
        }

      // Find the increments range for specified revision time.

        UShort_t firstIncrement = 0;
        UShort_t lastIncrement  = 0;
        {
          // Find out a the cluster the condition belongs to.

            CdbCPtr< CdbRooRoRClusterR > persistentClusterPtr;
            {
              // Find out the owner registry the cluster is supposed to be.

                CdbCPtr< CdbRooRoRegistry > conditionOwnerRegistryPtr;
                {
                    if( _localRegistryPtr->originId( ) == _physicalAddress.origin ) {
                        conditionOwnerRegistryPtr = _localRegistryPtr;

                    } else if( _masterRegistryPtr->originId( ) == _physicalAddress.origin ) {
                        conditionOwnerRegistryPtr = _masterRegistryPtr;

                    } else {
                        if( CdbStatus::Success != CdbRooRoRegistry::findByOrigin( conditionOwnerRegistryPtr,
                                                                                  _physicalAddress.origin )) {
                            cerr << errorStr << endl
                                 << "    Registry for specified origin ID #" << _physicalAddress.origin << " not found." << endl;
                            break;
                        }
                    }
                }

              // Proceed to the cluster in question

                if( CdbStatus::Success != conditionOwnerRegistryPtr->clusterCollection( )->find( _persistentConditionPtr->clusterId( ),
                                                                                                 persistentClusterPtr )) {
                    cerr << errorStr << endl
                         << "    Cluster with ID #" << _persistentConditionPtr->clusterId( ) << " not found" << endl
                         << "    at the collection with the origin ID #" << _physicalAddress.origin << endl;
                    break;
                }
            }

            UShort_t numIncrements = persistentClusterPtr->numIncrements( );
            assert( numIncrements > 0 );

          // Find the very first increment including the creation time
          // of the condition.

            {
                bool failed = true;

                for( UShort_t i = 0; i < numIncrements; ++i ) {

                    CdbRooRoIncrementR iVal;
                    if( CdbStatus::Success != persistentClusterPtr->increment( i,
                                                                               iVal )) {
                        break;
                    }
                    if( creationTime < iVal.end( )) {

                        firstIncrement = i;

                        failed = false;
                        break;
                    }
                }
                if( failed ) {
                    cerr << errorStr << endl
                         << "    Failed to find the smallest increment number for the condition." << endl
                         << "    The current federation may not be properly initialized/loaded." << endl;
                    break;
                }
            }

          // Find the very last increment including specified revision
          //
          // NOTE: This search begins with the above found very first
          //       increment number.

            if( BdbTime::plusInfinity == rId ) {
                lastIncrement = numIncrements - 1;
            } else {

                bool failed = true;

                for( UShort_t i = firstIncrement; i < numIncrements; ++i ) {

                    CdbRooRoIncrementR iVal;
                    if( CdbStatus::Success != persistentClusterPtr->increment( i,
                                                                               iVal )) {
                        break;
                    }
                    if(( rId >= iVal.begin( )) && ( rId <  iVal.end( ))) {

                        lastIncrement = i;

                        failed = false;
                        break;
                    }
                }
                if( failed ) {
                    cerr << errorStr << endl
                         << "    Failed to find the biggest increment number for the condition." << endl
                         << "    The current federation may not be properly initialized/loaded." << endl;
                    break;
                }
            }
/***********************************************************/
if( CdbEnvironment::getDebugMode( ) != 0 )
    cout << debugStr << endl
         << "{" << endl
         << "    creationTime   : " << creationTime   << endl
         << "    firstIncrement : " << firstIncrement << endl
         << "    lastIncrement  : " << lastIncrement  << endl
         << "    numIncrements  : " << numIncrements  << endl
         << "}" << endl;
/***********************************************************/
        }

      // Now we're ready to begin seraching for condition objects through
      // the sequence of increments. The search begins with the specified revision
      // of the found increment and it will proceed down to final revisions
      // of previous increments until either the desired interval is found or the smallest
      // avaialble for this condition increment of the stack is met.
      //
      // NOTE: This algorithm is used for both states of the "useRevisions" flag
      //       calculated above. The only difference is that in case of "!useRevisions"
      //       we're only given one chance to try the above calculated increment
      //       where the answer for specified insertionTime should be.
      //       See the details at the implementation of the CdbRooRoMetaDataR::findByInsertion()
      //       method.
      //
      // Here is a pseudo-graphical representation of this process:
      //
      //           <validity time>
      //                   |
      //   ................|....................................................
      //   :Increment N    |                                                   :
      //   :               |                              ==================== :
      //   :               |                         ========================= :
      //   + + + + + + + + X + + + + + + + + + + + + + + + + + + + + + + + + + +  Rev.M/insertion time
      //   :               |                   =============================== :
      //   :               |              ==================================== :
      //   :               |        ========================================== :
      //   ................|....................................................
      //                   |
      //   ................|....................................................
      //   :Increment N-1  |                                                   :
      //   + + + + + + + + X + + + + + + + + + + + + + + + + + + + + + + + + + +  Rev.Final
      //   :               |     ============================================= :
      //   :               | ================================================= :
      //   :             ==X================================================== :
      //   :         ========================================================= :
      //   .....................................................................
      //
      // This algorithm can be optimized in the future by caching all the relevant
      // information in the virtual memory of an application to avoid expensive
      // operations with peristsent store.
      //
      // NOT IMPLEMENTED: Will be implemented after the special failure test will
      //                  be done.

        for( int i = lastIncrement; i >= firstIncrement; --i ) {

          // Find out the meta-data object.

            CdbCPtr< CdbRooRoMetaDataR > mdPtr;

            if( CdbStatus::Success != CdbRooRoFileUtils::instance( ).findMetaData( mdPtr,
                                                                                   _physicalAddress.local,                 // theConditionId
                                                                                   false,                                  // isPartitionableFlag
                                                                                   0,                                      // thePartitionId
                                                                                   _persistentConditionPtr->clusterId( ),  // theClusterId
                                                                                   i,                                      // theIncrementId
                                                                                   _physicalAddress.origin )) {            // theOriginId
                cerr << errorStr << endl
                     << "    Failed to find a MetaData object." << endl
                     << "        CONDITION 'PHYSICAL' ADDRESS : " << _physicalAddress << endl
                     << "        IS PARTITIONABLE             : " << "No" << endl
                     << "        PARTITION ID                 : " << 0 << endl
                     << "        CLUSTER   ID                 : " << _persistentConditionPtr->clusterId( ) << endl
                     << "        INCREMENT ID                 : " << i << endl;
                break;
            }

          // If this is not the very first step in the loop then we need to switch
          // to the "final" revision of the just found metadata object.
          //
          // NOTE: The "final" revision of a metadata object is the one corresponding
          //       to its most recent "modification" time.
          //
          //       @see CdbRooRoMetaDataR::modified()

            if( i != lastIncrement ) rId = mdPtr->modified( );

          // Try finding the persistent object in the meta-data object of
          // the current increment.
          //
          // NOTE: We do only one attemp for "useRevisions == false".

            if( useRevisions ) {

              // The explicit "visible" validity interval correction at this level of
              // the object mining algorithm may be needed when "diving" into metadata-s
              // beneath an upper one.

                BdbTime beginOfVisiblePeriod = BdbTime( 0 );        // Just to have an initialized value
                BdbTime endOfVisiblePeriod   = BdbTime( 0 );        // -//-

                result = mdPtr->findByRevision( rId,
                                                theValidityTime,
                                                theOriginalInterval,
                                                beginOfVisiblePeriod,
                                                endOfVisiblePeriod );

                if( beginOfVisiblePeriod > theBeginOfVisiblePeriod ) theBeginOfVisiblePeriod = beginOfVisiblePeriod;
                if( endOfVisiblePeriod   < theEndOfVisiblePeriod   ) theEndOfVisiblePeriod   = endOfVisiblePeriod;

                if( CdbStatus::NotFound != result ) {

                  // The duration of this object begins with its insertion time up
                  // to +Infinity

                    theBeginOfDurationPeriod = theOriginalInterval.inserted( );
                    theEndOfDurationPeriod   = BdbTime::plusInfinity;

                  // No matter if it's success or anything else except "NotFound".

                    break;
                }

            } else {

                result = mdPtr->findByInsertion( rId,
                                                 theValidityTime,
                                                 theOriginalInterval,
                                                 theBeginOfDurationPeriod,
                                                 theEndOfDurationPeriod );

              // Special situation when an 'original' interval becomes the 'visible' one

                theBeginOfVisiblePeriod = theOriginalInterval.begin( );
                theEndOfVisiblePeriod   = theOriginalInterval.end  ( );

              // No more attempts.

                break;
            }
        }

    } while( false );

    return result;
}

namespace {

    std::string
    fullPathName( const CdbRooRoCondition* theConditionPtr )
    {
        if( 0 == theConditionPtr ) return std::string( "" );

      // Note, that a condition found by its 'physical' address or name does not
      // have a valid "full path", which would only make sense in a view.
 
        if( theConditionPtr->parent( ).isNull( )) return std::string( "" );
 
      // Proceed for conditions found through a view
 
        CdbPathName result( theConditionPtr->name( ));
 
        CdbFolderPtr parentFolder = theConditionPtr->parent( );
        while( !parentFolder.isNull( )) {
            result = CdbPathName( parentFolder->name( )) + result;
            parentFolder = parentFolder->parentFolder( );
        }
        return result.toString( );
    }

    CdbStatus
    findMetaData( std::vector< CdbCPtr< CdbRooRoMetaDataR > >& theVectorOfPtrs,
                  const CdbCPtr< CdbRooRoRegistry >&           theMasterRegistryPtr,
                  const CdbCPtr< CdbRooRoRegistry >&           theLocalRegistryPtr,
                  const CdbId&                                 theExtendedConditionId,
                  UShort_t                                     thePartitionId,
                  bool                                         allIncrementsFlag,
                  bool                                         recentIncrementFlag,
                  UShort_t                                     theIncrementNumber )
    {
        const char* errorStr = "CdbRooRoCondition::findMetaData() -- ERROR";

        CdbStatus result = CdbStatus::Error;
        do {

          // Make sure the procedure is called with correct set of parameters

            assert( !theMasterRegistryPtr.isNull( ));
            assert( !theLocalRegistryPtr.isNull( ));
            assert( theMasterRegistryPtr->isMaster( ));

            UShort_t originId    = theExtendedConditionId.origin;
            UShort_t conditionId = theExtendedConditionId.local;

          // Find out which registry hosts the condition

            CdbCPtr< CdbRooRoRegistry > conditionOwnerRegistryPtr;
            {
                if( theLocalRegistryPtr->originId( ) == originId ) {
                    conditionOwnerRegistryPtr = theLocalRegistryPtr;

                } else if( theMasterRegistryPtr->originId( ) == originId ) {
                    conditionOwnerRegistryPtr = theMasterRegistryPtr;

                } else {
                    if( CdbStatus::Success != CdbRooRoRegistry::findByOrigin( conditionOwnerRegistryPtr,
                                                                              originId )) {
                        cerr << errorStr << endl
                             << "    Registry for specified origin ID #" << originId << " not found." << endl;
                        break;
                    }
                }
            }

          // Find specified condition in the collection.

            CdbCPtr< CdbRooRoConditionR > persistentConditionPtr;

            if( CdbStatus::Success != conditionOwnerRegistryPtr->conditionCollection( )->find( conditionId,
                                                                                               persistentConditionPtr )) {
                cerr << errorStr << endl
                     << "    Condition with ID #" << conditionId << " not found" << endl
                     << "    at the collection with the origin ID #" << originId << endl;
                break;
            }

          // Get the characteristics of the condition
          // Currently there are two of them:
          //
          // - its creation time. We would need this information
          //   when looking for a subset of increments including or newer
          //   than that time. The reason is that conditions could be created
          //   later on when a number of increments for a cluster/partition may
          //   already exist.
          //
          // - its "partitionable" property. This will tell us which (of two)
          //   groups of clusters we should use. Partitionable conditions
          //   go into a separate set of clusters.

            BdbTime creationTime        = persistentConditionPtr->created( );
            bool    isPartitionableFlag = persistentConditionPtr->isPartitionable( );

            CdbCPtr< CdbRooRoPartitionR > persistentPartitionPtr;

            if( isPartitionableFlag ) {

              // Use master to get general information about the partition

                if( CdbStatus::Success != theMasterRegistryPtr->partitionsLayout( )->find( thePartitionId,
                                                                                           persistentPartitionPtr )) {
                    cerr << errorStr << endl
                         << "    Partition with ID #" << thePartitionId << " not found" << endl
                         << "    at the master collection." << endl;
                    break;
                }

              // Check if this partition is available

                if( theLocalRegistryPtr->originId( ) == persistentPartitionPtr->originId( )) {

                  // Switch to the actual partition object if the current database
                  // is not the master one and if the partition belongs to the current database.
                  // Then the current (local) database is the ultimate source of information.

                    if( theLocalRegistryPtr->originId( ) != theMasterRegistryPtr->originId( )) {

                        if( CdbStatus::Success != theLocalRegistryPtr->partitionsLayout( )->find( thePartitionId,
                                                                                                  persistentPartitionPtr )) {
                            cerr << errorStr << endl
                                 << "    Partition with ID #" << thePartitionId << " not found" << endl
                                 << "    at the local (non-master) collection." << endl;
                            break;
                        }
                    }
                }
                if( !persistentPartitionPtr->isInstantiated( )) {
                    cerr << errorStr << endl
                         << "    Partition with ID #" << thePartitionId << " is not instantiated." << endl
                         << "    No MetaData containers should exist for this condition yet." << endl;
                    break;
                }
            }

          // Get the range of increments for the condition/partition
          //
          // NOTE: We're using the condition creation time to determine the first
          //       increment inclusing this time. We do it because a condition may
          //       be created when a number of increments already exist in the cluster.

            UShort_t firstIncrement = 0;
            UShort_t lastIncrement  = 0;
            {
                bool failed = false;

                UShort_t numIncrements = 0;

                if( isPartitionableFlag ) {

                    numIncrements = persistentPartitionPtr->numIncrements( );
                    for( UShort_t i = 0; i < numIncrements; ++i ) {

                        CdbRooRoIncrementR iVal;
                        if( CdbStatus::Success != persistentPartitionPtr->increment( i,
                                                                                     iVal )) {
                            failed = true;
                            break;
                        }
                        if( creationTime < iVal.end( )) {
                            firstIncrement = i;
                            break;
                        }
                    }
                    if( failed ) break;

                } else {

                    CdbCPtr< CdbRooRoRClusterR > persistentClusterPtr;

                    if( CdbStatus::Success != conditionOwnerRegistryPtr->clusterCollection( )->find( persistentConditionPtr->clusterId( ),
                                                                                                     persistentClusterPtr )) {
                        cerr << errorStr << endl
                             << "    Cluster with ID #" << persistentConditionPtr->clusterId( ) << " not found" << endl
                             << "    at the collection with the origin ID #" << originId << endl;
                        break;
                    }

                    numIncrements = persistentClusterPtr->numIncrements( );
                    for( UShort_t i = 0; i < numIncrements; ++i ) {

                        CdbRooRoIncrementR iVal;
                        if( CdbStatus::Success != persistentClusterPtr->increment( i,
                                                                                   iVal )) {
                            failed = true;
                            break;
                        }
                        if( creationTime < iVal.end( )) {
                            firstIncrement = i;
                            break;
                        }
                    }
                    if( failed ) break;

                }
                if( numIncrements < 1 ) {
                    assert( 0 );
                    break;
                }
                lastIncrement = numIncrements - 1;
            }

          // Find metadata for specified increment(s)
          //
          // NOTE: Watch for the origin ID used in the look up operations. For 'REGULAR' conditions
          //       it's going to be the owner of the condition, meanwhile for the 'PARTITIONABLE'
          //       ones it will be an owner of the specified partition.

            UShort_t lookupOriginId = ( isPartitionableFlag ? persistentPartitionPtr->originId( ) : originId );

            std::vector< CdbCPtr< CdbRooRoMetaDataR > > vectorOfPtrs;

            CdbCPtr< CdbRooRoMetaDataR > mdPtr;

            if( allIncrementsFlag ) {

                bool failed = false;
                {
                    for( UShort_t i = firstIncrement; i <= lastIncrement; ++i ) {

                        if( CdbStatus::Success != CdbRooRoFileUtils::instance( ).findMetaData( mdPtr,
                                                                                               conditionId,
                                                                                               isPartitionableFlag,
                                                                                               thePartitionId,
                                                                                               persistentConditionPtr->clusterId( ),
                                                                                               i,
                                                                                               lookupOriginId )) {

                            cerr << errorStr << endl
                                 << "    Failed to find a MetaData object for increment #" << i << endl;

                            failed = true;
                            break;
                        }
                        vectorOfPtrs.push_back( mdPtr );
                    }
                }
                if( failed ) break;

            } else {

                if( recentIncrementFlag ) {

                    if( CdbStatus::Success != CdbRooRoFileUtils::instance( ).findMetaData( mdPtr,
                                                                                           conditionId,
                                                                                           isPartitionableFlag,
                                                                                           thePartitionId,
                                                                                           persistentConditionPtr->clusterId( ),
                                                                                           lastIncrement,
                                                                                           lookupOriginId )) {

                        cerr << errorStr << endl
                             << "    Failed to find a MetaData object for recent increment #" << lastIncrement << endl;
                        break;
                    }
                    vectorOfPtrs.push_back( mdPtr );

                } else {

                    if( theIncrementNumber > lastIncrement ) {
                        cerr << errorStr << endl
                             << "    Passed increment number is not valid." << endl
                             << "        PASSED NUMBER:       " << theIncrementNumber << endl
                             << "        MAX.POSSIBLE NUMBER: " << lastIncrement << endl;
                        break;
                    }
                    if( CdbStatus::Success != CdbRooRoFileUtils::instance( ).findMetaData( mdPtr,
                                                                                           conditionId,
                                                                                           isPartitionableFlag,
                                                                                           thePartitionId,
                                                                                           persistentConditionPtr->clusterId( ),
                                                                                           theIncrementNumber,
                                                                                           originId )) {
                        cerr << errorStr << endl
                             << "    Failed to find a MetaData object for specified increment #" << theIncrementNumber << endl;
                        break;
                    }
                    vectorOfPtrs.push_back( mdPtr );
                }
            }

          // Done

            theVectorOfPtrs = vectorOfPtrs;
            result          = CdbStatus::Success;

        } while( false );

        return result;
    }

  ////////////////////////////////////
  // End Of The Anonymous Namespace //
  ////////////////////////////////////

}

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

---