---

CdbBdbSConfigCollectionP.cc

Go to the documentation of this file.

// File and Version Information:
//      $Id: CdbBdbSConfigCollectionP.cc,v 1.9 2004/08/06 05:54:24 bartoldu Exp $

/// The implementation file for the CdbBdbSConfigCollectionP class
/**
  * @see CdbBdbSConfigCollectionP
  */

#include "BaBar/BaBar.hh"

#include "CdbBdbShared/CdbBdbSConfigCollectionP.hh"
#include "CdbBdbShared/CdbBdbSSimpleConfigIterator.hh"

#include <assert.h>
using std::cout;
using std::endl;
using std::ostream;

CdbBdbSConfigCollectionP::CdbBdbSConfigCollectionP( ) :
    _complexConfigRef(0)
{ }

CdbBdbSConfigCollectionP::CdbBdbSConfigCollectionP( const CdbBdbSConfigElement& theConfig ) :
    _simpleConfig(theConfig),
    _complexConfigRef(0)
{ }

CdbBdbSConfigCollectionP::CdbBdbSConfigCollectionP( const CdbBdbSConfigInterval& theConfigInterval ) :
    _complexConfigRef(0)
{
    BdbTime begin = theConfigInterval.begin;
    BdbTime end   = theConfigInterval.end;

  // Check if the "simple" would be enough.

    if(( BdbTime::minusInfinity == begin ) && ( BdbTime::plusInfinity == end )) {
        _simpleConfig = theConfigInterval.value;
    } else {

        _complexConfigRef = new( ooThis( )) CdbBdbSTimeLineP< CdbBdbSConfigElement >( );

        if( CdbStatus::Success != _complexConfigRef->insert( theConfigInterval )) {
            cout << "CdbBdbSConfigCollectionP::CdbBdbSConfigCollectionP() - FATAL ERROR IN THE CONSTRUCTOR" << endl
                 << "    Failed to insert an original configuration element into the TimeLine" << endl
                 << "    for the following range of the validity dimension" << endl
                 << "        BEGIN: " << begin << endl
                 << "        END:   " << end << endl;

            BdbDelete(_complexConfigRef);

            assert( 0 );
        }
    }
}

CdbBdbSConfigCollectionP::~CdbBdbSConfigCollectionP( ) 
{
    if( ! BdbIsNull(_complexConfigRef)) {
        BdbDelete( _complexConfigRef );
        _complexConfigRef = 0;
    }
}

void
CdbBdbSConfigCollectionP::reset( )
{
    ooUpdate( );

    _simpleConfig = CdbBdbSConfigElement( );

    if( ! BdbIsNull(_complexConfigRef)) {
        BdbDelete(_complexConfigRef);
        _complexConfigRef = 0;
    }
}

CdbStatus
CdbBdbSConfigCollectionP::insert( const CdbBdbSConfigElement& theInitialConfig,
                                  const BdbTime&              theBeginTime,
                                  const BdbTime&              theEndTime )
{
    return insert( CdbBdbSConfigInterval( theInitialConfig,
                                          theBeginTime,
                                          theEndTime ));
}

CdbStatus
CdbBdbSConfigCollectionP::insert( const CdbBdbSConfigInterval& theConfigInterval )
{
    const char* errorMsg = "CdbBdbSConfigCollectionP::insert() -- ERROR";

    ooUpdate( );

    CdbStatus result = CdbStatus::Error;
    do {

      // Verify parameters.

        BdbTime begin = theConfigInterval.begin;
        BdbTime end   = theConfigInterval.end;

        if( begin >= end )  {
            cout << errorMsg << endl
                 << "    Invaid validity range for the configuration. " << endl;
            break;
        }

      // Check for the simplest scenario, when the passed interval cover the whole
      // range of the validity dimension.

        if(( BdbTime::minusInfinity == begin ) && ( BdbTime::plusInfinity == end )) {

            _simpleConfig = theConfigInterval.value;

            if( ! BdbIsNull(_complexConfigRef)) {
                BdbDelete(_complexConfigRef);
                _complexConfigRef = 0;
            }

        } else {

          // Put the interval into the TimeLine.

            if( BdbIsNull(_complexConfigRef)) {

              // Form complex collection and copy existing simple configuration
              // into it to preserve the old configuration as the complex configuration's
              // initial value covering the whole range of the validity timeline.
              // This background will be "patched" by the user defined config.element passed
              // into the current method.

               _complexConfigRef = new( ooThis( )) CdbBdbSTimeLineP< CdbBdbSConfigElement >( _simpleConfig );
            }
            if( CdbStatus::Success != _complexConfigRef->insert( theConfigInterval )) {
                cout << errorMsg << endl
                     << "    Failed to insert a configuration element into the TimeLine" << endl
                     << "    for the following range of the validity dimension" << endl
                     << "        BEGIN: " << begin << endl
                     << "        END:   " << end << endl;
                break;
            }
        }

      // Done.

        result = CdbStatus::Success;

    } while( false );

    return result;
}

