---

CdbBdbSDatabase.cc

Go to the documentation of this file.

// File and Version Information:
//      $Id: CdbBdbSDatabase.cc,v 1.15 2005/08/13 01:25:44 gapon Exp $

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

#include "BaBar/BaBar.hh"

#include "CdbBdbShared/CdbBdbSDatabase.hh"

#include "CdbBase/Cdb.hh"
#include "CdbBase/CdbView.hh"
#include "CdbBase/CdbId.hh"
#include "CdbBase/CdbCompositeName.hh"
#include "CdbBase/CdbEnvironment.hh"
#include "CdbBase/CdbPartition.hh"
#include "CdbBase/CdbProperty.hh"
#include "CdbBase/CdbOrigin.hh"
#include "CdbBase/CdbFolder.hh"
#include "CdbBase/CdbCondition.hh"
#include "CdbBase/CdbSimpleVectorAdapterItr.hh"

#include "CdbBdbShared/CdbBdbSOriginP.hh"
#include "CdbBdbShared/CdbBdbSView.hh"
#include "CdbBdbShared/CdbBdbSViewItr.hh"
#include "CdbBdbShared/CdbBdbSPartitionsLayoutP.hh"
#include "CdbBdbShared/CdbBdbSPartitionP.hh"
#include "CdbBdbShared/CdbBdbSCondition.hh"

#include <iostream>
using std::cout;
using std::cerr;
using std::endl;

namespace {

///////////////////////////////
// Class CdbBdbSPartitionItr //
///////////////////////////////

// This iterator is only meant to retranslate type of the result
// produced by a persistent iterator.

class CdbBdbSPartitionItr : public CdbItr<unsigned short>::InterfaceType {

private:

  /// The default constructor (NOT IMPLEMENTED)
  /**
    */
    CdbBdbSPartitionItr( );

public:

  /// The normal constructor
  /**
    */
    CdbBdbSPartitionItr( const CdbItr<d_UShort>& theInputItr );

  /// The copy constructor
  /**
    * More details to come...
    */
    CdbBdbSPartitionItr( const CdbBdbSPartitionItr& theItr );

  /// The assignment operator
  /**
    * More details to come...
    */
    CdbBdbSPartitionItr& operator=( const CdbBdbSPartitionItr& theItr );

  /// The destructor
  /**
    * Details...
    */
    virtual ~CdbBdbSPartitionItr( );

  /// Reset an iterator to its initial state.
  /**
    * This implements the corresponding method of the base class.
    *
    * @see CdbIItr::reset
    * @see CdbStatus
    */
    virtual CdbStatus reset( );

  /// Advance an iterator to the next position.
  /**
    * This implements the corresponding method of the base class.
    *
    * @see CdbIItr::next()
    */
    virtual bool next( );

  /// Obtain the currently reffered value.
  /**
    * This implements the corresponding method of the base class.
    *
    * @see CdbIItr::value()
    * @see CdbIItr::ValueType
    *
    * @return the current value the iterator is set on
    */
    virtual ValueType value( );

  /// Check if an iterator is valid.
  /**
    * This implements the corresponding method of the base class.
    *
    * @see CdbIItr::isValid()
    */
    virtual bool isValid( );

  /// Make a clone of itself
  /**
    * @see CdbIItr::clone()
    */
    virtual InterfaceType* clone( ) const;

private:

    CdbItr<d_UShort> _itr;
};

CdbBdbSPartitionItr::CdbBdbSPartitionItr( const CdbItr<d_UShort>& theInputItr ) :
    _itr(theInputItr)
{ }

CdbBdbSPartitionItr::CdbBdbSPartitionItr( const CdbBdbSPartitionItr& theItr ) :
    _itr(theItr._itr)
{ }

CdbBdbSPartitionItr::~CdbBdbSPartitionItr( )
{ }

CdbBdbSPartitionItr&
CdbBdbSPartitionItr::operator=( const CdbBdbSPartitionItr& theItr )
{
    if( this != &theItr ) {
        _itr = theItr._itr;
    }
    return *this;
}

CdbStatus
CdbBdbSPartitionItr::reset( )
{
    return _itr.reset( );
}

bool
CdbBdbSPartitionItr::next( )
{
    return _itr.next( );
}

CdbBdbSPartitionItr::ValueType
CdbBdbSPartitionItr::value( )
{
    return _itr.value( );
}

bool
CdbBdbSPartitionItr::isValid( )
{
    return _itr.isValid( );
}

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

////////////////////////////
// Class CdbBdbSPartition //
////////////////////////////

class CdbBdbSPartition : public CdbPartition {

private:

  /// The default constructor (NOT IMPLEMENTED)
  /**
    */
    CdbBdbSPartition( );

  /// The copy constructor (NOT IMPLEMENTED)
  /**
    * More details to come...
    */
    CdbBdbSPartition( const CdbBdbSPartition& thePartition );

  /// The assignment operator (NOT IMPLEMENTED)
  /**
    * More details to come...
    */
    CdbBdbSPartition& operator=( const CdbBdbSPartition& thePartition );

public:

  /// The normal constructor
  /**
    */
    CdbBdbSPartition( const CdbDatabasePtr&               theDatabasePtr,                      
                      const BdbHandle(CdbBdbSPartitionP)& thePartitionH,
                      unsigned short                      theOwnerId,
                      const char*                         theOwnerName );

  /// The destructor
  /**
    * Details...
    */
    virtual ~CdbBdbSPartition( );

  /// The begin time in the "insertion" dimension
  /**
    * Implements the corresponding method of its base class or an interface.
    *
    * @see CdbPartition::endInsertion()
    */
    virtual BdbTime endInsertion( ) const;

  /// The recent modification time of the partition
  /**
    * Implements the corresponding method of its base class or an interface.
    *
    * @see CdbPartition::modified()
    */
    virtual BdbTime modified( ) const;

  /// The status of the partition
  /**
    * Implements the corresponding method of its base class or an interface.
    *
    * @see CdbPartition::isClosed()
    */
    virtual bool isClosed( ) const;

  /// The status of the partition
  /**
    * Implements the corresponding method of its base class or an interface.
    *
    * @see CdbPartition::isInstantiated()
    */
    virtual bool isInstantiated( ) const;

private:

