---

CdbRooRoFileUtils.cc

Go to the documentation of this file.

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

/// The implementation of the CdbRooRoFileUtils singleton.
/**
  * @see CdbRooRoFileUtils
  */

#include "BaBar/BaBar.hh"

#include "CdbRooReadonly/CdbRooRoFileUtils.hh"
#include "CdbRooReadonly/CdbRooRoRegistry.hh"
#include "CdbRooReadonly/CdbRooRoMetaDataR.hh"
#include "CdbRooReadonly/CdbRooRoOriginR.hh"
#include "CdbRooReadonly/CdbRooRoCollectionAddressR.hh"
#include "CdbRooReadonly/CdbRooRoContextSaver.hh"

#include "CdbBase/CdbStringUtils.hh"
#include "CdbBase/CdbEnvironment.hh"
#include "CdbBase/CdbAnyTypeDict.hh"

#include "BbrStdUtils/Tokenize.hh"
#include "BbrStdUtils/String.hh"
using namespace babar::String;

#include <TFile.h>

#include <string.h>     // strdup()
#include <libgen.h>     // dirname()
#include <assert.h>

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

namespace {

    std::string
    buildDatabaseName( bool               isPartitionableFlag,
                       UShort_t           thePartitionId,
                       UShort_t           theClusterId,
                       UShort_t           theIncrementNumber,
                       UShort_t           theOriginId,
                       const std::string& theSuffix = "" )
    {
        return "cdb_o" + CdbStringUtils::toString( theOriginId  ) +
                  "_c" + CdbStringUtils::toString( theClusterId ) +
               ( isPartitionableFlag ?
                  "_p" + CdbStringUtils::toString( thePartitionId )
               :
                  std::string("")
               ) +
                  "_i" + CdbStringUtils::toString( theIncrementNumber ) + theSuffix + ".root";
    }

    std::string
    buildDatabaseName( UShort_t theOriginId )
    {
        return "cdb_o" + CdbStringUtils::toString( theOriginId ) + "_registry.root";
    }

    std::string
    buildContainerName( const std::string& theContainerType,
                        UShort_t           theConditionId,
                        bool               isPartitionableFlag,
                        UShort_t           thePartitionId,
                        UShort_t           theClusterId,
                        UShort_t           theIncrementNumber,
                        UShort_t           theOriginId )
    {
        return "o" + CdbStringUtils::toString( theOriginId  ) +
               ".c" + CdbStringUtils::toString( theClusterId ) +
               ( isPartitionableFlag ?
               ".p" + CdbStringUtils::toString( thePartitionId ) : std::string("") ) +
               ".i" + CdbStringUtils::toString( theIncrementNumber ) +
               "."  + theContainerType + "." + CdbStringUtils::toString( theConditionId );
    }

  // A default limit for a number of TTree-s to be cached in the local cache

    const unsigned DefaultMaxNumOfTrees = 32;
}

CdbRooRoFileUtils&
CdbRooRoFileUtils::instance( )
{
    static CdbRooRoFileUtils myInstance;
    return myInstance;
}

std::string
CdbRooRoFileUtils::nameOfMetaDataContainer( UShort_t theConditionId,
                                            bool     isPartitionableFlag,
                                            UShort_t thePartitionId,
                                            UShort_t theClusterId,
                                            UShort_t theIncrementNumber,
                                            UShort_t theOriginId )
{
    return ::buildContainerName( "MetaData",
                                 theConditionId,
                                 isPartitionableFlag,
                                 thePartitionId,
                                 theClusterId,
                                 theIncrementNumber,
                                 theOriginId );
}

std::string
CdbRooRoFileUtils::nameOfObjectsContainer( UShort_t theConditionId,
                                           bool     isPartitionableFlag,
                                           UShort_t thePartitionId,
                                           UShort_t theClusterId,
                                           UShort_t theIncrementNumber,
                                           UShort_t theOriginId )
{
    return ::buildContainerName( "Objects",
                                 theConditionId,
                                 isPartitionableFlag,
                                 thePartitionId,
                                 theClusterId,
                                 theIncrementNumber,
                                 theOriginId );
}

