---

CdbRooRoDatabase.cc

Go to the documentation of this file.

// File and Version Information:
//      $Id: CdbRooRoDatabase.cc,v 1.6 2005/08/13 01:42:15 gapon Exp $

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

#include "BaBar/BaBar.hh"

#include "CdbRooReadonly/CdbRooRoDatabase.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 "CdbRooReadonly/CdbRooRoRegistry.hh"
#include "CdbRooReadonly/CdbRooRoOriginR.hh"
#include "CdbRooReadonly/CdbRooRoOriginCollectionR.hh"
#include "CdbRooReadonly/CdbRooRoView.hh"
#include "CdbRooReadonly/CdbRooRoViewR.hh"
#include "CdbRooReadonly/CdbRooRoViewCollectionR.hh"
#include "CdbRooReadonly/CdbRooRoViewItr.hh"
#include "CdbRooReadonly/CdbRooRoPartitionsLayoutR.hh"
#include "CdbRooReadonly/CdbRooRoPartitionR.hh"
#include "CdbRooReadonly/CdbRooRoCondition.hh"
#include "CdbRooReadonly/CdbRooRoConditionAtFolderR.hh"
#include "CdbRooReadonly/CdbRooRoConditionCollectionR.hh"

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

namespace {

  ////////////////////////////////
  // Class CdbRooRoPartitionItr //
  ////////////////////////////////

  /// The implementation of the iterator of partitions
  /**
    * This iterator is only meant to retranslate type of the result
    * produced by a persistent iterator.
    */
    class CdbRooRoPartitionItr : public CdbItr<unsigned short>::InterfaceType {

    private:

      /// The default constructor (NOT IMPLEMENTED)

        CdbRooRoPartitionItr( );

    public:

      /// The normal constructor
 
        CdbRooRoPartitionItr( const CdbItr<UShort_t>& theInputItr ) : _itr(theInputItr) { }

      /// The copy constructor

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

      /// The assignment operator

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

      /// The destructor

        virtual ~CdbRooRoPartitionItr( ) { }

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

      /// Advance an iterator to the next position.
      /**
        * This implements the corresponding method of the base class.
        *
        * @see CdbIItr::next()
        */
        virtual bool next( ) { return _itr.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( ) { return _itr.value( ); }

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

      /// Make a clone of itself
      /**
        * @see CdbIItr::clone()
        */
        virtual InterfaceType* clone( ) const { return new CdbRooRoPartitionItr( *this ); }

    private:

        CdbItr<UShort_t> _itr;
    };

  /////////////////////////////
  // Class CdbRooRoPartition //
  /////////////////////////////

  /// The implementation of the partition API class

    class CdbRooRoPartition : public CdbPartition {

    private:

      /// The default constructor (NOT IMPLEMENTED)

        CdbRooRoPartition( );

      /// The copy constructor (NOT IMPLEMENTED)

        CdbRooRoPartition( const CdbRooRoPartition& thePartition );

      /// The assignment operator (NOT IMPLEMENTED)

        CdbRooRoPartition& operator=( const CdbRooRoPartition& thePartition );

    public:

      /// The normal constructor

        CdbRooRoPartition( const CdbDatabasePtr&                theDatabasePtr,                      
                           const CdbCPtr< CdbRooRoPartitionR >& thePartitionPtr,
                           unsigned short                       theOwnerId,
                           const char*                          theOwnerName )  :
            CdbPartition( theDatabasePtr,
                          thePartitionPtr->id( ),
                          theOwnerId,
                          theOwnerName,
                          thePartitionPtr->description( ).c_str( ),
                          thePartitionPtr->created( ),
                          thePartitionPtr->cell( ).beginValidity ( ),
                          thePartitionPtr->cell( ).endValidity   ( ),
                          thePartitionPtr->cell( ).beginInsertion( )),
            _partitionPtr(thePartitionPtr)
        { }

      /// The destructor

        virtual ~CdbRooRoPartition( ) { }

      /// 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 { return _partitionPtr->cell( ).endInsertion( ); }

      /// 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 { return _partitionPtr->modified( ); }

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

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

    private:

        CdbCPtr< CdbRooRoPartitionR > _partitionPtr;
    };

  /////////////////////////////
  // Class CdbRooRoOriginItr //
  /////////////////////////////