    BdbHandle(CdbBdbSPartitionP) _partitionH;
};

CdbBdbSPartition::CdbBdbSPartition( const CdbDatabasePtr&               theDatabasePtr,
                                    const BdbHandle(CdbBdbSPartitionP)& thePartitionH,
                                    unsigned short                      theOwnerId,
                                    const char*                         theOwnerName ) :
    CdbPartition( theDatabasePtr,
                  thePartitionH->id( ),
                  theOwnerId,
                  theOwnerName,
                  thePartitionH->description( ).head( ),
                  thePartitionH->created( ),
                  thePartitionH->cell( ).beginValidity,
                  thePartitionH->cell( ).endValidity,
                  thePartitionH->cell( ).beginInsertion ),
   _partitionH(thePartitionH)
{ }

CdbBdbSPartition::~CdbBdbSPartition( )
{ }

BdbTime 
CdbBdbSPartition::endInsertion( ) const
{
    return _partitionH->cell( ).endInsertion;
}

BdbTime
CdbBdbSPartition::modified( ) const
{
    return _partitionH->modified( );
}

bool
CdbBdbSPartition::isClosed( ) const
{
    return _partitionH->isClosed( );
}

bool
CdbBdbSPartition::isInstantiated( ) const
{
    return _partitionH->isInstantiated( );
}

////////////////////////////
// Class CdbBdbSOriginItr //
////////////////////////////

// This iterator is only meant to retranslate type of the result
// produced by a persistent iterator.

class CdbBdbSOriginItr : public CdbItr<unsigned short>::InterfaceType {

private:

  /// The default constructor (NOT IMPLEMENTED)
  /**
    */
    CdbBdbSOriginItr( );

public:

  /// The normal constructor
  /**
    */
    CdbBdbSOriginItr( const CdbItr<d_UShort>& theInputItr );

  /// The copy constructor
  /**
    * More details to come...
    */
    CdbBdbSOriginItr( const CdbBdbSOriginItr& theItr );

  /// The assignment operator
  /**
    * More details to come...
    */
    CdbBdbSOriginItr& operator=( const CdbBdbSOriginItr& theItr );

  /// The destructor
  /**
    * Details...
    */
    virtual ~CdbBdbSOriginItr( );

  /// Reset an iterator to its initial state.
  /**
    * This implements the corresponding method of the base class.
    *
    * @see CdbIItr::reset
    * @see CdbStatus
    */
    virtual CdbStatus reset( );

  /// Advance an iterator to the next position.
  /**
    * This implements the corresponding method of the base class.
    *
    * @see CdbIItr::next()
    */
    virtual bool next( );

  /// Obtain the currently reffered value.
  /**
    * This implements the corresponding method of the base class.
    *
    * @see CdbIItr::value()
    * @see CdbIItr::ValueType
    *
    * @return the current value the iterator is set on
    */
    virtual ValueType value( );

  /// Check if an iterator is valid.
  /**
    * This implements the corresponding method of the base class.
    *
    * @see CdbIItr::isValid()
    */
    virtual bool isValid( );

  /// Make a clone of itself
  /**
    * @see CdbIItr::clone()
    */
    virtual InterfaceType* clone( ) const;

private:

    CdbItr<d_UShort> _itr;
};

CdbBdbSOriginItr::CdbBdbSOriginItr( const CdbItr<d_UShort>& theInputItr ) :
    _itr(theInputItr)
{ }

CdbBdbSOriginItr::CdbBdbSOriginItr( const CdbBdbSOriginItr& theItr ) :
    _itr(theItr._itr)
{ }

CdbBdbSOriginItr::~CdbBdbSOriginItr( )
{ }

CdbBdbSOriginItr&
CdbBdbSOriginItr::operator=( const CdbBdbSOriginItr& theItr )
{
    if( this != &theItr ) {
        _itr = theItr._itr;
    }
    return *this;
}

CdbStatus
CdbBdbSOriginItr::reset( )
{
    return _itr.reset( );
}

bool
CdbBdbSOriginItr::next( )
{
    return _itr.next( );
}

CdbBdbSOriginItr::ValueType
CdbBdbSOriginItr::value( )
{
    return _itr.value( );
}

bool
CdbBdbSOriginItr::isValid( )
{
    return _itr.isValid( );
}

CdbBdbSOriginItr::InterfaceType*
CdbBdbSOriginItr::clone( ) const
{
    return new CdbBdbSOriginItr( *this );
}
////////////////////////////////////
// Class CdbBdbSOriginPropertyItr //
////////////////////////////////////

/// The wrapper implementation of a transient origin's property iterator
/**
  * This is the "one-element" iterator since there is just one
  * property specific to the "Shared" implementation - the DBID range name
  * of an origin.
  */
class CdbBdbSOriginPropertyItr : public CdbItr<CdbProperty>::InterfaceType {

private:

  /// The default constructor (NOT IMPLEMENTED)
  /**
    */
    CdbBdbSOriginPropertyItr( );

public:

  /// The normal constructor
  /**
    * NOTE: The pointer passed as the parameter must not be 0 one.
    */
    CdbBdbSOriginPropertyItr( const char* theDBIDRangeName );

  /// The copy constructor
  /**
    * More details to come...
    */
    CdbBdbSOriginPropertyItr( const CdbBdbSOriginPropertyItr& theItr );

  /// The assignment operator
  /**
    * More details to come...
    */
    CdbBdbSOriginPropertyItr& operator=( const CdbBdbSOriginPropertyItr& theItr );

  /// The destructor
  /**
    * Details...
    */
    virtual ~CdbBdbSOriginPropertyItr( );

  /// Reset an iterator to its initial state.
  /**
    * This implements the corresponding method of the base class.
    *
    * @see CdbIItr::reset
    * @see CdbStatus
    */
    virtual CdbStatus reset( );

  /// Advance an iterator to the next position.
  /**
    * This implements the corresponding method of the base class.
    *
    * @see CdbIItr::next()
    */
    virtual bool next( );

  /// Obtain the currently reffered value.
  /**
    * This implements the corresponding method of the base class.
    *
    * @see CdbIItr::value()
    * @see CdbIItr::ValueType
    *
    * @return the current value the iterator is set on
    */
    virtual ValueType value( );

  /// Check if an iterator is valid.
  /**
    * This implements the corresponding method of the base class.
    *
    * @see CdbIItr::isValid()
    */
    virtual bool isValid( );

  /// Make a clone of itself
  /**
    * @see CdbIItr::clone()
    */
    virtual InterfaceType* clone( ) const;

private:

    bool _isValid;
    bool _hasEverBeenAdvanced;

