---

CdbRooRoRevCollectionR.cc

Go to the documentation of this file.

// File and Version Information:
//      $Id: CdbRooRoRevCollectionR.cc,v 1.7 2005/11/11 01:41:28 gapon Exp $

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

#include "BaBar/BaBar.hh"

#include "CdbRooReadonly/CdbRooRoRevCollectionR.hh"
#include "CdbRooReadonly/CdbRooRoCollectionAddressR.hh"

#include "CdbBase/CdbVectorAdapterItr.hh"
#include "CdbBase/CdbSimpleVectorAdapterItr.hh"
#include "CdbBase/CdbTimeUtils.hh"

#include "ErrLogger/ErrLog.hh"

#include <assert.h>

#include <iostream>
using std::cout;
using std::endl;

namespace {

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

    class RevisionNameIterator : public CdbVectorAdapterItr< const char*, std::string > {

    private:

      /// Default constructor (IS NOT IMPLEMENTED)

        RevisionNameIterator( );

    protected:

      /// Copy constructor

        RevisionNameIterator( const RevisionNameIterator& theOther ) :
            CdbVectorAdapterItr< const char*, std::string >( theOther )
        { }

    public:

      /// The normal constructor
      /**
        * @see CdbVectorAdapterItr::CdbVectorAdapterItr()
        */
        RevisionNameIterator( const std::vector< std::string >& theList ) :
            CdbVectorAdapterItr< const char*, std::string >( theList )
        { }

       /// Make a clone of itself
      /**
        * @see CdbIItr::clone()
        */
        virtual CdbVectorAdapterItr< const char*, std::string >::InterfaceType* clone( ) const
        {
            return new RevisionNameIterator( *this );
        }

    protected:

      /// User defined translation for the currently refered value
      /**
        * @see CdbVectorAdapterItr::CdbVectorAdapterItr()
        */
        virtual const char* toValue( const std::string& theValue ) const
        {
            return theValue.c_str( );
        }
    };
}

//////////////////////////////////
// Class: CdbRooRoRevCollectionR //
//////////////////////////////////

CdbRooRoRevCollectionR::CdbRooRoRevCollectionR( ) :
    CdbRooRoPersistentCollectionR( ),
    _revisions         (1),
    _useTopmostRevision(false)
{ }

UInt_t
CdbRooRoRevCollectionR::size( ) const
{
  // IMPLEMENTATION NOTE:
  //
  //   The number returned doesn't include the very first element with the special 0 index.
  //   This internal index is internally used for the "no-information" signalling mechanizm.

    return _revisions.size( ) - 1 + ( _useTopmostRevision ? 1 : 0 );
}

CdbStatus
CdbRooRoRevCollectionR::insert( const CdbRooRoRevisionR& theRevision )
{
    const char* errorMsg = "CdbRooRoRevCollectionR::insert() -- ERROR";

    CdbStatus result = CdbStatus::Error;

    if( isStored( )) return CdbStatus::Error;

  // Verify parameters.

    BdbTime     id   = theRevision.id( );
    std::string name = theRevision.name( );

    if( BdbTime::minusInfinity == id )  {
        cout << errorMsg << endl
             << "    Passed persistent revision object has invalid identifier. " << endl;
        return CdbStatus::IllegalParameters;
    }

  // Check if it's the 'topmost' revision. If so then it has to be handled separatedly
  // through dedicated data structures.

    if( BdbTime::plusInfinity == id )  {

        if( _useTopmostRevision ) {
            cout << errorMsg << endl
                 << "    Sorry, the 'topmost' revision is already stored in the collection. " << endl;
            return CdbStatus::Error;
        }
        _useTopmostRevision = true;
        _topmostRevision    = theRevision;

        return CdbStatus::Success;
    }

  // Put the revision into the vector of ones. Capture its index in vectore as we're
  // going to use it as an internal identifier in indexes.

    UInt_t numBeforeInsert = _revisions.size( );

    if( CdbStatus::Success != _revisions.addElement( theRevision )) {
        ErrMsg(error)
            << errorMsg << endl
            << "    Failed to add a revision into the internal storage."
            << endmsg;
        return CdbStatus::Error;
    }

    UInt_t idx = numBeforeInsert;
    assert( 0 != idx );

  // 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 != ( result = insertIntoMap( theRevision,
                                                        idx ))) {

        if( CdbStatus::Success != _revisions.resize( numBeforeInsert )) {
            ErrMsg(error)
                << errorMsg << endl
                << "    Failed to resize the internal storage after failing to insert" << endl
                << "    a new revision into the map."
                << endmsg;
        }
        return result;
    }
    if( CdbStatus::Success != ( result = insertIntoTimeLine( theRevision,
                                                             idx )))  {

      // To maintain consistency of the collection's context.

        removeFromMap( theRevision.name( ));

        if( CdbStatus::Success != _revisions.resize( numBeforeInsert )) {
            ErrMsg(error)
                << errorMsg << endl
                << "    Failed to resize the internal storage after failing to insert" << endl
                << "    a new revision into the timeline."
                << endmsg;
        }
        return result;
    }
    return CdbStatus::Success;
}