  /// The implementation of the iterator of partitions
  /**
    * This iterator is only meant to retranslate type of the result
    * produced by a persistent iterator.
    */
    class CdbRooRoOriginItr : public CdbItr<unsigned short>::InterfaceType {

    private:

      /// The default constructor (NOT IMPLEMENTED)
 
        CdbRooRoOriginItr( );

    public:

      /// The normal constructor

        CdbRooRoOriginItr( const CdbItr<UShort_t>& theInputItr ) : _itr(theInputItr) { }

      /// The copy constructor

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

      /// The assignment operator

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

      /// The destructor

        virtual ~CdbRooRoOriginItr( ) { }

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

      /// Advance an iterator to the next position.
      /**
        * This implements the corresponding method of the base class.
        *
        * @see CdbIItr::next()
        */
        virtual bool next( ) { return _itr.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( ) { return _itr.value( ); }

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

      /// Make a clone of itself
      /**
        * @see CdbIItr::clone()
        */
        virtual InterfaceType* clone( ) const { return new CdbRooRoOriginItr( *this ); }

    private:

        CdbItr<UShort_t> _itr;
    };

  /////////////////////////////////////
  // Class CdbRooRoOriginPropertyItr //
  /////////////////////////////////////

  /// The implementation of a transient origin's property iterator
  /**
    * This is the "no-one-element" iterator since there are no properties
    * specific to the current implementation of the CDB API.
    */
    class CdbRooRoOriginPropertyItr : public CdbItr<CdbProperty>::InterfaceType {

    public:

      /// The default constructor

        CdbRooRoOriginPropertyItr( ) { }

      /// The copy constructor

        CdbRooRoOriginPropertyItr( const CdbRooRoOriginPropertyItr& theItr ) { }

      /// The assignment operator

        CdbRooRoOriginPropertyItr& operator=( const CdbRooRoOriginPropertyItr& theItr ) { return *this; }

      /// The destructor

        virtual ~CdbRooRoOriginPropertyItr( ) { }

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

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

      /// 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( )
        {
            assert( 0 );
            return CdbProperty( );
        }

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

      /// Make a clone of itself
      /**
        * @see CdbIItr::clone()
        */
        virtual InterfaceType* clone( ) const { return new CdbRooRoOriginPropertyItr( *this ); }
    };

  //////////////////////////
  // Class CdbRooRoOrigin //
  //////////////////////////

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

    private:

      /// The constructor (NOT IMPLEMENTED)

        CdbRooRoOrigin( );

      /// The copy constructor (NOT IMPLEMENTED)

        CdbRooRoOrigin( const CdbRooRoOrigin& theOrigin );

      /// The assignment operator (NOT IMPLEMENTED)

        CdbRooRoOrigin& operator=( const CdbRooRoOrigin& theOrigin );

    public:

      /// The normal constructor.
      /**
        * Initialize context with specified parameters.
        *
        * @see CdbDatabase
        * @see CdbDatabasePtr
        */
        CdbRooRoOrigin( const CdbDatabasePtr&             theDatabasePtr,           /**< the smart pointer providing a back back link to the parent database object */
                        const CdbCPtr< CdbRooRoOriginR >& thePersistentOriginPtr    /**< the persistent origin */
                      ) :
            CdbOrigin( theDatabasePtr,
                       thePersistentOriginPtr->name( ).c_str( ),
                       thePersistentOriginPtr->id( )),
            _persistentOriginPtr(thePersistentOriginPtr)
        { }

      /// The destructor.
      /**
        * More details...
        */
        virtual ~CdbRooRoOrigin( ) { }

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