    CdbProperty _value;
};

CdbBdbSOriginPropertyItr::CdbBdbSOriginPropertyItr( const char* theDBIDRangeName ) :
    _isValid(false),
    _hasEverBeenAdvanced(false),
    _value( "DBID Range Name", theDBIDRangeName )
{ }

CdbBdbSOriginPropertyItr::CdbBdbSOriginPropertyItr( const CdbBdbSOriginPropertyItr& theItr ) :
    _isValid(theItr._isValid),
    _hasEverBeenAdvanced(theItr._hasEverBeenAdvanced),
    _value(theItr._value)
{ }

CdbBdbSOriginPropertyItr::~CdbBdbSOriginPropertyItr( )
{ }

CdbBdbSOriginPropertyItr&
CdbBdbSOriginPropertyItr::operator=( const CdbBdbSOriginPropertyItr& theItr )
{
    if( &theItr != this ) {
        _isValid             = theItr._isValid;
        _hasEverBeenAdvanced = theItr._hasEverBeenAdvanced;
        _value               = theItr._value;
    }
    return *this;
}

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

    return CdbStatus::Success;
}

bool
CdbBdbSOriginPropertyItr::next( )
{
    if( _isValid ) {
        _isValid             = false;
    } else {
        _isValid             = true;
        _hasEverBeenAdvanced = true;
    }
    return _isValid;
}

CdbBdbSOriginPropertyItr::ValueType
CdbBdbSOriginPropertyItr::value( )
{
    assert( isValid( ));
    return _value;
}

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

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

/////////////////////////
// Class CdbBdbSOrigin //
/////////////////////////

/// The wrapper implementation of a transient origin
/**
  * This is the only "origin" of the 'Wraper' implementation.
  */
class CdbBdbSOrigin : public CdbOrigin {

private:

  /// The constructor (NOT IMPLEMENTED)
  /**
    * Is disabled...
    */
    CdbBdbSOrigin( );

  /// The copy constructor (NOT IMPLEMENTED)
  /**
    * Is disabled...
    */
    CdbBdbSOrigin( const CdbBdbSOrigin& theOrigin );

  /// The assignment operator (NOT IMPLEMENTED)
  /**
    * Is disabled...
    */
    CdbBdbSOrigin& operator=( const CdbBdbSOrigin& theOrigin );

public:

  /// The normal constructor.
  /**
    * Initialize context with specified parameters.
    *
    * @see CdbDatabase
    * @see CdbDatabasePtr
    */
    CdbBdbSOrigin( const CdbDatabasePtr&         theDatabasePtr,    /**< the smart pointer providing a back back link to the parent database object */
                   const BdbRef(CdbBdbSOriginP)& theOriginRef       /**< the persistent origin */
                 );

  /// The destructor.
  /**
    * More details...
    */
    virtual ~CdbBdbSOrigin( );

  /// Obtain the creation time of the origin
  /**
    * This implements the corresponding method of the base class.
    *
    * @see CdbOrigin::created()
    */
    virtual BdbTime created( );

  /// Obtain the origin description
  /**
    * This implements the corresponding method of the base class.
    *
    * @see CdbOrigin::description()
    */
    virtual std::string description( );

  /// Check if this origin is the local one
  /**
    * This implements the corresponding method of the base class.
    *
    * @see CdbOrigin::isLocal()
    */
    virtual bool isLocal( ) const;

  /// Check if data corresponding to this origin are available in the local database
  /**
    * This implements the corresponding method of the base class.
    *
    * @see CdbOrigin::isInstantiated()
    */
    virtual bool isInstantiated( ) const;

  /// Check if this origin is the "master" one
  /**
    * This implements the corresponding method of the base class.
    *
    * @see CdbOrigin::isMaster()
    */
    virtual bool isMaster( ) const;

  /// Check if this origin is a "slave" one
  /**
    * This implements the corresponding method of the base class.
    *
    * @see CdbOrigin::isSlave()
    */
    virtual bool isSlave( ) const;

  /// Check if this origin is a "test" one
  /**
    * This implements the corresponding method of the base class.
    *
    * @see CdbOrigin::isTest()
    */
    virtual bool isTest( ) const;

  /// Set up an iterator of properties
  /**
    * This implements the corresponding method of the base class.
    *
    * @see CdbOrigin::propertyIterator()
    */
    virtual CdbStatus propertyIterator( CdbItr<CdbProperty>& theItr );

private:

    BdbHandle(CdbBdbSOriginP) _originH;
};

CdbBdbSOrigin::CdbBdbSOrigin( const CdbDatabasePtr&         theDatabasePtr,
                              const BdbRef(CdbBdbSOriginP)& theOriginRef ) :
    CdbOrigin( theDatabasePtr,
               theOriginRef->name( ).head( ),
               theOriginRef->id( )),
    _originH(theOriginRef)
{ }

CdbBdbSOrigin::~CdbBdbSOrigin( )
{ }

BdbTime
CdbBdbSOrigin::created( )
{
    return  _originH->created( );
}

std::string
CdbBdbSOrigin::description( )
{
    return std::string(  _originH->description( ).head( ));
}

bool
CdbBdbSOrigin::isLocal( ) const
{
  // Use parent object to get the local origin's identifier.

    return parent( )->localOrigin( )->id( ) == _originH->id( );
}

bool
CdbBdbSOrigin::isInstantiated( ) const
{
  // Try to find the persistent registry corresponding to the current origin's identifier.
  // The presense of this reqistry would mean that the data from this database are either
  // native to the current database or they have already been brough from the corresponding
  // remote database into the current one.

    BdbHandle(CdbBdbSRegistryP) h;
    return CdbStatus::Success == CdbBdbSRegistryP::findByOrigin( h, _originH->id( ));
}

bool
CdbBdbSOrigin::isMaster( ) const
{
    return _originH->type( ) == CdbBdbSOriginP::MASTER;
}

bool
CdbBdbSOrigin::isSlave( ) const
{
    return _originH->type( ) == CdbBdbSOriginP::SLAVE;
}

bool
CdbBdbSOrigin::isTest( ) const
{
    return _originH->type( ) == CdbBdbSOriginP::TEST;
}

CdbStatus
CdbBdbSOrigin::propertyIterator( CdbItr<CdbProperty>& theItr )
{
  // ATTENTION: This is not a memory leak - the created object
  //            will be destroyed by the iterator.

    theItr = CdbItr<CdbProperty>( new CdbBdbSOriginPropertyItr( _originH->dbidrange( ).head( )));

    return CdbStatus::Success;
}

};

