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

                 

---

/BdbCond/BdbIntervalItr.cc

Go to the documentation of this file.

//-----------------------------------------------------------------------------
//
// File and Version Information:
//      $Id: BdbIntervalItr.cc,v 1.6 2002/08/07 21:45:26 gapon Exp $
//
// Description:
//      Class BdbIntervalItr. 
//      This class has an iterator semantics. It provides an easier way
//      to iterate through intervals in a interval container.
//
// Environment:
//      Software developed for the BaBar Detector at the SLAC B-Factory.
//
// Author List:
//      Igor A. Gaponenko       Original Author
//
// Copyright Information:
//      Copyright (C) 1999      Lawrence Berkeley Laboratory
//
//-----------------------------------------------------------------------------

// -------------------------
// -- This Class's Header --
// -------------------------

#include "BdbCond/BdbIntervalItr.hh"

// ---------------
// -- C Headers --
// ---------------

extern "C" {
#include <assert.h>
#include <ctype.h>
#include <stddef.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
}

// -----------------
// -- C++ Headers --
// -----------------

#include <iostream.h>

// ---------------------------------
// -- Collaborating Class Headers --
// ---------------------------------

#include "BdbCond/BdbCondErrors.hh"
#include "BdbCond/BdbIntervalR.hh"
#include "BdbCond/BdbIntervalGene.hh"
#include "BdbTime/BdbTime.hh"
#include "ErrLogger/ErrLog.hh"

// --------------------------------------------------------------------------
// -- Local Macros, Typedefs, Structures, Unions, and Forward Declarations --
// --------------------------------------------------------------------------

static const char rcsid[] = "$Id: BdbIntervalItr.cc,v 1.6 2002/08/07 21:45:26 gapon Exp $";

// ------------------
// -- Constructors --
// ------------------

BdbIntervalItr::BdbIntervalItr( ) :
    _db((BdbObsoleteDatabase*) 0)
{
    clearContext( );
}

BdbIntervalItr::BdbIntervalItr( const BdbIntervalItr& theItr )
{
    _direction   = theItr._direction;
    _nextH       = theItr._nextH;
    _topmostH    = theItr._topmostH;
    _detector    = theItr._detector;
    _container   = theItr._container;
    _revisionId  = theItr._revisionId;
    _beginTime   = theItr._beginTime;
    _db          = new BdbObsoleteDatabase( theItr._detector );
    _initialized = theItr._initialized;
}

// ----------------
// -- Destructor --
// ----------------

BdbIntervalItr::~BdbIntervalItr( )
{
    clearContext( );
}

// ----------------
// -- Operations --
// ----------------

BdbIntervalItr&
BdbIntervalItr::operator=( const BdbIntervalItr& theItr )
{
    _direction   = theItr._direction;
    _nextH       = theItr._nextH;
    _topmostH    = theItr._topmostH;
    _detector    = theItr._detector;
    _container   = theItr._container;
    _revisionId  = theItr._revisionId;
    _beginTime   = theItr._beginTime;
    _db          = new BdbObsoleteDatabase( theItr._detector );
    _initialized = theItr._initialized;

    return *this;
}

BdbIntervalItr::operator BdbIntervalBase&( ) const
{
    return *_nextH;
}

BdbIntervalItr::operator BdbHandle(BdbInterval)&( ) const
{
    return (BdbHandle(BdbIntervalR)&) _nextH;
}

BdbIntervalItr::operator BdbHandle(BdbIntervalR)&( ) const
{
    return (BdbHandle(BdbIntervalR)&) _nextH;
}

// ----------------
// -- Operations --
// ----------------

bool
BdbIntervalItr::setBaseline( const char*    theDetector,
                             const char*    theContainer,
                             const BdbTime& theBeginTime )
{
    const char* errorString = "BdbIntervalItr::setBaseline( ) -- error.";

  // Clear previous context.

    clearContext( );

  // Create the database.

    _db = new BdbObsoleteDatabase( theDetector );

  // Try specified parameters.

    BdbHandle(BdbIntervalR) theIntervalH;
    BdbStatus status;

    status = getFirstBaselineInterval( theIntervalH,
                                       theContainer,
                                       theBeginTime );
    if( BdbcSuccess != status ) {
        ErrMsg(error) << errorString << endl
                      << "    Unable to initialize iterator with specified parameters." << endl
                      << "        Detector:   " << theDetector << endl
                      << "        Container:  " << theContainer << endl
                      << "        Begin time: " << theBeginTime << endmsg;
        return false;
    }

  // Set the internal context.

    _direction   = DIRECTION_BASELINE;
    _detector    = theDetector;
    _container   = theContainer;
    _beginTime   = theBeginTime;

    return true;
}

