---

CdbBdbSRevCollectionP.cc

Go to the documentation of this file.

// File and Version Information:
//      $Id: CdbBdbSRevCollectionP.cc,v 1.10 2004/08/06 05:54:25 bartoldu Exp $

/// Implementation file for the CdbBdbSRallocatorP class
/**
  * @see CdbBdbSRallocatorP
  */

#include "BaBar/BaBar.hh"

#include "CdbBdbShared/CdbBdbSRevCollectionP.hh"

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

namespace {

    ///////////////////////////////
    // Class: RevisionIdIterator //
    ///////////////////////////////

    class RevisionIdIterator : public CdbItr<BdbTime>::InterfaceType {

    private:

      /// The default constructor (NOT IMPLEMENTED)

        RevisionIdIterator( );

      /// The assignment operator (NOT IMPLEMENTED)

        RevisionIdIterator& operator=( const RevisionIdIterator& theItr );

    protected:

      /// The copy constructor
      /**
        * The only reason why we have it implemented is because it's needed
        * to implement the clone method.
        *
        * @see RevisionIdIterator::clone()
        */
        RevisionIdIterator( const RevisionIdIterator& theItr ) :
            _itr(theItr._itr)
        { }

    public:

      /// The normal constructor

        RevisionIdIterator( const CdbBdbSTimeLineP< BdbRef(CdbBdbSRevisionP) >::IteratorOfIntervals& theItr ) :
            _itr(theItr)
        { }

      /// The destructor

        virtual ~RevisionIdIterator( )
        { }

      /// Reset an iterator to its initial state.
      /**
        * This implements the corresponding method of the base class.
        *
        * @see CdbIItr::reset
        * @see CdbStatus
        */
        virtual CdbStatus reset( )
        {
            return _itr.reset( );
        }

      /// Advance an iterator to the next position.
      /**
        * This implements the corresponding method of the base class.
        *
        * @see CdbIItr::next()
        */
        virtual bool next( )
        {
            if( _itr.next( )) {

                CdbBdbSTimeLineInterval< BdbRef(CdbBdbSRevisionP) > i = _itr.value( );

                BdbRef(CdbBdbSRevisionP) rRef = i.value;

              // IMPLEMENTATION NOTE: if the revision reference is 0-0-0-0 it means that
              //                      there is no revision in that block of the timeline.
              //                      This is only allowed for the very first element of
              //                      the time line.
              //                      However we're not performing this test now and just
              //                      repeating the operation.

                if( BdbIsNull(rRef)) return next( );

                _value = rRef->id( );

                return true;
            }
            return false;
        }

      /// Obtain the currently reffered value.
      /**
        * This implements the corresponding method of the base class.
        *
        * @see CdbIItr::value()
        * @see CdbIItr::ValueType
        *
        * @return the current value the iterator is set on
        */
        virtual ValueType value( )
        {
            if( isValid( )) {
                return _value;
            }

          // Invalid revision identifier.

            return BdbTime::minusInfinity;
        }

      /// Check if an iterator is valid.
      /**
        * This implements the corresponding method of the base class.
        *
        * @see CdbIItr::isValid()
        */
        virtual bool isValid( )
        {
            return _itr.isValid( );
        }

      /// Make a clone of itself
      /**
        * @see CdbIItr::clone()
        */
        virtual InterfaceType* clone( ) const
        {
            return new RevisionIdIterator( *this );
        }

    private:

      // We're delegating all the operations to this iterator

        CdbBdbSTimeLineP< BdbRef(CdbBdbSRevisionP) >::IteratorOfIntervals _itr;

        BdbTime _value;
    };

    /////////////////////////////////
    // Class: RevisionNameIterator //
    /////////////////////////////////

    class RevisionNameIterator : public CdbItr<const char*>::InterfaceType {

    private:

      /// The default constructor (NOT IMPLEMENTED)

        RevisionNameIterator( );

      /// The assignment operator (NOT IMPLEMENTED)

        RevisionNameIterator& operator=( const RevisionNameIterator& theItr );

    protected:

      /// The copy constructor
      /**
        * The only reason why we have it implemented is because it's needed
        * to implement the clone method.
        *
        * @see RevisionNameIterator::clone()
        */
        RevisionNameIterator( const RevisionNameIterator& theItr ) :
            _itr(theItr._itr),
            _value(theItr._value)
        { }

