---

CdbBdbSCondition.cc

Go to the documentation of this file.

// File and Version Information:
//      $Id: CdbBdbSCondition.cc,v 1.36 2005/10/31 22:19:34 gapon Exp $
#include "BaBar/BaBar.hh"

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

#include "CdbBdbShared/CdbBdbSCondition.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 "CdbBdb/CdbBdbObjectCreator.hh"
#include "CdbBdb/CdbBdbObjectConvertor.hh"

#include "CdbBdbShared/CdbBdbSViewP.hh"
#include "CdbBdbShared/CdbBdbSFolderP.hh"
#include "CdbBdbShared/CdbBdbSConditionAtFolderP.hh"
#include "CdbBdbShared/CdbBdbSClusterP.hh"
#include "CdbBdbShared/CdbBdbSSimpleClusterP.hh"
#include "CdbBdbShared/CdbBdbSClusterCollectionP.hh"
#include "CdbBdbShared/CdbBdbSPartitionP.hh"
#include "CdbBdbShared/CdbBdbSPartitionsLayoutP.hh"
#include "CdbBdbShared/CdbBdbSMetaDataP.hh"
#include "CdbBdbShared/CdbBdbSConfigCollectionP.hh"
#include "CdbBdbShared/CdbBdbSOriginP.hh"
#include "CdbBdbShared/CdbBdbSOriginCollectionP.hh"
#include "CdbBdbShared/CdbBdbSRevision.hh"

#include "CdbBdbShared/CdbBdbSUtils.hh"
#include "CdbBdbShared/CdbBdbSOi.hh"
#include "CdbBdbShared/CdbBdbSView.hh"
#include "CdbBdbShared/CdbBdbSSimpleConfigIterator.hh"

#include "BdbApplication/BdbDomain.hh"

#include "BdbTime/BdbTime.hh"
#include "BdbCond/BdbObject.hh"

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

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

namespace {

/////////////////////////////////////////////
// Function declaration: Meta Data locator //
/////////////////////////////////////////////

/// Find MetaData object(s) for specified condition
/**
  * 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<BdbRef(CdbBdbSMetaDataP)>& theVectorOfRefs,
              const BdbHandle(CdbBdbSRegistryP)&     theMasterRegistryH,
              const BdbHandle(CdbBdbSRegistryP)&     theLocalRegistryH,
              const CdbBdbSId&                       theExtendedConditionId,
              d_UShort                               thePartitionId,
              bool                                   allIncrementsFlag   = true,
              bool                                   recentIncrementFlag = true,
              d_UShort                               theIncrementNumber  = 0 );

/// Serialize a value of time into a string

std::string
time2string( const BdbTime& theTime );

///////////////////////////////
// Class: RevisionIdIterator //
///////////////////////////////

class RevisionIdIterator : public CdbItr<BdbTime>::InterfaceType {

private:

    RevisionIdIterator( );

    RevisionIdIterator& operator=( const RevisionIdIterator& theItr );

protected:

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

public:


    RevisionIdIterator( const std::vector<BdbRef(CdbBdbSMetaDataP)>& theMetaDataRefs ) :
        _metaDataRefs       (theMetaDataRefs),
        _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( _metaDataRefs.end( ) != _itr ) {

                BdbRef(CdbBdbSMetaDataP) rRef = (*_itr);
                if( CdbStatus::Success != rRef->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 = _metaDataRefs.begin( );
            if( _metaDataRefs.end( ) == _itr ) {
                _isValid = false;
                return _isValid;    // go into the "past the last element" state      
            }
            BdbRef(CdbBdbSMetaDataP) rRef = (*_itr);

            if( CdbStatus::Success != rRef->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<BdbRef(CdbBdbSMetaDataP)> _metaDataRefs;

    bool _isValid;
    bool _hasEverBeenAdvanced;

    BdbTime _value;

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

    std::vector<BdbRef(CdbBdbSMetaDataP)>::const_iterator _itr;

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

    CdbItr<BdbTime> _revItr;
};

/////////////////////////////////
// Class: RevisionNameIterator //
/////////////////////////////////

class RevisionNameIterator : public CdbItr<const char*>::InterfaceType {

private:

    RevisionNameIterator( );

    RevisionNameIterator& operator=( const RevisionNameIterator& theItr );

protected:

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

public:


    RevisionNameIterator( const std::vector<BdbRef(CdbBdbSMetaDataP)>& theMetaDataRefs ) :
        _metaDataRefs       (theMetaDataRefs),
        _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( _metaDataRefs.end( ) != _itr ) {

                BdbRef(CdbBdbSMetaDataP) rRef = (*_itr);
                if( CdbStatus::Success != rRef->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 = _metaDataRefs.begin( );
            if( _metaDataRefs.end( ) == _itr ) {
                _isValid = false;
                return _isValid;    // go into the "past the last element" state      
            }
            BdbRef(CdbBdbSMetaDataP) rRef = (*_itr);

            if( CdbStatus::Success != rRef->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<BdbRef(CdbBdbSMetaDataP)> _metaDataRefs;

    bool _isValid;
    bool _hasEverBeenAdvanced;

    std::string _value;

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

    std::vector<BdbRef(CdbBdbSMetaDataP)>::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< CdbBdbSConfigInterval >& theConfigItr,
                                 const BdbHandle(CdbBdbSRegistryP)&     theMasterRegistryH,
                                 const BdbHandle(CdbBdbSRegistryP)&     theLocalRegistryH,
                                 const CdbBdbSId&                       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( BdbHandle(CdbBdbSPartitionP)& theHandle,
                        d_UShort                      thePartitionId );

private:

  // Parameters

    CdbConditionPtr _parent;

    BdbTime _begin;
    BdbTime _end;

    CdbItr< CdbBdbSConfigInterval > _configItr;

    BdbHandle(CdbBdbSRegistryP) _masterRegistryH;
    BdbHandle(CdbBdbSRegistryP) _localRegistryH;

    CdbBdbSId _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 BdbHandle(CdbBdbSMetaDataP)& theMetaDataH,
            const BdbTime&                     theRevisionId );

        MD( const BdbHandle(CdbBdbSMetaDataP)& theMetaDataH,
            const CdbItr<CdbBdbSCi>&           theObjectItr,
            const BdbTime&                     theRevisionId,
            const BdbTime&                     theBeginTime,
            const BdbTime&                     theEndTime );

        MD( const MD& theMd );

        ~MD( );

        MD& operator=( const MD& theMd );

    public:

        BdbHandle(CdbBdbSMetaDataP) handle;

        CdbItr<CdbBdbSCi> itr;

        BdbTime revision;
        BdbTime begin;
        BdbTime end;

        bool inHole;

        CdbItr< CdbBdbSPartitionInterval > 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( d_UShort                           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:

        d_UShort _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 BdbHandle(CdbBdbSMetaDataP)& theMetaDataH,
                                     const BdbTime&                     theRevisionId ) :
    handle  (theMetaDataH ),
    revision(theRevisionId),
    inHole  (false        )
{ }

PartitionableObjectIterator::MD::MD( const BdbHandle(CdbBdbSMetaDataP)& theMetaDataH,
                                     const CdbItr<CdbBdbSCi>&           theObjectItr,
                                     const BdbTime&                     theRevisionId,
                                     const BdbTime&                     theBeginTime,
                                     const BdbTime&                     theEndTime ) :
    handle  (theMetaDataH ),
    itr     (theObjectItr ),
    revision(theRevisionId),
    begin   (theBeginTime ),
    end     (theEndTime   ),
    inHole  (false        )
{ }

PartitionableObjectIterator::MD::MD( const PartitionableObjectIterator::MD& theMd ) :
    handle  (theMd.handle  ),
    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 ) {
        handle   = theMd.handle;
        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( d_UShort                           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),
    _masterRegistryH      (theItr._masterRegistryH),
    _localRegistryH       (theItr._localRegistryH),
    _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< CdbBdbSConfigInterval >& theConfigItr,
                                                          const BdbHandle(CdbBdbSRegistryP)&     theMasterRegistryH,
                                                          const BdbHandle(CdbBdbSRegistryP)&     theLocalRegistryH,
                                                          const CdbBdbSId&                       theExtendedConditionId,
                                                          const BdbTime&                         theConditionCreationTime ) :
    _parent               (theParentPtr),
    _begin                (theBegin),
    _end                  (theEnd),
    _configItr            (theConfigItr),
    _masterRegistryH      (theMasterRegistryH),
    _localRegistryH       (theLocalRegistryH),
    _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 = "CdbBdbSCondition::PartitionableObjectIterator::tryNextPartition()";
    const char* errorStr = "CdbBdbSCondition::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      = " << time2string( theBeginTime ).c_str( ) << endl
         << "        theEndTime        = " << time2string( theEndTime ).c_str( ) << endl
         << "}" << endl;
/*********************************************************************************************/

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

    BdbHandle(CdbBdbSPartitionsLayoutP) pLayoutH;

