Bdb packages | Design docs | Source docs | Guidelines | Recent releases
	Search | Site Map .

                 

---

/CdbBdbShared/CdbBdbSView.cc

Go to the documentation of this file.

/// The implementation of the CdbBdbSView class.
/**
  * @see CdbBdbSView
  */
#include "BaBar/BaBar.hh"

#include "CdbBdbShared/CdbBdbSView.hh"

#include "CdbBase/Cdb.hh"
#include "CdbBase/CdbId.hh"
#include "CdbBase/CdbStateId.hh"
#include "CdbBase/CdbFolder.hh"
#include "CdbBase/CdbPathName.hh"
#include "CdbBase/CdbRevisionPolicy.hh"

#include "CdbBdbShared/CdbBdbSFolder.hh"
#include "CdbBdbShared/CdbBdbSPartitionP.hh"
#include "CdbBdbShared/CdbBdbSViewP.hh"
#include "CdbBdbShared/CdbBdbSConditionAtFolderP.hh"
#include "CdbBdbShared/CdbBdbSConfigCollectionP.hh"

#include "BdbTime/BdbTime.hh"

#include <iostream.h>

namespace {

    /////////////////////////////
    // Class: CdbBdbSConfigItr //
    /////////////////////////////

    class CdbBdbSConfigItr : public CdbItr<CdbConfigElement>::InterfaceType {

    private:

        CdbBdbSConfigItr( );

        CdbBdbSConfigItr& operator=( const CdbBdbSConfigItr& theItr );

    protected:

        CdbBdbSConfigItr( const CdbBdbSConfigItr& theItr ) :
            _itr  (theItr._itr),
            _value(theItr._value)
        { }

    public:

        CdbBdbSConfigItr( const CdbBdbSConfigCollectionP::IteratorOfIntervals& theInputItr ) :
            _itr(theInputItr)
        { }

        virtual ~CdbBdbSConfigItr( )
        { }

        virtual CdbStatus reset( )
        {
            return _itr.reset( );
        }

        virtual bool next( )
        {
            bool result = _itr.next( );
            if( result ) {

                CdbBdbSConfigInterval in = _itr.value( );
                if( in.value.accessIsAllowed( )) {

                  // This interval is allowed for accessing the database.

                    CdbRevisionPolicy policy;
                    if( in.value.useRevision ) {
                        policy = CdbRevisionPolicy( in.value.revision,
                                                    in.value.partition );
                    }
                    _value = CdbConfigElement( policy,
                                               in.begin,
                                               in.end );
                } else {

                  // This interval is NOT allowed.

                    _value = CdbConfigElement( in.begin,
                                               in.end );
                }

            } else {

              // The default constructor will construct an element disallowing any
              // access to the database for the whole range of the validity time.

                _value = CdbConfigElement( );
            }
            return result;
        }

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

        virtual bool isValid( )
        {
            return _itr.isValid( );
        }

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

    private:

        CdbBdbSConfigCollectionP::IteratorOfIntervals _itr;

        CdbConfigElement _value;
    };
};

////////////////////////
// Class: CdbBdbSView //
////////////////////////

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

    CdbBdbSView* mySelf = const_cast<CdbBdbSView*>( this );
    return new CdbBdbSView( mySelf->parent( ),
                            mySelf->name( ),
                            mySelf->id( ),
                            _viewH,
                            _masterRegistryH,
                            _localRegistryH );
}

CdbBdbSView::CdbBdbSView( const CdbDatabasePtr&              thePtr,
                          const char*                        theName,
                          const CdbId&                       theId,
                          const BdbHandle(CdbBdbSViewP)&     theViewH,
                          const BdbHandle(CdbBdbSRegistryP)& theMasterRegistryH ,
                          const BdbHandle(CdbBdbSRegistryP)& theLocalRegistryH ) :
    CdbView( thePtr,
             theName,
             theId ),
    _viewH(theViewH),
    _masterRegistryH(theMasterRegistryH),
    _localRegistryH(theLocalRegistryH)
{ }

CdbBdbSView::~CdbBdbSView( )
{ }

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

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

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

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