bool
BdbIntervalItr::setTopmost(  const char*    theDetector,
                             const char*    theContainer,
                             const BdbTime& theBeginTime  )
{
    const char* errorString = "BdbIntervalItr::setTopmost( ) -- error.";

  // Clear previous context.

    clearContext( );

  // Create the database.

    _db = new BdbObsoleteDatabase( theDetector );

  // Try specified parameters.

    BdbHandle(BdbIntervalR) theIntervalH;
    BdbStatus status;

    status = getFirstTopmostInterval( theIntervalH,
                                      theContainer,
                                      theBeginTime );
    if( BdbcSuccess != status ) {
        ErrMsg(error) << errorString << endl
                      << "    Unable to initialize iterator with specified parameters." << endl
                      << "        Detector:   " << theDetector << endl
                      << "        Container:  " << theContainer << endl
                      << "        Begin time: " << theBeginTime << endmsg;
        return false;
    }

  // Set the internal context.

    _direction   = DIRECTION_TOPMOST;
    _detector    = theDetector;
    _container   = theContainer;
    _beginTime   = theBeginTime;

    return true;
}

bool
BdbIntervalItr::setRevision( const char*    theDetector,
                             const char*    theContainer,
                             d_ULong        theRevisionId,
                             const BdbTime& theBeginTime )
{
    const char* errorString = "BdbIntervalItr::setRevision( ) -- error.";

  // Clear previous context.

    clearContext( );

  // Create the database.

    _db = new BdbObsoleteDatabase( theDetector );

  // Try specified parameters.

    BdbHandle(BdbIntervalR) theIntervalH;
    BdbHandle(BdbIntervalR) theTopmostIntervalH;
    BdbStatus status;

    status = getFirstRevisedInterval( theIntervalH,
                                      theTopmostIntervalH,
                                      theContainer,
                                      theRevisionId,
                                      theBeginTime );
    if( BdbcSuccess != status ) {
        ErrMsg(error) << errorString << endl
                      << "    Unable to initialize iterator with specified parameters." << endl
                      << "        Detector:    " << theDetector << endl
                      << "        Container:   " << theContainer << endl
                      << "        Revision ID: " << theRevisionId << endl
                      << "        Begin time:  " << theBeginTime << endmsg;
        return false;
    }

  // Set the internal context.

    _direction   = DIRECTION_REVISION;
    _detector    = theDetector;
    _container   = theContainer;
    _revisionId  = theRevisionId;
    _beginTime   = theBeginTime;

    return true;
}

