---

CdbBdbWView.cc

Go to the documentation of this file.

// File and Version Information:
//      $Id: CdbBdbWView.cc,v 1.17 2005/07/26 00:16:10 gapon Exp $

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

#include "CdbBdbWrapper/CdbBdbWView.hh"

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

#include "CdbBdbWrapper/CdbBdbWFolder.hh"
#include "CdbBdbWrapper/CdbBdbWFolderItr.hh"

#include "BdbTime/BdbTime.hh"
#include "BdbCond/BdbCondPath.hh"
#include "BdbCond/BdbObsoleteDatabase.hh"
#include "BdbCond/BdbCondRegistry.hh"
#include "BdbCond/BdbCondRevision.hh"

#include "ErrLogger/ErrLog.hh"
using std::endl;

namespace {

    /////////////////////////////
    // Class: CdbBdbWConfigItr //
    /////////////////////////////

    class CdbBdbWConfigItr : public CdbIItr<CdbConfigElement> {

    private:

        CdbBdbWConfigItr( );

        CdbBdbWConfigItr& operator=( const CdbBdbWConfigItr& theItr );

    protected:

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

    public:


        CdbBdbWConfigItr( const CdbConfigElement& theConfigElement ) :
            _isValid            (false),
            _hasEverBeenAdvanced(false),
            _value              (theConfigElement)
        { }

        virtual ~CdbBdbWConfigItr( )
        { }

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

            return CdbStatus::Success;
        }

        virtual bool next( )
        {
            if( _hasEverBeenAdvanced ) {
                if( _isValid ) {
                    _isValid = false;   // get into the BEYOND_PAST_ELEMENT state
                } else {
                    ;                   // stay in  the BEYOND_PAST_ELEMENT state
                }
            } else {
                _hasEverBeenAdvanced = true;
                _isValid             = true;
            }
            return _isValid;
        }

        virtual CdbConfigElement value( )
        {
            if( !isValid( )) ErrMsg(fatal) << "attempting to use a non-initialized iterator." << endmsg;
            return _value;
        }

        virtual bool isValid( )
        {
            return _isValid;
        }

        virtual CdbIItr<CdbConfigElement>* clone( ) const
        {
            return new CdbBdbWConfigItr( *this );
        }

    private:

        bool _isValid;
        bool _hasEverBeenAdvanced;

        CdbConfigElement _value;
    };
};

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

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

CdbBdbWView::CdbBdbWView( const CdbDatabasePtr& thePtr,
                          const char*           theName ) :
    CdbView( thePtr,
             theName,
             CdbId( ))
{ }

CdbBdbWView::~CdbBdbWView( )
{ }

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

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

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

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

BdbTime
CdbBdbWView::minValidity( ) const
{
    return BdbTime::minusInfinity;
}

BdbTime
CdbBdbWView::maxValidity( ) const
{
    return BdbTime::plusInfinity;
}

BdbTime
CdbBdbWView::created( ) const
{
    return BdbTime::minusInfinity;
}

std::string
CdbBdbWView::description( ) const
{
    return std::string( "<not available in current implementation>" );
}

bool
CdbBdbWView::hasDefaultConfig( ) const
{
    return false;
}

bool
CdbBdbWView::isLocal( ) const
{
    return false;
}

bool
CdbBdbWView::isFrozen( ) const
{
    return false;
}

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

    thePtr = 0;

    do {

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

            ErrMsg(error) << "no such folder in this implementation: \"" << theName << "\"" << endl
                          << "The only name allowed is the rood one: \"" << CdbPathName::separator( ) << "\"" << endmsg;

            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 CdbBdbWFolder( myPtr,
                                    fPtr,
                                    theName );

        result = CdbStatus::Success;

    } while( false );

    return result;
}

CdbStatus
CdbBdbWView::folderIterator( CdbFolderItr& theItr )
{
  // Since we're not passing any parent folder to this iterator
  // then only ROOT folder will be delivered by it.

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

    theItr = CdbFolderItr( new CdbBdbWFolderItr( ));

    return CdbStatus::Success;
}

CdbStatus
CdbBdbWView::getDefault( const BdbTime&    theValidityTime,
                         CdbConfigElement& theConfigElement ) const
{
    return CdbStatus::NotFound;
}