    public:

      /// The normal constructor

        RevisionNameIterator( const CdbBdbSTimeLineP< BdbRef(CdbBdbSRevisionP) >::IteratorOfIntervals& theItr ) :
            _itr(theItr),
            _value("")
        { }

      /// The destructor

        virtual ~RevisionNameIterator( )
        { }

      /// Reset an iterator to its initial state.
      /**
        * This implements the corresponding method of the base class.
        *
        * @see CdbIItr::reset
        * @see CdbStatus
        */
        virtual CdbStatus reset( )
        {
            return _itr.reset( );
        }

      /// Advance an iterator to the next position.
      /**
        * This implements the corresponding method of the base class.
        *
        * @see CdbIItr::next()
        */
        virtual bool next( )
        {
            if( _itr.next( )) {

                CdbBdbSTimeLineInterval< BdbRef(CdbBdbSRevisionP) > i = _itr.value( );

                BdbRef(CdbBdbSRevisionP) rRef = i.value;

              // IMPLEMENTATION NOTE: if the revision reference is 0-0-0-0 it means that
              //                      there is no revision in that block of the timeline.
              //                      This is only allowed for the very first element of
              //                      the time line.
              //                      However we're not performing this test now and just
              //                      repeating the operation.

                if( BdbIsNull(rRef)) return next( );

                _value = rRef->name( );

                return true;
            }
            return false;
        }

      /// Obtain the currently reffered value.
      /**
        * This implements the corresponding method of the base class.
        *
        * @see CdbIItr::value()
        * @see CdbIItr::ValueType
        *
        * @return the current value the iterator is set on
        */
        virtual ValueType value( )
        {
            if( isValid(  )) {
                return _value.c_str( );
            }

          // Invalid revision name.

            return 0;
        }

      /// Check if an iterator is valid.
      /**
        * This implements the corresponding method of the base class.
        *
        * @see CdbIItr::isValid()
        */
        virtual bool isValid( )
        {
            return _itr.isValid( );
        }

      /// Make a clone of itself
      /**
        * @see CdbIItr::clone()
        */
        virtual InterfaceType* clone( ) const
        {
            return new RevisionNameIterator( *this );
        }

    private:

      // We're delegating all the operations to this iterator

        CdbBdbSTimeLineP< BdbRef(CdbBdbSRevisionP) >::IteratorOfIntervals _itr;

        std::string _value;
    };
};

//////////////////////////////////
// Class: CdbBdbSRevCollectionP //
//////////////////////////////////

CdbBdbSRevCollectionP::CdbBdbSRevCollectionP( )
{
    _timeLineRef = new( ooThis( )) CdbBdbSTimeLineP< BdbRef(CdbBdbSRevisionP) >( );
    _mapRef      = new( ooThis( )) BdbMap( );
}

CdbBdbSRevCollectionP::~CdbBdbSRevCollectionP( ) 
{
  // Delete the registered revisions first

    CdbBdbSTimeLineP< BdbRef(CdbBdbSRevisionP) >::IteratorOfIntervals itr
        = _timeLineRef->iterator( );

    while( itr.next( )) {

        Interval i = itr.value( );

        BdbRef(CdbBdbSRevisionP) revisionRef = i.value;
        if( ! BdbIsNull(revisionRef)) BdbDelete( revisionRef );
    }

  // Then we delete the local data structures

    BdbDelete( _timeLineRef );
    BdbDelete( _mapRef );
}

