---

CdbRooRoMetaDataR.cc

Go to the documentation of this file.

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

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

#include "BaBar/BaBar.hh"

#include "CdbRooReadonly/CdbRooRoMetaDataR.hh"

#include "CdbBase/CdbTimeUtils.hh"

#include "ErrLogger/ErrLog.hh"

#include <assert.h>
#include <string.h>

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

namespace {

    /////////////////////////////////////
    // Class: CombinedIntervalIterator //
    /////////////////////////////////////

    class CombinedIntervalIterator : public CdbItr<CdbRooRoCi>::InterfaceType {

    private:

      /// The default constructor (NOT IMPLEMENTED)

        CombinedIntervalIterator( );

      /// The assignment operator (NOT IMPLEMENTED)

        CombinedIntervalIterator& operator=( const CombinedIntervalIterator& theItr );

    protected:

      /// The copy constructor
      /**
        * The only reason why we have it implemented is because it's needed
        * to implement the clone method.
        *
        * @see CombinedIntervalIterator::clone()
        */
        CombinedIntervalIterator( const CombinedIntervalIterator& theItr ) :
            _viCollection       (theItr._viCollection),
            _oiCollection       (theItr._oiCollection),
            _beginTime          (theItr._beginTime),
            _endTime            (theItr._endTime),
            _isValid            (theItr._isValid),
            _hasEverBeenAdvanced(theItr._hasEverBeenAdvanced),
            _value              (theItr._value),
            _viItr              (theItr._viItr)
        { }

    public:

      /// The normal constructor

        CombinedIntervalIterator( const CdbRooRoViCollectionR& theViCollection,
                                  const CdbRooRoOiCollectionR& theOiCollection,
                                  const BdbTime&               theBeginTime,
                                  const BdbTime&               theEndTime ) :
            _viCollection       (theViCollection),
            _oiCollection       (theOiCollection),
            _beginTime          (theBeginTime),
            _endTime            (theEndTime),
            _isValid            (false),
            _hasEverBeenAdvanced(false)
        { }

      /// The destructor

        virtual ~CombinedIntervalIterator( )
        { }

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

            return CdbStatus::Success;
        }

      /// Try advancing the input iterator

        bool tryNext( )
        {
            bool result = false;
            do {

              // Advance the VI iterator to the next interval

                if( !_viItr.next( )) break;

                CdbRooRoViR vi = _viItr.value( );

              // Check for the end condition requering that the begin time
              // of found visible interval fall into the iterator's validity limits.
              //
              // Either of two scenarious:
              //
              // - begin time of the interval #1 falls into Interval #2
              // - begin time of the interval #2 falls into Interval #1
              //
              // In other "words":
              //
              //   #1    [.....)
              //   #2   [....)
              //
              // or:
              //
              //   #1  [.....)
              //   #2    [.....)
/*
 * DEBUG
                cout << "_beginTime = " << _beginTime.getGmtSec( ) << "." << _beginTime.getGmtNsec( ) << endl
                     << "vi.begin( )   = " << vi.begin( ).getGmtSec  ( ) << "." << vi.begin( ).getGmtNsec  ( ) << endl
                     << "vi.end( )     = " << vi.end( ).getGmtSec    ( ) << "." << vi.end( ).getGmtNsec    ( ) << endl
                     << "_endTime   = " << _endTime.getGmtSec  ( ) << "." << _endTime.getGmtNsec  ( ) << endl;
*/
                if( ! ((( _beginTime  <= vi.begin( )) && ( vi.begin( ) < _endTime )) ||
                       (( vi.begin( ) <= _beginTime ) && ( _beginTime  < vi.end( ))))) break;

              // Construct the current value
              //
              // NOTE: We're not changing the "visibility" of found interval
              //       even if it partially falls beyond the limits of the current
              //       iterator. It's up to the application's logic to catch this
              //       problem. See the corresponding desciption in the client
              //       class's method.

                if( 0 == vi.value( )){

                  // This is a "hole" in the visible timeline because there is
                  // no any object for the duration of foudn visible interval.

                    _value = CdbRooRoCi( vi.begin( ),
                                         vi.end( ));
                } else {

                  // Ther emust be a valid object. Get the "original" interval
                  // describing it.

                    CdbRooRoOiR oi;
                    BdbTime   beginOfDuration;  // not used
                    BdbTime   endOfDuration;    // not used

                    if( CdbStatus::Success != _oiCollection.find( vi.value( ),
                                                                  oi,
                                                                  beginOfDuration,
                                                                  endOfDuration )) {

                        assert( 0 );    // FATAL ERROR: inconsistent "visible"
                                        //              and "original" collections.
                        break;
                    }
                    _value = CdbRooRoCi( vi.begin( ),
                                         vi.end( ),
                                         oi );
                }

              // Done.

                result = true;

            } while( false );

            return result;
        }

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