std::string
CdbRooRoFileUtils::nameOfSystemContainer( UShort_t           theOriginId,
                                          const std::string& theContainerName )
{
    return "o" + CdbStringUtils::toString( theOriginId ) + ".System." + theContainerName;
}

CdbRooRoFileUtils::CdbRooRoFileUtils( ) :
    _localOriginName    ("<undefined>"),
    _localOriginId      (0xFFFF),
    _bootFileLocation   ("<undefined>"),
    _baseLocation       ("<undefined>"),
    _cacheOfTreesMaxSize(DefaultMaxNumOfTrees),
    _cacheOfTreesSize   (0),
    _cacheOfTreesStatTotal  (0),
    _cacheOfTreesStatCached (0),
    _cacheOfTreesStatRemoved(0)
{ }

CdbRooRoFileUtils::~CdbRooRoFileUtils( )
{
    if( CdbEnvironment::getDebugMode( ) > 0 )
        dump( cerr );
}

void
CdbRooRoFileUtils::reset( )
{
    _localOriginName  = "<undefined>";
    _localOriginId    = 0xFFFF;
    _bootFileLocation = "<undefined>";
    _baseLocation     = "<undefined>";

    _database2LocationMap.clear( );
    _object2DatabaseMap.clear( );

    _origin2RegistryMapById.clear( );
    _origin2RegistryMapByName.clear( );

    _cacheOfTreesMaxSize = DefaultMaxNumOfTrees;
    _cacheOfTreesSize    = 0;

    _cacheOfTreesByUseTime.clear( );
    _cacheOfTreesByName.clear( );

    _cacheOfTreesStatTotal   = 0;
    _cacheOfTreesStatCached  = 0;
    _cacheOfTreesStatRemoved = 0;

    _cacheOfTreesStatTrees.clear( );
}

void
CdbRooRoFileUtils::setLocalOrigin( const std::string& theOriginName,
                                   UShort_t           theOriginId  )
{
    assert( !theOriginName.empty( ));
    _localOriginName = theOriginName;
    _localOriginId   = theOriginId;
}

void
CdbRooRoFileUtils::setBootFileLocation( const std::string& theFileName )
{
    assert( !theFileName.empty( ));
    _bootFileLocation = theFileName;

  // Calculate the base file location

    char* fileNameCopyPtr = strdup( theFileName.c_str( ));
    {
        char* baseLocationPtr = dirname( fileNameCopyPtr );     // This call may return a pointer either within "fileNameCopy"
                                                                // or onto a statically allocated string. Don't touch result!
        _baseLocation = baseLocationPtr;
        if( "." == _baseLocation ) _baseLocation = "./";        // we want '/' to present at all times
    }
    free( fileNameCopyPtr );    // its an opposit operation for the C-style "strdup()"
}

void
CdbRooRoFileUtils::setDatabase2LocationMap( const std::map<std::string,std::string>& theMap )
{
    _database2LocationMap = theMap;
}

void
CdbRooRoFileUtils::setObject2DatabaseMap( const std::map<std::string,std::string>& theMap )
{
    _object2DatabaseMap = theMap;
}

void
CdbRooRoFileUtils::setRegistry( const CdbCPtr< CdbRooRoRegistry >& theRegistry )
{
    if( theRegistry.isNull( )) return;
    _origin2RegistryMapById  [theRegistry->originId  ( )] = theRegistry;
    _origin2RegistryMapByName[theRegistry->originName( )] = theRegistry;
}

CdbCPtr< CdbRooRoRegistry >
CdbRooRoFileUtils::registry( UShort_t theOriginId ) const
{
    std::map< UShort_t, CdbCPtr< CdbRooRoRegistry > >::const_iterator itr = _origin2RegistryMapById.find( theOriginId );
    if( itr != _origin2RegistryMapById.end( )) return (*itr).second;
    return 0;
}