///////////////////////////
// Class CdbBdbSDatabase //
///////////////////////////

CdbDatabase*
CdbBdbSDatabase::clone( ) const
{
  // Get rid of the "const" to access non-const methods

    CdbBdbSDatabase* mySelf = const_cast<CdbBdbSDatabase*>( this );
    return new CdbBdbSDatabase( mySelf->parent( ),
                                mySelf->name( ));
}

CdbBdbSDatabase::CdbBdbSDatabase( const CdbPtr& theCdbPtr,
                                  const char*   theName ) :
    CdbDatabase( theCdbPtr,
                 theName ),
    _isValid(true),
    _isOpen(false)
{ }

CdbBdbSDatabase::~CdbBdbSDatabase( )
{ }

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

bool
CdbBdbSDatabase::isOpen( )
{
    return _isOpen;
}

CdbStatus
CdbBdbSDatabase::open( )
{
    const char* errorStr = "CdbBdbSDatabase::open() - ERROR.";

    CdbStatus result = CdbStatus::Error;
    do {

        if( ! _isOpen ) {

          // Find local registry first because it can also be a master one

            if( CdbStatus::Success != CdbBdbSRegistryP::findLocal( _localRegistryH )) {
                cout << errorStr << endl
                     << "    Failed to find the local registry. The database was not properly" << endl
                     << "    initialized/loaded." << endl;
                break;
            }

          // Find the master if required

            if( _localRegistryH->isMaster( )) {
                _masterRegistryH = _localRegistryH;
            } else {
                if( CdbStatus::Success != CdbBdbSRegistryP::findMaster( _masterRegistryH )) {
                    cout << errorStr << endl
                         << "    Failed to find the master registry. The database was not properly" << endl
                         << "    initialized/loaded." << endl;
                    break;
                }
            }
            _isOpen = true;
        }

      // Done

        result = CdbStatus::Success;

    } while( false );

    return result;
}

CdbStatus
CdbBdbSDatabase::close( )
{
    if( _isOpen ) {
        _isOpen = false;

        _masterRegistryH = 0;
        _localRegistryH  = 0;
    }
    return CdbStatus::Success;
}

BdbTime
CdbBdbSDatabase::id( )
{
  // Make sure the database is open

    if( CdbStatus::Success != open( )) {
        assert( 0 );
        return BdbTime::plusInfinity;
    }
    return _localRegistryH->id( );
}

BdbTime
CdbBdbSDatabase::created( )
{
  // Make sure the database is open

    if( CdbStatus::Success != open( )) {
        assert( 0 );
        return BdbTime::plusInfinity;
    }
    return _localRegistryH->created( );
}

std::string
CdbBdbSDatabase::description( )
{
  // Make sure the database is open

    if( CdbStatus::Success != open( )) {
        assert( 0 );
        return std::string( );
    }
    return std::string( _localRegistryH->description( ).head( ));
}

std::string
CdbBdbSDatabase::defaultView( ) const
{
    return CdbEnvironment::defaultView( parent( )->technologyName( ),
                                        parent( )->implementationName( ),
                                        name( ));
}

CdbStatus
CdbBdbSDatabase::findView( CdbViewPtr& thePtr,
                           const char* theName )
{
    const char* errorStr = "CdbBdbSDatabase::findView(name) -- ERROR" ;

    CdbStatus result = CdbStatus::Error;
    do {

      // Make sure the database is open

        if( CdbStatus::Success != open( )) break;

      // Verify and correct parameters if 0 pointer is passed to indicate
      // that default database is needed.

        std::string viewName = defaultView( );
        if( 0 != theName ) viewName = theName;

        CdbCompositeName vName( viewName.c_str( ));
        if( !vName.isValid( )) {
            cout << errorStr << endl
                 << "    The view name passed to the procedure has invalid format: \"" << viewName.c_str( ) << "\"" << endl;
            break;
        }

      // Extract origin name and local view names

        std::string originName    = vName.first( );
        std::string localViewName = vName.last( );

      // Find the registry where the specified view is supposed to belong to
      //
      // NOTE: Watch for the simple optimizations in case of local or master
      //       origins.

        BdbHandle(CdbBdbSRegistryP) rH;
        if(      "<master>" == originName ) rH = _masterRegistryH;
        else if( "<local>"  == originName ) rH = _localRegistryH;
        else {
            if( CdbStatus::Success != CdbBdbSRegistryP::findByOrigin( rH,
                                                                      originName.c_str( ))) {
                cout << errorStr << endl
                     << "    Registry for specified origin was not found." << endl;
                break;
            }
        }

      // Get to the collection of views managed by found registry.

        BdbRef(CdbBdbSViewCollectionP) vCollRef = rH->viewCollection( );
        assert( ! BdbIsNull(vCollRef));

      // Find the view by its name at the collection.
      //
      // NOTE: Watch for side track in case if view nicknames are used.

        BdbRef(CdbBdbSViewP) vRef;
        if( 0 == strcmp( "<recent>", localViewName.c_str( ))) {
            if( CdbStatus::Success != vCollRef->newest( vRef )) {
                result = CdbStatus::NotFound;
                break;
            }
        } else {
            if( CdbStatus::Success != vCollRef->find( localViewName.c_str( ),
                                                      vRef )) {
                result = CdbStatus::NotFound;
                break;
            }
        }

      // Construct the extended identifier of the view (nneded to construct
      // the transient API object).

        CdbId viewId( rH->originId( ),
                      vRef->id( ));

      // 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.
      //
      // NOTE: The above corrected parameters object is used.

        CdbDatabasePtr myPtr( this->clone( ));

        thePtr = new CdbBdbSView( myPtr,
                                  viewName.c_str( ),
                                  viewId,
                                  vRef,
                                  _masterRegistryH,
                                  _localRegistryH );

        result = CdbStatus::Success;

    } while( false );

    return result;
}