CdbStatus
CdbBdbSConfigCollectionP::find( const BdbTime&         theTime,
                                CdbBdbSConfigInterval& theConfigInterval ) const
{
    CdbStatus result = CdbStatus::Error;
    do {
        if( ! BdbIsNull(_complexConfigRef)) {
            if( ! _complexConfigRef->find( theConfigInterval,
                                           theTime )) {
                result = CdbStatus::NotFound;
                break;
            }
        } else {
            theConfigInterval = CdbBdbSConfigInterval( _simpleConfig,
                                                       BdbTime::minusInfinity,
                                                       BdbTime::plusInfinity );
        }

      // Done

        result = CdbStatus::Success;

    } while( false );
    
    return result;
}

CdbBdbSConfigCollectionP::IteratorOfIntervals
CdbBdbSConfigCollectionP::iterator( ) const
{
    if( !BdbIsNull(_complexConfigRef)) {
        return _complexConfigRef->iterator( );
    }

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

    return IteratorOfIntervals( new CdbBdbSSimpleConfigIterator( _simpleConfig ));
}

CdbStatus
CdbBdbSConfigCollectionP::clone( BdbRef(CdbBdbSConfigCollectionP)& theRef,
                                 const BdbRefAny&                  theHint ) const
{
    const char* errorMsg = "CdbBdbSConfigCollectionP::clone() -- ERROR";

  // Calculate the hint

    BdbRefAny hint = theHint;
    if( BdbIsNull(hint)) hint = ooThis( );

  // Use handle for optimization only

    BdbHandle(CdbBdbSConfigCollectionP) configH;
    {
      // Create an object with the similar "simple" configuration

        configH = new( hint ) CdbBdbSConfigCollectionP( _simpleConfig );

      // Switch to the "complex" configuration if the current object has
      // the one.

        if( ! BdbIsNull(_complexConfigRef)) {

            BdbRef( CdbBdbSTimeLineP< CdbBdbSConfigElement > ) complexConfigRef;

            CdbStatus status = _complexConfigRef->clone( complexConfigRef,
                                                         theHint );
            if( CdbStatus::Success != status ) {
                cout << errorMsg << endl
                     << "    Failed to clone the TimeLine object due to: " << status << endl;

                BdbDelete(configH);

                return status;
            }
            configH->_complexConfigRef = complexConfigRef;
        }
    }
    theRef = configH;

    return CdbStatus::Success;
}

bool
CdbBdbSConfigCollectionP::isEqual( const BdbRef(CdbBdbSConfigCollectionP)& theRef ) const
{
    assert( !BdbIsNull(theRef));

    if( BdbIsNull(_complexConfigRef)) {
        if( !BdbIsNull(theRef->_complexConfigRef)) {
            return false;
        } else {
            return ( _simpleConfig == theRef->_simpleConfig );
        }
    } else {
        if( BdbIsNull(theRef->_complexConfigRef)) {
            return false;
        } else {

            IteratorOfIntervals currentItr = iterator( );
            IteratorOfIntervals   inputItr = theRef->iterator( );

            while( currentItr.next( )) {
                if( !inputItr.next( )) {
                    return false;
                } else {

                    const CdbBdbSConfigInterval currentIVal = currentItr.value( );
                    const CdbBdbSConfigInterval   inputIVal =   inputItr.value( );

                    if(( currentIVal.begin != inputIVal.begin ) ||
                       ( currentIVal.end   != inputIVal.end   ) ||
                       ( currentIVal.value != inputIVal.value )) return false;
                }
            }
            if( inputItr.next( )) return false;
        }
    }

    return true;
}


void
CdbBdbSConfigCollectionP::dump( ostream& o ) const
{
    o << "=== Condition Cofiguration Collection ===" << endl
      << endl;

    if( BdbIsNull(_complexConfigRef)) {

        o << "[ -Infinity , +Infinity )" << endl
          << "  -> " << _simpleConfig << endl
          << endl;

    } else {

        CdbBdbSTimeLineP< CdbBdbSConfigElement >::IteratorOfIntervals itr
            = _complexConfigRef->iterator( );

        while( itr.next( ))
            o << itr.value( ) << endl
              << endl;
    }
    o << "=== End Of The Collection ===" << endl;
}

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

---