                if( !_hasEverBeenAdvanced ) {
                    _hasEverBeenAdvanced = true;

                    _viItr = _viCollection.iterator( _beginTime );

                } else {

                  // This iterator should remain at "PAST_LAST_ELEMENT" state. The only way
                  // to get out of this state is to to call ::reset() method.

                    return false;
                }
            }
            if( !_isValid ) {

              // The first attemp to advance an iterator since it was initialized

                _isValid = tryNext( );

            } else if( _isValid && _viItr.isValid( )) {

              // We keep iterating in the valid state of the input iterator

                _isValid = tryNext( );

            } else {

              // Now we've got into the "PAST_LAST_ELEMENT" state.

               _isValid = false;
            }
            return _isValid;
        }

      /// 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 ) assert( 0 );
            return _value;
        }

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

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

    private:

      // Parameters of the iterator

        CdbRooRoViCollectionR _viCollection;
        CdbRooRoOiCollectionR _oiCollection;

        BdbTime _beginTime;
        BdbTime _endTime;

      // The state of the iterator

        bool _isValid;
        bool _hasEverBeenAdvanced;

        CdbRooRoCi _value;

        CdbRooRoViCollectionR::IteratorOfIntervals _viItr;
    };
};

/////////////////////////////
// Class: CdbRooRoMetaDataR //
/////////////////////////////

CdbRooRoMetaDataR::CdbRooRoMetaDataR( const BdbTime& theMinValidityTime,
                                      const BdbTime& theMaxValidityTime,
                                      const BdbTime& theMinInsertionTime ) :
    CdbRooRoPersistentCollectionR( ),
    _minValidityTime (theMinValidityTime),
    _maxValidityTime (theMaxValidityTime),
    _minInsertionTime(theMinInsertionTime),
    _maxInsertionTime(BdbTime::plusInfinity),
    _modified        (theMinInsertionTime)
{ }

CdbRooRoMetaDataR::CdbRooRoMetaDataR( const BdbTime&                theMinValidityTime,
                                      const BdbTime&                theMaxValidityTime,
                                      const BdbTime&                theMinInsertionTime,
                                      const BdbTime&                theMaxInsertionTime,
                                      const BdbTime&                theModificationTime,
                                      const CdbRooRoOiCollectionR&  theOriginalCollection,
                                      const CdbRooRoRevCollectionR& theRevisionCollection ) :
    CdbRooRoPersistentCollectionR( ),
    _minValidityTime   (theMinValidityTime),
    _maxValidityTime   (theMaxValidityTime),
    _minInsertionTime  (theMinInsertionTime),
    _maxInsertionTime  (theMaxInsertionTime),
    _modified          (theModificationTime),
    _originalCollection(theOriginalCollection),
    _revCollection     (theRevisionCollection)
{ }

CdbCPtr< CdbRooRoOiCollectionR>
CdbRooRoMetaDataR::originalIntervalsCollection( ) const
{
    return CdbCPtr< CdbRooRoOiCollectionR>( new CdbRooRoOiCollectionR( _originalCollection ));
}