CdbStatus
CdbBdbSDatabase::findView( CdbViewPtr&  thePtr,
                           const CdbId& theId )
{
    const char* errorStr = "CdbBdbSDatabase::findView(id) -- ERROR" ;

    CdbStatus result = CdbStatus::Error;
    do {

      // Make sure the database is open

        if( CdbStatus::Success != open( )) break;

      // Find the registry where the specified view is supposed to belong to
      //
      // NOTE: Watch for the simple optimizations in case of local or master
      //       origins.

        BdbHandle(CdbBdbSRegistryP) rH;
        if(      theId.origin == _masterRegistryH->originId( )) rH = _masterRegistryH;
        else if( theId.origin == _localRegistryH->originId( ))  rH = _localRegistryH;
        else {
            if( CdbStatus::Success != CdbBdbSRegistryP::findByOrigin( rH,
                                                                      theId.origin )) {
                cout << errorStr << endl
                     << "    Registry for specified origin was not found." << endl;
                break;
            }
        }

      // Get to the collection of views managed by found registry.

        BdbRef(CdbBdbSViewCollectionP) vCollRef = rH->viewCollection( );
        assert( ! BdbIsNull(vCollRef));

      // Find the view by its name at the collection.

        BdbRef(CdbBdbSViewP) vRef;
        if( CdbStatus::Success != vCollRef->find( theId.local,
                                                  vRef )) {
            result = CdbStatus::NotFound;
            break;
        }

      // Build the full name of the view

        std::string viewName( "" );
        {
            BdbRef(CdbBdbSOriginCollectionP) oCollRef = _masterRegistryH->originCollection( );
            assert( ! BdbIsNull(oCollRef));

            BdbRef(CdbBdbSOriginP) oRef;
            if( CdbStatus::Success != oCollRef->find( theId.origin,
                                                      oRef )) {
                cout << errorStr << endl
                     << "    The origin with ID: " << theId.origin << " not found in the master." << endl;
                break;
            }
            CdbCompositeName vName( oRef->name( ), vRef->name( ));
            assert( vName.isValid( ));

            viewName = vName.getName( );
        }

      // 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.
      //
      // NOTE: The above corrected parameters object is used.

        CdbDatabasePtr myPtr( this->clone( ));

        thePtr = new CdbBdbSView( myPtr,
                                  viewName.c_str( ),
                                  theId,
                                  vRef,
                                  _masterRegistryH,
                                  _localRegistryH );

        result = CdbStatus::Success;

    } while( false );

    return result;
}

CdbStatus
CdbBdbSDatabase::viewIterator( CdbViewItr& theItr )
{
    CdbStatus result = CdbStatus::Error;
    do {

      // Make sure the database is open

        if( CdbStatus::Success != open( )) break;

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

        theItr = CdbViewItr( new CdbBdbSViewItr( _masterRegistryH ));

      // Done

        result = CdbStatus::Success;

    } while( false );

    return result;
}

CdbStatus
CdbBdbSDatabase::physicalConditionIterator( CdbItr<CdbId>& theItr )
{
    const char* errorStr = "CdbBdbSDatabase::physicalConditionIterator() -- ERROR" ;

    CdbStatus result = CdbStatus::Error;

  // Make sure the database is open

    if( CdbStatus::Success != open( )) return CdbStatus::Error;

  // Find all physical conditions and put their 'global physical identifiers'
  // into thsi vector.

    std::vector<CdbId> vectorOfIds;

    CdbBdbSOriginCollectionP::IteratorOfIdentifiers originItr = _masterRegistryH->originCollection( )->iterator_identifiers( );
    while( originItr.next( )) {

        d_UShort originId = originItr.value( );

      // Try to get the corresponding registry. If it doesn't exist (not instantiated) then we
      // won't look for conditions of that registry.

        BdbHandle(CdbBdbSRegistryP) registryH;
        {
            if( CdbStatus::Success != ( result = CdbBdbSRegistryP::findByOrigin( registryH,
                                                                                 originId ))) {
                if( CdbStatus::NotFound == result ) {

                  // The origin is not currently instantiated in the input database. This may happen
                  // when the origin's data are yet to be imported.

                    continue;

                } else {
                    cerr << errorStr << endl
                         << "    Failed to find a registry for origin ID = " << originId << "." << endl;
                    return result;
                }
            }
        }

      // Get a collection of physical conditions from the registry
      //
      // NOTE; Some registries may not have local collections.. So we just skip them.

        BdbHandle(CdbBdbSConditionCollectionP) conditionCollectionH = registryH->conditionCollection( );
        if( !BdbIsNull(conditionCollectionH)) {

            CdbBdbSConditionCollectionP::IteratorOfIdentifiers pConditionItr = conditionCollectionH->iterator_identifiers( );
            while( pConditionItr.next( )) {
                vectorOfIds.push_back( CdbId( originId,
                                              pConditionItr.value( )));
            }
        }
    }

  // Build an iterator out of the vector

    theItr = CdbItr<CdbId>( new CdbSimpleVectorAdapterItr<CdbId>( vectorOfIds ));

    return CdbStatus::Success;
}

CdbStatus
CdbBdbSDatabase::findCondition( CdbConditionPtr& thePtr,
                                const CdbId&     theId )
{
    const char* errorStr = "CdbBdbSDatabase::findCondition('physical address') -- ERROR" ;

    CdbStatus result = CdbStatus::Error;
    do {

      // Make sure the database is open

        if( CdbStatus::Success != open( )) break;

      // Find the registry where the specified physical condition is supposed to belong to
      //
      // NOTE: Watch for the simple optimizations in case of local or master
      //       origins.

        BdbHandle(CdbBdbSRegistryP) rH;
        if(      theId.origin == _masterRegistryH->originId( )) rH = _masterRegistryH;
        else if( theId.origin == _localRegistryH->originId( ))  rH = _localRegistryH;
        else {
            if( CdbStatus::Success != CdbBdbSRegistryP::findByOrigin( rH,
                                                                      theId.origin )) {
                cout << errorStr << endl
                     << "    Registry for specified origin " << theId.origin << " was not found." << endl;
                break;
            }
        }

      // Get to the collection of physical conditions managed by found registry.

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

      // Find the condition by its identifier at the collection.

        BdbRef(CdbBdbSConditionP) cRef;
        if( CdbStatus::Success != cCollRef->find( theId.local,
                                                  cRef )) {
            result = CdbStatus::NotFound;
            break;
        }

      // Build the full name of the condition

        std::string conditionName( "" );
        {
            BdbRef(CdbBdbSOriginCollectionP) oCollRef = _masterRegistryH->originCollection( );
            assert( ! BdbIsNull(oCollRef));

            BdbRef(CdbBdbSOriginP) oRef;
            if( CdbStatus::Success != oCollRef->find( theId.origin,
                                                      oRef )) {
                cout << errorStr << endl
                     << "    The origin with ID: " << theId.origin << " not found in the master." << endl;
                break;
            }
            conditionName = std::string( oRef->name( )) + std::string( "::" ) + std::string( cRef->name( ).head( ));
        }

      // DESIGN NOTE: The condition API component is going to be disjoined from
      //              any view or a folder. The direct database pointer will be added instead.

        CdbFolderPtr fPtr = 0;
        BdbHandle(CdbBdbSConditionAtFolderP) conditionAtFolderH = 0;

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

        CdbDatabasePtr myPtr( this->clone( ));

        thePtr = new CdbBdbSCondition( fPtr,
                                       myPtr,
                                       conditionName.c_str( ),
                                       CdbBdbSId( theId.origin,
                                                  theId.local ),
                                       conditionAtFolderH,
                                       cRef,
                                       _masterRegistryH,
                                       _localRegistryH );

        result = CdbStatus::Success;

    } while( false );

    return result;
}

