---

CdbRooRoNameIdCollectionR.cc

Go to the documentation of this file.

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

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

#include "BaBar/BaBar.hh"

#include "CdbRooReadonly/CdbRooRoNameIdCollectionR.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 >
CdbRooRoNameIdCollectionR<T>::CdbRooRoNameIdCollectionR( ) :
    CdbRooRoPersistentCollectionR( )
{ }

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

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

template< class T >
CdbStatus
CdbRooRoNameIdCollectionR<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( _indexByName.count( theObject.name( ))) 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;
    _indexByName[theObject.name( )] = _objects.size( ) - 1;

    return CdbStatus::Success;
}

template< class T >
CdbStatus
CdbRooRoNameIdCollectionR<T>::find( UShort_t theId,
                                    T&       theObject ) const
{
    const char* fatalStr = "CdbRooRoNameIdCollectionR<T>::find(id,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
CdbRooRoNameIdCollectionR<T>::find( UShort_t      theId,
                                    CdbCPtr< T >& theObjectPtr ) const
{
    const char* fatalStr = "CdbRooRoNameIdCollectionR<T>::find(id,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 >
CdbStatus
CdbRooRoNameIdCollectionR<T>::find( const std::string& theName,
                                    T&                 theObject ) const
{
    const char* fatalStr = "CdbRooRoNameIdCollectionR<T>::find(name,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<std::string,UInt_t>::const_iterator itr = _indexByName.find( theName );
    if( itr == _indexByName.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
CdbRooRoNameIdCollectionR<T>::find( const std::string& theName,
                                    CdbCPtr< T >&      theObjectPtr  ) const
{
    const char* fatalStr = "CdbRooRoNameIdCollectionR<T>::find(name,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<std::string,UInt_t>::const_iterator itr = _indexByName.find( theName );
    if( itr == _indexByName.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
CdbRooRoNameIdCollectionR<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 >
void
CdbRooRoNameIdCollectionR<T>::names( std::vector<std::string>& theCollection ) const
{
    theCollection.resize( 0 );

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

template< class T >
CdbItr< UShort_t >
CdbRooRoNameIdCollectionR<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.

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

template< class T >
CdbItr< std::string >
CdbRooRoNameIdCollectionR<T>::iterator_names( ) const
{
    std::vector<std::string> vectorOfNames;
    names( vectorOfNames );
    std::sort( vectorOfNames.begin( ),
               vectorOfNames.end( ));

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

    CdbItr< std::string > itr( new CdbSimpleVectorAdapterItr< std::string >( vectorOfNames ));
    return itr;
}

template< class T >
void
CdbRooRoNameIdCollectionR<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 << "  _indexByName.size()        : " << _indexByName.size( ) << endl
      << indent << "}" << endl;
}

template< class T >
CdbStatus
CdbRooRoNameIdCollectionR<T>::storeSubCollectionsAt( const CdbRooRoCollectionAddressR& theCollectionAddress,
                                                     const CdbCPtr<TFile>&             theFilePtr,
                                                     Int_t&                            theNumBytesStored )
{
    const char* errorStr = "CdbRooRoNameIdCollectionR<T>::storeSubCollectionsAt() -- ERROR";
    const char* fatalStr = "CdbRooRoNameIdCollectionR<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 nPersistentIndexById   = _indexById.size( );
        const unsigned int nPersistentIndexByName = _indexByName.size( );

        if(( nObjects != nPersistentIndexById ) || ( nObjects != nPersistentIndexByName )) {
            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.1 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 #2.2 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 #2.3 has been found. Report the problem" << endl
                              << "   to the code developer." << endmsg;
                return CdbStatus::Error;
            }
        }
        for( typename std::map<std::string,UInt_t>::const_iterator itr = _indexByName.begin( );
                                                                   itr != _indexByName.begin( );
                                                                 ++itr ) {
            std::string name  = itr->first;
            UInt_t      index = itr->second;

            if( index >= nObjects ) {
                ErrMsg(fatal) << fatalStr << endl
                              << "   A fatal internal error #3.1 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.2 has been found. Report the problem" << endl
                              << "   to the code developer." << endmsg;
                return CdbStatus::Error;
            }
            if( name != objectPtr->name( )) {
                ErrMsg(fatal) << fatalStr << endl
                              << "   A fatal internal error #3.3 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 //
/////////////////

---