CdbCPtr< CdbRooRoRegistry >
CdbRooRoFileUtils::registry( const std::string& theOriginName ) const
{
    std::map< std::string, CdbCPtr< CdbRooRoRegistry > >::const_iterator itr = _origin2RegistryMapByName.find( theOriginName );
    if( itr != _origin2RegistryMapByName.end( )) return (*itr).second;
    return 0;
}

CdbStatus
CdbRooRoFileUtils::findMetaData( CdbCPtr< CdbRooRoMetaDataR >& theMetaDataPtr,
                                 UShort_t                      theConditionId,
                                 bool                          isPartitionableFlag,
                                 UShort_t                      thePartitionId,
                                 UShort_t                      theClusterId,
                                 UShort_t                      theIncrementNumber,
                                 UShort_t                      theOriginId )
{
    const char* errorStr = "CdbRooRoFileUtils::findMetaData() -- ERROR.";
/*
    cout << "CdbRooRoFileUtils::findMetaData: theConditionId      = " << theConditionId      << endl
         << "                                 isPartitionableFlag = " << isPartitionableFlag << endl
         << "                                 thePartitionId      = " << thePartitionId      << endl
         << "                                 theClusterId        = " << theClusterId        << endl
         << "                                 theIncrementNumber  = " << theIncrementNumber  << endl
         << "                                 theOriginId         = " << theOriginId         << endl;
*/
    CdbStatus result = CdbStatus::Error;

  // Build the database name

    const std::string databaseName = ::buildDatabaseName( isPartitionableFlag,
                                                          thePartitionId,
                                                          theClusterId,
                                                          theIncrementNumber,
                                                          theOriginId );

  // Build the metadata oject name. This name will also be used as a key in
  // a transient cache of the found objects (see below).

    std::string objectName =
        CdbRooRoFileUtils::nameOfMetaDataContainer( theConditionId,
                                                    isPartitionableFlag,
                                                    thePartitionId,
                                                    theClusterId,
                                                    theIncrementNumber,
                                                    theOriginId );

  // See if the MetaData is already in the local cache. I not - then find it in a persistent
  // store an populate the cache.

    std::map< std::string, CdbCPtr< CdbRooRoMetaDataR > >::const_iterator itr = _cacheOfMetaData.find( objectName );
    if( itr != _cacheOfMetaData.end( )) {
        theMetaDataPtr = (*itr).second;
        return CdbStatus::Success;
    }

  // Get the database file handle

    CdbCPtr< TFile > databaseFile;
    if( CdbStatus::Success != ( result = findDatabase( databaseFile,
                                                       databaseName ))) {

      // Make a complain if it's not a normal "NotFound" case.

        if( CdbStatus::NotFound != result ) {
            cerr << errorStr << endl
                 << "    An error occured when attempting to locate the database: \"" << databaseName << "\"." << endl;
        }
        return result;
    }

  // Make sure the current ROOT path is preserved.

    CdbRooRoContextSaver saveCurrentPath;

  // Get the specified object out of the database

    CdbRooRoMetaDataR* mdPtr = 0;
    {
        databaseFile->Cd( "" );
        gDirectory->Cd( databaseFile->GetPath( ));
        databaseFile->GetObject( objectName.c_str( ),
                                 mdPtr );
        if( 0 == mdPtr ) return CdbStatus::NotFound;
    }
    theMetaDataPtr = mdPtr;     // Fill resulting pointer. This will also transfer the ownership!

   // Register the found object in the cache.

    _cacheOfMetaData[objectName] = theMetaDataPtr;

    return CdbStatus::Success;
}