CdbStatus
CdbBdbSDatabase::findCondition( CdbConditionPtr&        thePtr,
                                const CdbCompositeName& thePhysicalName )
{
    const char* errorStr = "CdbBdbSDatabase::findCondition('physical name') -- ERROR" ;

    CdbStatus result = CdbStatus::Error;
    do {

      // Make sure the database is open

        if( CdbStatus::Success != open( )) break;

      // Verify parameters

        if( !thePhysicalName.isValid( )) {
            cout << errorStr << endl
                 << "    The 'physical name' name passed to the procedure has invalid format: \"" << thePhysicalName.getName( ).c_str( ) << "\"" << endl;
            break;
        }

      // Extract origin name and local condition names

        std::string originName         = thePhysicalName.first( );
        std::string localConditionName = thePhysicalName.last( );

      // Find the registry where the specified physical condition is supposed to belong to
      //
      // NOTE: Watch for the simple optimizations in case of local or master
      //       origins.

        BdbHandle(CdbBdbSRegistryP) rH;
        if     ( "<master>" == originName ) rH = _masterRegistryH;
        else if(  "<local>" == originName ) rH =  _localRegistryH;
        else {
            if( CdbStatus::Success != CdbBdbSRegistryP::findByOrigin( rH,
                                                                      originName.c_str( ))) {
                cout << errorStr << endl
                     << "    Registry for specified origin \"" << originName.c_str( ) << "\" was not found." << endl;
                break;
            }
        }

      // Get to the collection of physical conditions managed by found registry.

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

      // Find the condition by its 'physical' name at the collection.

        BdbRef(CdbBdbSConditionP) cRef;
        if( CdbStatus::Success != cCollRef->find( localConditionName.c_str( ),
                                                  cRef )) {
            result = CdbStatus::NotFound;
            break;
        }

      // DESIGN NOTE: The condition API component is going to be disjoined from
      //              any view or a folder. The direct database pointer will be added instead.

        CdbFolderPtr fPtr = 0;
        BdbHandle(CdbBdbSConditionAtFolderP) conditionAtFolderH = 0;

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

        CdbDatabasePtr myPtr( this->clone( ));

        thePtr = new CdbBdbSCondition( fPtr,
                                       myPtr,
                                       thePhysicalName.getName( ).c_str( ),
                                       CdbBdbSId( rH->originId( ),
                                                  cRef->id( )),
                                       conditionAtFolderH,
                                       cRef,
                                       _masterRegistryH,
                                       _localRegistryH );

        result = CdbStatus::Success;

    } while( false );

    return result;
}

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

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

CdbStatus
CdbBdbSDatabase::partitionIterator( CdbItr<unsigned short>& theItr )
{
    CdbStatus result = CdbStatus::Error;
    do {

      // Make sure the database is open

        if( CdbStatus::Success != open( )) break;

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

        theItr = CdbItr<unsigned short>( new CdbBdbSPartitionItr( _masterRegistryH->partitionsLayout( )->iterator( )));

      // Done

        result = CdbStatus::Success;

    } while( false );

    return result;
}

CdbStatus
CdbBdbSDatabase::partitionIterator( CdbItr<unsigned short>& theItr,
                                    unsigned int            theOriginId )
{
    const char* errorStr = "CdbBdbSDatabase::partitionIterator(by origin id) - ERROR.";

    CdbStatus result = CdbStatus::Error;
    do {

      // Make sure the database is open

        if( CdbStatus::Success != open( )) break;

      // Find the corresponding registry

        BdbHandle(CdbBdbSRegistryP) registryH;
        CdbStatus                   status = CdbBdbSRegistryP::findByOrigin( registryH,
                                                                             theOriginId );
        if( CdbStatus::Success != status ) {
            if( CdbStatus::NotFound == status ) {
                cout << errorStr << endl
                     << "    The specified origin identifier " << theOriginId << " does not correspond to any" << endl
                     << "    known origin in the current database. Please check the logic of your application." << endl;
            } else {
                cout << errorStr << endl
                     << "    Failed to find the registry for specified origin identifier " << theOriginId << "." << endl
                     << "    Perhaps the database was not properly initialized/loaded." << endl;
            }
            break;
        }

      // Try to get the P-Layout. Some origins may not have it. Silently return
      // the CdbStatus::NotFound if this is going to be the case.

        BdbRef(CdbBdbSPartitionsLayoutP) pLayoutRef = registryH->partitionsLayout( );
        if( BdbIsNull(pLayoutRef)) {
            result = CdbStatus::NotFound;
            break;
        }

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

        theItr = CdbItr<unsigned short>( new CdbBdbSPartitionItr( pLayoutRef->iterator( )));

      // Done

        result = CdbStatus::Success;

    } while( false );

    return result;
}

CdbStatus
CdbBdbSDatabase::partitionIterator( CdbItr<unsigned short>& theItr,
                                    const char*             theOriginName )
{
    const char* errorStr = "CdbBdbSDatabase::partitionIterator(by origin name) - ERROR.";

    CdbStatus result = CdbStatus::Error;
    do {

      // Make sure the database is open

        if( CdbStatus::Success != open( )) break;

      // Find the corresponding registry

        BdbHandle(CdbBdbSRegistryP) registryH;
        CdbStatus                   status = CdbBdbSRegistryP::findByOrigin( registryH,
                                                                             theOriginName );
        if( CdbStatus::Success != status ) {
            if( CdbStatus::NotFound == status ) {
                cout << errorStr << endl
                     << "    The specified origin name \"" << theOriginName << "\" does not correspond to any" << endl
                     << "    known origin in the current database. Please check the logic of your application." << endl;
            } else {
                cout << errorStr << endl
                     << "    Failed to find the registry for specified origin name \"" << theOriginName << "\"." << endl
                     << "    Perhaps the database was not properly initialized/loaded." << endl;
            }
            break;
        }

      // Try to get the P-Layout. Some origins may not have it. Silently return
      // the CdbStatus::NotFound if this is going to be the case.

        BdbRef(CdbBdbSPartitionsLayoutP) pLayoutRef = registryH->partitionsLayout( );
        if( BdbIsNull(pLayoutRef)) {
            result = CdbStatus::NotFound;
            break;
        }

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

        theItr = CdbItr<unsigned short>( new CdbBdbSPartitionItr( pLayoutRef->iterator( )));

      // Done

        result = CdbStatus::Success;

    } while( false );

    return result;
}