      /// Obtain the origin description
      /**
        * This implements the corresponding method of the base class.
        *
        * @see CdbOrigin::description()
        */
        virtual std::string description( ) { return _persistentOriginPtr->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
        {
          // Use parent object to get the local origin's identifier.

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

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

            CdbCPtr< CdbRooRoRegistry > ptr;
            return CdbStatus::Success == CdbRooRoRegistry::findByOrigin( ptr,
                                                                         _persistentOriginPtr->id( ));
        }

      /// Check if this origin is the "master" one
      /**
        * This implements the corresponding method of the base class.
        *
        * @see CdbOrigin::isMaster()
        */
        virtual bool isMaster( ) const { return _persistentOriginPtr->type( ) == CdbRooRoOriginR::MASTER; }

      /// Check if this origin is a "slave" one
      /**
        * This implements the corresponding method of the base class.
        *
        * @see CdbOrigin::isSlave()
        */
        virtual bool isSlave( ) const { return _persistentOriginPtr->type( ) == CdbRooRoOriginR::SLAVE; }

      /// Check if this origin is a "test" one
      /**
        * This implements the corresponding method of the base class.
        *
        * @see CdbOrigin::isTest()
        */
        virtual bool isTest( ) const { return _persistentOriginPtr->type( ) == CdbRooRoOriginR::TEST; }

      /// Set up an iterator of properties
      /**
        * This implements the corresponding method of the base class.
        *
        * @see CdbOrigin::propertyIterator()
        */
        virtual CdbStatus propertyIterator( CdbItr<CdbProperty>& theItr )
        {
          // ATTENTION: This is not a memory leak - the created object
          //            will be destroyed by the iterator.

            theItr = CdbItr<CdbProperty>( new CdbRooRoOriginPropertyItr( ));

            return CdbStatus::Success;
        }

    private:

        CdbCPtr< CdbRooRoOriginR > _persistentOriginPtr;
    };
}

////////////////////////////
// Class CdbRooRoDatabase //
////////////////////////////

CdbDatabase*
CdbRooRoDatabase::clone( ) const
{
  // IMPLEMENTATION NOTE: The resulting object will be "closed".

    return new CdbRooRoDatabase( this->parent( ),
                                 this->name( ));
}

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

CdbRooRoDatabase::~CdbRooRoDatabase( )
{ }

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

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

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

    if( !_isOpen ) {

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

        if( CdbStatus::Success != CdbRooRoRegistry::findLocal( _localRegistryPtr )) {
            cerr << errorStr << endl
                 << "    Failed to find the local registry. The database was not properly" << endl
                 << "    initialized/loaded." << endl;
            return CdbStatus::Error;
        }

      // Find the master if required

        if( _localRegistryPtr->isMaster( )) {
            _masterRegistryPtr = _localRegistryPtr;
        } else {
            if( CdbStatus::Success != CdbRooRoRegistry::findMaster( _masterRegistryPtr )) {
                cerr << errorStr << endl
                     << "    Failed to find the master registry. The database was not properly" << endl
                     << "    initialized/loaded." << endl;
                return CdbStatus::Error;
            }
        }
        _isOpen = true;
    }
    return CdbStatus::Success;
}

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