CdbStatus
CdbBdbSRevCollectionP::insert( const BdbRef(CdbBdbSRevisionP)& theRevisionRef )
{
    const char* errorMsg = "CdbBdbSRevCollectionP::insert() -- ERROR";

    ooUpdate( );

    CdbStatus result = CdbStatus::Error;
    do {

      // Verify parameters.

        if( BdbIsNull(theRevisionRef) || !theRevisionRef.isValid( )) {
            cout << errorMsg << endl
                 << "    Null or invalid persistent revision object " << theRevisionRef.sprint( ) << " passed to the procedure." << endl;
            break;
        }
        BdbTime   id   = theRevisionRef->id( );
        ooVString name = theRevisionRef->name( );

        if(( BdbTime::minusInfinity == id ) || ( BdbTime::plusInfinity == id ))  {
            cout << errorMsg << endl << "    Passed persistent revision object has invalid identifier. " << endl;
            break;
        }
        if( 0 == name.length( ))  {
            cout << errorMsg << endl << "    Passed persistent revision object does not have a name. " << endl;
            break;
        }

      // Follow up with revision registration in the map and the TimeLine
      //
      // NOTE: The registration sequence is only important from the recovery point
      //       of view just in case this (recovery) would be required. Removing an element
      //       from the map is much easier than from the TimeLine

        if( CdbStatus::Success != insertIntoMap( theRevisionRef)) {
            break;
        }
        if( CdbStatus::Success != insertIntoTimeLine( theRevisionRef ))  {
            removeFromMap( name.head( ));   // To maintain consistency of the collection's context.
            break;
        }

      // Done.

        result = CdbStatus::Success;

    } while( false );

    return result;
}

CdbStatus
CdbBdbSRevCollectionP::find( const BdbTime&            theId,
                             BdbRef(CdbBdbSRevisionP)& theRevisionRef ) const
{
    const char* errorMsg = "CdbBdbSRevCollectionP::find(id) -- ERROR";

    CdbStatus result = CdbStatus::Error;
    do {

      // Verify the parameters

        if(( BdbTime::minusInfinity == theId ) || ( BdbTime::plusInfinity == theId ))  {
            cout << errorMsg << endl
                 << "    Passed revision identifier is not valid in this context." << endl
                 << "        ID: " << theId << endl;
            break;
        }

      // This method uses "exact match" search in the B-tree to locate specified
      // revision object.

        Interval i;
        if(( ! _timeLineRef->findAtBegin( i, theId )) || BdbIsNull(i.value)) {
            result = CdbStatus::NotFound;
            break;
        }
        theRevisionRef = i.value;

      // Done

        result = CdbStatus::Success;

    } while( false );
    
    return result;
}

CdbStatus
CdbBdbSRevCollectionP::find( const char*               theName,
                             BdbRef(CdbBdbSRevisionP)& theRevisionRef ) const
{
    const char* errorMsg = "CdbBdbSRevCollectionP::find(name) -- ERROR";

    CdbStatus result = CdbStatus::Error;
    do {

      // Verify the parameters

        if( 0 == theName )  {
            cout << errorMsg << endl
                 << "    Passed revision name can't be 0 in this context." << endl;
            break;
        }

      // Look up the object in the map.
      //
      // NOTE: If the object is not found then we let a client to interpret
      //       the result of this search.

        BdbRef(BdbPersObj) objectRef;
        if( BdbcSuccess != _mapRef->lookup( theName,
                                            objectRef )) {
            result = CdbStatus::NotFound;
            break;
        }

      // Make sure it has correct type.

        BdbRef(CdbBdbSRevisionP) revisionRef = (const BdbRef(CdbBdbSRevisionP)&) objectRef;
        if( !revisionRef.isValid( ) || BdbIsNull(revisionRef)) {

            cout << errorMsg << endl
                 << "    Fatal internal error #2." << endl
                 << "    Map contain elements of unexpected persistent type." << endl;

            assert( 0 );

            break;
        }
        theRevisionRef = revisionRef;

      // Done

        result = CdbStatus::Success;

    } while( false );
    
    return result;
}

CdbStatus
CdbBdbSRevCollectionP::last( BdbTime& theId ) const
{
    Interval i;

    CdbStatus result = _timeLineRef->last( i );
    if( CdbStatus::Success == result ) theId = i.begin;

    return result;
}

CdbItr<BdbTime>
CdbBdbSRevCollectionP::iterator_identifiers( ) const
{
  // ATTENTION: This is not a memory leak - the created object
  //            will be destroyed by the iterator.

    return CdbItr<BdbTime>( new RevisionIdIterator( _timeLineRef->iterator( )));
}


CdbItr<const char*>
CdbBdbSRevCollectionP::iterator_names( ) const
{
  // ATTENTION: This is not a memory leak - the created object
  //            will be destroyed by the iterator.

    return CdbItr<const char*>( new RevisionNameIterator( _timeLineRef->iterator( )));
}