CdbStatus
CdbRooRoMetaDataR::findByRevision( const BdbTime& theRevisionId,
                                   const BdbTime& theValidityTime,
                                   CdbRooRoOiR&   theOriginalInterval,
                                   BdbTime&       theBeginOfVisiblePeriod,
                                   BdbTime&       theEndOfVisiblePeriod ) const
{
    const char* errorStr = "CdbRooRoMetaDataR::findByRevision() -- ERROR";
    const char* fatalStr = "CdbRooRoMetaDataR::findByRevision() -- FATAL INTERNAL ERROR!!!";

    CdbStatus result = CdbStatus::Error;
    do {

      // This is required by the public contract of the method.

        theBeginOfVisiblePeriod = minValidity( );
        theEndOfVisiblePeriod   = maxValidity( );

      // Verify the parameters

        if(( theValidityTime <  minValidity( )) ||
           ( theValidityTime >= maxValidity( ))) {
            cout << errorStr << endl
                 << "    The passed validity time is out of the validity window" << endl
                 << "    of the current metadata object." << endl;
            break;
        }

      // Get to the specified revision, and then to the collection
      // of "visible" intervals.

        CdbRooRoRevisionR revision;
        if( CdbStatus::Success != _revCollection.find( theRevisionId,
                                                       revision )) {
            cout << errorStr << endl
                 << "    Specified revision was not found in the collection." << endl
                 << "        PASSED REVISION ID: " << CdbTimeUtils::time2string( theRevisionId ) << endl;
            break;
        }

      // Find a "visible" interval through the "visible" collection.
      //
      // IMPORTANT NOTE:
      //
      //     This operation if successfull will return us a short description
      //     of visible interval. The "successful" may also mean 0 index. No matter what
      //     is the value of the original interval's index carried by the visible interval
      //     still we have very important information about the visible validity range of
      //     the found index. If this ois 0 index the we have the visible validity interval
      //     of a 'hole', and if it's not then its the interval of an actual object.
      //
      //     Assigning the correct value to the visible validity interval is required
      //     by the contract of the current method.

        CdbRooRoViR viInterval;

        if( !revision.collection( ).find( viInterval, theValidityTime )) {

            assert( 0 );    // Inconsistent TimeLine. All range of the insertion time
                            // must be covered.
            break;
        }

        theBeginOfVisiblePeriod = viInterval.begin( );
        theEndOfVisiblePeriod   = viInterval.end( );

        UInt_t oiIdx = viInterval.value( );         // Get to the index of the 'original' interval
        if( 0 == oiIdx ) {
            result = CdbStatus::NotFound;
            break;
        }

      // Extract the "original" interval information and setup the values
      // of parameters to be returned.

        BdbTime beginOfDurationPeriod( 0 );     // Don't need this information
        BdbTime endOfDurationPeriod  ( 0 );     // Don't need this information

        if( CdbStatus::Success != _originalCollection.find( oiIdx,
                                                            theOriginalInterval,
                                                            beginOfDurationPeriod,
                                                            endOfDurationPeriod )) {
            cout << fatalStr << endl
                 << "    The collection of 'visible' intervals does not match" << endl
                 << "    the collection of 'original' intervals." << endl;

            assert( 0 );    // FATAL INTERNAL ERROR!!!!

            break;
        }

      // Done

        result = CdbStatus::Success;

    } while( false );
    
    return result;
}

CdbStatus
CdbRooRoMetaDataR::findByRevision( const char*    theRevisionName,
                                   const BdbTime& theValidityTime,
                                   CdbRooRoOiR&   theOriginalInterval,
                                   BdbTime&       theBeginOfVisiblePeriod,
                                   BdbTime&       theEndOfVisiblePeriod ) const
{
    const char* errorStr = "CdbRooRoMetaDataR::findByRevision() -- ERROR";

    CdbStatus result = CdbStatus::Error;
    do {

      // This is required by the public contract of the method.

        theBeginOfVisiblePeriod = minValidity( );
        theEndOfVisiblePeriod   = maxValidity( );

      // Do not verify anything - just find a revision by name
      // and do the rest through the similar procedure.

        BdbTime revisionId( 0 );

        if( 0 == theRevisionName ) {
            revisionId = BdbTime::plusInfinity;     // TOPMOST revision
        } else {
            CdbRooRoRevisionR revision;
            if( CdbStatus::Success != _revCollection.find( theRevisionName,
                                                           revision )) {
                cout << errorStr << endl
                     << "    Specified revision was not found in the collection." << endl
                     << "        PASSED REVISION NAME: \"" << theRevisionName << "\"" << endl;
                break;
            }
            revisionId = revision.id( );
        }

      // Proceed to the actual finder...

        result = findByRevision( revisionId,
                                 theValidityTime,
                                 theOriginalInterval,
                                 theBeginOfVisiblePeriod,
                                 theEndOfVisiblePeriod );

    } while( false );
    
    return result;
}