CdbStatus
CdbRooRoFileUtils::findDatabase( CdbCPtr< TFile >&  theDatabasePtr,
                                 const std::string& theName,
                                 const std::string& theOpenMode )
{
    if( theName.empty( )) return CdbStatus::IllegalParameters;

  // Build a final location of the database. If its logical name is found
  // in the map then, depending on a type of the path we should use it either "as is"
  // (for an absolute path) or prepend it with the base path.
  //
  // For databases for which the mapping doesn't exist we always assume that the files
  // are placed next to the boot file (which is the "base" location of the database
  // installation) just like for the above mentioned relative path.

    std::string fullPath = baseLocation( ) + "/";
    {
        std::map< std::string, std::string >::const_iterator itr = _database2LocationMap.find( theName );
        if( itr != _database2LocationMap.end( )) {
            if( '/' == itr->second[0] ) fullPath =  itr->second;  // absolute
            else                        fullPath += itr->second;  // relative
        } else {
            fullPath += theName;
        }
    }

  // See if the file is already in the local cache. I not - then find it in a persistent
  // store an populate the cache.

    std::map< std::string, CdbCPtr< TFile > >::const_iterator itr = _cacheOfFiles.find( fullPath );
    if( itr != _cacheOfFiles.end( )) {
        theDatabasePtr = (*itr).second;
        return CdbStatus::Success;
    }

  // Proceed to the opening procedure

    CdbCPtr< TFile > databasePtr = new TFile( fullPath.c_str( ),
                                              theOpenMode.c_str( ));
    if( databasePtr->IsZombie( )) return CdbStatus::NotFound;

    theDatabasePtr = databasePtr;

  // Register the file in the cache

    _cacheOfFiles[fullPath] = theDatabasePtr;

    return CdbStatus::Success;
}

CdbStatus
CdbRooRoFileUtils::findDatabase( CdbCPtr< TFile >&                 theDatabasePtr,
                                 const CdbRooRoCollectionAddressR& theCollectionAddress,
                                 const std::string&                theOpenMode )
{
    if( !theCollectionAddress.isValid( )) return CdbStatus::IllegalParameters;

  // Dispatch the requst to the right database locator

    switch( theCollectionAddress.schema( )) {

    case CdbRooRoCollectionAddressR::SCHEMA_REGISTRY:

        return findDatabase( theDatabasePtr,
                             theCollectionAddress.origin( ),
                             theOpenMode );

    case CdbRooRoCollectionAddressR::SCHEMA_REGULAR:

        return findDatabase( theDatabasePtr,
                             false,
                             0,
                             theCollectionAddress.cluster( ),
                             theCollectionAddress.increment( ),
                             theCollectionAddress.origin( ),
                             theOpenMode );

    case CdbRooRoCollectionAddressR::SCHEMA_PARTITIONABLE:

        return findDatabase( theDatabasePtr,
                             true,
                             theCollectionAddress.partition( ),
                             theCollectionAddress.cluster( ),
                             theCollectionAddress.increment( ),
                             theCollectionAddress.origin( ),
                             theOpenMode );
    }
    return CdbStatus::IllegalParameters;
}

CdbStatus
CdbRooRoFileUtils::findDatabase( CdbCPtr< TFile >&  theDatabasePtr,
                                 UShort_t           theOriginId,
                                 const std::string& theOpenMode  )
{
    if( theOpenMode.empty( )) return CdbStatus::IllegalParameters;

    const std::string databaseName = ::buildDatabaseName( theOriginId );

    return findDatabase( theDatabasePtr,
                         databaseName,
                         theOpenMode );
}

CdbStatus
CdbRooRoFileUtils::findDatabase( CdbCPtr< TFile >&  theDatabasePtr,
                                 bool               isPartitionableFlag,
                                 UShort_t           thePartitionId,
                                 UShort_t           theClusterId,
                                 UShort_t           theIncrementNumber,
                                 UShort_t           theOriginId,
                                 const std::string& theOpenMode )
{
    if( theOpenMode.empty( )) return CdbStatus::IllegalParameters;

    const std::string databaseName = ::buildDatabaseName( isPartitionableFlag,
                                                          thePartitionId,
                                                          theClusterId,
                                                          theIncrementNumber,
                                                          theOriginId );
    return findDatabase( theDatabasePtr,
                         databaseName,
                         theOpenMode );
}