CdbStatus
CdbRooRoRevCollectionR::find( const BdbTime&     theId,
                              CdbRooRoRevisionR& theRevision ) const
{
    const char* errorMsg = "CdbRooRoRevCollectionR::find(id) -- ERROR";

  // Verify the parameters

    if( BdbTime::minusInfinity == theId )  {
        cout << errorMsg << endl
             << "    Passed revision identifier is not valid in this context." << endl
             << "        ID: " << CdbTimeUtils::time2string( theId ) << " : " << theId << endl;
        return CdbStatus::Error;
    }

  // Check if the 'topmost' revision is requested. If so then it has to be handled separatedly
  // through dedicated data structures.

    if( BdbTime::plusInfinity == theId )  {

        if( !_useTopmostRevision ) return CdbStatus::NotFound;

        theRevision = _topmostRevision;

        return CdbStatus::Success;
    }

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

    Interval dInterval;
    if(( !_indexById.findAtBegin( dInterval, theId )) || ( 0 == dInterval.value( ))) {
        return CdbStatus::NotFound;
    }
    if( CdbStatus::Success != _revisions.elementAt( dInterval.value( ),
                                                    theRevision )) {
        ErrMsg(error)
            << errorMsg << endl
            << "    Failed to find a revision in the internal storage."
            << endmsg;
        return CdbStatus::Error;
    }
    return CdbStatus::Success;
}

CdbStatus
CdbRooRoRevCollectionR::find( const char*        theName,
                              CdbRooRoRevisionR& theRevision ) const
{
    const char* errorMsg = "CdbRooRoRevCollectionR::find(name) -- ERROR";

  // Verify the parameters

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

  // Check if the 'topmost' revision is requested. If so then it has to be handled separatedly
  // through dedicated data structures.

    if( std::string( "<topmost>" ) == theName )  {

        if( !_useTopmostRevision ) return CdbStatus::NotFound;

        theRevision = _topmostRevision;

        return CdbStatus::Success;
    }

  // 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.

    std::map< std::string, UInt_t >::const_iterator itr = _indexByName.find( theName );
    if( itr == _indexByName.end( )) {
        return CdbStatus::NotFound;
    }
    UInt_t idx = (*itr).second;
    assert( 0 != idx );

    if( CdbStatus::Success != _revisions.elementAt( idx,
                                                    theRevision )) {
        ErrMsg(error)
            << errorMsg << endl
            << "    Failed to find a revision in the internal storage."
            << endmsg;
        return CdbStatus::Error;
    }
    return CdbStatus::Success;
}

CdbStatus
CdbRooRoRevCollectionR::last( BdbTime& theId ) const
{
  // Check if the 'topmost' revision is present.

    if( _useTopmostRevision ) {
        theId = BdbTime::plusInfinity;
        return CdbStatus::Success;
    }

  // If not, then proceed with normal revisions

    Interval dInterval;

    CdbStatus result = _indexById.last( dInterval );
    if( CdbStatus::Success == result ) {

        if( 0 != dInterval.value( )) {
            theId = dInterval.begin( );
        } else {
            result = CdbStatus::NotFound;
        }
    }
    return result;
}