        _masterRegistryPtr = 0;
        _localRegistryPtr  = 0;
    }
    return CdbStatus::Success;
}

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

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

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

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

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

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

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

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

  // 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 compositeViewName( viewName.c_str( ));
    if( !compositeViewName.isValid( )) {
        cerr << errorStr << endl
             << "    The view name passed to the procedure has invalid" << endl
             << "    format: \"" << viewName << "\"" << endl;

        return CdbStatus::IllegalParameters;
    }

  // Extract origin name and local view names

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

  // Make sure the database is open

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

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

    CdbCPtr< CdbRooRoRegistry > registryPtr;
    if(      "<master>" == originName ) registryPtr = _masterRegistryPtr;
    else if( "<local>"  == originName ) registryPtr = _localRegistryPtr;
    else {
        if( CdbStatus::Success != CdbRooRoRegistry::findByOrigin( registryPtr,
                                                                  originName )) {
            cerr << errorStr << endl
                 << "    Registry for specified origin was not found." << endl;

            return CdbStatus::Error;
        }
    }

  // Find the view by its name at the collection of the found registry.
  //
  // NOTE: Watch for "short cut" in case if view nicknames are used.

    CdbCPtr< CdbRooRoViewR > persistentViewPtr;
    if( "<recent>" == localViewName ) {

        CdbStatus result = registryPtr->viewCollection( )->newest( persistentViewPtr );
        if( CdbStatus::Success != result ) return result;

    } else {

        CdbStatus result = registryPtr->viewCollection( )->find( localViewName,
                                                                 persistentViewPtr );
        if( CdbStatus::Success != result ) return result;
    }

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

    CdbId viewId( registryPtr->originId( ),
                  persistentViewPtr->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.

    thePtr = new CdbRooRoView( CdbDatabasePtr( this->clone( )),
                               viewName.c_str( ),
                               viewId,
                               persistentViewPtr,
                               _masterRegistryPtr,
                               _localRegistryPtr );

    return CdbStatus::Success;
}

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

  // Make sure the database is open

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

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

    CdbCPtr< CdbRooRoRegistry > registryPtr;
    if(      theId.origin == _masterRegistryPtr->originId( )) registryPtr = _masterRegistryPtr;
    else if( theId.origin == _localRegistryPtr->originId( ))  registryPtr = _localRegistryPtr;
    else {
        if( CdbStatus::Success != CdbRooRoRegistry::findByOrigin( registryPtr,
                                                                  theId.origin )) {
            cerr << errorStr << endl
                 << "    Registry for specified origin was not found." << endl;

            return CdbStatus::Error;
        }
    }

  // Find the view by its name at the collection of the found registry.

    CdbCPtr< CdbRooRoViewR > persistentViewPtr;
    CdbStatus                result = registryPtr->viewCollection( )->find( theId.local,
                                                                            persistentViewPtr );
    if( CdbStatus::Success != result ) return result;

  // Build the full name of the view

    std::string viewName( "" );
    {
        CdbCPtr< CdbRooRoOriginR > persistentOriginPtr;
        if( CdbStatus::Success != _masterRegistryPtr->originCollection( )->find( theId.origin,
                                                                                 persistentOriginPtr )) {
            cerr << errorStr << endl
                 << "    The origin with ID: " << theId.origin << " not found in the master." << endl;

            return CdbStatus::Error;
        }
        CdbCompositeName compositeViewName( persistentOriginPtr->name( ).c_str( ),
                                            persistentViewPtr->name( ).c_str( ));
        assert( compositeViewName.isValid( ));

        viewName = compositeViewName.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.

    thePtr = new CdbRooRoView( CdbDatabasePtr( this->clone( )),
                               viewName.c_str( ),
                               theId,
                               persistentViewPtr,
                               _masterRegistryPtr,
                               _localRegistryPtr );

    return CdbStatus::Success;
}

CdbStatus
CdbRooRoDatabase::viewIterator( CdbViewItr& theItr )
{
  // Make sure the database is open

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

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

    theItr = CdbViewItr( new CdbRooRoViewItr( _masterRegistryPtr ));

    return CdbStatus::Success;
}