CdbStatus
CdbRooRoFileUtils::findObjectsDatabase( CdbCPtr< TFile >&  theDatabasePtr,
                                        bool               isPartitionableFlag,
                                        UShort_t           thePartitionId,
                                        UShort_t           theClusterId,
                                        UShort_t           theIncrementNumber,
                                        UShort_t           theOriginId,
                                        const std::string& theOpenMode )
{
    if( theOpenMode.empty( )) return CdbStatus::IllegalParameters;

    const std::string databaseName = ::buildDatabaseName( isPartitionableFlag,
                                                          thePartitionId,
                                                          theClusterId,
                                                          theIncrementNumber,
                                                          theOriginId,
                                                          "_objects" );
    return findDatabase( theDatabasePtr,
                         databaseName,
                         theOpenMode );
}

CdbStatus
CdbRooRoFileUtils::findTree( CdbCPtr< TTree >&  theTreePtr,
                             const std::string& theFileName,
                             const std::string& theTreeName,
                             const std::string& theOpenMode )
{
    const char* errorStr = "CdbRooRoFileUtils::findTree(file_name) -- ERROR.";

    if( theFileName.empty( )) return CdbStatus::IllegalParameters;
    if( theTreeName.empty( )) return CdbStatus::IllegalParameters;
    if( theOpenMode.empty( )) return CdbStatus::IllegalParameters;

  // Find/open the database file
  //
  // IMPORTANT QUESTION:
  //
  //   What we're going to do if a new handle gets open while an old TTree associated
  //   with a previous handle for the same file was already in cache?
  //
  //   This is not happening in the current implementation of the class, but we have
  //   to keep in mind this potential problem in the future!

    CdbCPtr< TFile > databasePtr;
    if( CdbStatus::Success != findDatabase( databasePtr,
                                            theFileName,
                                            theOpenMode )) {
        cerr << errorStr << "\n"
            << "    Failed to find/open the database file by its name: '" << theFileName << "'" << endl;
        return CdbStatus::Error;
    }

  /// Proceed to the locator of the tree

    return doFindTree( theTreePtr,
                       databasePtr,
                       theTreeName );
}

CdbStatus
CdbRooRoFileUtils::findTree( CdbCPtr< TTree >&                 theTreePtr,
                             const CdbRooRoCollectionAddressR& theCollectionAddress,
                             const std::string&                theTreeName,
                             const std::string&                theOpenMode )
{
    const char* errorStr = "CdbRooRoFileUtils::findTree(collection_address) -- ERROR.";

    if( !theCollectionAddress.isValid( )) return CdbStatus::IllegalParameters;
    if( theTreeName.empty( )) return CdbStatus::IllegalParameters;
    if( theOpenMode.empty( )) return CdbStatus::IllegalParameters;

  // Find/open the database file
  //
  // IMPORTANT QUESTION:
  //
  //   What we're going to do if a new handle gets open while an old TTree associated
  //   with a previous handle for the same file was already in cache?
  //
  //   This is not happening in the current implementation of the class, but we have
  //   to keep in mind this potential problem in the future!

    CdbCPtr< TFile > databasePtr;
    if( CdbStatus::Success != findDatabase( databasePtr,
                                            theCollectionAddress,
                                            theOpenMode )) {
        cerr << errorStr << "\n"
            << "    Failed to find/open the database file by the collection address: " << theCollectionAddress << endl;
        return CdbStatus::Error;
    }

  /// Proceed to the locator of the tree

    return doFindTree( theTreePtr,
                       databasePtr,
                       theTreeName );
}