bool
BdbIntervalItr::next( )
{
    const char* errorString = "BdbIntervalItr::next( ) -- error.";

    bool result = false;

    BdbHandle(BdbIntervalR) theIntervalH;
    BdbHandle(BdbIntervalR) theTopmostIntervalH;
    BdbStatus status;

  // The operation depends on a direction of the iteration.

    switch( _direction ) {

    case DIRECTION_BASELINE:

        if( ! _initialized ) {

          // Get the first BASELINE interval.

            status = getFirstBaselineInterval( _nextH,
                                               _container,
                                               _beginTime );
            if( BdbcSuccess != status ) {
                ErrMsg(error) << errorString << endl
                              << "    Unable to initialize iterator with specified parameters." << endl
                              << "        Detector:   " << (const char*) _detector << endl
                              << "        Container:  " << (const char*) _container << endl
                              << "        Begin time: " << _beginTime << endmsg;
                _nextH = NULL;
                break;
            }

            _initialized = true;

        } else {

          // Get the next BASELINE interval.

            if( ! BdbIsNull( _nextH )) {
                _nextH->getBaselineNext( theIntervalH );
                _nextH = theIntervalH;
            }
        }

        if( BdbIsNull( _nextH )) {
            return false;
        } else {
            return true;
        }

    case DIRECTION_TOPMOST:

        if( ! _initialized ) {

          // Get the first TOPMOST interval.

            status = getFirstTopmostInterval( _nextH,
                                              _container,
                                              _beginTime );
            if( BdbcSuccess != status ) {
                ErrMsg(error) << errorString << endl
                              << "    Unable to initialize iterator with specified parameters." << endl
                              << "        Detector:   " << (const char*) _detector << endl
                              << "        Container:  " << (const char*) _container << endl
                              << "        Begin time: " << _beginTime << endmsg;
                _nextH = NULL;
                break;
            }

            _initialized = true;

        } else {

          // Get the next TOPMOST interval.

            if( ! BdbIsNull( _nextH )) {
                _nextH->getTopNext( theIntervalH );
                _nextH = theIntervalH;
            }
        }

        if( BdbIsNull( _nextH )) {
            return false;
        } else {
            return true;
        }

    case DIRECTION_REVISION:

        if( ! _initialized ) {

          // Get the first REVISED interval.

            status = getFirstRevisedInterval( _nextH,
                                              _topmostH,
                                              _container,
                                              _revisionId,
                                              _beginTime );
            if( BdbcSuccess != status ) {
                ErrMsg(error) << errorString << endl
                              << "    Unable to initialize iterator with specified parameters." << endl
                              << "        Detector:    " << (const char*) _detector << endl
                              << "        Container:   " << (const char*) _container << endl
                              << "        Revision ID: " << _revisionId << endl
                              << "        Begin time:  " << _beginTime << endmsg;
                _nextH = NULL;
                break;
            }

            _initialized = true;

        } else {

          // Get the next REVISED interval.

            if( ! BdbIsNull( _nextH )) {

                status = getNextRevisedInterval( theIntervalH, theTopmostIntervalH );
                if( BdbcSuccess != status ) {
                    ErrMsg(error) << errorString << endl
                                  << "    Unable to advance iterator with specified parameters." << endl
                                  << "        Detector:    " << (const char*) _detector << endl
                                  << "        Container:   " << (const char*) _container << endl
                                  << "        Revision ID: " << _revisionId << endl
                                  << "        Begin time:  " << _beginTime << endmsg;
                    _nextH = NULL;
                    break;
                }
                _nextH    = theIntervalH;
                _topmostH = theTopmostIntervalH;
            }
        }

        if( BdbIsNull( _nextH )) {
            return false;
        } else {
            return true;
        }

    default:
    
        ErrMsg(error) << errorString << endl
                      << "    The iterator was not set. Use corresponding ::setXXX() method" << endl
                      << "    in order to select iteration direction and parameters." << endmsg;             
        break;
    }

  // We set this flag in order to be sure that we have properly
  // initialized context.

    if( result ) {
        clearContext( );
    }

    return result;
}

// -----------------------------------------------------------------
// This operation just resets an iterator context to the state right
// after calling any of setXXX methods thus ensuring that
// the next ::next() will begin from the first element.
// -----------------------------------------------------------------

void
BdbIntervalItr::reset( )
{
    _nextH       = NULL;
    _initialized = false;
}

void
BdbIntervalItr::clearContext( )
{
    _direction   = DIRECTION_UNKNOWN;
    _nextH       = NULL;
    _topmostH    = NULL;
    _detector    = (char*) 0;
    _container   = (char*) 0;
    _revisionId  = BdbCondRevision::BASELINE;
    _beginTime   = BdbTime::minusInfinity;
    delete _db;
    _initialized = false;
}

BdbStatus
BdbIntervalItr::getFirstBaselineInterval( BdbHandle(BdbIntervalR)& theIntervalH,
                                          const char*              theContainer,
                                          const BdbTime&           theBeginTime )
{
    const char* errorString = "BdbIntervalItr::getFirstBaselineInterval( ) -- error.";

  // Fetch the BASELINE interval for specified time to be sure
  // that a valid database and container name were specified.
  //
  // NOTE: This operation will also verify if we have a "revised"
  //       container.
  //
  // NOTE: We explicitly fetch the FIRST interval if the "-oo" is specified.

    BdbStatus status;

    if( BdbTime::minusInfinity == theBeginTime ) {
        status = _db->firstInterval( theIntervalH, theContainer );
    } else {
        status = _db->getBaselineInterval( theIntervalH, theContainer, theBeginTime );
    }
    if( BdbcSuccess != status ) {
        ErrMsg(error) << errorString << endl
                      << "    Unable to locate BASELINE interval." << endmsg;
    }

    return status;
}