CdbStatus
CdbRooRoMetaDataR::findByInsertion( const BdbTime& theInsertionTime,
                                    const BdbTime& theValidityTime,
                                    CdbRooRoOiR&   theOriginalInterval,
                                    BdbTime&       theBeginOfDurationPeriod,
                                    BdbTime&       theEndOfDurationPeriod ) const
{
    const char* errorStr = "CdbRooRoMetaDataR::findByInsertion() -- ERROR";

    CdbStatus result = CdbStatus::Error;
    do {

      // Verify the parameters

        if(( theValidityTime <  minValidity( )) ||
           ( theValidityTime >= maxValidity( ))) {
            cout << errorStr << endl
                 << "    The passed validity time is out of the validity window" << endl
                 << "    of the current metadata object." << endl;
            break;
        }
        if(( theInsertionTime <  minInsertion( )) ||
           ( theInsertionTime >= maxInsertion( ))) {
            cout << errorStr << endl
                 << "    The passed insertion time is out of the insertion window" << endl
                 << "    of the current metadata object." << endl;
            break;
        }

      // Find the "original" interval and its "duration" interval through
      // the "original" collection.
      //
      // NOTE: We preserve the returned status since it may also be equal
      //       to CdbStatus::NotFound if the 0-0-0-0 reference found instead
      //       of an actual object.

        CdbStatus status = _originalCollection.find( theInsertionTime,
                                                     theOriginalInterval,
                                                     theBeginOfDurationPeriod,
                                                     theEndOfDurationPeriod );
        if( CdbStatus::Success != status ) {
            result = status;
            break;
        }

      // Check if the specified "validity" time falls into the "original"
      // "validity" of this interval.

        if(( theValidityTime <  theOriginalInterval.begin( )) ||
           ( theValidityTime >= theOriginalInterval.end( )   )) {
            cout << errorStr << endl
                 << "    This is inappropriate use of this finding method since" << endl
                 << "    the passed validity time does not fall into the 'validity' period" << endl
                 << "    of found 'original' interval." << endl;
            break;
        }

      // Done

        result = CdbStatus::Success;

    } while( false );
    
    return result;
}
CdbStatus
CdbRooRoMetaDataR::findRevision( const BdbTime&     theId,
                                 CdbRooRoRevisionR& theRef ) const
{
    CdbStatus result = CdbStatus::NotFound;
    do {

      // Check if the specified revision identifier time falls into
      // the "window" of current metadata object.
      //
      // NOTE: Passing +Infinity is allowed.

        if( theId < minInsertion( )) break;
        if(( BdbTime::plusInfinity != maxInsertion( )) && ( theId >= maxInsertion( ))) break;

      // Delegate revision lookup down to the revisions collection

        result = _revCollection.find( theId,
                                      theRef );
    } while( false );

    return result;
}

CdbStatus
CdbRooRoMetaDataR::findRevision( const BdbTime&                theId,
                                 CdbCPtr< CdbRooRoRevisionR >& thePtr ) const
{
    CdbStatus result = CdbStatus::Error;
    {
        CdbRooRoRevisionR revision;
        if( CdbStatus::Success == ( result = findRevision( theId,
                                                           revision ))) thePtr = new CdbRooRoRevisionR( revision );
    }
    return result;
}