bool 
CdbBdbSView::isFrozen( ) const
{
    return _viewH->isFrozen( );
}

CdbStatus
CdbBdbSView::findFolder( CdbFolderPtr& thePtr,
                         const char*   theName
                       )
{
    CdbStatus result = CdbStatus::Error;

    thePtr = 0;

    do {

        if( 0 != strcmp( theName, CdbPathName::separator( ))) {

            cout << "CdbBdbSView::findFolder() -- ERROR" << endl
                 << "    No such folder in this implementation: \"" << theName                   << "\"" << endl
                 << "    The only name allowed is the rood one: \"" << CdbPathName::separator( ) << "\"" << endl;

            break;
        }

      // Find out persistent folder for sp[ecified name

        BdbRef(CdbBdbSFolderP) fRef;
        if( CdbStatus::Success != _viewH->findFolder( theName,
                                                      fRef )) {
            result = CdbStatus::NotFound;
            break;
        }

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

        CdbViewPtr   myPtr( this->clone( ));
        CdbFolderPtr fPtr( 0 );

        thePtr = new CdbBdbSFolder( myPtr,
                                    fPtr,
                                    theName,
                                    fRef,
                                    _masterRegistryH,
                                    _localRegistryH );

      // Done.

        result = CdbStatus::Success;

    } while( false );

    return result;
}

CdbStatus
CdbBdbSView::folderIterator( CdbFolderItr& theItr )
{
    return _viewH->folderIterator( theItr );
}

CdbStatus
CdbBdbSView::get( const char*       theName,
                  const BdbTime&    theValidityTime,
                  CdbConfigElement& theConfigElement ) const
{
    const char* errorStr = "CdbBdbSView::get() -- ERROR.";

    CdbStatus result = CdbStatus::Error;
    do {

      // Verify the condition path name.

        if( 0 == theName ) {
            cout << errorStr << endl
                 << "    Non 0 pointer onto a fully qualified condition path name was expected." << endl;
            break;
        }

        CdbPathName fullPath( theName );

        if( ! ( fullPath.isValid( ) &&
                fullPath.isAbsolute( ) &&
                fullPath.isComposite( ))) {

            cout << errorStr << endl
                 << "    Unsupported format of the condition name. Fully qualified" << endl
                 << "    condition name including its folder path was expected." << endl
                 << "        Passed condition name: \"" << theName << "\"" << endl;
            break;
        }

      // Check if specified time fits into the validity interval covered by
      // the current view.

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

            cout << errorStr << endl
                 << "    The pased validity time is out of the validity interval covered" << endl
                 << "    by the current view." << endl
                 << "        Passed  validity time: " << theValidityTime << endl
                 << "        Minimum validity time: " << _viewH->minValidity( ) << endl
                 << "        Maximum validity time: " << _viewH->maxValidity( ) << endl;
            break;
        }

      // First we're going to see if specified condition has  its own revision
      // configuration. This always superseeds the default configuration at
      // the level of the view.

        BdbRef(CdbBdbSConditionAtFolderP) cRef;
        if( CdbStatus::Success != _viewH->findCondition( theName,
                                                         cRef )) {
            result = CdbStatus::NotFound;
            break;
        }

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

          // No configuration found at the conditin level. Get the default
          // configuration at the view level then.

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

      // Get the configuration interval.

        CdbBdbSConfigInterval configInterval;
        if( CdbStatus::Success != configCollRef->find( theValidityTime,
                                                       configInterval )) {
            cout << errorStr << endl
                 << "    The current view is inproperly configured for specified condition." << endl
                 << "    No configuration record found for specified validity time." << endl
                 << "    at the view level." << endl
                 << "        Current view name:     \"" << name( ) << "\"" << endl
                 << "        Passed condition name: \"" << theName << "\"" << endl
                 << "        Passed validity time:  "   << theValidityTime << endl;
            break;
        }

      // Build the configuration element

        if( configInterval.value.accessIsAllowed( )) {

            CdbRevisionPolicy policy;
            if( configInterval.value.useRevision ) {
                policy = CdbRevisionPolicy( configInterval.value.revision,
                                            configInterval.value.partition );
            } else {
                policy = CdbRevisionPolicy( );
            }
            theConfigElement = CdbConfigElement( policy,
                                                 configInterval.begin,
                                                 configInterval.end );

        } else {

          // This element will prohibit accessing the database
          // for specified validity interval

            theConfigElement = CdbConfigElement( configInterval.begin,
                                                 configInterval.end );
        }

      // Done

        result = CdbStatus::Success;

    } while( false );

    return result;
}