BdbStatus
BdbIntervalItr::getFirstTopmostInterval( BdbHandle(BdbIntervalR)& theIntervalH,
                                         const char*              theContainer,
                                         const BdbTime&           theBeginTime )
{
    const char* errorString = "BdbIntervalItr::getFirstTopmostInterval( ) -- error.";

  // Fetch the TOPMOST interval for specified time to be sure
  // that a valid database and container name were specified.
  //
  // NOTE: This operation will also verify if we have a "revised"
  //       container.
  //
  // NOTE: We explicitly fetch the FIRST interval if the "-oo" is specified.

    BdbStatus status;

    if( BdbTime::minusInfinity == theBeginTime ) {
        status = _db->firstInterval( theIntervalH, theContainer );
    } else {
        status = _db->getTopmostInterval( theIntervalH, theContainer, theBeginTime );
    }
    if( BdbcSuccess != status ) {
        ErrMsg(error) << errorString << endl
                      << "    Unable to locate TOPMOST interval." << endmsg;
    }

    return status;
}

BdbStatus
BdbIntervalItr::getFirstRevisedInterval( BdbHandle(BdbIntervalR)& theIntervalH,
                                         BdbHandle(BdbIntervalR)& theTopmostIntervalH,
                                         const char*              theContainer,
                                         d_ULong                  theRevisionId,
                                         const BdbTime&           theBeginTime )
{
    const char* errorString = "BdbIntervalItr::getFirstRevisedInterval( ) -- error.";

  // Fetch the REVISED interval for specified time and revision to be sure
  // that a valid database and container name were specified.
  //
  // NOTE: This operation will also verify if we have a "revised"
  //       container.
  //
  // NOTE: We explicitly fetch the FIRST interval if the "-oo" is specified.

    BdbStatus status;

    if( BdbTime::minusInfinity == theBeginTime ) {
        status = _db->firstInterval( theIntervalH, theContainer );
    } else {
        status = _db->getRevisedInterval( theIntervalH, theContainer, theBeginTime, theRevisionId );
    }
    if( BdbcSuccess != status ) {
        ErrMsg(error) << errorString << endl
                      << "    Unable to locate REVISED interval." << endmsg;
        return status;
    }

    status = _db->getTopmostInterval( theTopmostIntervalH, theContainer, theBeginTime );
    if( BdbcSuccess != status ) {
        ErrMsg(error) << errorString << endl
                      << "    Unable to locate TOPMOST interval." << endmsg;
        return status;
    }

    return status;
}

BdbStatus
BdbIntervalItr::getNextRevisedInterval( BdbHandle(BdbIntervalR)& theIntervalH,
                                        BdbHandle(BdbIntervalR)& theTopmostIntervalH  )
{
    const char* errorString = "BdbIntervalItr::getNextRevisedInterval( ) -- error.";

    BdbStatus status;

  // Some preliminary checks.

    if( BdbIsNull( _nextH )) {
        theIntervalH = _nextH;
        return BdbcSuccess;
    }

    if( BdbIsNull( _topmostH )) {
        ErrMsg(error) << errorString << endl
                      << "    Internal bug was detected." << endmsg;
        return BdbcError;
    }

  // The following loop will proceed along the TOPMOST intervals
  // until different then the current REVISED interval is met.

    BdbHandle(BdbIntervalR) theNextTopmostIntervalH;
    theNextTopmostIntervalH = _topmostH;

    do {

      // We need to make next try from the begin time of the next
      // TOPMOST interval wich provides us the next split point.

        theNextTopmostIntervalH->getTopNext( theTopmostIntervalH );
        if( BdbIsNull( theTopmostIntervalH )) {
            break;
        }
        theNextTopmostIntervalH = theTopmostIntervalH;

      // Now we will locate the desired REVISED interval

        status = _db->getRevisedInterval( theIntervalH,
                                          _container,
                                          theTopmostIntervalH->getBeginTime( ),
                                          _revisionId );
        if( BdbcSuccess != status ) {
            ErrMsg(error) << errorString << endl
                          << "    Unable to locate REVISED interval." << endmsg;
            return status;
        }
        if( BdbIsNull( theIntervalH )) {
            break;
        }
 
    } while( theIntervalH == _nextH );

    return BdbcSuccess;
}

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

 

---

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

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