---

CdbProxyCache.cc

Go to the documentation of this file.

// File and Version Information:
//      $Id: CdbProxyCache.cc,v 1.1 2005/03/08 00:56:49 gapon Exp $

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

#include "CdbBase/CdbProxyCache.hh"
#include "CdbBase/CdbProxyElement.hh"

#include "CdbBase/CdbCPtr.hh"
#include "CdbBase/CdbStateId.hh"
#include "CdbBase/CdbObject.hh"
#include "CdbBase/CdbCondition.hh"
#include "CdbBase/CdbRevision.hh"
#include "CdbBase/CdbRevisionPolicy.hh"
#include "CdbBase/CdbTimeUtils.hh"

#include "BdbTime/BdbTime.hh"

#include "ErrLogger/ErrLog.hh"

#include <stdio.h>  // sprintf()
using std::endl;

CdbProxyCache::CdbProxyCache( const char* theFullConditionPath )
{
    if( 0 != theFullConditionPath ) {
        _elements.push_back( CdbProxyElement( std::string( theFullConditionPath ),
                                              0,
                                              BdbIntervalBase( BdbTime::minusInfinity,
                                                               BdbTime::plusInfinity ),
                                              false ));
    }
}

CdbProxyCache::~CdbProxyCache( )
{ }

void
CdbProxyCache::subscribeCondition( const char* theFullPath )
{
    if( 0 == theFullPath ) ErrMsg(fatal) << "a null string passed instead of a condition name." << endmsg;

    _elements.push_back( CdbProxyElement( std::string( theFullPath ),
                                          0,
                                          BdbIntervalBase( BdbTime::minusInfinity,
                                                           BdbTime::plusInfinity ),
                                          false ));
}

void
CdbProxyCache::subscribeCondition( const std::string& theFullPath )
{
    subscribeCondition( theFullPath.c_str( ));
}


void
CdbProxyCache::unSubscribeCondition( const char* theFullPath )
{
    unSubscribeCondition( std::string( theFullPath ));
}

void
CdbProxyCache::unSubscribeCondition( const std::string& theFullPath )
{
    std::vector<CdbProxyElement>::iterator itr;
    for( itr = _elements.begin( ); itr < _elements.end( ); ++itr ) {
        if((*itr).name( ) == theFullPath ) {
            _elements.erase( itr );
        }
    }
}

void
CdbProxyCache::unSubscribeAllConditions( )
{
    _elements.clear( );
}

bool
CdbProxyCache::isCacheValid( const BdbTime& theValidityTime ) const
{
    bool result = true;
    {
        std::vector<CdbProxyElement>::const_iterator itr;
        for( itr = _elements.begin( ); itr < _elements.end( ); ++itr ) {

          // The cache is not valid if an element has 0persistent
          // pointer or the specified time is not in the validity interval
          // of the object.

            if( (*itr).objectPtr( ).isNull( ) ||
                !(*itr).validity( ).inInterval( theValidityTime )) {

                result = false;
                break;
            }
        }
    }
    return result;
}

void
CdbProxyCache::invalidatePersistentCacheAll( )
{
    unsigned int num = _elements.size( );
    for( unsigned int idx = 0; idx < num; ++idx ) {
        _elements[idx] = CdbProxyElement( _elements[idx].name( ),
                                          0,
                                          BdbIntervalBase( BdbTime::minusInfinity,
                                                           BdbTime::plusInfinity ),
                                          false );
    }
}

CdbStatus
CdbProxyCache::invalidatePersistentCache( const char* theFullPath )
{
    return invalidatePersistentCache( std::string( theFullPath ));
}

CdbStatus
CdbProxyCache::invalidatePersistentCache( const std::string& theFullPath )
{
    unsigned int num = _elements.size( );
    for( unsigned int idx = 0; idx < num; ++idx ) {
        if( _elements[idx].name( ) == theFullPath ) {
            _elements[idx] = CdbProxyElement( _elements[idx].name( ),
                                              0,
                                              BdbIntervalBase( BdbTime::minusInfinity,
                                                               BdbTime::plusInfinity ),
                                              false );
            return CdbStatus::Success;
        }
    }
    return CdbStatus::NotFound;
}