CdbItr<BdbTime>
CdbRooRoRevCollectionR::iterator_identifiers( ) const
{
    const char* fatalMsg = "CdbRooRoRevCollectionR::iterator_identifiers() -- FATAL ERROR";

  // Build a vector of identifiers

    std::vector<BdbTime> vectorOfIdentifiers;
    {
      // Browse the normal revisions first

        CdbRooRoTimeLineR< UInt_t >::IteratorOfIntervals itr = _indexById.iterator( );
        while( itr.next( )) {

            UInt_t idx = itr.value( ).value( );

            if( 0 == idx ) continue;    // Skip this index as it's reserved
                                        // for special purposes.

            CdbRooRoRevisionR revision;
            if( CdbStatus::Success != _revisions.elementAt( idx,
                                                            revision )) {
                ErrMsg(fatal)
                    << fatalMsg << endl
                    << "    Failed to find a revision in the internal storage."
                    << endmsg;
                break;
            }
            vectorOfIdentifiers.push_back( revision.id( ));
        }

      // Add the 'topmost' revision if present

        if( _useTopmostRevision ) vectorOfIdentifiers.push_back( BdbTime::plusInfinity );
    }

  // Build the resulting iterator

    CdbItr<BdbTime> itr( new CdbSimpleVectorAdapterItr<BdbTime>( vectorOfIdentifiers ));

    return itr;
}

CdbItr<const char*>
CdbRooRoRevCollectionR::iterator_names( ) const
{
    const char* fatalMsg = "CdbRooRoRevCollectionR::iterator_names() -- FATAL ERROR";

  // Build a vector of identifiers

    std::vector<std::string> vectorOfNames;
    {
      // Browse the normal revisions first

        CdbRooRoTimeLineR< UInt_t >::IteratorOfIntervals itr = _indexById.iterator( );
        while( itr.next( )) {

            UInt_t idx = itr.value( ).value( );

            if( 0 == idx ) continue;    // Skip this index as it's reserved
                                        // for special purposes.

            CdbRooRoRevisionR revision;
            if( CdbStatus::Success != _revisions.elementAt( idx,
                                                            revision )) {
                ErrMsg(fatal)
                    << fatalMsg << endl
                    << "    Failed to find a revision in the internal storage."
                    << endmsg;
                break;
            }
            vectorOfNames.push_back( revision.name( ));
        }

      // Add the 'topmost' revision if present

        if( _useTopmostRevision ) vectorOfNames.push_back( std::string( "<topmost>" ));
    }

  // Build the resulting iterator

    CdbItr<const char*> itr( new RevisionNameIterator( vectorOfNames ));

    return itr;
}

void
CdbRooRoRevCollectionR::dump( std::ostream& o ) const
{
    const char* fatalMsg = "CdbRooRoRevCollectionR::dump() -- FATAL ERROR";

    do {

      // Do the dump

        o << "** COLLECTION OF REVISIONS **" << endl
          << endl;

        CdbRooRoTimeLineR< UInt_t >::IteratorOfIntervals itr = _indexById.iterator( );

        while( itr.next( )) {

            Interval dInterval = itr.value( );
            UInt_t   idx       = dInterval.value( );

            if( 0 == idx ) {

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

            } else {

              // NOTE: Keep an eye on the 'tiopmost' revision, which is managed through
              //       a separate storage.

                BdbTime     rId   = BdbTime::plusInfinity;
                std::string rName = "<topmost>";

                if( !_useTopmostRevision ) {

                    CdbRooRoRevisionR revision;
                    if( CdbStatus::Success != _revisions.elementAt( idx,
                                                                    revision )) {
                        ErrMsg(fatal)
                            << fatalMsg << endl
                            << "    Failed to find a revision in the internal storage."
                            << endmsg;
                        break;
                    }
                    rId   = revision.id( );
                    rName = revision.name( );
                }

                o << "  ID       : "   << CdbTimeUtils::time2string( rId ) << " : " << rId << endl
                  << "  NAME     : \"" << rName << "\"" << endl
                  << "  DURATION : "   << "[ " << CdbTimeUtils::time2string( dInterval.begin( ), true ) << " , "
                  <<                              CdbTimeUtils::time2string( dInterval.end( ),   true ) << " )" << endl
                  << endl;
            }
        }

        o << "** END OF THE COLLECTION **" << endl;

    } while( false );
}

