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

                 

---

/CdbBdb/CdbBdbProxyCache.cc

Go to the documentation of this file.

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

#include "CdbBdb/CdbBdbProxyCache.hh"
#include "CdbBdb/CdbBdbProxyElement.hh"
#include "CdbBdb/CdbBdbObjectConvertor.hh"

#include "CdbBase/CdbStateId.hh"
#include "CdbBase/CdbObject.hh"
#include "CdbBase/CdbCondition.hh"

#include "BdbTime/BdbTime.hh"

#include <assert.h>

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

CdbBdbProxyCache::~CdbBdbProxyCache( )
{ }

void
CdbBdbProxyCache::subscribeCondition( const char* theFullPath )
{
    assert( 0 != theFullPath );

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

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


void
CdbBdbProxyCache::unSubscribeCondition( const char* theFullPath )
{
    std::vector<CdbBdbProxyElement>::iterator itr;
    for( itr = _elements.begin( ); itr < _elements.end( ); ++itr ) {
        if((*itr).name( ) == theFullPath ) {
            _elements.erase( itr );
        }
    }
}

void
CdbBdbProxyCache::unSubscribeCondition( const std::string& theFullPath )
{
  unSubscribeCondition(theFullPath.c_str());
}

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

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

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

            if( BdbIsNull((*itr).objectRef( )) ||
                !(*itr).validity( ).inInterval( theValidityTime )) {

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

CdbStatus
CdbBdbProxyCache::updateCache( const BdbTime&                   theValidityTime,
                               const CdbStateId&                theStateId,
                               std::vector<CdbBdbProxyElement>& 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-0-0-0 persistent
              // reference or the specified time is not in the validity interval
              // of the object.

                if( BdbIsNull(_elements[idx].objectRef( )) ||
                    !_elements[idx].validity( ).inInterval( theValidityTime )) {

                  // Reload condition

                    CdbConditionPtr cPtr;
                    if( CdbStatus::Success != CdbCondition::instance( cPtr,
                                                                      _elements[idx].name( ).c_str( ))) {
 
                        cout << "CdbBdbProxyCache::updateCache() - ERROR." << endl
                             << "    Failed to find a condition for:" << endl
                             << "        CONDITION: " << _elements[idx].name( ).c_str( ) << endl;

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

                        cout << "CdbBdbProxyCache::updateCache() - ERROR." << endl
                             << "    Failed to find a condition object for:" << endl
                             << "        CONDITION:     " << _elements[idx].name( ).c_str( ) << endl
                             << "        VALIDITY TIME: " << theValidityTime << endl;

                        failed = true;
                        break;
                    }

                    BdbHandle(BdbObject) objectH;
                    if( CdbStatus::Success != CdbBdbObjectConvertor::narrow( objectH, oPtr )) {

                        cout << "CdbBdbProxyCache::updateCache() - ERROR." << endl
                             << "    Failed to narrow the loaded condition object into BdbObject type." << endl
                             << "    This might be an indication of inproper job configuration." << endl;

                        failed = true;
                        break;
                    }

                  // Update cache

                    _elements[idx] = CdbBdbProxyElement( _elements[idx].name( ),
                                                         objectH,
                                                         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] = CdbBdbProxyElement( _elements[idx].name( ),
                                                             _elements[idx].objectRef( ),
                                                             _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 //
/////////////////

 

---

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

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