CdbStatus
CdbBdbSView::configIterator( const char*               theName,
                             CdbItr<CdbConfigElement>& theItr ) const
{
    const char* errorStr = "CdbBdbSView::configIterator() -- ERROR.";

    CdbStatus result = CdbStatus::Error;
    do {

      // Verify the condition path name.

        if( 0 == theName ) {
            cout << errorStr << endl
                 << "    Non 0 pointer onto a fully qualified condition path name was expected." << endl;
            break;
        }

        CdbPathName fullPath( theName );

        if( ! ( fullPath.isValid( ) &&
                fullPath.isAbsolute( ) &&
                fullPath.isComposite( ))) {

            cout << errorStr << endl
                 << "    Unsupported format of the condition name. Fully qualified" << endl
                 << "    condition name including its folder path was expected." << endl
                 << "        Passed condition name: \"" << theName << "\"" << endl;
            break;
        }

      // First we're going to see if specified condition has  its own revision
      // configuration. This always superseeds the default configuration at
      // the level of the view.

        BdbRef(CdbBdbSConditionAtFolderP) cRef;
        if( CdbStatus::Success != _viewH->findCondition( theName,
                                                         cRef )) {
            result = CdbStatus::NotFound;
            break;
        }

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

          // No configuration found at the conditin level. Get the default
          // configuration at the view level then.

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

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

        theItr = CdbItr<CdbConfigElement>( new CdbBdbSConfigItr( configCollRef->iterator( )));

      // Done

        result = CdbStatus::Success;

    } while( false );

    return result;
}

CdbStateId
CdbBdbSView::currentStateId( const BdbTime& theValidityTime ) const
{
    CdbStateId result;
    {
      // Find out an open partition corresponding to specified validity time
      // and obtain its modification time. If there is no open partition then
      // we should go along with the _current_ time.
      //
      // IMPLEMENTATION NOTE:
      //
      //       For the simplicity of this implementation, we're only looking for
      //       a partiton in the master registry. This may not give us the correct result
      //       if the found partition belongs to the current database and the current database
      //       is not the master one. So the right answer would be to check if the found
      //       (through the master) partition belongs to the current database, and then
      //       look for the correct value of the modification time in the local
      //       replica of the partition.
      //
      //       A similar problem is when the found partition belongs to some other database
      //       (not the local one). In this case the only correct state for the partition is
      //       the closed one. In addition we may have a problem of incompatible type, which
      //       we're not checking below, since "foreign" partitions are represented through
      //       simplified type in the master database, until they (partitions) got synchronized
      //       from the database they belong to.
      //
      //       This correct logic will be implemented later with the distributed version of
      //       the Condition/DB implementation.

        BdbTime partitionModificationTime( BdbTime::now( ));    // _current_ time by default
        {
            BdbRef(CdbBdbSPartitionsLayoutP) pLayoutRef = _masterRegistryH->partitionsLayout( );
            assert( !BdbIsNull(pLayoutRef));

            BdbRef(CdbBdbSPartitionP) pRef;
            if( CdbStatus::Success == pLayoutRef->find( theValidityTime,
                                                        pRef )) {

                if( pRef->isInstantiated( ) && !pRef->isClosed( )) {
                    partitionModificationTime = pRef->modified( );
                }
            }
        }

      // Build the state identifier

        result = CdbStateId( id( ), partitionModificationTime );
    }
    return result;
}

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

CdbStatus
CdbBdbSView::historyEventTypeIterator( CdbHistoryEventTypeItr& theItr )
{
    return CdbStatus::Error;
}

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

 

---

BaBar Public Site | SLAC | News | Links | Who's Who | Contact Us

Page Owner: Jacek Becla
Last Update: October 04, 2002