    pLayoutH = _masterRegistryH->partitionsLayout( );
    if( BdbIsNull(pLayoutH)) {
        cout << errorStr << endl
             << "    The database could be corrupted or be in an inconsistent state." << endl;
        assert( 0 );
        return false;
    }
    BdbRef(CdbBdbSPartitionP) pRef;
    if( CdbStatus::Success != pLayoutH->find( _cxt._partitionId, pRef )) {
        cout << 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 = pLayoutH->iterator( pRef->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 = "CdbBdbSCondition::PartitionableObjectIterator::tryNextObject()";
    const char* errorStr = "CdbBdbSCondition::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.

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

                {
                    d_UShort partitionId = iVal.id;

                    BdbHandle(CdbBdbSPartitionP) pH;
                    if( ! findPartition( pH, partitionId )) {
                        cout << errorStr << endl
                             << "    Failed to locate the partition with ID=" << partitionId << endl;
                        return false;
                    }

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

                    if( pH->isClosed( )) {
                        CdbBdbSCell pCell = pH->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    = " << time2string( _cxt._md[_cxt._mdCurrent].begin    ).c_str( ) << endl
         << "    _cxt._md[" << _cxt._mdCurrent << "].end      = " << time2string( _cxt._md[_cxt._mdCurrent].end      ).c_str( ) << endl
         << "    _cxt._md[" << _cxt._mdCurrent << "].revision = " << time2string( _cxt._md[_cxt._mdCurrent].revision ).c_str( ) << endl
         << "}" << endl;
/**************************************************************************************************************************************/

                    if( CdbStatus::Success != _cxt._md[_cxt._mdCurrent].handle->objectIterator( _cxt._md[_cxt._mdCurrent].itr,
                                                                                                _cxt._md[_cxt._mdCurrent].revision,
                                                                                                _cxt._md[_cxt._mdCurrent].begin,
                                                                                                _cxt._md[_cxt._mdCurrent].end )) {
                        cout << 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          = " << time2string( _cxt._begin ).c_str( ) << endl
         << "        _cxt._end            = " << time2string( _cxt._end ).c_str( ) << endl
         << "}" << endl;

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

                std::vector< BdbRef(CdbBdbSMetaDataP) > vectorOfMdRefs;

                bool allIncrementsFlag = true;

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

                _cxt._md.clear( );

                std::vector< BdbRef(CdbBdbSMetaDataP) >::size_type i;
                std::vector< BdbRef(CdbBdbSMetaDataP) >::size_type num = vectorOfMdRefs.size( );

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

                    BdbHandle(CdbBdbSMetaDataP) mdH;
                    mdH = vectorOfMdRefs[i];

                    BdbTime modified = mdH->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<CdbBdbSCi> itr;
                        if( CdbStatus::Success != mdH->objectIterator( itr,
                                                                       modified,
                                                                       _cxt._begin,
                                                                       _cxt._end )) {
                            cout << errorStr << endl
                                 << "    Failed to set up the iterator." << endl;
                            return false;
                        }

                      // Top element of the stack

                        _cxt._md.push_back( MD( mdH,
                                                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( mdH,
                                                modified ));
                    }
               }

              // Switch to the topmost MD of the prepared context

                if( 0 == _cxt._md.size( )) {
                    cout << 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( )) {

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

/**************************************************************************************************************************************/
if( CdbEnvironment::getDebugMode( ) != 0 )
    cout << debugStr << endl
         << "{" << endl
         << "    _cxt._md[" << _cxt._mdCurrent << "].begin    = " << time2string( _cxt._md[_cxt._mdCurrent].begin    ).c_str( ) << endl
         << "    _cxt._md[" << _cxt._mdCurrent << "].end      = " << time2string( _cxt._md[_cxt._mdCurrent].end      ).c_str( ) << endl
         << "    _cxt._md[" << _cxt._mdCurrent << "].revision = " << time2string( _cxt._md[_cxt._mdCurrent].revision ).c_str( ) << 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].handle->objectIterator( _cxt._md[_cxt._mdCurrent].itr,
                                                                                                _cxt._md[_cxt._mdCurrent].revision,
                                                                                                _cxt._md[_cxt._mdCurrent].begin,
                                                                                                _cxt._md[_cxt._mdCurrent].end )) {
                        cout << 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.

                    if( CdbStatus::Success != CdbBdbObjectCreator::object( _value,
                                                                           _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 )) {
                        cout << errorStr << endl
                             << "    Failed to creae a generic object." << endl;
                        return false;
                    }

                    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( BdbHandle(CdbBdbSPartitionP)& theHandle,
                                            d_UShort                      thePartitionId )
{
    const char* errorStr = "CdbBdbSCondition::PartitionableObjectIterator::findPartition() -- ERROR";

    bool result = false;
    do {

      // The temporary partition reference required by some interfaces.

        BdbRef(CdbBdbSPartitionP) pRef;

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

        BdbRef(CdbBdbSPartitionsLayoutP) pLayoutRef = _masterRegistryH->partitionsLayout( );
        assert( ! BdbIsNull(pLayoutRef));

        if( CdbStatus::Success != pLayoutRef->find( thePartitionId,
                                                    pRef )) {
            cout << errorStr << endl
                     << "    Failed to find a partition #" << thePartitionId << " at the master registry." << endl;
            break;
        }
        theHandle = pRef;

        if(( _localRegistryH->originId( ) == theHandle->originId( )) &&
           ( _localRegistryH->originId( ) != _masterRegistryH->originId( ))) {

            pLayoutRef = _localRegistryH->partitionsLayout( );
            assert( ! BdbIsNull(pLayoutRef));

            if( CdbStatus::Success != pLayoutRef->find( thePartitionId,
                                                        pRef )) {
                cout << errorStr << endl
                     << "    Failed to find a partition #" << thePartitionId << " at the local registry." << endl;
                break;
            }
            theHandle = pRef;
        }

      // Done.

        result = true;

    } while( false );

    return result;
}

bool
PartitionableObjectIterator::tryNextConfigElement( )
{
    const char* debugStr = "CdbBdbSCondition::PartitionableObjectIterator::tryNextConfigElement()";
    const char* errorStr = "CdbBdbSCondition::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."

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

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

        if( in.value.useRevision ) _revisionId = in.value.revision;
        else                       _revisionId = BdbTime::plusInfinity;

        _cxt._partitionId = in.value.partition;

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

        {
            BdbHandle(CdbBdbSPartitionP) pH;
            if( ! findPartition( pH, _cxt._partitionId )) {
                cout << errorStr << endl
                     << "    Failed to locate the partition with ID=" << _cxt._partitionId << endl;
                break;
            }

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

            if( pH->isClosed( )) {
                CdbBdbSCell pCell = pH->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< BdbRef(CdbBdbSMetaDataP) > vectorOfMdRefs;

        bool allIncrementsFlag = true;

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

        const std::vector< BdbRef(CdbBdbSMetaDataP) >::size_type numPart = vectorOfMdRefs.size( );
        if( 0 == numPart ) {
            cout << 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< BdbRef(CdbBdbSMetaDataP) >::size_type i = 0; i < numPart; ++i ) {

            BdbHandle(CdbBdbSMetaDataP) mdH;
            mdH = vectorOfMdRefs[i];

            if( _revisionId >= mdH->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 == mdH->maxInsertion( ))) ||
                   ( _revisionId < mdH->maxInsertion( ))) {

                  // -1-

                  // Set up an iterator matching the exact revision.

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

                  // Top element of the stack

                    _cxt._md.push_back( MD( mdH,
                                            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          = " << time2string( _cxt._begin ).c_str( ) << endl
         << "        _cxt._end            = " << time2string( _cxt._end ).c_str( ) << endl
         << "        mdH->minInsertion( ) = " << time2string( mdH->minInsertion( )).c_str( ) << endl
         << "        mdH->maxInsertion( ) = " << time2string( mdH->maxInsertion( )).c_str( ) << endl
         << "        _revisionId          = " << time2string( _revisionId ).c_str( ) << 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 != mdH->maxInsertion( ))){

                  // -2-

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

                    BdbTime modified = mdH->modified( );

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

                  // Top element of the stack

                    _cxt._md.push_back( MD( mdH,
                                            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          = " << time2string( _cxt._begin ).c_str( ) << endl
         << "        _cxt._end            = " << time2string( _cxt._end ).c_str( ) << endl
         << "        mdH->minInsertion( ) = " << time2string( mdH->minInsertion( )).c_str( ) << endl
         << "        mdH->maxInsertion( ) = " << time2string( mdH->maxInsertion( )).c_str( ) << endl
         << "        modified             = " << time2string( modified ).c_str( ) << 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 = mdH->modified( );
                    assert( BdbTime::plusInfinity != modified );

                    _cxt._md.push_back( MD( mdH,
                                        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          = " << time2string( _cxt._begin ).c_str( ) << endl
         << "        _cxt._end            = " << time2string( _cxt._end ).c_str( ) << endl
         << "        mdH->minInsertion( ) = " << time2string( mdH->minInsertion( )).c_str( ) << endl
         << "        mdH->maxInsertion( ) = " << time2string( mdH->maxInsertion( )).c_str( ) << endl
         << "        modified             = " << time2string( modified ).c_str( ) << endl
         << "    }" << endl
         << "}" << endl;
/**************************************************************************************************************************************/

                }

            } else {

              // We're above specified revision.

                break;
            }
        }
        if( 0 == _cxt._md.size( )) {
            cout << 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),
        _masterRegistryH    (theItr._masterRegistryH),
        _localRegistryH     (theItr._localRegistryH),
        _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< CdbBdbSConfigInterval > theConfigItr,
                           const BdbHandle(CdbBdbSRegistryP)&    theMasterRegistryH,
                           const BdbHandle(CdbBdbSRegistryP)&    theLocalRegistryH,
                           const CdbBdbSId&                      theExtendedConditionId ) :
        _parent             (theParentPtr),
        _begin              (theBegin),
        _end                (theEnd),
        _configItr          (theConfigItr),
        _masterRegistryH    (theMasterRegistryH),
        _localRegistryH     (theLocalRegistryH),
        _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< CdbBdbSConfigInterval > _configItr;

    BdbHandle(CdbBdbSRegistryP) _masterRegistryH;
    BdbHandle(CdbBdbSRegistryP) _localRegistryH;

    CdbBdbSId _extendedConditionId;

  // The current state

    bool _isValid;
    bool _hasEverBeenAdvanced;

    CdbObjectPtr _value;

  // The context : configuration element

    BdbTime _beginConfig;
    BdbTime _endConfig;
    BdbTime _revisionId;

    d_UShort _partitionId;

  // The context : meta-data

    class MD {

    public:

        MD( ) { }

        MD( const BdbHandle(CdbBdbSMetaDataP)& theMetaDataH,
            const BdbTime&                     theRevisionId ) :
            handle  (theMetaDataH ),
            revision(theRevisionId) { }

        MD( const BdbHandle(CdbBdbSMetaDataP)& theMetaDataH,
            const CdbItr<CdbBdbSCi>&           theObjectItr,
            const BdbTime&                     theRevisionId,
            const BdbTime&                     theBeginTime,
            const BdbTime&                     theEndTime ) :
            handle  (theMetaDataH ),
            itr     (theObjectItr ),
            revision(theRevisionId),
            begin   (theBeginTime ),
            end     (theEndTime   ) { }

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

        ~MD( ) { }

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

    public:

        BdbHandle(CdbBdbSMetaDataP) handle;

        CdbItr<CdbBdbSCi> itr;

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

  // The context : object
};

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

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

    do {

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

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

/**************************************************************************************************************/
if( CdbEnvironment::getDebugMode( ) != 0 )
    cout << debugStr << endl
         << "{" << endl
         << "    _md[" << _mdCurrent << "].begin    = " << time2string( _md[_mdCurrent].begin    ).c_str( ) << endl
         << "    _md[" << _mdCurrent << "].end      = " << time2string( _md[_mdCurrent].end      ).c_str( ) << endl
         << "    _md[" << _mdCurrent << "].revision = " << time2string( _md[_mdCurrent].revision ).c_str( ) << 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].handle->objectIterator( _md[_mdCurrent].itr,
                                                                                      _md[_mdCurrent].revision,
                                                                                      _md[_mdCurrent].begin,
                                                                                      _md[_mdCurrent].end )) {
                        cout << 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.

                    if( CdbStatus::Success != CdbBdbObjectCreator::object( _value,
                                                                           _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 )) {
                        cout << errorStr << endl
                             << "    Failed to creae a generic object." << endl;
                        return false;
                    }

                    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 = "CdbBdbSCondition::RegularObjectIterator::tryNextConfigElement()";
    const char* errorStr = "CdbBdbSCondition::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."

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

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

        if( in.value.useRevision ) _revisionId = in.value.revision;
        else                       _revisionId = BdbTime::plusInfinity;

        _partitionId = in.value.partition;

      // 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< BdbRef(CdbBdbSMetaDataP) > vectorOfMdRefs;

        bool allIncrementsFlag = true;

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

        _md.clear( );

        for( std::vector< BdbRef(CdbBdbSMetaDataP) >::size_type i = 0; i < vectorOfMdRefs.size( ); ++i ) {

            BdbHandle(CdbBdbSMetaDataP) mdH;
            mdH = vectorOfMdRefs[i];

            if( _revisionId >= mdH->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 == mdH->maxInsertion( )))
                    ||
                    ( _revisionId < mdH->maxInsertion( ))) {

                  // Set up an iterator matching the revision.

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

                  // Top element of the stack

                    _md.push_back( MD( mdH,
                                       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 = mdH->modified( );
                    assert( BdbTime::plusInfinity != modified );

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

            } else {

              // We're above specified revision.

                break;
            }
        }
        if( 0 == _md.size( )) {
            cout << 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;
}

///////////////////////////////////
// Class: OriginalObjectIterator //
///////////////////////////////////

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),
        _masterRegistryH       (theItr._masterRegistryH),
        _localRegistryH        (theItr._localRegistryH),
        _extendedConditionId   (theItr._extendedConditionId),
        _partitionId           (theItr._partitionId),

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

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

public:

    OriginalObjectIterator( const CdbConditionPtr&             theParentPtr,
                            const BdbTime&                     theBegin,
                            const BdbTime&                     theEnd,
                            const BdbHandle(CdbBdbSRegistryP)& theMasterRegistryH,
                            const BdbHandle(CdbBdbSRegistryP)& theLocalRegistryH,
                            const CdbBdbSId&                   theExtendedConditionId,
                            const d_UShort                     thePartitionId ) :
        _parent             (theParentPtr),
        _begin              (theBegin),
        _end                (theEnd),
        _masterRegistryH    (theMasterRegistryH),
        _localRegistryH     (theLocalRegistryH),
        _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 = "CdbBdbSCondition::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,
                                                     _masterRegistryH,
                                                     _localRegistryH,
                                                     _extendedConditionId,
                                                     _partitionId,
                                                     allIncrementsFlag )) {
                cout << 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.

                _mdCurrentOiCollectionH = _md[_mdCurrent]->originaIntervalsCollection( );

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

    BdbHandle(CdbBdbSRegistryP) _masterRegistryH;
    BdbHandle(CdbBdbSRegistryP) _localRegistryH;

    CdbBdbSId _extendedConditionId;

    d_UShort _partitionId;

  // The current state

    bool _isValid;
    bool _hasEverBeenAdvanced;

    CdbObjectPtr _value;

  // The context : meta-data

    std::vector<BdbRef(CdbBdbSMetaDataP)>            _md;
    std::vector<BdbRef(CdbBdbSMetaDataP)>::size_type _mdCurrent;

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

    BdbHandle( CdbBdbSOiCollectionP ) _mdCurrentOiCollectionH;

    d_ULong _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

    _mdCurrentOiCollectionH = _md[_mdCurrent]->originaIntervalsCollection( );
    _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 = "CdbBdbSCondition::OriginalObjectIterator::tryNextObject() -- ERROR";

    assert( _md.size( ) > 0 );
    assert( _mdCurrent < _md.size( ));
    assert( !BdbIsNull(_mdCurrentOiCollectionH));
    assert( _mdCurrentOi < _mdCurrentOiCollectionH->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 >= _mdCurrentOiCollectionH->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.

    CdbBdbSOi oi;

    BdbTime beginDuration;
    BdbTime endDuration;

    do {

        if( CdbStatus::Success != _mdCurrentOiCollectionH->find( _mdCurrentOi,
                                                                 oi,
                                                                 beginDuration,
                                                                 endDuration )) {
            cout << 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 >= _mdCurrentOiCollectionH->size( )) return tryNextMetaData( );

    } while( true );

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

    if( CdbStatus::Success != CdbBdbObjectCreator::object( _value,
                                                           _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 )) {
        cout << errorStr << endl
             << "    Failed to create a generic object." << endl;

        return false;
    }
    return true;
}

//////////////////////////////////////////////
// Function: Build Composite Condition Name //
//////////////////////////////////////////////
//
// DESCRIPTION:
//
//   This function will attempt to translate the condition identifier into a composite
//   name. The corresponding physical condition must be available in the database.
//
// NOTES:
//
//   The output value passed to the function by its reference
//   will not change if the operation will fail.
//
//   If the function will fail for one or another reason then
//   it will print the corresponding message onto the styandard output
//   and return CdbStatus::Error.

CdbStatus
buildCompositeConditionName( CdbCompositeName&                  theCompositeName,
                             const CdbBdbSId&                   theId,
                             const BdbHandle(CdbBdbSRegistryP)& theMasterRegistryH );

/////////////////////////////////////////////////////
// Function: Calculate Condition Modification Time //
/////////////////////////////////////////////////////
//
// DESCRIPTION:
//
//   This method will calculate the condition modification time as it's seen through
//   the current view. In reality it may mean that the actual modification time may be newer
//   than the one found by this method. However in practice the clients of the view should not
//   be aware about this.
//
// NOTES:
//
//   The output value passed to the function by its reference
//   will not change if the operation will fail.
//
//   If the function will fail for one or another reason then
//   it will print the corresponding message onto the styandard output
//   and return CdbStatus::Error.

CdbStatus
calculateConditionModificationTime( BdbTime&                                    theModificationTime,
                                    const CdbBdbSId&                            thePhysicalAddress,
                                    const BdbHandle(CdbBdbSConditionAtFolderP)& theConditionAtFolderH,
                                    const BdbHandle(CdbBdbSRegistryP)&          theMasterRegistryH,
                                    const BdbHandle(CdbBdbSRegistryP)&          theLocalRegistryH );
};

//////////////////////////////
/// Class: CdbBdbSCondition //
//////////////////////////////

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

CdbBdbSCondition::CdbBdbSCondition( const CdbFolderPtr&                         theFolderPtr,
                                    const CdbDatabasePtr&                       theDatabasePtr,
                                    const char*                                 theName,
                                    const CdbBdbSId&                            thePhysicalAddress,
                                    const BdbHandle(CdbBdbSConditionAtFolderP)& theConditionAtFolderH,
                                    const BdbHandle(CdbBdbSConditionP)&         theConditionH,
                                    const BdbHandle(CdbBdbSRegistryP)&          theMasterRegistryH,
                                    const BdbHandle(CdbBdbSRegistryP)&          theLocalRegistryH ) :
    CdbCondition( theFolderPtr,
                  theDatabasePtr,
                  theName ),
    _physicalAddress   (thePhysicalAddress),
    _conditionAtFolderH(theConditionAtFolderH),
    _conditionH        (theConditionH),
    _masterRegistryH   (theMasterRegistryH),
    _localRegistryH    (theLocalRegistryH),
    _mdContH           (0),
    _obContH           (0)
{ }

CdbBdbSCondition::CdbBdbSCondition( const CdbBdbSCondition& theCondition ) :
    CdbCondition( theCondition ),
    _physicalAddress   (theCondition._physicalAddress),
    _conditionAtFolderH(theCondition._conditionAtFolderH),
    _conditionH        (theCondition._conditionH),
    _masterRegistryH   (theCondition._masterRegistryH),
    _localRegistryH    (theCondition._localRegistryH),
    _mdContH           (theCondition._mdContH),
    _obContH           (theCondition._obContH)
{ }

CdbBdbSCondition::~CdbBdbSCondition( )
{ }

std::string
CdbBdbSCondition::description( ) const
{
    if( BdbIsNull(_conditionAtFolderH)) return std::string( _conditionH->description( ).head( ));
    return std::string( _conditionAtFolderH->description( ).head( ));
}

bool
CdbBdbSCondition::isPartitionable( ) const
{
    return _conditionH->isPartitionable( );
}

CdbCompositeName
CdbBdbSCondition::physicalName( ) const
{
    CdbCompositeName result;    // object in the "non-valid" state

    if( CdbStatus::Success != buildCompositeConditionName( result,
                                                           _physicalAddress,
                                                           _masterRegistryH )) {

      // By the contract of the above used method it's not going to change
      // the original value of the returned object unless operation is successfull.

      // No further actions to be taken here. Just return an object in the "non-valid".
      // It's up to the client applications to catch up this problem properly.

        ;
    }
    return result;
}

CdbId
CdbBdbSCondition::physicalId( ) const
{
    return CdbId( _physicalAddress.origin,
                  _physicalAddress.local );
}

BdbTime
CdbBdbSCondition::created( ) const
{
    return _conditionH->created( );
}

BdbTime
CdbBdbSCondition::registered( ) const
{
    if( BdbIsNull(_conditionAtFolderH)) return _conditionH->created( );
    return _conditionAtFolderH->created( );
}

BdbTime
CdbBdbSCondition::modified( ) const
{
    BdbTime result = BdbTime::minusInfinity;    // this default value means a failure of the algorithm

    if( CdbStatus::Success != calculateConditionModificationTime( result,
                                                                  _physicalAddress,
                                                                  _conditionAtFolderH,
                                                                  _masterRegistryH,
                                                                  _localRegistryH )) {

      // By the contract of the above used method it's not going to change
      // the original value of the returned object unless operation is successfull.

      // No further actions to be taken here. Just return an object in its default state.
      // It's up to the client applications to catch up this problem properly.

        ;
    }
    return result;

}

CdbStatus
CdbBdbSCondition::findObject( CdbObjectPtr&  theObjectPtr,
                              const BdbTime& theValidityTime,
                              const BdbTime& theInsertionTime )
{
    const char* errorStr = "CdbBdbSCondition::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( BdbIsNull(_conditionAtFolderH)) {

      // 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( _conditionH->isPartitionable( )) {

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

                d_ULong partitionId = 0;
                {
                    BdbHandle(CdbBdbSPartitionP) pH;

                    std::string dbIdRange;  // don't really need and use it here.

                    if( CdbStatus::Success != findInitialPartition( theValidityTime,
                                                                    theInsertionTime,
                                                                    pH,
                                                                    dbIdRange )) {
                        cout << 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              : " << time2string( theValidityTime ).c_str( )  << " : " << theValidityTime  << endl
                             << "        INSERTION TIME             : " << time2string( theInsertionTime ).c_str( ) << " : " << theInsertionTime << endl;

                        return CdbStatus::Error;
                    }
                    partitionId = pH->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<BdbRef(CdbBdbSMetaDataP)> vectorOfMdRefs;

                    bool allIncrementsFlag   = false;
                    bool recentIncrementFlag = true;


                    if( CdbStatus::Success != findMetaData( vectorOfMdRefs,
                                                            _masterRegistryH,
                                                            _localRegistryH,
                                                            _physicalAddress,
                                                            partitionId,
                                                            allIncrementsFlag,
                                                            recentIncrementFlag )) {
                        cout << 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              : " << time2string( theValidityTime ).c_str( )  << " : " << theValidityTime  << endl
                             << "        INSERTION TIME             : " << time2string( theInsertionTime ).c_str( ) << " : " << theInsertionTime << endl;

                        return CdbStatus::Error;
                    }

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

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

                  // Find the most recent revision

                    BdbHandle(CdbBdbSMetaDataP) mdH = vectorOfMdRefs[0];

                    CdbItr<BdbTime> rItr;

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

                        cout << errorStr << endl
                             << "    Failed to setup an iterator of revision identifiers in" << endl
                             << "    the most recent MetaData objects for the current condition/partition." << endl
                             << "        META-DATA OBJECT           : " << mdH.sprint( ) << endl
                             << "        PARTITION                  : " << partitionId << endl
                             << "        PHYSICAL CONDITION ADDRESS : " << _physicalAddress << endl
                             << "        VALIDITY TIME              : " << time2string( theValidityTime ).c_str( )  << " : " << theValidityTime  << endl
                             << "        INSERTION TIME             : " << time2string( theInsertionTime ).c_str( ) << " : " << 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=" << CdbCondition::fullPathName( this->clone( ))
        << " validity_time=" << theValidityTime.getGmtSec( ) << "." << theValidityTime.getGmtNsec( )
        << " insertion_time=" << theInsertionTime.getGmtSec( ) << "." << theInsertionTime.getGmtNsec( ) << endl;

    theObjectPtr = 0;

    BdbRef(BdbObject) foundObjectRef = 0;
    CdbStatus         result         = CdbStatus::Error;
    do {

      // Check if the current view is frozen.

        BdbRef(CdbBdbSFolderP) fRef = _conditionAtFolderH->parentFolder( );
        assert( !BdbIsNull(fRef));

        BdbRef(CdbBdbSViewP) vRef = fRef->parentView( );
        assert( !BdbIsNull(vRef));
/***
 *** NOTE: This test is disabled because we should allow reading through
 ***       views even though they are open for modifications.
 ***
        if( !vRef->isFrozen( )) {
            cout << errorStr << endl
                 << "    The current view is not 'frozen' from modifications. This sort of view" << endl
                 << "    can not be used to find condition objects at the database." << endl
                 << "        VIEW NAME: \"" << parent( )->parentView( )->name( ) << "\"" << endl;
            break;
        }
***/
      // Check if specified validity time is covered by the validity
      // interval of the current view.

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

            cout << 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: " << theValidityTime << endl;
            break;
        }

      // All we need to do is to find out a revision policy for
      // the condition.

        CdbBdbSConfigInterval rConfigInterval;
        {
            BdbRef(CdbBdbSConfigCollectionP) rConfigRef = _conditionAtFolderH->config( );
            if( BdbIsNull(rConfigRef)) {

                rConfigRef = vRef->defaultConfig( );
                if( BdbIsNull(rConfigRef)) {
                    cout << errorStr << endl
                         << "    Failed to find revision configuration for current condition" << endl
                         << "    at the current view." << endl
                         << "    The view may be inproperly configured." << endl
                         << "        CONDITION NAME: \"" << name( ) << "\"" << endl
                         << "        VIEW NAME:      \"" << parent( )->parentView( )->name( ) << "\"" << endl;
                    break;
                }
            }
            if( CdbStatus::Success != rConfigRef->find( theValidityTime,
                                                        rConfigInterval )) {
                cout << errorStr << endl
                     << "    Failed to find revision policy information for specified validity time" << endl
                     << "    at the condition description of the  the current view." << endl
                     << "    The view may be inproperly configured." << endl
                     << "        PASSED TIME:    " << theValidityTime << endl
                     << "        CONDITION NAME: \"" << name( ) << "\"" << endl
                     << "        VIEW NAME:      \"" << parent( )->parentView( )->name( ) << "\"" << endl;
                break;
            }
        }
        if( ! rConfigInterval.value.accessIsAllowed( )) {
            cout << 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: " << theValidityTime << endl;
            break;
        }
        CdbRevisionPolicy rPolicy;
        {
            CdbBdbSConfigElement rConfigElement = rConfigInterval.value;
            if( d_True == rConfigElement.useRevision ) {
                rPolicy = CdbRevisionPolicy( rConfigElement.revision,
                                             rConfigElement.partition );
            }
        }

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

        CdbBdbSOi originalInterval;

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

        if( _conditionH->isPartitionable( )) {
            if( CdbStatus::Success != doFindObjectAtPartition( rPolicy,
                                                               theValidityTime,
                                                               theInsertionTime,
                                                               originalInterval, 
                                                               beginOfVisiblePeriod,
                                                               endOfVisiblePeriod,
                                                               beginOfDurationPeriod,
                                                               endOfDurationPeriod )) break;
        } else {
            if( CdbStatus::Success != doFindObject( rPolicy,
                                                    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( rConfigInterval.begin > beginOfVisiblePeriod ) beginOfVisiblePeriod = rConfigInterval.begin;
        if( rConfigInterval.end   < endOfVisiblePeriod   ) endOfVisiblePeriod   = rConfigInterval.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.

        CdbConditionPtr myPtr( this->clone( ));

        if( CdbStatus::Success != CdbBdbObjectCreator::object( theObjectPtr,
                                                               myPtr,
                                                               originalInterval.begin,
                                                               originalInterval.end,
                                                               beginOfVisiblePeriod,
                                                               endOfVisiblePeriod,
                                                               beginOfDurationPeriod,
                                                               endOfDurationPeriod,
                                                               originalInterval.inserted,
                                                               originalInterval.object )) break;

     // Done

       foundObjectRef = originalInterval.object;
       result         = CdbStatus::Success;

    } while( false );

    CDB_DEBUG_STREAM << "CDB_FIND_OBJECT_1: " << foundObjectRef.sprint( ) << endl;

    return result;
}

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

    CDB_DEBUG_STREAM
        << "CDB_FIND_OBJECT_2: condition=" << CdbCondition::fullPathName( this->clone( ))
        << " validity_time=" << theValidityTime.getGmtSec( ) << "." << theValidityTime.getGmtNsec( ) 
        << " insertion_time=" << theInsertionTime.getGmtSec( ) << "." << theInsertionTime.getGmtNsec( ) << endl;

    BdbRef(BdbObject) foundObjectRef = 0;
    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.

        CdbBdbSOi originalInterval;

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

        if( _conditionH->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.

        CdbConditionPtr myPtr( this->clone( ));

        if( CdbStatus::Success != CdbBdbObjectCreator::object( theObjectPtr,
                                                               myPtr,
                                                               originalInterval.begin,
                                                               originalInterval.end,
                                                               beginOfVisiblePeriod,
                                                               endOfVisiblePeriod,
                                                               beginOfDurationPeriod,
                                                               endOfDurationPeriod,
                                                               originalInterval.inserted,
                                                               originalInterval.object )) break;

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

    return result;
}

CdbStatus
CdbBdbSCondition::objectIterator( CdbObjectItr&  theItr,
                                  const BdbTime& theBeginValidity,
                                  const BdbTime& theEndValidity )
{
    const char* errorStr = "CdbBdbSCondition::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( BdbIsNull(_conditionAtFolderH)) {
        return CdbStatus::NotImplemented;
    }

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

    CdbStatus result = CdbStatus::NotFound;
    do {

      // Verify parameters

        if( theEndValidity <= theBeginValidity ) {
            cout << 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;
        }

        BdbHandle(CdbBdbSViewP) viewH;
        viewH = _conditionAtFolderH->parentFolder( )->parentView( );

        BdbTime minValidity = viewH->minValidity( );
        BdbTime maxValidity = viewH->maxValidity( );

        if(( theBeginValidity >= maxValidity ) || ( theEndValidity <= minValidity )) {
            cout << 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 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.

        BdbRef(CdbBdbSConfigCollectionP) configCollRef = _conditionAtFolderH->config( );
        if( BdbIsNull(configCollRef)) {

            configCollRef = viewH->defaultConfig( );
            if( BdbIsNull(configCollRef)) {
                cout << errorStr << endl
                     << "    The current view is inproperly configured for specified condition." << endl
                     << "    No configuration found both at specified condition scope and" << endl
                     << "    at the view level." << endl
                     << "        VIEW              : \"" << parent( )->parentView( )->name( ) << "\"" << endl
                     << "        CONDITION         : \"" << name( ) << "\"" << endl;
                break;
            }
        }

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

        CdbConditionPtr myPtr( this->clone( ));

        if( _conditionH->isPartitionable( )) {

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

            theItr = CdbObjectItr( new PartitionableObjectIterator( myPtr,
                                                                    theBeginValidity,
                                                                    theEndValidity,
                                                                    configCollRef->iterator( ),
                                                                    _masterRegistryH,
                                                                    _localRegistryH,
                                                                    _physicalAddress,
                                                                    _conditionH->created( )));
        } else {

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

            theItr = CdbObjectItr( new RegularObjectIterator( myPtr,
                                                              theBeginValidity,
                                                              theEndValidity,
                                                              configCollRef->iterator( ),
                                                              _masterRegistryH,
                                                              _localRegistryH,
                                                              _physicalAddress));
        }

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

    return result;
}

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

    CdbStatus result = CdbStatus::NotFound;
    do {

      // Verify parameters

        if( theEndValidity <= theBeginValidity ) {
            cout << 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<CdbBdbSConfigInterval> configItr( new CdbBdbSSimpleConfigIterator( CdbBdbSConfigElement( thePolicy.revisionId( ),
                                                                                                        thePolicy.partitionId( ),
                                                                                                        thePolicy.useRevision( )),
                                                                                  theBeginValidity,
                                                                                  theEndValidity ));

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

        CdbConditionPtr myPtr( this->clone( ));

        if( _conditionH->isPartitionable( )) {

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

            theItr = CdbObjectItr( new PartitionableObjectIterator( myPtr,
                                                                    theBeginValidity,
                                                                    theEndValidity,
                                                                    configItr,
                                                                    _masterRegistryH,
                                                                    _localRegistryH,
                                                                    _physicalAddress,
                                                                    _conditionH->created( )));
        } else {

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

            theItr = CdbObjectItr( new RegularObjectIterator( myPtr,
                                                              theBeginValidity,
                                                              theEndValidity,
                                                              configItr,
                                                              _masterRegistryH,
                                                              _localRegistryH,
                                                              _physicalAddress ));
        }

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

    return result;
}

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

    CdbStatus result = CdbStatus::NotFound;
    do {

      // Verify parameters

        if( theBeginInsertion >= theEndInsertion ) {
            cout << 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...

        CdbConditionPtr myPtr( this->clone( ));


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

        theItr = CdbObjectItr( new OriginalObjectIterator( myPtr,
                                                           theBeginInsertion,
                                                           theEndInsertion,
                                                           _masterRegistryH,
                                                           _localRegistryH,
                                                           _physicalAddress,
                                                           thePartitionId ));

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

    return result;
}

CdbStatus
CdbBdbSCondition::storeObject( CdbObjectFactoryBase& theObjectFactory,
                               const BdbTime&        theBegin,
                               const BdbTime&        theEnd,
                               CdbObjectPtr&         theObjectPtr )
{
    const char* errorStr = "CdbBdbSCondition::storeObject() -- ERROR";

    CDB_DEBUG_STREAM
        << "CDB_STORE_OBJECT_1: condition=" << CdbCondition::fullPathName( this->clone( ))
        << " begin_time=" << theBegin.getGmtSec( ) << "." << theBegin.getGmtNsec( ) 
        << " end_time=" << theEnd.getGmtSec( ) << "." << theEnd.getGmtNsec( ) << endl;

    CdbStatus result = CdbStatus::Error;

    theObjectPtr = 0;

    do {

      // Truncated end validity time for the new object.
      //
      // NOTES:
      //
      //    (1) This time can be truncated to the end of the current partition if this
      //        is a partitionable condition and if the end time does not fit into the
      //        same partition the begin time falls into.
      //
      //    (2) This time can be further truncated if the "truncate" parameter delivered
      //        by by CdbEnvironment is less than the adjusted end time. This rule applies
      //        for both 'regular' and 'partitionable' conditions.
      //
      //        NOTE: The resulting truncate time should not be less or equal to the begin
      //              time. Otherwise the current operation would fail.

        BdbTime truncatedEnd = theEnd;

      // Find out a the cluster the condition belongs to

        BdbRef(CdbBdbSClusterP) clusterRef = _conditionH->cluster( );
        assert( !BdbIsNull(clusterRef));

      // Find & verify the partition if the current condition is the partitionable one.
      // We may also truncate the end time of the partition if required.

        bool isPartitionable = _conditionH->isPartitionable( );

        BdbRef(CdbBdbSPartitionP) pRef;
        if( isPartitionable ) {

          // Find the partition

            BdbRef(CdbBdbSPartitionsLayoutP) pLayoutRef = _localRegistryH->partitionsLayout( );
            assert( !BdbIsNull(pLayoutRef));

            if( CdbStatus::Success != pLayoutRef->find( theBegin,
                                                        pRef )) {
                cout << errorStr << endl
                     << "    Failed to locate an open partition for the begin time" << endl
                     << "        BEGIN VALIDITY TIME: " << theBegin << endl
                     << "        CONDITION NAME:      \"" << name( ) << "\"" << endl;
                break;
            }

          // Verify the partition

            if( pRef->isClosed( )) {
                cout << errorStr << endl
                     << "    The partition is closed for modifications." << endl
                     << "    Storing new objects in the closed partition is not allowed." << endl
                     << "        PARTITION ID:   " << pRef->id( ) << endl
                     << "        CONDITION NAME: \"" << name( ) << "\"" << endl;
                break;
            }
            if( !pRef->isInstantiated( )) {
                cout << errorStr << endl
                     << "    The partition is not instantiated yet." << endl
                     << "    Storing new objects into a partition in this state is not allowed." << endl
                     << "        PARTITION ID:   " << pRef->id( ) << endl
                     << "        CONDITION NAME: \"" << name( ) << "\"" << endl;
                break;
            }

          // Truncate the end time if needed.

            CdbBdbSCell cell = pRef->cell( );
            if( truncatedEnd > cell.endValidity ) truncatedEnd = cell.endValidity;
        }

      // Now make another adjustment (for both 'regular' and 'partitionable' conditions)
      // to the end time if the corresponding restriction is required by CdbEnvironment.

        {
            BdbTime truncateTime = CdbEnvironment::getTruncateTime( );
            if( truncateTime  < truncatedEnd ) {

                if( truncateTime <= theBegin ) {
                    cout << errorStr << endl
                         << "    Wrong value of the truncate time found in the job's environment." << endl
                         << "    This time is not allwed to be less or equal to the begin time" << endl
                         << "    of stored objects. The job may be inproperly configured." << endl
                         << "        TRUNCATE TIME: " << truncatedEnd.getGmtSec( ) << "." << truncatedEnd.getGmtNsec( ) << endl;
                    break;
                }
                truncatedEnd = truncateTime;

                CDB_DEBUG_STREAM << "CDB_STORE_OBJECT_1: truncated_end_time=" << truncatedEnd.getGmtSec( ) << "." << truncatedEnd.getGmtNsec( ) << endl;
            }
        }

      // Get the identifier of the condition and check if it can be modified
      // localy.

        CdbBdbSId cId = _physicalAddress;
        if( isPartitionable ) {
            if( _localRegistryH->originId( ) != pRef->originId( )) {
                cout << errorStr << endl
                     << "    The partition does not belong to current database. Therefore it can't" << endl
                     << "    be used to store new objects locally." << endl
                     << "        PARTITION ID:   " << pRef->id( ) << endl
                     << "        CONDITION NAME: \"" << name( ) << "\"" << endl;
                break;
            }
        } else {
            if( _localRegistryH->originId( ) != cId.origin ) {
                cout << errorStr << endl
                     << "    The condition does not belong to current database. Therefore it can't" << endl
                     << "    be used to store new objects locally." << endl
                     << "        CONDITION NAME: \"" << name( ) << "\"" << endl;
                break;
            }
        }

      // Find out the most recent increment number for the condition

        d_UShort clusterIncrement = 0;
        {
            d_UShort numIncrementes = 0;
            if( isPartitionable ) {
                numIncrementes = pRef->numIncrements( );
            } else {
                BdbRef(CdbBdbSSimpleClusterP) simpleClusterRef = (const BdbRef(CdbBdbSSimpleClusterP)&) clusterRef;
                numIncrementes = simpleClusterRef->numIncrements( );
            }
            assert( numIncrementes > 0 );
            clusterIncrement = numIncrementes - 1;
        }

      // Now we've got everything to build the system name of the database file
      // containing the "topmost" meta-data container and the corresponding container
      // with condition objects.

        char cIdStr[12];
        sprintf( cIdStr, "%u", cId.local );

        std::string databaseName( "con_cdb" );
        {
            if( isPartitionable ) {

                char pIdStr[12];
                sprintf( pIdStr, "%u", pRef->id( ));

                databaseName = databaseName + std::string( "_p" ) + std::string( pIdStr );
            }

            char clusterIdStr[12];
            char clusterIncrementStr[12];

            sprintf( clusterIdStr, "%u", clusterRef->id( ));
            sprintf( clusterIncrementStr, "%u", clusterIncrement );

            std::string localDbIdRange;
            if( CdbStatus::Success != CdbBdbSUtils::getLocalDbIdRange( localDbIdRange )) {
                cout << errorStr << endl
                     << "    Failed to obtain the local DBID range. The current federation" << endl
                     << "    may not be properly initialized/loaded." << endl;
                break;
            }

            databaseName = databaseName + std::string( "_c" ) + std::string( clusterIdStr ) +
                                          std::string( "_i" ) + std::string( clusterIncrementStr ) +
                                          std::string( "_"  ) + localDbIdRange;
        }
        std::string mdContainerName = std::string( "MetaData." ) + std::string( cIdStr );
        std::string obContainerName = std::string( "Objects."  ) + std::string( cIdStr );

      // Find these containers
      //
      // IMPLEMENTATION NOTE:
      // WARNING: Watch for the optimization of very expensive
      //          database location operations. We use a current object data member
      //          to cache container handles. Our assumption is that this cache
      //          never gets invalidated during the lifetime of the current object, which
      //          in theory can be wrong. For example if a new partition/increment was created.
      //          This scenario will be evalueated later.

        if( BdbIsNull(_mdContH)) {
            if( CdbStatus::Success != CdbBdbSUtils::findContainer( _mdContH,
                                                                   databaseName.c_str( ),
                                                                   mdContainerName.c_str( ),
                                                                   BdbcUpdate )) {
                cout << errorStr << endl
                     << "    Failed to locate/open a persistent container with meta-data." << endl
                     << "    The database may not be properly initialized/loaded." << endl
                     << "        CONTAINER NAME:     \"" << mdContainerName.c_str( ) << "\"" << endl
                     << "        DATABASE FILE NAME: \"" << databaseName.c_str( ) << "\"" << endl;
                break;
            }
        }
        if( BdbIsNull(_obContH)) {
            if( CdbStatus::Success != CdbBdbSUtils::findContainer( _obContH,
                                                                   databaseName.c_str( ),
                                                                   obContainerName.c_str( ),
                                                                   BdbcUpdate )) {
                cout << errorStr << endl
                     << "    Failed to locate/open a persistent container with condition objects." << endl
                     << "    The database may not be properly initialized/loaded." << endl
                     << "        CONTAINER NAME:     \"" << obContainerName.c_str( ) << "\"" << endl
                     << "        DATABASE FILE NAME: \"" << databaseName.c_str( ) << "\"" << endl;
                break;
            }
        }

      // Find out the meta-data object.

        BdbHandle(CdbBdbSMetaDataP) mdH;
        if( BdbcSuccess != mdH.lookupObj( _mdContH,
                                          "MetaData" )) {
            cout << errorStr << endl
                 << "    Failed to locate the \"MetaData\" registry object in the container." << endl
                 << "    The database may not be properly initialized/loaded." << endl
                 << "        CONTAINER NAME:     \"" << mdContainerName.c_str( ) << "\"" << endl
                 << "        DATABASE FILE NAME: \"" << databaseName.c_str( ) << "\"" << endl;
            break;
        }
        assert( mdH->ooIsKindOf( ooTypeN( CdbBdbSMetaDataP )));

      // Invoke the object creator.
      //
      // NOTE #1: That we're using the truncated end time instead of the original
      //          one. It's important for partitionable conditions.
      //
      // NOTE #2: The creator will use the condition objects container open above
      //          to place new condition objects.

        CdbConditionPtr myPtr( this->clone( ));

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

      // Get object handle

        BdbHandle(BdbObject) objectH;
        if( CdbStatus::Success != CdbBdbObjectConvertor::narrow( objectH,
                                                                 theObjectPtr )) {
            cout << errorStr << endl
                 << "    Failed to narrow just created object into a paersistent handle." << endl
                 << "        CONDITION NAME: \"" << name( ) << "\"" << endl;
            break;
        }
        assert( !BdbIsNull(objectH));

      // Update partition's modification time if the current condition
      // is the partitionable one.

        BdbTime insertionTime( BdbTime::now( ));

        if( isPartitionable ) {
            if( CdbStatus::Success != pRef->update( insertionTime )) {

                cout << errorStr << endl
                     << "    Failed to update the partition modification time." << endl
                     << "        PARTITION ID:   " << pRef->id( ) << endl
                     << "        CONDITION NAME: \"" << name( ) << "\"" << endl;

                BdbDelete(objectH);
                break;
            }
        }

      // Register the persistent object in the meta-data.

        if( CdbStatus::Success != mdH->insert( CdbBdbSOi( theBegin,
                                                          truncatedEnd,
                                                          insertionTime,
                                                          objectH ))) {
            cout << errorStr << endl
                 << "    Failed to insert the information about a newely created object" << endl
                 << "    into meta-data structures of the condition." << endl
                 << "        CONDITION NAME: \"" << name( ) << "\"" << endl;

            BdbDelete(objectH);
            break;
        }

        CDB_DEBUG_STREAM << "CDB_STORE_OBJECT_1: " << objectH.sprint( ) << endl; 

      // Done

        result = CdbStatus::Success;

    } while( false );

    return result;
}

CdbStatus
CdbBdbSCondition::storeAndTruncateObject( CdbObjectFactoryBase& theObjectFactory,
                                          const BdbTime&        theStoreTime,
                                          const BdbTime&        theTruncateTime,
                                          CdbObjectPtr&         theObjectPtr )
{
    return storeObject( theObjectFactory,
                        theStoreTime,
                        BdbTime::plusInfinity,
                        theObjectPtr );
}

CdbStatus
CdbBdbSCondition::split( const BdbTime& theTime )
{
    cout << "CdbBdbSCondition::split() -- WARNING" << endl
         << "    The 'split interval' is the 'noop' operations in this" << endl
         << "    implementation of the API. This operation is only provided for backward" << endl
         << "    compatibility with the old condition database. Eventually it will be phased out." << endl;

    return CdbStatus::Success;
}

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

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

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

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

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

    CdbStatus result = CdbStatus::NotFound;
    do {

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

        std::vector<BdbRef(CdbBdbSMetaDataP)> vectorOfMdRefs;

        bool allIncrementsFlag = true;

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

      // Find an appropriate one

        BdbRef(CdbBdbSRevisionP) rRef;
        {
            bool found = false;

            std::vector<BdbRef(CdbBdbSMetaDataP)>::const_iterator itr;
            for( itr = vectorOfMdRefs.begin( ); itr < vectorOfMdRefs.end( ); ++itr ) {

                BdbRef(CdbBdbSMetaDataP) mdRef = (*itr);
                if( CdbStatus::Success == mdRef->findRevision( theId,
                                                               rRef )) {
                    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.

        CdbConditionPtr myPtr( this->clone( ));

        thePtr = new CdbBdbSRevision( myPtr,
                                      rRef );

      // Done

        result = CdbStatus::Success;

    } while( false );

    return result;
}

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

    CdbStatus result = CdbStatus::NotFound;
    do {

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

        std::vector<BdbRef(CdbBdbSMetaDataP)> vectorOfMdRefs;

        bool allIncrementsFlag = true;

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

      // Find an appropriate one

        BdbRef(CdbBdbSRevisionP) rRef;
        {
            bool found = false;

            std::vector<BdbRef(CdbBdbSMetaDataP)>::const_iterator itr;
            for( itr = vectorOfMdRefs.begin( ); itr < vectorOfMdRefs.end( ); ++itr ) {

                BdbRef(CdbBdbSMetaDataP) mdRef = (*itr);
                if( CdbStatus::Success == mdRef->findRevision( theName,
                                                               rRef )) {
                    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.

        CdbConditionPtr myPtr( this->clone( ));

        thePtr = new CdbBdbSRevision( myPtr,
                                      rRef );

      // Done

        result = CdbStatus::Success;

    } while( false );

    return result;
}

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

    CdbStatus result = CdbStatus::Error;
    do {

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

        std::vector<BdbRef(CdbBdbSMetaDataP)> vectorOfMdRefs;

        bool allIncrementsFlag = true;

        if( CdbStatus::Success !=  findMetaData( vectorOfMdRefs,
                                                 _masterRegistryH,
                                                 _localRegistryH,
                                                 _physicalAddress,
                                                 thePartitionId,
                                                 allIncrementsFlag )) {
            cout << 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( vectorOfMdRefs ));

      // Done

        result = CdbStatus::Success;

    } while( false );

    return result;
}

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

    CdbStatus result = CdbStatus::Error;
    do {

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

        std::vector<BdbRef(CdbBdbSMetaDataP)> vectorOfMdRefs;

        bool allIncrementsFlag = true;

        if( CdbStatus::Success !=  findMetaData( vectorOfMdRefs,
                                                 _masterRegistryH,
                                                 _localRegistryH,
                                                 _physicalAddress,
                                                 thePartitionId,
                                                 allIncrementsFlag )) {
            cout << 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( vectorOfMdRefs ));

      // Done

        result = CdbStatus::Success;

    } while( false );

    return result;
}

CdbStatus
CdbBdbSCondition::createRevision( CdbRevisionPtr& thePtr,
                                  const BdbTime&  theId,
                                  const char*     theName,
                                  const char*     theDescription,
                                  unsigned short  thePartitionId )
{
    const char* errorStr = "CdbBdbSCondition::createRevision() -- ERROR";
    const char* fatalStr = "CdbBdbSCondition::createRevision() -- FATAL ERROR";

    CdbStatus result = CdbStatus::Error;
    do {

      // Verify parameters

        if( 0 == theName ) {
            cout << errorStr << endl
                 << "    The null pointer passed as a parameter where a revision name was expected." << endl
                 << "        CONDITION NAME               : \"" << name( ) << "\"" << endl
                 << "        CONDITION 'PHYSICAL ADDRESS' : " << _physicalAddress << endl;
            break;            
        }

      // Check if the revsion can be created in the current condition
      // (and specified partition if we have a 'PARTITIONABLE' condition).
      //
      // The criteria is as follows:
      //
      //   'regular'       :  these condition can only be modified in their (condition's) origin database
      //
      //   'partitionable' :  the specified partition of these conditions can only be modified
      //                      in their (partition's) origin database. The partition must be "instantiated"
      //                      and it must be in the "open" state.

        if( isPartitionable( )) {

          // Find the partition

            BdbHandle(CdbBdbSPartitionP) pH;
            if( CdbStatus::Success != findPartition( pH,thePartitionId )) {
                cout << errorStr << endl
                     << "    Failed to find the specified partition." << endl
                     << "        PARTITION ID : " << thePartitionId << endl;
                break;            
            }

          // Cross-check the partition's origin against the current database's origin
          // to see if they're equal.

            if( _localRegistryH->originId( ) != pH->originId( )) {
                cout << errorStr << endl
                     << "    The specified partition is not the local one. This operation does" << endl
                     << "    not allow modifying partitions of 'partitionable' conditions which" << endl
                     << "    are not owned by the current database origin." << endl
                     << "        CONDITION NAME               : \"" << name( ) << "\"" << endl
                     << "        CONDITION 'PHYSICAL ADDRESS' : " << _physicalAddress << endl
                     << "        PARTITION ID                 : " << thePartitionId << endl
                     << "        LOCAL ORIGIN ID              : " << _localRegistryH->originId( ) << endl
                     << "        PARTITION ORIGIN ID          : " << pH->originId( ) << endl;
                break;
            }

          // Also check if the partition is in the right state.

            if( !pH->isInstantiated( )) {
                cout << errorStr << endl
                     << "    The specified partition is not instantiated inthe local database." << endl
                     << "        CONDITION NAME               : \"" << name( ) << "\"" << endl
                     << "        CONDITION 'PHYSICAL ADDRESS' : " << _physicalAddress << endl
                     << "        PARTITION ID                 : " << thePartitionId << endl;
                break;
            }
            if( pH->isClosed( )) {
                cout << errorStr << endl
                     << "    The specified partition is already 'closed' for any further modifications." << endl
                     << "    The requested operations can not be completed." << endl
                     << "        CONDITION NAME               : \"" << name( ) << "\"" << endl
                     << "        CONDITION 'PHYSICAL ADDRESS' : " << _physicalAddress << endl
                     << "        PARTITION ID                 : " << thePartitionId << endl;
                break;
            }

        } else {

          // Just cross-check the origin of the condition with the local origin.

            if( _localRegistryH->originId( ) != _physicalAddress.origin ) {
                cout << errorStr << endl
                     << "    The current condition is not the local one. This operation does" << endl
                     << "    not allow modifying 'regular' conditions which" << endl
                     << "    are not owned by the current database origin." << endl
                     << "        CONDITION NAME               : \"" << name( ) << "\"" << endl
                     << "        CONDITION 'PHYSICAL ADDRESS' : " << _physicalAddress << endl
                     << "        LOCAL ORIGIN ID              : " << _localRegistryH->originId( ) << endl;
                break;
            }
        }

      // Find the metadata object corresponding to the topmost revision.
      // This is where we're going to ceate a new revision by cloning from
      // the topmost one.

        BdbHandle(CdbBdbSMetaDataP) mdH;
        {
            std::vector<BdbRef(CdbBdbSMetaDataP)> vectorOfMdRefs;

            bool allIncrementsFlag   = false;
            bool recentIncrementFlag = true;

            if( CdbStatus::Success !=  findMetaData( vectorOfMdRefs,
                                                     _masterRegistryH,
                                                     _localRegistryH,
                                                     _physicalAddress,
                                                     thePartitionId,
                                                     allIncrementsFlag,
                                                     recentIncrementFlag )) {
                cout << errorStr << endl
                     << "    Failed to locate the most recent MetaData object for the condition/partition." << endl
                     << "        CONDITION NAME               : \"" << name( ) << "\"" << endl
                     << "        CONDITION 'PHYSICAL ADDRESS' : " << _physicalAddress << endl
                     << "        PARTITION ID                 : " << thePartitionId << endl;
                break;
            }
            assert( 1 == vectorOfMdRefs.size( ));

            mdH = vectorOfMdRefs[0];
        }

      // Create the specified revision

        BdbTime rCreated( BdbTime::now( ));

        if( CdbStatus::Success !=  mdH->createRevision( theId,
                                                        theName,
                                                        rCreated,
                                                        theDescription )) {
            cout << errorStr << endl
                 << "    Failed to create a new revision with specified parameters in the most recent" << endl
                 << "    MetaData object for the condition/partition." << endl
                 << "        CONDITION NAME               : \"" << name( ) << "\"" << endl
                 << "        CONDITION 'PHYSICAL ADDRESS' : " << _physicalAddress << endl
                 << "        PARTITION ID                 : " << thePartitionId << endl
                 << "        REVISION ID                  : " << CdbTimeUtils::time2string( theId ) << " : " << theId << endl
                 << "        REVISION NAME                : \"" << theName << endl;
            break;
        }

      // Create a transient API object representing a newely created revision

        {

          // Find the persistent object

            BdbRef(CdbBdbSRevisionP) rRef;
            if( CdbStatus::Success !=  mdH->findRevision( theId,
                                                          rRef )) {
                cout << fatalStr << endl
                     << "    Failed to find just created new revision in the most recent" << endl
                     << "    MetaData object for the condition/partition." << endl
                     << "        CONDITION NAME               : \"" << name( ) << "\"" << endl
                     << "        CONDITION 'PHYSICAL ADDRESS' : " << _physicalAddress << endl
                     << "        PARTITION ID                 : " << thePartitionId << endl
                     << "        REVISION ID                  : " << CdbTimeUtils::time2string( theId ) << " : " << theId << endl
                     << "        REVISION NAME                : \"" << theName << endl;

                assert(0);

                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.

            CdbConditionPtr myPtr( this->clone( ));

            thePtr = new CdbBdbSRevision( myPtr,
                                          rRef );
        }

      // Done

        result = CdbStatus::Success;

    } while( false );

    return result;
}

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

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

CdbStatus
CdbBdbSCondition::hint( BdbRefAny&     theHint,
                        const BdbTime& theBegin,
                        const BdbTime& theEnd )
{
    CdbStatus result = CdbStatus::NotFound;
    do {

        assert( !BdbIsNull(_obContH));

      // Return the cached value of the objects container handle
      // initialized at the "storeObject()" stage.

        theHint = _obContH;

      // Done

        result = CdbStatus::Success;

    } while( false );

    return result;
}

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

    do {

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

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

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

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

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

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

    } while( false );

    return result;
}

CdbStatus
CdbBdbSCondition::findPartition( BdbHandle(CdbBdbSPartitionP)& theHandle,
                                 d_UShort                      thePartitonId ) const
{
    const char* errorStr = "CdbBdbSCondition::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.

        BdbHandle(CdbBdbSPartitionP) pH;
        {
            BdbHandle(CdbBdbSPartitionsLayoutP) pLayoutH = _masterRegistryH->partitionsLayout( );
            assert( ! BdbIsNull(pLayoutH));

            BdbRef(CdbBdbSPartitionP) pRef;
            if( CdbStatus::Success != pLayoutH->find( thePartitonId,
                                                      pRef )) {
                cout << errorStr << endl
                     << "    Failed to find a partition #" << thePartitonId << " at the MASTER registry." << endl;
                break;
            }
            pH = pRef;
        }
        if(( _localRegistryH->originId( ) == pH->originId( )) &&
           ( _localRegistryH->originId( ) != _masterRegistryH->originId( ))) {

            BdbHandle(CdbBdbSPartitionsLayoutP) pLayoutH = _localRegistryH->partitionsLayout( );
            assert( ! BdbIsNull(pLayoutH));

            BdbRef(CdbBdbSPartitionP) pRef;
            if( CdbStatus::Success != pLayoutH->find( thePartitonId,
                                                      pRef )) {
                cout << 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;
            }
            pH = pRef;
        }
        theHandle = pH;

      // Done

        result = CdbStatus::Success;

    } while( false );

    return result;
}

CdbStatus
CdbBdbSCondition::findInitialPartition( const BdbTime&                theValidityTime,
                                        const BdbTime&                theInsertionTime,
                                        BdbHandle(CdbBdbSPartitionP)& theHandle,
                                        std::string&                  theDbIdRange ) const
{
    const char* errorStr = "CdbBdbSCondition::findInitialPartition() -- ERROR";

    CdbStatus result = CdbStatus::Error;

    do {

      // The temporary partition reference required by some interfaces.

        BdbRef(CdbBdbSPartitionP) pRef;

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

        BdbRef(CdbBdbSPartitionsLayoutP) pLayoutRef = _masterRegistryH->partitionsLayout( );
        assert( ! BdbIsNull(pLayoutRef));

        if( BdbTime::plusInfinity == theInsertionTime ) {

            if( CdbStatus::Success != pLayoutRef->topmost( theValidityTime,
                                                           pRef )) {
                cout << 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 != pLayoutRef->find( theValidityTime,
                                                        theInsertionTime,
                                                        pRef )) {
                cout << 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;
            }
        }
        theHandle = pRef;

        d_UShort partitionId = theHandle->id( );

        if(( _localRegistryH->originId( ) == theHandle->originId( )) &&
           ( _localRegistryH->originId( ) != _masterRegistryH->originId( ))) {

            pLayoutRef = _localRegistryH->partitionsLayout( );
            assert( ! BdbIsNull(pLayoutRef));

            if( CdbStatus::Success != pLayoutRef->find( partitionId,
                                                        pRef )) {
                cout << errorStr << endl
                     << "    Failed to find a partition #" << partitionId << " at the local registry." << endl;
                break;
            }
            theHandle = pRef;
        }

      // Now find the DBID range name for the partition

        BdbRef(CdbBdbSOriginCollectionP) originCollRef = _masterRegistryH->originCollection( );
        assert( ! BdbIsNull(originCollRef));

        BdbRef(CdbBdbSOriginP) originRef;
        if( CdbStatus::Success != originCollRef->find( theHandle->originId( ),
                                                       originRef )) {
            cout << errorStr << endl
                 << "    Failed to find origin information for the partition #" << partitionId << " at the master registry." << endl;
            break;
        }
        theDbIdRange = originRef->dbidrange( ).head( );

      // Done

        result = CdbStatus::Success;

    } while( false );

    return result;
}

CdbStatus
CdbBdbSCondition::findNextPartition( const BdbTime&                theValidityTime,
                                     BdbHandle(CdbBdbSPartitionP)& theHandle,
                                     std::string&                  theDbIdRange ) const
{
    const char* errorStr = "CdbBdbSCondition::findNextPartition() -- ERROR";

    assert( !BdbIsNull(theHandle));

    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-

        BdbRef(CdbBdbSPartitionsLayoutP) pLayoutRef = _masterRegistryH->partitionsLayout( );
        assert( ! BdbIsNull(pLayoutRef));

        d_UShort prevPartitionId = theHandle->id( );

        BdbRef(CdbBdbSPartitionP) prevPartRef;
        if( CdbStatus::Success != pLayoutRef->find( prevPartitionId,
                                                    prevPartRef )) {
            cout << errorStr << endl
                     << "    Failed to find a partition #" << prevPartitionId << " at the master registry." << endl;
            break;
        }

      // -2-

        BdbRef(CdbBdbSPartitionP) nextPartRef = prevPartRef;
        CdbStatus tmpResult = pLayoutRef->next( theValidityTime,
                                                nextPartRef );
        if( CdbStatus::Success == tmpResult ) {
            ;
        } else {
            if( CdbStatus::NotFound == tmpResult ) {
                result = tmpResult;
            } else {
                cout << 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-

        theHandle = nextPartRef;

        d_UShort partitionId = theHandle->id( );

        if(( _localRegistryH->originId( ) == theHandle->originId( )) &&
           ( _localRegistryH->originId( ) != _masterRegistryH->originId( ))) {

            pLayoutRef = _localRegistryH->partitionsLayout( );
            assert( ! BdbIsNull(pLayoutRef));

            BdbRef(CdbBdbSPartitionP) pRef;
            if( CdbStatus::Success != pLayoutRef->find( partitionId,
                                                        pRef )) {
                cout << errorStr << endl
                     << "    Failed to find a partition #" << partitionId << " at the local registry." << endl;
                break;
            }
            theHandle = pRef;
        }

      // Now find the DBID range name for the partition

        BdbRef(CdbBdbSOriginCollectionP) originCollRef = _masterRegistryH->originCollection( );
        assert( ! BdbIsNull(originCollRef));

        BdbRef(CdbBdbSOriginP) originRef;
        if( CdbStatus::Success != originCollRef->find( theHandle->originId( ),
                                                       originRef )) {
            cout << errorStr << endl
                 << "    Failed to find origin information for the partition #" << partitionId << " at the master registry." << endl;
            break;
        }
        theDbIdRange = originRef->dbidrange( ).head( );

      // Done

        result = CdbStatus::Success;

    } while( false );

    return result;
}

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

    CdbStatus result = CdbStatus::Error;

    do {

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

        assert( _conditionH->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 = _conditionH->created( );

        if( rId < creationTime ) {
            cout << 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 out a the cluster the condition belongs to.

        BdbRef(CdbBdbSClusterP) clusterRef = _conditionH->cluster( );
        assert( !BdbIsNull(clusterRef));

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

        BdbHandle(CdbBdbSPartitionP) pH;

        std::string dbIdRange;

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

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

        if( pH->isClosed( )) {
            CdbBdbSCell pCell = pH->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.

        d_UShort firstIncrement = 0;
        d_UShort lastIncrement  = 0;
        {
            d_UShort numIncrements = pH->numIncrements( );
            assert( numIncrements > 0 );

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

            {
                bool failed = true;

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

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

                        firstIncrement = i;

                        failed = false;
                        break;
                    }
                }
                if( failed ) {
                    cout << errorStr << endl
                         << "    Failed to find the smallest increment number at a partition #" << pH->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( d_UShort i = firstIncrement; i < numIncrements; ++i ) {

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

                        lastIncrement = i;

                        failed = false;
                        break;
                    }
                }
                if( failed ) {
                    cout << errorStr << endl
                         << "    Failed to find the biggest increment number at a partition #" << pH->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;
/*********************************************************************/

      // Invariant parameters of the databases with metadata information.
      // Other parameters, including <partition> & <increment> will be dynamically
      // (re-)calculated by the mining algorith described below.

        CdbBdbSId cId = _physicalAddress;

        char cIdStr[12];
        sprintf( cIdStr, "%u", cId.local );

        char clusterIdStr[12];
        sprintf( clusterIdStr, "%u", clusterRef->id( ));

        std::string mdContainerName = std::string( "MetaData." ) + std::string( cIdStr );

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

        CdbBdbSCell pCell = pH->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,
                                                             pH,
                                                             dbIdRange )) {
                    break;
                }

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

                if( pH->isClosed( )) {
                    CdbBdbSCell pCell = pH->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.

                {
                    d_UShort numIncrements = pH->numIncrements( );
                    assert( numIncrements > 0 );

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

                  // Find the first increment first

                    bool found  = false;
                    bool failed = true;

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

                        CdbBdbSIncrement iVal;
                        if( CdbStatus::Success != pH->increment( i,
                                                                 iVal )) {
                            cout << errorStr << endl
                                 << "    Failed to find the increment #" << i << " at the partition #" << pH->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 = pH->cell( );

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

                assert( theBeginOfVisiblePeriod < theEndOfVisiblePeriod );
            }

            char partitionIdStr[12];
            sprintf( partitionIdStr, "%u", pH->id( ));

            bool isBreaking  = false;

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

              // Now we've got everything to build the system name of the database file
              // containing the "topmost" meta-data container.

                std::string databaseName( "con_cdb" );
                {
                    char clusterIncrementStr[12];
                    sprintf( clusterIncrementStr, "%u", i );

                    databaseName = databaseName + std::string( "_p" ) + std::string( partitionIdStr ) +
                                                  std::string( "_c" ) + std::string( clusterIdStr ) +
                                                  std::string( "_i" ) + std::string( clusterIncrementStr ) +
                                                  std::string( "_"  ) + dbIdRange;
                }

              // Find the container

                BdbHandle(BdbContObj) mdContH;
                if( CdbStatus::Success != CdbBdbSUtils::findContainer( mdContH,
                                                                       databaseName.c_str( ),
                                                                       mdContainerName.c_str( ),
                                                                       BdbcRead )) {
                    cout << errorStr << endl
                         << "    Failed to locate/open a persistent container with meta-data." << endl
                         << "    The database may not be properly initialized/loaded." << endl
                         << "        CONTAINER NAME:     \"" << mdContainerName.c_str( ) << "\"" << endl
                         << "        DATABASE FILE NAME: \"" << databaseName.c_str( ) << "\"" << endl;

                    isBreaking = true;
                    break;
                }

              // Find out the meta-data object.

                BdbHandle(CdbBdbSMetaDataP) mdH;
                if( BdbcSuccess != mdH.lookupObj( mdContH,
                                                  "MetaData" )) {
                    cout << errorStr << endl
                         << "    Failed to locate the \"MetaData\" registry object in the container." << endl
                         << "    The database may not be properly initialized/loaded." << endl
                         << "        CONTAINER NAME:     \"" << mdContainerName.c_str( ) << "\"" << endl
                         << "        DATABASE FILE NAME: \"" << databaseName.c_str( ) << "\"" << endl;

                    isBreaking = true;
                    break;
                }
                assert( mdH->ooIsKindOf( ooTypeN( CdbBdbSMetaDataP )));

              // 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 CdbBdbSMetaDataP::modified()

                if( isFirstPath && ( i == lastIncrement )) {
                    ;
                } else {
                    rId = mdH->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
         << "               database                : \"" << databaseName.c_str( ) << "\"" << endl
         << "               rId                     : " << rId << endl
         << "               theValidityTime         : " << theValidityTime << endl
         << "}" << endl;
/*************************************************************************************************/

                    result = mdH->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 = mdH->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
CdbBdbSCondition::doFindObject( const CdbRevisionPolicy& thePolicy,
                                const BdbTime&           theValidityTime,
                                const BdbTime&           theInsertionTime,
                                CdbBdbSOi&               theOriginalInterval, 
                                BdbTime&                 theBeginOfVisiblePeriod,
                                BdbTime&                 theEndOfVisiblePeriod,
                                BdbTime&                 theBeginOfDurationPeriod,
                                BdbTime&                 theEndOfDurationPeriod ) const
{
    const char* debugStr = "CdbBdbSCondition::doFindObject()";
    const char* errorStr = "CdbBdbSCondition::doFindObject() -- ERROR";

    CdbStatus result = CdbStatus::Error;

    do {

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

        assert( !_conditionH->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 = _conditionH->created( );

        if( rId < creationTime ) {
            cout << 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 out a the cluster the condition belongs to. Then find the increments
      // range for specified revision time.

        BdbRef(CdbBdbSClusterP) clusterRef = _conditionH->cluster( );
        assert( !BdbIsNull(clusterRef));

        d_UShort firstIncrement = 0;
        d_UShort lastIncrement  = 0;
        {
            BdbHandle(CdbBdbSSimpleClusterP) simpleClusterH;
            simpleClusterH = (const BdbRef(CdbBdbSSimpleClusterP)&) clusterRef;

            d_UShort numIncrements = simpleClusterH->numIncrements( );
            assert( numIncrements > 0 );

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

            {
                bool failed = true;

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

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

                        firstIncrement = i;

                        failed = false;
                        break;
                    }
                }
                if( failed ) {
                    cout << 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( d_UShort i = firstIncrement; i < numIncrements; ++i ) {

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

                        lastIncrement = i;

                        failed = false;
                        break;
                    }
                }
                if( failed ) {
                    cout << 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;
/***********************************************************/
        }

      // Get the identifier of the condition and the corresponding DBID range name.

        CdbBdbSId cId = _physicalAddress;

        std::string dbIdRange;
        {
          // Trivial optimization if the condition is in the local DBID range

            if( _localRegistryH->originId( ) == cId.origin ) {

                if( CdbStatus::Success != CdbBdbSUtils::getLocalDbIdRange( dbIdRange )) {
                    cout << errorStr << endl
                         << "    Failed to obtain the local DBID range. The current federation" << endl
                         << "    may not be properly initialized/loaded." << endl;
                    break;
                }

            } else {

                BdbRef(CdbBdbSOriginCollectionP) oCollRef = _masterRegistryH->originCollection( );
                assert( !BdbIsNull(oCollRef));

                BdbRef(CdbBdbSOriginP) oRef;
                if( CdbStatus::Success != oCollRef->find( cId.origin,
                                                          oRef )) {
                    cout << errorStr << endl
                         << "    Failed to obtain the origin from the corresponding collection." << endl
                         << "    The current federation may not be properly initialized/loaded." << endl;
                    break;
                }
                dbIdRange = oRef->dbidrange( ).head( );
            }
        }

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

        char cIdStr[12];
        sprintf( cIdStr, "%u", cId.local );

        char clusterIdStr[12];
        sprintf( clusterIdStr, "%u", clusterRef->id( ));

        std::string mdContainerName = std::string( "MetaData." ) + std::string( cIdStr );

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

          // Now we've got everything to build the system name of the database file
          // containing the "topmost" meta-data container.

            std::string databaseName( "con_cdb" );
            {
                char clusterIncrementStr[12];
                sprintf( clusterIncrementStr, "%u", i );

                databaseName = databaseName + std::string( "_c" ) + std::string( clusterIdStr ) +
                                              std::string( "_i" ) + std::string( clusterIncrementStr ) +
                                              std::string( "_"  ) + dbIdRange;
            }

          // Find the container

            BdbHandle(BdbContObj) mdContH;
            if( CdbStatus::Success != CdbBdbSUtils::findContainer( mdContH,
                                                                   databaseName.c_str( ),
                                                                   mdContainerName.c_str( ),
                                                                   BdbcRead )) {
                cout << errorStr << endl
                     << "    Failed to locate/open a persistent container with meta-data." << endl
                     << "    The database may not be properly initialized/loaded." << endl
                     << "        CONTAINER NAME:     \"" << mdContainerName.c_str( ) << "\"" << endl
                     << "        DATABASE FILE NAME: \"" << databaseName.c_str( ) << "\"" << endl;
                break;
            }

          // Find out the meta-data object.

            BdbHandle(CdbBdbSMetaDataP) mdH;
            if( BdbcSuccess != mdH.lookupObj( mdContH,
                                              "MetaData" )) {
                cout << errorStr << endl
                     << "    Failed to locate the \"MetaData\" registry object in the container." << endl
                     << "    The database may not be properly initialized/loaded." << endl
                     << "        CONTAINER NAME:     \"" << mdContainerName.c_str( ) << "\"" << endl
                     << "        DATABASE FILE NAME: \"" << databaseName.c_str( ) << "\"" << endl;
                break;
            }
            assert( mdH->ooIsKindOf( ooTypeN( CdbBdbSMetaDataP )));

          // 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 CdbBdbSMetaDataP::modified()

            if( i != lastIncrement ) rId = mdH->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 = mdH->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 = mdH->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 {

/////////////////////////////////
// Function: Meta Data locator //
/////////////////////////////////

CdbStatus
findMetaData( std::vector<BdbRef(CdbBdbSMetaDataP)>& theVectorOfRefs,
              const BdbHandle(CdbBdbSRegistryP)&     theMasterRegistryH,
              const BdbHandle(CdbBdbSRegistryP)&     theLocalRegistryH,
              const CdbBdbSId&                       theExtendedConditionId,
              d_UShort                               thePartitionId,
              bool                                   allIncrementsFlag,
              bool                                   recentIncrementFlag,
              d_UShort                               theIncrementNumber )
{
    const char* errorStr = "CdbBdbSCondition::findMetaData() -- ERROR";

    CdbStatus result = CdbStatus::Error;
    do {

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

        assert( ! BdbIsNull( theMasterRegistryH ));
        assert( ! BdbIsNull( theLocalRegistryH ));
        assert( theMasterRegistryH->isMaster( ));

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

      // Find out which registry may be required to accomplish our mission.
      //
      // NOTE: There is a little optimization.

        BdbHandle(CdbBdbSRegistryP) originRegistryH;
        {
            if( theLocalRegistryH->originId( ) == originId ) {
                originRegistryH = theLocalRegistryH;

            } else if( theMasterRegistryH->originId( ) == originId ) {
                originRegistryH = theMasterRegistryH;

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

      // Find specified condition in the collection.

        BdbRef(CdbBdbSConditionCollectionP) cCollRef = originRegistryH->conditionCollection( );
        assert( ! BdbIsNull(cCollRef));

        BdbRef(CdbBdbSConditionP) cRef;
        if( CdbStatus::Success != cCollRef->find( conditionId,
                                                  cRef )) {
            cout << 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 = cRef->created( );

        bool isPartitionableFlag = cRef->isPartitionable( );

        BdbRef(CdbBdbSPartitionP) pRef;
        if( isPartitionableFlag ) {

          // Use master to get general information about the partition

            BdbRef(CdbBdbSPartitionsLayoutP) pLayoutRef = theMasterRegistryH->partitionsLayout( );
            assert( ! BdbIsNull(pLayoutRef));

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

          // Check if this partition is available

            if( theLocalRegistryH->originId( ) == pRef->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( theLocalRegistryH->originId( ) != theMasterRegistryH->originId( )) {

                    BdbRef(CdbBdbSPartitionsLayoutP) localPartitionsLayoutRef = theLocalRegistryH->partitionsLayout( );
                    assert( ! BdbIsNull(localPartitionsLayoutRef));

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

      // Get the DBID range for the condition/partition

        std::string dbIdRange;
        {
          // For partitionable conditions we should use the partition's origin
          // rather than the one of the condition itself in order to get the DBID
          // range name of database files where the MetaData objects are located.

            d_UShort oId = originId;
            if( isPartitionableFlag ) {
                oId = pRef->originId( );
            }

          // Get the origin

            BdbRef(CdbBdbSOriginCollectionP) oCollRef = theMasterRegistryH->originCollection( );
            assert( ! BdbIsNull(oCollRef));

            BdbRef(CdbBdbSOriginP) oRef;
            if( CdbStatus::Success != oCollRef->find( oId,
                                                      oRef )) {
                cout << errorStr << endl
                     << "    Origin with ID #" << oId << " not found." << endl;
                break;
            }

          // Fetch the range's name

            dbIdRange = std::string( oRef->dbidrange( ).head( ));
        }

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

        BdbRef(CdbBdbSClusterP) clusterRef = cRef->cluster( );
        assert( ! BdbIsNull(clusterRef));

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

            d_UShort numIncrements = 0;

            if( isPartitionableFlag ) {

                numIncrements = pRef->numIncrements( );
                for( d_UShort i = 0; i < numIncrements; ++i ) {

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

            } else {

                BdbHandle(CdbBdbSSimpleClusterP) simpleClusterH;
                simpleClusterH = (const BdbRef(CdbBdbSSimpleClusterP)&) clusterRef;

                numIncrements = simpleClusterH->numIncrements( );
                for( d_UShort i = 0; i < numIncrements; ++i ) {

                    CdbBdbSIncrement iVal;
                    if( CdbStatus::Success != simpleClusterH->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;
        }

        d_UShort clusterId = clusterRef->id( );

      // Find metadata for specified increment(s)

        theVectorOfRefs.clear( );

        BdbRef(CdbBdbSMetaDataP) mdRef;

        if( allIncrementsFlag ) {

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

                    if( CdbStatus::Success != CdbBdbSUtils::findMetaData( mdRef,
                                                                          conditionId,
                                                                          isPartitionableFlag,
                                                                          thePartitionId,
                                                                          clusterId,
                                                                          i,
                                                                          dbIdRange )) {

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

                        failed = true;
                        break;
                    }
                    theVectorOfRefs.push_back( mdRef );
                }
            }
            if( failed ) break;

        } else {

            if( recentIncrementFlag ) {

                if( CdbStatus::Success != CdbBdbSUtils::findMetaData( mdRef,
                                                                      conditionId,
                                                                      isPartitionableFlag,
                                                                      thePartitionId,
                                                                      clusterId,
                                                                      lastIncrement,
                                                                      dbIdRange )) {

                    cout << errorStr << endl
                         << "    Failed to find a MetaData object for recent increment #" << lastIncrement << endl;
                    break;
                }
                theVectorOfRefs.push_back( mdRef );

            } else {

                if( theIncrementNumber > lastIncrement ) {
                    cout << errorStr << endl
                         << "    Passed increment number is not valid." << endl
                         << "        PASSED NUMBER:       " << theIncrementNumber << endl
                         << "        MAX.POSSIBLE NUMBER: " << lastIncrement << endl;
                    break;
                }
                if( CdbStatus::Success != CdbBdbSUtils::findMetaData( mdRef,
                                                                      conditionId,
                                                                      isPartitionableFlag,
                                                                      thePartitionId,
                                                                      clusterId,
                                                                      theIncrementNumber,
                                                                      dbIdRange )) {
                    cout << errorStr << endl
                         << "    Failed to find a MetaData object for specified increment #" << theIncrementNumber << endl;
                    break;
                }
                theVectorOfRefs.push_back( mdRef );
            }
        }

      // Done

        result = CdbStatus::Success;

    } while( false );

    return result;
}

std::string
time2string( const BdbTime& theTime )
{
    char buf[80];
    if       ( BdbTime::minusInfinity == theTime ) {
        sprintf( buf, "      -Infinity      " );
    } else if( BdbTime::plusInfinity  == theTime ) {
        sprintf( buf, "      +Infinity      " );
    } else {
        sprintf( buf, "%10.10u.%10.10u", theTime.getGmtSec( ), theTime.getGmtNsec( ));
    }
    return std::string( buf );
}


//////////////////////////////////////////////
// Function: Build Composite Condition Name //
//////////////////////////////////////////////

CdbStatus
buildCompositeConditionName( CdbCompositeName&                  theCompositeName,
                             const CdbBdbSId&                   theId,
                             const BdbHandle(CdbBdbSRegistryP)& theMasterRegistryH )
{
    const char* errorStr = "CdbBdbSCondition::anonymous::buildCompositeConditionName() -- ERROR";

    assert( !BdbIsNull(theMasterRegistryH));
    assert( theMasterRegistryH->isMaster( ));

    CdbStatus result = CdbStatus::Error;

    do {

      // Get to the origin first

        BdbRef(CdbBdbSOriginP) originRef;
        {
          // Get to the collection of origins

            BdbRef(CdbBdbSOriginCollectionP) originCollectionRef;
            originCollectionRef = theMasterRegistryH->originCollection( );
            assert( !BdbIsNull(originCollectionRef));

          // Find the origin matchin specified identifier

            if( CdbStatus::Success != originCollectionRef->find( theId.origin, originRef )) {
                cout << errorStr << endl
                     << "    Failed to obtain a persistent object describing the 'origin' for" << endl
                     << "    the following ID=" << theId.origin << endl;
                break;
            }
            assert( !BdbIsNull(originRef));
        }

      // Find the physical condition by its identifier

        BdbRef(CdbBdbSConditionP) conditionRef;
        {

          // Get to a collection of conditions of this origin. This collection can be
          // be located through the registry corresponding to specified origin.
          //
          // NOTE: A little optimization if the above found origin corresponds to the MASTER one.

            BdbRef(CdbBdbSConditionCollectionP) conditionCollectionRef;
            if( theId.origin == theMasterRegistryH->originId( )) {
                conditionCollectionRef = theMasterRegistryH->conditionCollection( );
            } else {

              // Get to the registry

                BdbHandle(CdbBdbSRegistryP) registryH;
                if( CdbStatus::Success != CdbBdbSRegistryP::findByOrigin( registryH, theId.origin )) {
                    cout << errorStr << endl
                         << "    Failed to obtain a persistent object describing the 'registry' for" << endl
                         << "    the following ID=" << theId.origin << endl;
                    break;
                }
                assert( !BdbIsNull(registryH));

              // Get to the collection of conditions

                conditionCollectionRef = registryH->conditionCollection( );                
            }
            assert( !BdbIsNull(conditionCollectionRef));

          // Find the physical condition matching the specified one by its identifier

            if( CdbStatus::Success != conditionCollectionRef->find( theId.local, conditionRef )) {
                cout << errorStr << endl
                     << "    Failed to obtain a persistent object describing the 'physical' condition for" << endl
                     << "    the following ID=" << theId.local << " in the 'origin' with ID=" << theId.origin << endl;
                break;
            }
            assert( !BdbIsNull(conditionRef));
        }

      // Done.

        theCompositeName = CdbCompositeName( originRef->name( ).head( ),
                                             conditionRef->name( ).head( ));

        result = CdbStatus::Success;

    } while( false );

    return result;
}


/////////////////////////////////////////////////////
// Function: Calculate Condition Modification Time //
/////////////////////////////////////////////////////

CdbStatus
calculateConditionModificationTime( BdbTime&                                    theModificationTime,
                                    const CdbBdbSId&                            thePhysicalAddress,
                                    const BdbHandle(CdbBdbSConditionAtFolderP)& theConditionAtFolderH,
                                    const BdbHandle(CdbBdbSRegistryP)&          theMasterRegistryH,
                                    const BdbHandle(CdbBdbSRegistryP)&          theLocalRegistryH )
{
    const char* errorStr = "CdbBdbSCondition::anonymous::calculateConditionModificationTime() -- ERROR";

    assert( !BdbIsNull(theMasterRegistryH));
    assert( theMasterRegistryH->isMaster( ));
    assert( !BdbIsNull(theLocalRegistryH));

  /*
   * =================
   * 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( BdbIsNull(theConditionAtFolderH)) {
        return CdbStatus::NotImplemented;
    }

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

    BdbTime modificationTime = theModificationTime; // This value will be modified and returned
                                                    // in case of success.

    CdbStatus result = CdbStatus::Error;

    do {

      // Use the specific configuration of the condition.

        BdbRef(CdbBdbSConfigCollectionP) configCollRef = theConditionAtFolderH->config( );
        if( BdbIsNull(configCollRef)) {
            break;
        }

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

        CdbBdbSConfigCollectionP::IteratorOfIntervals itr = configCollRef->iterator( );
        while( itr.next( )) {

            CdbBdbSConfigInterval configInterval = itr.value( );
            CdbBdbSConfigElement  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<BdbRef(CdbBdbSMetaDataP)> mdRefs;

                bool allIncrementsFlag   = false;
                bool recentIncrementFlag = true;

                if( CdbStatus::Success != findMetaData( mdRefs,
                                                        theMasterRegistryH,
                                                        theLocalRegistryH,
                                                        thePhysicalAddress,
                                                        configElement.partition,
                                                        allIncrementsFlag,
                                                        recentIncrementFlag )) {
                    cout << errorStr << endl
                         << "    Failed to find the most recent MetaData objects for the condition known as \"" << theConditionAtFolderH->name( ).head( ) << "\"" << endl
                         << "    at the current view." << endl
                         << "    The database may not be properly initialized/loaded." << endl;

                    break;
                }
                assert( 1 == mdRefs.size( ));

                cModificationTime = mdRefs[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;
        }

      // Done.

        theModificationTime = modificationTime;

        result = CdbStatus::Success;

    } while( false );

    return result;
}

};

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

---