CdbStatus
CdbRooRoMetaDataR::findRevision( const char*        theName,
                                 CdbRooRoRevisionR& theRef ) const
{
    const char* errorStr = "CdbRooRoMetaDataR::findRevision(name) -- ERROR";

    CdbStatus result = CdbStatus::NotFound;
    do {

      // Verify parameters

        if( 0 == theName ) {
            cout << errorStr << endl
                 << "    Null pointer passed instead of a valid revision name." << endl;
            break;
        }

      // Delegate revision lookup down to the revisions collection

        result = _revCollection.find( theName,
                                      theRef );
    } while( false );

    return result;
}

CdbStatus
CdbRooRoMetaDataR::findRevision( const char*                   theName,
                                 CdbCPtr< CdbRooRoRevisionR >& thePtr ) const
{
    CdbStatus result = CdbStatus::Error;
    {
        CdbRooRoRevisionR revision;
        if( CdbStatus::Success == ( result = findRevision( theName,
                                                           revision ))) thePtr = new CdbRooRoRevisionR( revision );
    }
    return result;
}

CdbStatus
CdbRooRoMetaDataR::revisionIdIterator( CdbItr<BdbTime>& theItr ) const
{
    theItr = _revCollection.iterator_identifiers( );
    return CdbStatus::Success;
}

CdbStatus
CdbRooRoMetaDataR::revisionNameIterator( CdbItr<const char*>& theItr ) const
{
    theItr = _revCollection.iterator_names( );
    return CdbStatus::Success;
}

bool
CdbRooRoMetaDataR::verifyObjectIteratorParameters( const BdbTime& theBeginTime,
                                                   const BdbTime& theEndTime ) const
{
    const char* errorStr = "CdbRooRoMetaDataR::verifyObjectIteratorParameters() -- ERROR";

    bool result = false;
    do {

      // See formal requirements at the class's description

        if( ! (( minValidity( ) <= theBeginTime ) && ( theBeginTime < maxValidity( )))) {
            cout << errorStr << endl
                 << "    Incorrect begin time passed to the method. It's out of the validity" << endl
                 << "    time window of the current meta-data object." << endl
                 << "        PASSED BEGIN TIME : " << CdbTimeUtils::time2string( theBeginTime ) << endl
                 << "        WINDOW BEGIN TIME : " << CdbTimeUtils::time2string( minValidity( )) << endl
                 << "        WINDOW END   TIME : " << CdbTimeUtils::time2string( maxValidity( )) << endl;
            break;
        }
        if( ! (( minValidity( ) < theEndTime ) && ( theEndTime <= maxValidity( )))) {
            cout << errorStr << endl
                 << "    Incorrect end time passed to the method. It's out of the validity" << endl
                 << "    time window of the current meta-data object." << endl
                 << "        PASSED END   TIME : " << CdbTimeUtils::time2string( theEndTime ) << endl
                 << "        WINDOW BEGIN TIME : " << CdbTimeUtils::time2string( minValidity( )) << endl
                 << "        WINDOW END   TIME : " << CdbTimeUtils::time2string( maxValidity( )) << endl;
            break;
        }
        if(  ! ( theBeginTime < theEndTime )) {
            cout << errorStr << endl
                 << "    Incorrect begin and end times passed to the method." << endl
                 << "    The begin time must be strictly less (older) than the end one. " << endl
                 << "        PASSED BEGIN TIME : " << CdbTimeUtils::time2string( theBeginTime ) << endl
                 << "        PASSED END   TIME : " << CdbTimeUtils::time2string( theEndTime ) << endl;
            break;
        }

      // Done

        result = true;

    } while( false );

    return result;
}