CdbStatus
CdbRooRoDatabase::physicalConditionIterator( CdbItr<CdbId>& theItr )
{
    const char* errorStr = "CdbRooRoDatabase::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 this vector.

    std::vector<CdbId> vectorOfIds;

    CdbItr<UShort_t> originItr = _masterRegistryPtr->originCollection( )->iterator_identifiers( );
    while( originItr.next( )) {

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

        CdbCPtr< CdbRooRoRegistry > registryPtr;
        {
            if( CdbStatus::Success != ( result = CdbRooRoRegistry::findByOrigin( registryPtr,
                                                                                 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.

        CdbCPtr< CdbRooRoConditionCollectionR > conditionCollectionPtr = registryPtr->conditionCollection( );
        if( !conditionCollectionPtr.isNull( )) {

            CdbItr<UShort_t>  pConditionItr = conditionCollectionPtr->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
CdbRooRoDatabase::findCondition( CdbConditionPtr& thePtr,
                                 const CdbId&     theId )
{
    const char* errorStr = "CdbRooRoDatabase::findCondition('physical address') -- ERROR" ;

  // Make sure the database is open

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

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

    CdbCPtr< CdbRooRoRegistry > registryPtr;
    if(      theId.origin == _masterRegistryPtr->originId( )) registryPtr = _masterRegistryPtr;
    else if( theId.origin == _localRegistryPtr->originId( ))  registryPtr = _localRegistryPtr;
    else {
        if( CdbStatus::Success != CdbRooRoRegistry::findByOrigin( registryPtr,
                                                                  theId.origin )) {
            cerr << errorStr << endl
                 << "    Registry for specified origin " << theId.origin << " was not found." << endl;

            return CdbStatus::Error;
        }
    }

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

    CdbCPtr< CdbRooRoConditionR > persistentConditionPtr;
    CdbStatus                     result = registryPtr->conditionCollection( )->find( theId.local,
                                                                                      persistentConditionPtr );
    if( CdbStatus::Success != result ) return result;

  // Build the full name of the condition

    std::string conditionName( "" );
    {
        CdbCPtr< CdbRooRoOriginR > persistentOriginPtr;
        if( CdbStatus::Success != _masterRegistryPtr->originCollection( )->find( theId.origin,
                                                                                 persistentOriginPtr )) {
            cerr << errorStr << endl
                 << "    The origin with ID: " << theId.origin << " not found in the master." << endl;

            return CdbStatus::Error;
        }
        conditionName = persistentOriginPtr->name( ) + std::string( "::" ) + persistentConditionPtr->name( );
    }

  // 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                               parentFolderPtr = 0;
    CdbRooRoConditionAtFolderR* persistentConditionAtFolderPtr = 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.

    thePtr = new CdbRooRoCondition( parentFolderPtr,
                                    CdbDatabasePtr( this->clone( )),
                                    conditionName.c_str( ),
                                    theId,
                                    persistentConditionAtFolderPtr,
                                    persistentConditionPtr,
                                    _masterRegistryPtr,
                                    _localRegistryPtr );

    return CdbStatus::Success;
}

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

  // Make sure the database is open

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

  // Verify parameters

    if( !thePhysicalName.isValid( )) {

        cerr << errorStr << endl
             << "    The 'physical name' name passed to the procedure has invalid" << endl
             << "    format: \"" << thePhysicalName.getName( ) << "\"" << endl;

        return CdbStatus::IllegalParameters;
    }


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

    CdbCPtr< CdbRooRoRegistry > registryPtr;
    if     ( "<master>" == originName ) registryPtr = _masterRegistryPtr;
    else if(  "<local>" == originName ) registryPtr =  _localRegistryPtr;
    else {
        if( CdbStatus::Success != CdbRooRoRegistry::findByOrigin( registryPtr,
                                                                  originName )) {
            cerr << errorStr << endl
                 << "    Registry for specified origin \"" << originName << "\" was not found." << endl;

            return CdbStatus::Error;
        }
    }

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

    CdbCPtr< CdbRooRoConditionR > persistentConditionPtr;
    CdbStatus                     result = registryPtr->conditionCollection( )->find( localConditionName,
                                                                                      persistentConditionPtr );
    if( CdbStatus::Success != result ) return result;

  // 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                               parentFolderPtr = 0;
    CdbRooRoConditionAtFolderR* persistentConditionAtFolderPtr = 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.

    thePtr = new CdbRooRoCondition( parentFolderPtr,
                                    CdbDatabasePtr( this->clone( )),
                                    thePhysicalName.getName( ).c_str( ),
                                    CdbId( registryPtr->originId( ),
                                           persistentConditionPtr->id( )),
                                    persistentConditionAtFolderPtr,
                                    persistentConditionPtr,
                                    _masterRegistryPtr,
                                    _localRegistryPtr );

    return CdbStatus::Success;
}

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

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

CdbStatus
CdbRooRoDatabase::partitionIterator( CdbItr<unsigned short>& theItr )
{
  // Make sure the database is open

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

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

    theItr = CdbItr<unsigned short>( new CdbRooRoPartitionItr( _masterRegistryPtr->partitionsLayout( )->iterator( )));

    return CdbStatus::Success;
}

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

  // Make sure the database is open

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

  // Find the corresponding registry

    CdbCPtr< CdbRooRoRegistry > registryPtr;
    CdbStatus                   result = CdbRooRoRegistry::findByOrigin( registryPtr,
                                                                         theOriginId );
    if( CdbStatus::Success != result ) {
        if( CdbStatus::NotFound == result ) {
            cerr << 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 {
            cerr << errorStr << endl
                 << "    Failed to find the registry for specified origin identifier " << theOriginId << "." << endl
                 << "    Perhaps the database was not properly initialized/loaded." << endl;
        }
        return result;
    }

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

    CdbCPtr< CdbRooRoPartitionsLayoutR > pLayoutPtr = registryPtr->partitionsLayout( );
    if( pLayoutPtr.isNull( )) return CdbStatus::NotFound;

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

    theItr = CdbItr<unsigned short>( new CdbRooRoPartitionItr( pLayoutPtr->iterator( )));

    return CdbStatus::Success;
}

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

  // Make sure the database is open

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

  // Find the corresponding registry

    CdbCPtr< CdbRooRoRegistry > registryPtr;
    CdbStatus                   result = CdbRooRoRegistry::findByOrigin( registryPtr,
                                                                         theOriginName );
    if( CdbStatus::Success != result ) {
        if( CdbStatus::NotFound == result ) {
            cerr << 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 {
            cerr << errorStr << endl
                 << "    Failed to find the registry for specified origin name \"" << theOriginName << "\"." << endl
                 << "    Perhaps the database was not properly initialized/loaded." << endl;
        }
        return result;
    }

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

    CdbCPtr< CdbRooRoPartitionsLayoutR > pLayoutPtr = registryPtr->partitionsLayout( );
    if( pLayoutPtr.isNull( )) return CdbStatus::NotFound;

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

    theItr = CdbItr<unsigned short>( new CdbRooRoPartitionItr( pLayoutPtr->iterator( )));

    return CdbStatus::Success;
}

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

  // Make sure the database is open

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

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

    CdbCPtr< CdbRooRoPartitionR > partitionPtr;
    {
        CdbStatus result = _masterRegistryPtr->partitionsLayout( )->find( thePartition,
                                                                          partitionPtr );
        if( CdbStatus::Success != result ) return result;

        if( partitionPtr->originId( ) != _masterRegistryPtr->originId( )) {
            if( partitionPtr->originId( ) == _localRegistryPtr->originId( )) {

                CdbStatus result = _localRegistryPtr->partitionsLayout( )->find( thePartition,
                                                                                 partitionPtr );
                if( CdbStatus::Success != result ) {
                    cerr << 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;
                    return result;
                }
            }
        }
    }

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

    std::string ownerOriginName;
    {
        CdbCPtr< CdbRooRoOriginR > persistentOriginPtr;
        if( CdbStatus::Success != _masterRegistryPtr->originCollection( )->find( partitionPtr->originId( ),
                                                                                 persistentOriginPtr )) {
            cerr << errorStr << endl
                 << "    There is no information on the origin ID=" << partitionPtr->originId( ) << endl
                 << "    in the corresponding collection of the MASTER's registry." << endl
                 << "    The database may be corrupted or in an inconsistent state." << endl;

            return CdbStatus::Error;
        }
        ownerOriginName = persistentOriginPtr->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.

    thePtr = new CdbRooRoPartition( CdbDatabasePtr( this->clone( )),
                                    partitionPtr,
                                    partitionPtr->originId( ),
                                    ownerOriginName.c_str( ));

    return CdbStatus::Success;
}

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

  // Make sure the database is open

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

  // Find the corresponding registry

    CdbCPtr< CdbRooRoRegistry > registryPtr;
    {
        CdbStatus  result = CdbRooRoRegistry::findByOrigin( registryPtr,
                                                            theOriginId );
        if( CdbStatus::Success != result ) {
            if( CdbStatus::NotFound == result ) {
                cerr << 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 {
                cerr << errorStr << endl
                     << "    Failed to find the registry for specified origin identifier " << theOriginId << "." << endl
                     << "    Perhaps the database was not properly initialized/loaded." << endl;
            }
            return result;
        }
    }

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

    CdbCPtr< CdbRooRoPartitionsLayoutR > pLayoutPtr = registryPtr->partitionsLayout( );
    if( pLayoutPtr.isNull( )) {

        cerr << errorStr << endl
             << "    The origin for specified origin identifier " << theOriginId << " is not allowed" << endl
             << "    to have partitions. Please check the logic of your application." << endl;

        return CdbStatus::Error;
    }

  // Find the specified partition

    CdbCPtr< CdbRooRoPartitionR > partitionPtr;
    {
        CdbStatus result = pLayoutPtr->find( thePartition,
                                             partitionPtr );
        if( CdbStatus::Success != result ) return result;
    }

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

    std::string ownerOriginName;
    {
        CdbCPtr< CdbRooRoOriginR > persistentOriginPtr;
        if( CdbStatus::Success != _masterRegistryPtr->originCollection( )->find( partitionPtr->originId( ),
                                                                                 persistentOriginPtr )) {
            cerr << errorStr << endl
                 << "    There is no information on the origin ID=" << partitionPtr->originId( ) << endl
                 << "    in the corresponding collection of the MASTER's registry." << endl
                 << "    The database may be corrupted or in an inconsistent state." << endl;

            return CdbStatus::Error;
        }
        ownerOriginName = persistentOriginPtr->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.

    thePtr = new CdbRooRoPartition( CdbDatabasePtr( this->clone( )),
                                    partitionPtr,
                                    partitionPtr->originId( ),
                                    ownerOriginName.c_str( ));

    return CdbStatus::Success;
}

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

  // Make sure the database is open

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

  // Find the corresponding registry

    CdbCPtr< CdbRooRoRegistry > registryPtr;
    {
        CdbStatus result = CdbRooRoRegistry::findByOrigin( registryPtr,
                                                           theOriginName );
        if( CdbStatus::Success != result ) {
            if( CdbStatus::NotFound == result ) {
                cerr << 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 {
                cerr << errorStr << endl
                     << "    Failed to find the registry for specified origin name \"" << theOriginName << "\"." << endl
                     << "    Perhaps the database was not properly initialized/loaded." << endl;
            }
            return result;
        }
    }

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

    CdbCPtr< CdbRooRoPartitionsLayoutR > pLayoutPtr = registryPtr->partitionsLayout( );
    if( pLayoutPtr.isNull( )) {

        cerr << errorStr << endl
             << "    The origin for specified origin name \"" << theOriginName << "\" is not allowed" << endl
             << "    to have partitions. Please check the logic of your application." << endl;

        return CdbStatus::Error;
    }

  // Find the specified partition

    CdbCPtr< CdbRooRoPartitionR > partitionPtr;
    {
        CdbStatus result = pLayoutPtr->find( thePartition,
                                             partitionPtr );
        if( CdbStatus::Success != result ) return result;
    }

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

    std::string ownerOriginName;
    {
        CdbCPtr< CdbRooRoOriginR > persistentOriginPtr;
        if( CdbStatus::Success != _masterRegistryPtr->originCollection( )->find( partitionPtr->originId( ),
                                                                                 persistentOriginPtr )) {
            cerr << errorStr << endl
                 << "    There is no information on the origin ID=" << partitionPtr->originId( ) << endl
                 << "    in the corresponding collection of the MASTER's registry." << endl
                 << "    The database may be corrupted or in an inconsistent state." << endl;

            return CdbStatus::Error;
        }
        ownerOriginName = persistentOriginPtr->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.

    thePtr = new CdbRooRoPartition( CdbDatabasePtr( this->clone( )),
                                    partitionPtr,
                                    partitionPtr->originId( ),
                                    ownerOriginName.c_str( ));

    return CdbStatus::Success;
}

CdbOriginPtr
CdbRooRoDatabase::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,
                                              _localRegistryPtr->originId( ))) {
            assert( 0 );
            return 0;
        }
    }
    return _localOriginPtr;
}

CdbStatus
CdbRooRoDatabase::originIterator( CdbItr<unsigned short>& theItr )
{
  // Make sure the database is open

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

  // Set up an iterator of persistent origin identifiers. We're going
  // to retranslate this iterator to the corresponding transient one.
  //
  // ATTENTION: This is not a memory leak - the created object
  //            will be destroyed by the iterator.

    theItr = CdbItr<unsigned short>( new CdbRooRoOriginItr( _masterRegistryPtr->originCollection( )->iterator_identifiers( )));

    return CdbStatus::Success;
}

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

  // Make sure the database is open

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

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

    CdbCPtr< CdbRooRoOriginR > persistentOriginPtr;
    CdbStatus                  result = _masterRegistryPtr->originCollection( )->find( theName,
                                                                                       persistentOriginPtr );
    if( CdbStatus::Success != result ) return result;

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

    thePtr = new CdbRooRoOrigin( CdbDatabasePtr( this->clone( )),
                                 persistentOriginPtr );

    return CdbStatus::Success;
}

CdbStatus
CdbRooRoDatabase::findOrigin( CdbOriginPtr&  thePtr,
                              unsigned short theId )
{
  // Make sure the database is open

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

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

    CdbCPtr< CdbRooRoOriginR > persistentOriginPtr;
    CdbStatus                  result = _masterRegistryPtr->originCollection( )->find( theId,
                                                                                       persistentOriginPtr );
    if( CdbStatus::Success != result ) return result;

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

    thePtr = new CdbRooRoOrigin( CdbDatabasePtr( this->clone( )),
                                 persistentOriginPtr );

    return CdbStatus::Success;
}

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

---