---

CdbRooRoIdCollectionR.cc

Go to the documentation of this file.

// File and Version Information:
//      $Id: CdbRooRoIdCollectionR.cc,v 1.5 2005/11/11 01:41:26 gapon Exp $

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

#include "BaBar/BaBar.hh"

#include "CdbRooReadonly/CdbRooRoIdCollectionR.hh"
#include "CdbRooReadonly/CdbRooRoFileUtils.hh"

#include "CdbBase/CdbSimpleVectorAdapterItr.hh"

#include "ErrLogger/ErrLog.hh"

#include <algorithm>

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

template< class T >
CdbRooRoIdCollectionR<T>::CdbRooRoIdCollectionR( ) :
    CdbRooRoPersistentCollectionR( )
{ }

template< class T >
CdbRooRoIdCollectionR<T>::CdbRooRoIdCollectionR( const CdbRooRoIdCollectionR<T>& theOther ) :
    CdbRooRoPersistentCollectionR( theOther ),
    _objects  (theOther._objects),
    _indexById(theOther._indexById)
{ }

template< class T >
CdbRooRoIdCollectionR<T>::~CdbRooRoIdCollectionR( )
{ }

template< class T >
CdbStatus
CdbRooRoIdCollectionR<T>::add( const T& theObject )
{
    const char* errorStr = "CdbRooRoIdCollectionR<T>::add() -- ERROR";

  // Adding elements to a collection which has already been stored (or fetched
  // from a database) is not allowed.

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

  // Add the element into a transient cache. Also register the element
  // in the persistent index.

    if( _indexById.count( theObject.id( ))) return CdbStatus::Error;

    if( CdbStatus::Success != _objects.addElement( theObject )) {

        ErrMsg(error) << errorStr << endl
                      << "   Failed to add an object into a collection." << endmsg;
        return CdbStatus::Error;
    }
    _indexById[theObject.id( )] = _objects.size( ) - 1;

    return CdbStatus::Success;
}

template< class T >
CdbStatus
CdbRooRoIdCollectionR<T>::find( UShort_t theId,
                                T&       theObject ) const
{
    const char* fatalStr = "CdbRooRoIdCollectionR<T>::find(value) -- FATAL";

  // Check if an element with the specified identifier is known to
  // the collection and if so then get its index.

    typename std::map<UShort_t,UInt_t>::const_iterator itr = _indexById.find( theId );
    if( itr == _indexById.end( )) return CdbStatus::NotFound;

    UInt_t index = itr->second;

  // Get the actual object

    if( CdbStatus::Success != _objects.elementAt( index,
                                                  theObject )) {
        ErrMsg(fatal) << fatalStr << endl
                      << "   Failed to find an object with the index " << index << " at the collection." << endl
                      << "   The internal structure of the class is inconsistent." << endmsg;
        return CdbStatus::Error;
    }
    return CdbStatus::Success;
}

template< class T >
CdbStatus
CdbRooRoIdCollectionR<T>::find( UShort_t      theId,
                                CdbCPtr< T >& theObjectPtr ) const
{
    const char* fatalStr = "CdbRooRoIdCollectionR<T>::find(pointer) -- FATAL";

  // Check if an element with the specified identifier is known to
  // the collection and if so then get its index.

    typename std::map<UShort_t,UInt_t>::const_iterator itr = _indexById.find( theId );
    if( itr == _indexById.end( )) return CdbStatus::NotFound;

    UInt_t index = itr->second;

  // Get the actual object

    if( CdbStatus::Success != _objects.elementAt( index,
                                                  theObjectPtr )) {
        ErrMsg(fatal) << fatalStr << endl
                      << "   Failed to find an object with the index " << index << " at the collection." << endl
                      << "   The internal structure of the class is inconsistent." << endmsg;
        return CdbStatus::Error;
    }
    return CdbStatus::Success;

}