void
CdbBdbSRevCollectionP::dump( ostream& o ) const
{
    do {

      // Do the dump

        o << "=== REVISIONS COLLECTION ===" << endl
          << endl;

        CdbBdbSTimeLineP< BdbRef(CdbBdbSRevisionP) >::IteratorOfIntervals itr
            = _timeLineRef->iterator( );

        while( itr.next( )) {

            Interval i = itr.value( );

            BdbRef(CdbBdbSRevisionP) revisionRef = i.value;
            if( BdbIsNull(revisionRef)) {

                o << "  <IS EMPTY>" << endl
                  << endl;

            } else {

                o << revisionRef.sprint( ) << endl
                  << endl
                  << "  ID:            " << revisionRef->id( ) << endl
                  << "  NAME:          " << revisionRef->name( ).head( ) << endl
                  << "  VI COLLECTION: " << revisionRef->collection( ).sprint( ) << endl
                  << "  DURATION:      " << "[ " << i.begin.getGmtSec( ) << "." << i.begin.getGmtNsec( ) << " , "
                  <<                                i.end.getGmtSec  ( ) << "." << i.end.getGmtNsec  ( ) << " )" << endl
                  << endl;
            }
        }

        o << "=== END OF COLLECTION ===" << endl;

    } while( false );
}

CdbStatus
CdbBdbSRevCollectionP::insertIntoMap( const BdbRef(CdbBdbSRevisionP)& theRevisionRef )
{
    const char* errorMsg = "CdbBdbSRevCollectionP::insertIntoMap() -- ERROR";

    CdbStatus result = CdbStatus::Error;
    do {

      // Verify if the map does not contain any revision with such name.

        ooVString name = theRevisionRef->name( );

        if( _mapRef->isMember( name.head( ))) {
            cout << errorMsg << endl
                 << "    There is already a revision with such name." << endl
                 << "        Passed revision name: " << name.head( ) << endl;
            break;
        }

      // Now just add the revision.

        if( BdbcSuccess != _mapRef->add( name.head( ), theRevisionRef )) {
            cout << errorMsg << endl
                 << "    Failed to add new name to the map." << endl
                 << "        Passed revision name: " << name.head( ) << endl;
            break;
        }

      // Done.

        result = CdbStatus::Success;

    } while( false );

    return result;
}

void
CdbBdbSRevCollectionP::removeFromMap( const char* theName )
{
    _mapRef->remove( theName );
}

CdbStatus
CdbBdbSRevCollectionP::insertIntoTimeLine( const BdbRef(CdbBdbSRevisionP)& theRevisionRef )
{
    const char* errorMsg = "CdbBdbSRevCollectionP::insertIntoTimeLine() -- ERROR";

    CdbStatus result = CdbStatus::Error;
    do {

      // Verify the value of the revisin identifier. It must not be older
      // (less or equal) than the most recently known revision.

        BdbTime id = theRevisionRef->id( );

        Interval lastInterval;
        if( CdbStatus::Success != _timeLineRef->last( lastInterval )) {
            cout << errorMsg << endl
                 << "    Failed to obtain the last interval from the TimeLine." << endl;
            break;
        }
        if( id <= lastInterval.begin ) {
            cout << errorMsg << endl
                 << "    Passed revision object has incorrect identifier time, which" << endl
                 << "    should never be less or equal than the one of the last known revision." << endl
                 << "        Passed revision     ID: " << id << endl
                 << "        Last known revision ID: " << lastInterval.begin << endl;
            break;
        }

      // Append the "revision duration" interval by the end of the TimeLine.
      // This operation will cut existing "last" interval at the specified
      // insertion time point.
      //
      // NOTE: Intervals have the following semantics: [begin,end)

        if( CdbStatus::Success != _timeLineRef->insert( id,
                                                        BdbTime::plusInfinity,
                                                        theRevisionRef )) {
            cout << errorMsg << endl
                 << "    Failed to insert new interval into the TimeLine." << endl;
            break;
        }

      // Done.

        result = CdbStatus::Success;

    } while( false );

    return result;
}

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

---