void
CdbRooRoFileUtils::dump( std::ostream& theStream ) const
{
    theStream << "CdbRooRoFileUtils::dump( ) <DEBUG> {\n"
              << "  <PARAMETERS OF THE FACILITY> {\n"
              << "    _localOriginName  = '" << _localOriginName << "'\n"
              << "    _localOriginId    = " << _localOriginId << "\n"
              << "    _bootFileLocation = '" << _bootFileLocation << "'\n"
              << "    _baseLocation     = '" << _baseLocation << "'\n"
              << "    _database2LocationMap has " << _database2LocationMap.size( ) << " entries {\n";
    for( std::map<std::string,std::string>::const_iterator itr = _database2LocationMap.begin( );
                                                           itr != _database2LocationMap.end( );
                                                         ++itr ) {
        theStream << "      '" << itr->first << "' : '" << itr->second << "'\n";
    }
    theStream << "    }\n"
              << "    _object2DatabaseMap has " << _object2DatabaseMap.size( ) << " entries {\n";
    for( std::map<std::string,std::string>::const_iterator itr = _object2DatabaseMap.begin( );
                                                           itr != _object2DatabaseMap.end( );
                                                         ++itr ) {
        theStream << "      '" << itr->first << "' : '" << itr->second << "'\n";
    }
    theStream << "    }\n"
              << "  }\n"
              << "  <CACHE UTILIZATION STATISTICS>\n"
              << "    _origin2RegistryMapById has " << _origin2RegistryMapById.size( ) << " entries {\n";
    for( std::map< UShort_t, CdbCPtr< CdbRooRoRegistry > >::const_iterator itr = _origin2RegistryMapById.begin( );
                                                                           itr != _origin2RegistryMapById.end( );
                                                                         ++itr ) {
        theStream << "      " << itr->first << "\n";
    }
    theStream << "    }\n"
              << "    _origin2RegistryMapByName has " << _origin2RegistryMapByName.size( ) << " entries {\n";
    for( std::map< std::string, CdbCPtr< CdbRooRoRegistry > >::const_iterator itr = _origin2RegistryMapByName.begin( );
                                                                              itr != _origin2RegistryMapByName.end( );
                                                                            ++itr ) {
        theStream << "      '" << itr->first << "'\n";
    }
    theStream << "    }\n"
              << "    _cacheOfMetaData has " << _cacheOfMetaData.size( ) << " entries {\n";
    for( std::map< std::string, CdbCPtr< CdbRooRoMetaDataR > >::const_iterator itr = _cacheOfMetaData.begin( );
                                                                               itr != _cacheOfMetaData.end( );
                                                                             ++itr ) {
        theStream << "      '" << itr->first << "'\n";
    }
    theStream << "    }\n"
              << "    _cacheOfFiles has " << _cacheOfFiles.size( ) << " entries {\n";
    for( std::map< std::string, CdbCPtr< TFile > >::const_iterator itr = _cacheOfFiles.begin( );
                                                                   itr != _cacheOfFiles.end( );
                                                                 ++itr ) {
        theStream << "      '" << itr->first << "'\n";
    }
    theStream << "    }\n"
              << "    _cacheOfTreesMaxSize     = " << _cacheOfTreesMaxSize << "\n"
              << "    _cacheOfTreesSize        = " << _cacheOfTreesSize << "\n"
              << "    _cacheOfTreesStatTotal   = " << _cacheOfTreesStatTotal << "\n"
              << "    _cacheOfTreesStatCached  = " << _cacheOfTreesStatCached << "\n"
              << "    _cacheOfTreesStatRemoved = " << _cacheOfTreesStatRemoved << "\n"
              << "    _cacheOfTreesByUseTime has " << _cacheOfTreesByUseTime.size( ) << " entries {\n";
    for( MyListOfTrees::const_iterator itr = _cacheOfTreesByUseTime.begin( );
                                       itr != _cacheOfTreesByUseTime.end( );
                                     ++itr ) {
        theStream << "      '" << itr->name << "' : " << itr->used << "\n";
    }
    theStream << "    }\n"
              << "    _cacheOfTreesStatTrees has " << _cacheOfTreesStatTrees.size() << " entries {\n";
    for( std::map< std::string, unsigned >::const_iterator itr = _cacheOfTreesStatTrees.begin( );
                                                           itr != _cacheOfTreesStatTrees.end( );
                                                         ++itr ) {
        theStream << "      '" << itr->first << "' : " << itr->second << "\n";
    }
    theStream << "    }\n"
              << "  }\n"
              << "}\n"
              << endl;
}