CdbStatus
CdbBdbSDatabase::findPartition( CdbPartitionPtr& thePtr,
                                unsigned short   thePartition )
{
    const char* errorStr = "CdbBdbSDatabase::findPartition() -- ERROR" ;

    CdbStatus result = CdbStatus::Error;
    do {

      // Make sure the database is open

        if( CdbStatus::Success != open( )) break;

      // Find specified partition
      //
      // NOTE: This algorithm will use partition object from the local
      //       P-Layout if it will discover that the partition belongs to the current
      //       database. This is a typical scenario for the SLAVE type databases.

        BdbHandle( CdbBdbSPartitionP ) pH;
        {
            BdbRef(CdbBdbSPartitionsLayoutP) pLayoutRef = _masterRegistryH->partitionsLayout( );
            if( BdbIsNull(pLayoutRef)) {
                assert( 0 );
                break;
            }

            BdbRef( CdbBdbSPartitionP ) pRef;
            if( CdbStatus::Success != pLayoutRef->find( thePartition,
                                                        pRef )) {
                result = CdbStatus::NotFound;
                break;
            }
            pH = pRef;

            if( pH->originId( ) != _masterRegistryH->originId( )) {
                if( pH->originId( ) == _localRegistryH->originId( )) {

                    pLayoutRef = _localRegistryH->partitionsLayout( );
                    if( BdbIsNull(pLayoutRef)) {
                        assert( 0 );
                        break;
                    }
                    if( CdbStatus::Success != pLayoutRef->find( thePartition,
                                                                pRef )) {
                        cout << errorStr << endl
                             << "    Failed to find partition with ID=" << thePartition << " at the current" << endl
                             << "    database to whom the partition is supposed to belong to. The database" << endl
                             << "    may not be properly initialized/loaded." << endl;

                        result = CdbStatus::NotFound;
                        break;
                    }
                    pH = pRef;
                }
            }
        }
        if( BdbIsNull(pH)) {
            assert( 0 );
            break;
        }

      // Get the owner's origin name of this partition.

        std::string ownerOriginName;
        {
            BdbHandle(CdbBdbSOriginCollectionP) oCollectionH;

            oCollectionH = _masterRegistryH->originCollection( );
            assert( !BdbIsNull(oCollectionH));

            BdbRef(CdbBdbSOriginP) oRef;
            if( CdbStatus::Success != oCollectionH->find( pH->originId( ),
                                                          oRef )) {
                cout << errorStr << endl
                     << "    There is no information on the origin ID=" << pH->originId( ) << endl
                     << "    in the corresponding collection of the MASTER's registry." << endl
                     << "    The database may be corrupted or in an inconsistent state." << endl;
                break;
            }

            ownerOriginName = oRef->name( );
        }

      // 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.
      //
      // NOTE: The above corrected parameters object is used.

        CdbDatabasePtr myPtr = this->clone( );

        thePtr = new CdbBdbSPartition( myPtr,
                                       pH,
                                       pH->originId( ),
                                       ownerOriginName.c_str( ));

      // Done

        result = CdbStatus::Success;

    } while( false );

    return result;
}

CdbStatus
CdbBdbSDatabase::findPartition( CdbPartitionPtr& thePtr,
                                unsigned short   thePartition,
                                unsigned int     theOriginId )
{
    const char* errorStr = "CdbBdbSDatabase::findPartition(by origin id) -- ERROR" ;

    CdbStatus result = CdbStatus::Error;
    do {

      // Make sure the database is open

        if( CdbStatus::Success != open( )) break;

      // Find the corresponding registry

        BdbHandle(CdbBdbSRegistryP) registryH;
        CdbStatus                   status = CdbBdbSRegistryP::findByOrigin( registryH,
                                                                             theOriginId );
        if( CdbStatus::Success != status ) {
            if( CdbStatus::NotFound == status ) {
                cout << errorStr << endl
                     << "    The specified origin identifier " << theOriginId << " does not correspond to any" << endl
                     << "    known origin in the current database. Please check the logic of your application." << endl;
            } else {
                cout << errorStr << endl
                     << "    Failed to find the registry for specified origin identifier " << theOriginId << "." << endl
                     << "    Perhaps the database was not properly initialized/loaded." << endl;
            }
            break;
        }

      // Try to get the P-Layout. Some origins may not have it.

        BdbRef(CdbBdbSPartitionsLayoutP) pLayoutRef = registryH->partitionsLayout( );
        if( BdbIsNull(pLayoutRef)) {
            cout << errorStr << endl
                 << "    The origin for specified origin identifier " << theOriginId << " is not allowed" << endl
                 << "    to have partitions. Please check the logic of your application." << endl;
            break;
        }

      // Find the specified partition

        BdbHandle( CdbBdbSPartitionP ) pH;
        {
            BdbRef( CdbBdbSPartitionP ) pRef;
            if( CdbStatus::Success != pLayoutRef->find( thePartition,
                                                        pRef )) {
                result = CdbStatus::NotFound;
                break;
            }
            pH = pRef;
        }

      // Get the owner's origin name of this partition.

        std::string ownerOriginName;
        {
            BdbHandle(CdbBdbSOriginCollectionP) oCollectionH;

            oCollectionH = _masterRegistryH->originCollection( );
            assert( !BdbIsNull(oCollectionH));

            BdbRef(CdbBdbSOriginP) oRef;
            if( CdbStatus::Success != oCollectionH->find( pH->originId( ),
                                                          oRef )) {
                cout << errorStr << endl
                     << "    There is no information on the origin ID=" << pH->originId( ) << endl
                     << "    in the corresponding collection of the MASTER's registry." << endl
                     << "    The database may be corrupted or in an inconsistent state." << endl;
                break;
            }

            ownerOriginName = oRef->name( );
        }

      // 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.
      //
      // NOTE: The above corrected parameters object is used.

        CdbDatabasePtr myPtr = this->clone( );

        thePtr = new CdbBdbSPartition( myPtr,
                                       pH,
                                       pH->originId( ),
                                       ownerOriginName.c_str( ));

      // Done

        result = CdbStatus::Success;

    } while( false );

    return result;
}