CdbStatus
CdbRooRoRevCollectionR::storeSubCollectionsAt( const CdbRooRoCollectionAddressR& theCollectionAddress,
                                               const CdbCPtr<TFile>&             theFilePtr,
                                               Int_t&                            theNumBytesStored )
{
    const char* errorStr = "CdbRooRoRevCollectionR::storeSubCollectionsAt() -- ERROR";

    Int_t numBytesStored = 0;

  // Store the embedded colletions.

    Int_t numBytes = 0;

    const CdbRooRoCollectionAddressR subCollectionAddress =
        CdbRooRoCollectionAddressR::createSubCollection( theCollectionAddress,
                                                         ".Revisions" );

    CdbStatus status = _revisions.storeAsEmbeddedAt( subCollectionAddress,
                                                     theFilePtr,
                                                     numBytes );
    if( CdbStatus::Success != status ) {

        ErrMsg(error) << errorStr << endl
                      << "   Failed to store an embedded sub-collection of revisions." << endl
                      << "       File Name              : " << theFilePtr->GetName( )  << endl
                      << "       Sub.Collection Address : " << subCollectionAddress    << endl
                      << "       Error Status           : " << status
                      << endmsg;
        return status;
    }
    numBytesStored += numBytes;

  // Done

    theNumBytesStored = numBytesStored;

    return CdbStatus::Success;
}

CdbStatus
CdbRooRoRevCollectionR::insertIntoMap( const CdbRooRoRevisionR& theRevision,
                                       UInt_t                   theIdx )
{
    const char* errorMsg = "CdbRooRoRevCollectionR::insertIntoMap() -- ERROR";

    assert( 0 != theIdx );

    CdbStatus result = CdbStatus::Error;
    do {

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

        std::string name = theRevision.name( );

        std::map< std::string, UInt_t >::const_iterator itr = _indexByName.find( name );
        if( itr != _indexByName.end( )) {
            cout << errorMsg << endl
                 << "    There is already a revision with such name." << endl
                 << "        Passed revision name: \"" << name << "\"" << endl;
            break;
        }

      // Now just add the revision.

        _indexByName[name] = theIdx;

      // Done.

        result = CdbStatus::Success;

    } while( false );

    return result;
}

void
CdbRooRoRevCollectionR::removeFromMap( const std::string& theName )
{
    std::map< std::string, UInt_t >::iterator itr = _indexByName.find( theName );
    if( itr != _indexByName.end( )) _indexByName.erase( itr );
}

CdbStatus
CdbRooRoRevCollectionR::insertIntoTimeLine( const CdbRooRoRevisionR& theRevision,
                                            UInt_t                   theIdx )
{
    const char* errorMsg = "CdbRooRoRevCollectionR::insertIntoTimeLine() -- ERROR";

    assert( 0 != theIdx );

    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 = theRevision.id( );

        Interval lastInterval;
        if( CdbStatus::Success != _indexById.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: " << CdbTimeUtils::time2string( id )                   << " : " << id << endl
                 << "        Last known revision ID: " << CdbTimeUtils::time2string( lastInterval.begin( )) << " : " << 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 != _indexById.insert( id,
                                                     BdbTime::plusInfinity,
                                                     theIdx )) {
            cout << errorMsg << endl
                 << "    Failed to insert new interval into the TimeLine." << endl;
            break;
        }

      // Done.

        result = CdbStatus::Success;

    } while( false );

    return result;
}

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

---