CdbStatus
CdbRooRoFileUtils::doFindTree( CdbCPtr< TTree >&       theTreePtr,
                               const CdbCPtr< TFile >& theDatabasePtr,
                               const std::string&      theTreeName )
{
    const char* errorStr = "CdbRooRoFileUtils::doFindTree() -- ERROR.";

    if( theTreeName.empty( )) return CdbStatus::IllegalParameters;

    ++_cacheOfTreesStatTotal;

  // Look nto the cache first

    const std::string key = std::string( theDatabasePtr->GetName( )) + "::" + theTreeName;

    if( _cacheOfTreesStatTrees.count( key )) ++_cacheOfTreesStatTrees[key];
    else _cacheOfTreesStatTrees[key] = 1;

    MyMapOfTrees::iterator itr = _cacheOfTreesByName.find( key );
    if( itr != _cacheOfTreesByName.end( )) {
        theTreePtr = itr->second->ptr;
        ++(itr->second->used);
        ++_cacheOfTreesStatCached;
        return CdbStatus::Success;
    }

  // Make sure the current ROOT path is preserved.

    CdbRooRoContextSaver saveCurrentPath;

  // Find the tree

    theDatabasePtr->Cd( "" );
    gDirectory->Cd( theDatabasePtr->GetPath( ));
    theTreePtr = (TTree*)theDatabasePtr->Get( theTreeName.c_str( ));
    if( theTreePtr.isNull( )) return CdbStatus::NotFound;

  // Adjust the cache size limit
  //
  // NOTE: If the new limit is found less than the one we already have then we'll adjust
  //       the cache accordingly. See the next step.

    {
        const std::string maxNumOfTreesParameter = "Roo/Readonly/max_num_ttrees";
        unsigned maxNumOfTrees = ::DefaultMaxNumOfTrees;

        CdbStatus status = CdbEnvironment::extra( ).find( maxNumOfTreesParameter,
                                                          maxNumOfTrees );
        if( CdbStatus::Success != status ) {
            if( CdbStatus::NotFound != status ) {
                cerr << errorStr << "\n"
                     << "    An error occured when attempting to obtain a value of the parameter\n"
                     << "    from the CDB API 'invironment'.\n"
                     << "        PARAMETER NAME: '" << maxNumOfTreesParameter << "'\n"
                     << "        ERROR CODE:     " << status << endl;
                return CdbStatus::Error;
            }
        } else {

          // Increase the current maximum only if the new one is not zero

            if( 0 != maxNumOfTrees ) _cacheOfTreesMaxSize = maxNumOfTrees;
        }
    }

  // Register the tree in the cache. The algorithm will get rid of the oldest
  // registered elements to make a room for the new tree if the cache limit
  // is exceeded. At this stage we'll also automatically readjust the cache size
  // if the smaller limit is set at the previous step (see above).

    while( _cacheOfTreesSize >= _cacheOfTreesMaxSize ) {
        const std::string key2remove = _cacheOfTreesByUseTime.rbegin( )->name;
        _cacheOfTreesByUseTime.pop_back( );
        _cacheOfTreesByName.erase( key2remove );
        ++_cacheOfTreesStatRemoved;
        --_cacheOfTreesSize;
    }
    _cacheOfTreesByUseTime.push_front( TreeCacheElement( key,
                                                         theTreePtr ));
    _cacheOfTreesByName[key] = _cacheOfTreesByUseTime.begin( );
    ++_cacheOfTreesSize;

    return CdbStatus::Success;
}

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

---