CdbStatus
CdbProxyCache::updateCache( const BdbTime&                theValidityTime,
                            const CdbStateId&             theStateId,
                            std::vector<CdbProxyElement>& theListOfElements )
{
    CdbStatus result = CdbStatus::Error;

  // Remove all elements from the passed vector

    theListOfElements.clear( );

    do {

      // Update elements, which need to be updated

        bool failed = false;
        {
            unsigned int num = _elements.size( );
            for( unsigned int idx = 0; idx < num; ++idx ) {

              // The cache is not valid if an element has 0 persistent
              // pointer or the specified time is not in the validity interval
              // of the object.

                if( _elements[idx].objectPtr( ).isNull( ) ||
                    !_elements[idx].validity( ).inInterval( theValidityTime )) {

                  // Reload condition

                    CdbConditionPtr cPtr;
                    if( CdbStatus::Success != CdbCondition::instance( cPtr,
                                                                      _elements[idx].name( ).c_str( ))) {
 
                        ErrMsg(error) << "failed to find the condition \"" << _elements[idx].name( ) << "\"." << endmsg;

                        failed = true;
                        break;
                    }
                    CdbObjectPtr oPtr;
                    if( CdbStatus::Success != cPtr->findObject( oPtr,
                                                                theValidityTime )) {

                        ErrMsg(error) << "failed to find a condition object from the condition \""<< _elements[idx].name( ) << "\"" << endl
                                      << "at the validity time point " << CdbTimeUtils::time2string( theValidityTime ) << " : " << theValidityTime << endmsg;

                        failed = true;
                        break;
                    }

                  // Update cache

                    _elements[idx] = CdbProxyElement( _elements[idx].name( ),
                                                      oPtr,
                                                      BdbIntervalBase( oPtr->begin( ),
                                                                       oPtr->end( )),
                                                      true );
                } else {

                  // The cache for this elements is up-to-data. Just make sure
                  // that there is no "update" flag at theis element. This flag
                  // could be set before.

                    if( _elements[idx].updated( )) {
                        _elements[idx] = CdbProxyElement( _elements[idx].name( ),
                                                          _elements[idx].objectPtr( ),
                                                          _elements[idx].validity( ),
                                                          false );
                    }
                }

              // Fill up the record in the output vector

                theListOfElements.push_back( _elements[idx] );
            }
        }
        if( failed ) break;

      // Done

        result = CdbStatus::Success;

    } while( false );

    return result;
}

CdbStatus
CdbProxyCache::updateCache( const BdbTime&                theValidityTime,
                            const char*                   theRevisionName,
                            unsigned int                  thePartitionId,
                            std::vector<CdbProxyElement>& theListOfElements )
{
    CdbStatus result = CdbStatus::Error;

  // Remove all elements from the passed vector

    theListOfElements.clear( );

    do {

      // Verify input parameters

        if( 0 == theRevisionName ) {
            ErrMsg(error) << "a null string passed to the method where a revision name was expected." << endmsg;
            result = CdbStatus::IllegalParameters;
            break;
        }

      // Update elements, which need to be updated

        bool failed = false;
        {
            unsigned int num = _elements.size( );
            for( unsigned int idx = 0; idx < num; ++idx ) {

              // The cache is not valid if an element has 0 persistent
              // pointer or the specified time is not in the validity interval
              // of the object.

                if( _elements[idx].objectPtr( ).isNull( ) ||
                    !_elements[idx].validity( ).inInterval( theValidityTime )) {

                  // Reload condition

                    CdbConditionPtr cPtr;
                    if( CdbStatus::Success != CdbCondition::instance( cPtr,
                                                                      _elements[idx].name( ).c_str( ))) {
 
                        ErrMsg(error) << "failed to find the condition \"" << _elements[idx].name( ) << "\"." << endmsg;

                        failed = true;
                        break;
                    }

                    CdbRevisionPtr rPtr;
                    if( CdbStatus::Success != cPtr->findRevision( rPtr,
                                                                  theRevisionName,
                                                                  thePartitionId )) {

                        ErrMsg(error) << "failed to find a revision object from the condition \""<< _elements[idx].name( ) << "\"" << endl
                                      << "for revision name \"" << theRevisionName << "\" in partition " << thePartitionId << "." << endmsg;

                        failed = true;
                        break;
                    }

                    CdbObjectPtr oPtr;
                    if( CdbStatus::Success != cPtr->findObject( oPtr,
                                                                CdbRevisionPolicy( rPtr->id( ),
                                                                                   thePartitionId ),
                                                                theValidityTime )) {

                        ErrMsg(error) << "failed to find a condition object from the condition \""<< _elements[idx].name( ) << "\"" << endl
                                      << "at the validity time point " << CdbTimeUtils::time2string( theValidityTime ) << " : " << theValidityTime << endl
                                      << "using revision name \"" << theRevisionName << "\" in partition " << thePartitionId << "." << endmsg;

                        failed = true;
                        break;
                    }

                  // Update cache

                    _elements[idx] = CdbProxyElement( _elements[idx].name( ),
                                                      oPtr,
                                                      BdbIntervalBase( oPtr->begin( ),
                                                                       oPtr->end( )),
                                                      true );
                } else {

                  // The cache for this elements is up-to-data. Just make sure
                  // that there is no "update" flag at theis element. This flag
                  // could be set before.

                    if( _elements[idx].updated( )) {
                        _elements[idx] = CdbProxyElement( _elements[idx].name( ),
                                                          _elements[idx].objectPtr( ),
                                                          _elements[idx].validity( ),
                                                          false );
                    }
                }

              // Fill up the record in the output vector

                theListOfElements.push_back( _elements[idx] );
            }
        }
        if( failed ) break;

      // Done

        result = CdbStatus::Success;

    } while( false );

    return result;
}

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

---