CdbStatus
CdbBdbSDatabase::findPartition( CdbPartitionPtr& thePtr,
                                unsigned short   thePartition,
                                const char*      theOriginName )
{
    const char* errorStr = "CdbBdbSDatabase::findPartition(by origin name) -- ERROR" ;

    CdbStatus result = CdbStatus::Error;
    do {

      // Make sure the database is open

        if( CdbStatus::Success != open( )) break;

      // Find the corresponding registry

        BdbHandle(CdbBdbSRegistryP) registryH;
        CdbStatus                   status = CdbBdbSRegistryP::findByOrigin( registryH,
                                                                             theOriginName );
        if( CdbStatus::Success != status ) {
            if( CdbStatus::NotFound == status ) {
                cout << errorStr << endl
                     << "    The specified origin name \"" << theOriginName << "\" does not correspond to any" << endl
                     << "    known origin in the current database. Please check the logic of your application." << endl;
            } else {
                cout << errorStr << endl
                     << "    Failed to find the registry for specified origin name \"" << theOriginName << "\"." << endl
                     << "    Perhaps the database was not properly initialized/loaded." << endl;
            }
            break;
        }

      // Try to get the P-Layout. Some origins may not have it.

        BdbRef(CdbBdbSPartitionsLayoutP) pLayoutRef = registryH->partitionsLayout( );
        if( BdbIsNull(pLayoutRef)) {
            cout << errorStr << endl
                 << "    The origin for specified origin name \"" << theOriginName << "\" is not allowed" << endl
                 << "    to have partitions. Please check the logic of your application." << endl;
            break;
        }

      // Find the specified partition

        BdbHandle( CdbBdbSPartitionP ) pH;
        {
            BdbRef( CdbBdbSPartitionP ) pRef;
            if( CdbStatus::Success != pLayoutRef->find( thePartition,
                                                        pRef )) {
                result = CdbStatus::NotFound;
                break;
            }
            pH = pRef;
        }

      // Get the owner's origin name of this partition.

        std::string ownerOriginName;
        {
            BdbHandle(CdbBdbSOriginCollectionP) oCollectionH;

            oCollectionH = _masterRegistryH->originCollection( );
            assert( !BdbIsNull(oCollectionH));

            BdbRef(CdbBdbSOriginP) oRef;
            if( CdbStatus::Success != oCollectionH->find( pH->originId( ),
                                                          oRef )) {
                cout << errorStr << endl
                     << "    There is no information on the origin ID=" << pH->originId( ) << endl
                     << "    in the corresponding collection of the MASTER's registry." << endl
                     << "    The database may be corrupted or in an inconsistent state." << endl;
                break;
            }

            ownerOriginName = oRef->name( );
        }

      // 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.
      //
      // NOTE: The above corrected parameters object is used.

        CdbDatabasePtr myPtr = this->clone( );

        thePtr = new CdbBdbSPartition( myPtr,
                                       pH,
                                       pH->originId( ),
                                       ownerOriginName.c_str( ));

      // Done

        result = CdbStatus::Success;

    } while( false );

    return result;
}

CdbOriginPtr
CdbBdbSDatabase::localOrigin( )
{
  // Make sure the database is open

    if( CdbStatus::Success != open( )) {
        assert( 0 );
        return 0;
    }

  // Use cached object pointer if possible

    if( _localOriginPtr.isNull( )) {
        if( CdbStatus::Success != findOrigin( _localOriginPtr,
                                              _localRegistryH->originId( ))) {
            assert( 0 );
            return 0;
        }
    }
    return _localOriginPtr;
}

CdbStatus
CdbBdbSDatabase::originIterator( CdbItr<unsigned short>& theItr )
{
    CdbStatus result = CdbStatus::Error;
    do {

      // Make sure the database is open

        if( CdbStatus::Success != open( )) break;

      // Set up an iterator of persistent origin identifiers. We're going
      // to retranslate this iterator to the corresponding transient one.

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

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

        theItr = CdbItr<unsigned short>( new CdbBdbSOriginItr( oCollRef->iterator_identifiers( )));

      // Done

        result = CdbStatus::Success;

    } while( false );

    return result;
}

CdbStatus
CdbBdbSDatabase::findOrigin( CdbOriginPtr& thePtr,
                             const char*   theName )
{
    assert( 0 != theName );

    CdbStatus result = CdbStatus::NotFound;
    do {

      // Make sure the database is open

        if( CdbStatus::Success != open( )) {
            result = CdbStatus::Error;
            break;
        }

      // Try to find a persistent object for specified origin. If not found then
      // return the whatever status is obtained.

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

        BdbRef(CdbBdbSOriginP) oRef;
        {
            result = oCollRef->find( theName, oRef );
            if( CdbStatus::Success != result ) break;
        }
        assert( ! BdbIsNull(oRef));

      // 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.
      //
      // NOTE: The above corrected parameters object is used.

        CdbDatabasePtr myPtr( this->clone( ));

        thePtr = new CdbBdbSOrigin( myPtr,
                                    oRef );

      // Done

        result = CdbStatus::Success;

    } while( false );

    return result;
}

CdbStatus
CdbBdbSDatabase::findOrigin( CdbOriginPtr&  thePtr,
                             unsigned short theId )
{
    CdbStatus result = CdbStatus::NotFound;
    do {

      // Make sure the database is open

        if( CdbStatus::Success != open( )) {
            result = CdbStatus::Error;
            break;
        }

      // Try to find a persistent object for specified origin. If not found then
      // return the whatever status is obtained.

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

        BdbRef(CdbBdbSOriginP) oRef;
        {
            result = oCollRef->find( theId, oRef );
            if( CdbStatus::Success != result ) break;
        }
        assert( ! BdbIsNull(oRef));

      // 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.
      //
      // NOTE: The above corrected parameters object is used.

        CdbDatabasePtr myPtr( this->clone( ));

        thePtr = new CdbBdbSOrigin( myPtr,
                                    oRef );

      // Done

        result = CdbStatus::Success;

    } while( false );

    return result;
}

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

---