CdbStatus
CdbBdbWView::defaultConfigIterator( CdbItr<CdbConfigElement>& theItr ) const
{
    return CdbStatus::NotFound;
}

CdbStatus
CdbBdbWView::get( const char*       theName,
                  const BdbTime&    theValidityTime,
                  CdbConfigElement& theConfigElement ) const
{
    CdbStatus result = CdbStatus::Error;
    do {

      // Verify the condition path name.

        if( 0 == theName ) {
            ErrMsg(error) << "a null pointer instad of the condition pass passed into the method." << endmsg;
            break;
        }

        CdbPathName fullPath( theName );
        CdbPathName detectorFolderPath( CdbPathName( fullPath.beforeLast( )).afterFirst( ));
        CdbPathName conditionPath( fullPath.last( ));

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

            ErrMsg(error) << "non supported format of the condition name. Fully qualified" << endl
                          << "condition name including its folder path was expected." << endl
                          << "    fullPath:           \"" << fullPath           << "\"" << endl
                          << "    detectorFolderPath: \"" << detectorFolderPath << "\"" << endl
                          << "    conditionPath:      \"" << conditionPath      << "\"" << endl
                          << "    PATH:               \"" << theName            << "\"" << endmsg;
            break;
        }

      // Get the revision description

        bool    useTopVersionFlag;
        d_ULong bdbRevisionId;

        if( BdbcSuccess !=  BdbCondPath::instance( )->getRevision( detectorFolderPath.toString( ).c_str( ),
                                                                   conditionPath.toString( ).c_str( ),
                                                                   useTopVersionFlag,
                                                                   bdbRevisionId )) break;

      // Translate this description into the corresponding revision policy of
      // of the new API.

        CdbRevisionPolicy policy;

        if( useTopVersionFlag ) {
            policy = CdbRevisionPolicy( BdbTime::plusInfinity );
        } else {

          // Find the corresponding "old" revision in the database in order to get
          // its identification (creation time).

            BdbTime rId;

            bool wasFound = false;
            {

                BdbObsoleteDatabase db( detectorFolderPath.toString( ).c_str( ));

                BdbHandle(BdbCondRegistry) registryH;
                BdbItr(BdbCondRevision)    revisionItr;
                BdbHandle(BdbCondRevision) revisionH;

                if( BdbcSuccess != db.findRegistry( registryH,
                                                    conditionPath.toString( ).c_str( ))) break;

                registryH->setRevisionItr( revisionItr );
                while( revisionItr.next( )) {

                    revisionH = revisionItr;

                    if( bdbRevisionId == revisionH->id( )) {

                        BdbTime revisionCreationTime( revisionH->creationTime( ));

                        char revisionIdName[11];
                        sprintf( revisionIdName, "%u", (unsigned int) revisionH->id( ));

                        rId = revisionCreationTime;

                        wasFound = true;
                        break;
                    }
                }
            }
            if( ! wasFound ) {
                ErrMsg(error) << "revision for the ID " << (unsigned int) bdbRevisionId << " was not found in the database." << endmsg;
                break;
            }
            policy = CdbRevisionPolicy( rId );
        }

      // The found policy always allows to access database and it covers
      // the whole range of the validity dimension

        theConfigElement = CdbConfigElement( policy,
                                             BdbTime::minusInfinity,
                                             BdbTime::plusInfinity );

      // Done

        result = CdbStatus::Success;

    } while( false );

    return result;
}

CdbStatus
CdbBdbWView::configIterator( const char*               theName,
                             CdbItr<CdbConfigElement>& theItr ) const
{
    CdbStatus result = CdbStatus::Error;
    do {

      // This implementation is allowed just one config element valid
      // for the whole range of the validity time dimension.
      // When we find it we'll put it into the iterator.

        CdbConfigElement configElement;

        if( CdbStatus::Success != get( theName,
                                       BdbTime::minusInfinity,
                                       configElement )) break;

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

        theItr = CdbItr<CdbConfigElement>( new CdbBdbWConfigItr( configElement ));

      // Done.

        result = CdbStatus::Success;

    } while( false );

    return result;
}

CdbStateId
CdbBdbWView::currentStateId( const BdbTime& theValidityTime ) const
{
  // The identifier of the current view and the current time (we don't have
  // anything more appropriate here).

    return CdbStateId( id( ),
                       BdbTime( ));
}

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

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

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

---