CdbStatus
CdbRooRoMetaDataR::objectIterator( CdbItr<CdbRooRoCi>& theItr,
                                   const BdbTime&      theRevisionId,
                                   const BdbTime&      theBeginTime,
                                   const BdbTime&      theEndTime ) const
{
    const char* errorStr = "CdbRooRoMetaDataR::objectIterator(id) -- ERROR";

    CdbStatus result = CdbStatus::Error;
    do {

        if( !verifyObjectIteratorParameters( theBeginTime,
                                             theEndTime )) break;
      // Find revision

        CdbRooRoRevisionR revision;
        if( CdbStatus::Success != findRevision( theRevisionId,
                                                revision )) {
            cout << errorStr << endl
                 << "    Failed to find a revision for specified identifier." << endl
                 << "        REVISION IDENTIFIER : " << CdbTimeUtils::time2string( theRevisionId ) << endl;
        }

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

        theItr = CdbItr<CdbRooRoCi>( new CombinedIntervalIterator( revision.collection( ),
                                                                  _originalCollection,
                                                                  theBeginTime,
                                                                  theEndTime ));

      // Done

        result = CdbStatus::Success;

    } while( false );

    return result;
}

CdbStatus
CdbRooRoMetaDataR::objectIterator( CdbItr<CdbRooRoCi>& theItr,
                                   const char*         theName,
                                   const BdbTime&      theBeginTime,
                                   const BdbTime&      theEndTime ) const
{
    const char* errorStr = "CdbRooRoMetaDataR::objectIterator(name) -- ERROR";

    CdbStatus result = CdbStatus::Error;
    do {

        if( !verifyObjectIteratorParameters( theBeginTime,
                                             theEndTime )) break;

      // Find revision

        CdbRooRoRevisionR revision;
        if( CdbStatus::Success != findRevision( theName,
                                                revision )) {
            cout << errorStr << endl
                 << "    Failed to find a revision for specified name." << endl
                 << "        REVISION NAME : \"" << theName << "\"" << endl;
            break;
        }

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

        theItr = CdbItr<CdbRooRoCi>( new CombinedIntervalIterator( revision.collection( ),
                                                                   _originalCollection,
                                                                   theBeginTime,
                                                                   theEndTime ));

      // Done

        result = CdbStatus::Success;

    } while( false );

    return result;
}

void
CdbRooRoMetaDataR::dump( std::ostream& o ) const
{
    o << "MIN.VALIDITY           : " << CdbTimeUtils::time2string( minValidity ( )) << " : " << minValidity ( ) << endl
      << "MAX.VALIDITY           : " << CdbTimeUtils::time2string( maxValidity ( )) << " : " << maxValidity ( ) << endl
      << "MIN.INSERTION          : " << CdbTimeUtils::time2string( minInsertion( )) << " : " << minInsertion( ) << endl
      << "MAX.INSERTION          : " << CdbTimeUtils::time2string( maxInsertion( )) << " : " << maxInsertion( ) << endl
      << "MODIFIED               : " << CdbTimeUtils::time2string( modified    ( )) << " : " << modified    ( ) << endl
      << "NUM.ORIGINAL INTERVALS : " << _originalCollection.size( ) << endl
      << "NUM.REVISIONS          : " << _revCollection.size( ) << endl;
}

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

    Int_t numBytesStored = 0;

  // Store the embedded colletions.

    Int_t numBytes = 0;

    CdbStatus status = CdbStatus::Error;

    if( CdbStatus::Success != ( status = _originalCollection.storeAsEmbeddedAt( theCollectionAddress,
                                                                                theFilePtr,
                                                                                numBytes ))) {
        ErrMsg(error) << errorStr << endl
                      << "   Failed to store an embedded collection of original intervals." << endl
                      << "       File Name         : " << theFilePtr->GetName( ) << endl
                      << "       Collection Address: " << theCollectionAddress   << endl
                      << "       Error Status      : " << status
                      << endmsg;
        return status;
    }
    numBytesStored += numBytes;

    if( CdbStatus::Success != ( status = _revCollection.storeAsEmbeddedAt( theCollectionAddress,
                                                                           theFilePtr,
                                                                           numBytes ))) {
        ErrMsg(error) << errorStr << endl
                      << "   Failed to store an embedded collection of revisions." << endl
                      << "       File Name         : " << theFilePtr->GetName( ) << endl
                      << "       Collection Address: " << theCollectionAddress   << endl
                      << "       Error Status      : " << status
                      << endmsg;
        return status;
    }
    numBytesStored += numBytes;

  // Done

    theNumBytesStored = numBytesStored;

    return CdbStatus::Success;
}

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

---