template< class T >
void
CdbRooRoIdCollectionR<T>::identifiers( std::vector<UShort_t>& theCollection ) const
{
    theCollection.resize( 0 );

    for( typename std::map<UShort_t,UInt_t>::const_iterator itr = _indexById.begin( );
                                                            itr != _indexById.end( );
                                                          ++itr ) {
        theCollection.push_back( itr->first );
    }
    std::sort( theCollection.begin( ),
               theCollection.end( ));
}

template< class T >
CdbItr< UShort_t >
CdbRooRoIdCollectionR<T>::iterator_identifiers( ) const
{
    std::vector<UShort_t> vectorOfIdentifiers;
    identifiers( vectorOfIdentifiers );
    std::sort( vectorOfIdentifiers.begin( ),
               vectorOfIdentifiers.end( ));

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

    return CdbItr< UShort_t >( new CdbSimpleVectorAdapterItr< UShort_t >( vectorOfIdentifiers ));
}

template< class T >
void
CdbRooRoIdCollectionR<T>::dump( std::ostream&      o,
                                const std::string& indent ) const
{
    o << indent << "CdbRooRoIdCollectionR<" << T::Class( )->GetName( ) << "> {" << endl
      << indent << endl
      << indent << "  isStored( )                : " << isStored( ) << endl
      << indent << "  storedCollectionAddress( ) : " << storedCollectionAddress( ) << endl
      << indent << endl
      << indent << "  _objects.size()            : " << _objects.size( ) << endl
      << indent << "  _indexById.size()          : " << _indexById.size( ) << endl
      << indent << "}" << endl;
}

template< class T >
CdbStatus
CdbRooRoIdCollectionR<T>::storeSubCollectionsAt( const CdbRooRoCollectionAddressR& theCollectionAddress,
                                                 const CdbCPtr<TFile>&             theFilePtr,
                                                 Int_t&                            theNumBytesStored )
{
    const char* errorStr = "CdbRooRoIdCollectionR<T>::storeSubCollectionsAt() -- ERROR";
    const char* fatalStr = "CdbRooRoIdCollectionR<T>::storeSubCollectionsAt() -- FATAL";

    Int_t numBytesStored = 0;

  // Verify the internal consistency of the collection's data structures. In particular
  // we want to make sure that the transient cache is consistent with the index(es).

    {
        const unsigned int nObjects         = _objects.size( );
        const unsigned int nPersistentIndex = _indexById.size( );

        if( nObjects != nPersistentIndex ) {
            ErrMsg(fatal) << fatalStr << endl
                          << "   A fatal internal error #1 has been found. Report the problem" << endl
                          << "   to the code developer." << endmsg;
            return CdbStatus::Error;
        }
        for( typename std::map<UShort_t,UInt_t>::const_iterator itr = _indexById.begin( );
                                                                itr != _indexById.begin( );
                                                              ++itr ) {
            UShort_t id    = itr->first;
            UInt_t   index = itr->second;

            if( index >= nObjects ) {
                ErrMsg(fatal) << fatalStr << endl
                              << "   A fatal internal error #2 has been found. Report the problem" << endl
                              << "   to the code developer." << endmsg;
                return CdbStatus::Error;
            }
            CdbCPtr<T> objectPtr;
            if( CdbStatus::Success != _objects.elementAt( index,
                                                          objectPtr )) {
                ErrMsg(fatal) << fatalStr << endl
                              << "   A fatal internal error #3 has been found. Report the problem" << endl
                              << "   to the code developer." << endmsg;
                return CdbStatus::Error;
            }
            if( id != objectPtr->id( )) {
                ErrMsg(fatal) << fatalStr << endl
                              << "   A fatal internal error #4 has been found. Report the problem" << endl
                              << "   to the code developer." << endmsg;
                return CdbStatus::Error;
            }
        }
    }

  // Store the embedded colletions.

    Int_t numBytes = 0;

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

        ErrMsg(error) << errorStr << endl
                      << "   Failed to store an embedded collection of objects." << 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 //
/////////////////

---