Bdb packages | Design docs | Source docs | Guidelines | Recent releases
	Search | Site Map .

                 

---

/BdbEventStore/BdbLocateDb.cc

Go to the documentation of this file.

//--------------------------------------------------------------------------
// File and Version Information:
//      $Id: BdbLocateDb.cc,v 1.36.2.1 2002/09/03 18:30:27 becla Exp $
//
// Description:
//      This class collectes the databases associated to the objects of 
//      collections or domains.
//
// Environment:
//      Software developed for the BaBar Detector at the SLAC B-Factory.
//
// Author List:
//      Jean-Noel Albert    First author
//      Moreno Marzolla     Added support for collection MetaData
//
// Copyright Information:
//      Copyright (C) 1998      Laboratoire de l'Accelerateur Lineaire
//      Copyright (C) 2000      INFN Padova
//
//------------------------------------------------------------------------

//------------------
// Class's Header --
//------------------
#include "BdbEventStore/BdbLocateDb.hh"
#include "BbrStdUtils/BbrStdDeleteObject.hh"

//-------------
// C Headers --
//-------------
extern "C" {
#include <stdlib.h>
#include <regex.h>
#include <string.h>
#include <strings.h>
}

//---------------
// C++ Headers --
//---------------

//-----------------------
// BaBar class headers --
//-----------------------
#include "BdbApplication/BdbDomain.hh"
#include "BdbTrees/BdbDbRegistrator.hh"
#include "BdbEventStore/BdbEventStore.hh"
#include "BdbEventStore/BdbCollectionTIterator.hh"
#include "BdbUtil/BdbCollectRef.hh"
#include "BdbTrees/BdbTreeNode.hh"
#include "BdbTrees/BdbTreeNodeIterator.hh"
#include "BdbEvent/BdbEventT.hh"
#include "BdbEvent/BdbEvent.hh"
#include "BdbEvent/BdbEvent_001.hh"
#include "BdbEventStore/BdbDistMetaDataMgr.hh"
#include <algorithm>

#ifdef   BABAR_COMP_INST
#undef   BABAR_COMP_INST
#endif
#include "BdbEventStore/BdbCollectionTCollTIterator.hh"

//--------------------
// Local definition --
//--------------------
#define INTERNAL_PATTERNS 2

//-------------------
// Local variables --
//-------------------
// Keep the list of the databases already checked
//      (``Invalid'' databases can be found after a partial transfer)
//  This is faster than testing each time the validity of the object
static set<BdbCollectRef*, babar::Collection::PtrLess> InvRefs, ValRefs;

///////////////////////////////////////////////////////////////////////////////
//
// Debug functions

//#define BDBSCANDB_TRACE

#ifndef BDBSCANDB_TRACE

#define objectDebug(type,obj)
#define collDebug(type,obj)

#else

#define objectDebug(type,obj)   objectInfo(type,obj)
#define collDebug(obj,lvl)      collInfo(obj,lvl)

static int traceLevel()
{
    static int trcLevel = -2;

    if (trcLevel == -2) {
        // Fly debug
        char* trcenv = getenv("BDBSCANDB_TRACE");
        if (trcenv == 0)
            trcLevel = -1;              // No trace
        else if (*trcenv == 'F')
            trcLevel = 1;               // Full trace
        else if (*trcenv == 'C')
            trcLevel = 2;               // Collection only
        else
            trcLevel = 0;               // Minimal trace
    }
    return trcLevel;
}

static void objectInfo (const char* trace_type, const BdbRef(BdbPersObj)& obj)
{
    BdbRef(BdbDBObj) db;
    BdbRef(BdbContObj) cont;

    switch (traceLevel()) {
        case 0 :
            cout << trace_type << ": " << obj.get_DB()
                 << "-" << obj.get_OC() 
                 << "-" << obj.get_page()
                 << "-" << obj.get_slot() << endl;
            break;

        case 1:
            cout << "Object id: " << obj.sprint()
                 << " type name: " << obj.typeName()
                 << " type number: " << obj.typeN() << endl;    

            obj.containedIn(cont);
            cont.containedIn(db);
            cout << " Container Id: " << cont.sprint()
                 << " Database Id: " << db.sprint()
                 << " name: " << db.name() << endl;
            break;
    }
}

static void collInfo(const BdbRef(BdbCollectionP)& coll, int level)
{
    if (traceLevel() == 2) {
        cout << "Collection level: " << level << endl
             << "\tCollection name: " << coll->name() << endl
             << "\tFull name: " << coll->pathName() << endl
             << "\tNumber of events: " << coll->size() << endl
             << "\tNumber of items: " << coll->collections() << endl
             << "\tOID: " << coll.sprint() << endl
             << "\ttype name: " << coll.typeName() << endl
             << "\ttype number: " << coll.typeN() << endl;
    }
}
#endif

///////////////////////////////////////////////////////////////////////////////
//
// Internal functions

d_Boolean BdbLocateDb::addDb(int dbid)
{
    BdbRef(BdbDBObj) db;
    db.set_DB(dbid);
    BdbCollectRef dbCR (db);

    if (InvRefs.find(&dbCR)!=InvRefs.end())
        return d_False;
    else if (ValRefs.find(&dbCR)==ValRefs.end()) {
        if (!db.isValid()) {
            InvRefs.insert(new BdbCollectRef(dbCR));
            return d_False;
        }
        else
          ValRefs.insert(new BdbCollectRef(dbCR));
    }

    if (_rejs.find(&dbCR)!=_rejs.end())
        return d_False;

    if (_dbs.find(&dbCR)==_dbs.end()) {
        int p;
        for (p = 0; p < _nbexcls; p++) {
            if (regexec((regex_t*)_excludes[p], db.name(), 0, 0, 0) == 0) {
                _rejs.insert(new BdbCollectRef(dbCR));
                return d_False;
            }
        }
        if (_nbpats > INTERNAL_PATTERNS) {
            for (p = 0; p < _nbpats; p++) {
                if (regexec((regex_t*)_patterns[p], db.name(), 0, 0, 0) == 0) {
                    _dbs.insert(new BdbCollectRef(dbCR));
                    return d_True;
                }
            }
            _rejs.insert(new BdbCollectRef(dbCR));
            return d_False;
        }
        else {
            _dbs.insert(new BdbCollectRef(dbCR));
            return d_True;
        }
    }
    return d_True;
}

d_Boolean BdbLocateDb::checkItem(const BdbRef(BdbPersObj)& item)
{
    // Create ``dummy'' database and container references using the first
    // part of the item ID.
    //  By definition, the Objectivity OID are:
    //          Database #, Container #, Page # and Slot #
    //  For a database, all the numbers but the first one are 0.
    //
    // The correct sequence would be:
    //  BdbRef(ooContObj) cont;
    //  item.containedIn(cont);
    //  BdbRef(BdbDBObj) db;
    //  cont.containedIn(db);
    //
    // but the <item.containedIn> is a handle call.
    // The <item> is pined in memory. 
    // The database *has* to be available.
    // If the databases are in the HPSS, the ``correct'' sequence
    // implies to down load *each* database !
    //
    // By creating a pseudo-reference, the following sequence
    // works only with the database catalog and does not
    // access the physical databases.

    if (item == 0)
        return d_False;                 // Invalid oid ?

    _theMgr.addDB( item ); // Update the metaDataManager object

    if (!addDb(item.get_DB()))
        return d_False;

    if (!_keepconts)
        return d_True;

    BdbRef(BdbContObj) cont;
    cont.set_DB(item.get_DB());
    cont.set_OC(item.get_OC());
    BdbCollectRef contCR (cont);

    if (InvRefs.find(&contCR)!=InvRefs.end())
        return d_False;
    else if (ValRefs.find(&contCR)==ValRefs.end()) {
        if (!item.isValid()) {
            cont = item.containedIn();
            if (cont == 0) {
                InvRefs.insert(new BdbCollectRef(contCR));
                return d_False;
            }
        }
        else
            ValRefs.insert(new BdbCollectRef(contCR));
    }

    cont = item.containedIn();
    contCR = cont;
    if (_conts.find(&contCR)==_conts.end())
      _conts.insert(new BdbCollectRef(cont));

    return d_True;
}

void BdbLocateDb::iterateOverHeader( const BdbGenericHdrT& hdr )
{
    // Iterate over all the items of the header
   BdbRef( BdbPersObj )* objects ;
   const size_t numberObjects( hdr.getPersObjs( objects ) ) ;
   for( size_t object( 0 ) ;
        numberObjects != object ;
        object++ ) {
      objectDebug("Item", objects[ object ] );
      checkItem( objects[ object ]);
   }
   if ( 0 != numberObjects ) {
     delete objects ;
   }
}

void BdbLocateDb::iterateOverCollection(BdbAbsCollectionT<BdbEventT>* collection,
                                        int level)
{
    // Persistent object associated to the collection
    BdbHandle(BdbCollectionP) collP = collection->persistent();
    if (collP != 0) {
#ifdef BDBSCANDB_TRACE
        if (traceLevel() == 2)
            collDebug(collP, level);
#endif
        checkItem(collP);
    }

    // Iterate over the embeded collections
    BdbAbsCollectionT<BdbEventT>* embededColl = 0;
    BdbCollectionTCollTIterator collItr (*collection);
    while (BdbcSuccess == collItr.next(embededColl)) {
        if ( 0 != embededColl ) {
            iterateOverCollection(embededColl, level+1);
        }
    }
}

///////////////////////////////////////////////////////////////////////////////
//
// Constructor

BdbLocateDb::BdbLocateDb (d_Boolean collectContainers)
    : _dbit(_dbs.begin()), _contit(_conts.begin()), _invdbit(InvRefs.begin()), _theMgr()
{
    _keepconts = collectContainers;

    // List of the filter patterns
    _patterns.resize(8);
    _nbpats = 0;
    _excludes.resize(8);
    _nbexcls = 0;

    // Create 2 default patterns for the mandatory Events Store databases (evt & col)
    filter(".+_.+_.+_col[0-9]+", d_True);
    filter(".+_.+_.+_evt[0-9]+", d_True);

    assert(_nbpats == INTERNAL_PATTERNS);

    // A dummy call to force the loading of the BdbEvent module
    int n = ooTypeN(BdbEvent);
    int n1 = ooTypeN(BdbEvent_001);
}

// Destructor
BdbLocateDb::~BdbLocateDb ()
{
    clear();
    clearFilters();
}

void BdbLocateDb::reset()
{
    _dbit=_dbs.begin();
    if (_keepconts)
        _contit=_conts.begin();
    _invdbit=InvRefs.begin();
    _theMgr.clear();
}

void BdbLocateDb::clear()
{
  std::for_each(_dbs.begin(),_dbs.end(),BbrStdDeleteObject());
  _dbs.clear();
  if (_keepconts){
    std::for_each(_conts.begin(),_conts.end(),BbrStdDeleteObject());
    _conts.clear();
  }
  std::for_each(ValRefs.begin(),ValRefs.end(),BbrStdDeleteObject());
  ValRefs.clear();
  std::for_each(InvRefs.begin(),InvRefs.end(),BbrStdDeleteObject());
  InvRefs.clear();
  _theMgr.clear();
}

void BdbLocateDb::clearFilters()
{
    // Clear the user patterns, but keep the default ones (col & evt)
    int p;
    for (p = INTERNAL_PATTERNS; p < _nbpats; p++)
        if (_patterns[p] != 0)
            delete[] _patterns[p];
    _nbpats = INTERNAL_PATTERNS;

    for (p = 0; p < _nbexcls; p++)
        if (_excludes[p] != 0)
            delete[] _excludes[p];
    _nbexcls = 0;
}

BdbStatus BdbLocateDb::filter(const char* pattern, d_Boolean include)
{
    regex_t regex;

    // Compile the regular expression pattern
    if (regcomp(&regex, pattern, REG_EXTENDED) != 0) {
        fprintf(stderr, "Invalid regular expression <%s>\n", pattern);
        return BdbcError;
    }
    if (include) {
        if (_patterns.size() <= _nbpats)
            _patterns.resize(_patterns.size() + 8);
        _patterns[_nbpats] = new char[sizeof(regex_t)];
        memcpy(_patterns[_nbpats], &regex, sizeof(regex_t));
        _nbpats++;
    }
    else {
        if (_excludes.size() <= _nbexcls)
            _excludes.resize(_excludes.size() + 8);
        _excludes[_nbexcls] = new char[sizeof(regex_t)];
        memcpy(_excludes[_nbexcls], &regex, sizeof(regex_t));
        _nbexcls++;
    }

    return BdbcSuccess;
}

BdbStatus BdbLocateDb::eventFilter(const char* type, d_Boolean include)
{
    char pattern[64];

    // Define a regular expression to filter the Events Store databases
    sprintf(pattern, ".+_.+_.+_%s[0-9]+", type);
    if (BdbcSuccess != filter(pattern, include))
        return BdbcError;

    // Define a regular expression to filter the Events Store header databases
    sprintf(pattern, ".+_.+_.+_%shdr[0-9]+", type);
    if (BdbcSuccess != filter(pattern, include))
        return BdbcError;

    return BdbcSuccess;
}

BdbStatus BdbLocateDb::domainFilter(const char* type, d_Boolean include)
{
    char pattern[64];

    // Define a regular expression to filter the non Events Store databases
    sprintf(pattern, ".+_%s_%s[0-9]+", type, type);
    if (BdbcSuccess != filter(pattern, include))
        return BdbcError;

    // Define a regular expression to filter the non Events Store index
    sprintf(pattern, ".+_%s_Index", type);
    if (BdbcSuccess != filter(pattern, include))
        return BdbcError;

    return BdbcSuccess;
}

BdbStatus BdbLocateDb::patternSelect(const char* pattern)
{
    return filter(pattern, d_True);
}

BdbStatus BdbLocateDb::patternExclude(const char* pattern)
{
    return filter(pattern, d_False);
}

BdbStatus BdbLocateDb::eventSelect(const char* type)
{
    return eventFilter(type, d_True);
}

BdbStatus BdbLocateDb::eventExclude(const char* type)
{
    return eventFilter(type, d_False);
}

BdbStatus BdbLocateDb::domainSelect(const char* type)
{
    return domainFilter(type, d_True);
}

BdbStatus BdbLocateDb::domainExclude(const char* type)
{
    return domainFilter(type, d_False);
}

BdbStatus BdbLocateDb::scanCatalog ()
{
    BdbItr(BdbDBObj) dbItr;
    if (BdbcSuccess != dbItr.scan(BdbEventStore::instance()->fd()))
        return BdbcError;

    while (dbItr.next()) {
        if (dbItr.isValid()) {
            BdbRef(BdbDBObj) db = (BdbRef(BdbDBObj)) dbItr;
            addDb(db.get_DB());
        }
    }
    return BdbcSuccess;
}

BdbStatus BdbLocateDb::scanCollection (const char* collectionName,
                                       d_Boolean trustMetaData,
                                       d_Boolean updateMetaData )
{
    BdbAbsCollectionT<BdbEventT>* collection = 
        BdbEventStore::instance()->collection(collectionName, (*(BdbEventT*)0) );

    if ( 0 == collection ) {
        return BdbcError;       // No such collection
    }
    scan(collection, trustMetaData, updateMetaData );
    return BdbcSuccess;
}

BdbStatus BdbLocateDb::scanDomain (const char* domainName)
{
    if (0 == strcasecmp("MetaData", domainName)) {
        scanMetaData();
        return BdbcSuccess;
    }

    for (int dmn = 0; dmn < int(BdbDomain::IllegalDomain); dmn++) {
        if (0 == strcasecmp(BdbDomain::domainName(BdbDomain::Domains(dmn)), 
                            domainName)) {
            scan(BdbDomain::Domains(dmn));
            return BdbcSuccess;
        }
    }
    return BdbcError;   // No such domain
}

int BdbLocateDb::scanMetaData()
{
    static const char* metaDbs[] = {
        "cfg_clustHintConfig", "con_clustHintConfig",
        "evs_clustHintConfig", "evs_treenodes",
        "management", "global", "empty"
    };
    static const int nbDbs = sizeof(metaDbs) / sizeof(metaDbs[0]);

    for (int d = 0; d < nbDbs; d++) {
        // Initialize a reference for this database
        BdbRef(BdbDBObj) db;
        if (BdbcSuccess != db.exist(BdbEventStore::instance()->fd(), metaDbs[d]))
            continue;           // Ignore it...

        addDb(db.get_DB());
    }

    return _dbs.size();
}

int BdbLocateDb::scan(BdbDomain::Domains domain)
{
    BdbTreeNode domainNode ;
    if (BdbcSuccess != domainNode.moveToRootChild(BdbDomain::domainName(domain), 
                                                  BdbDbRegistrator::_rootName))
        return _dbs.size();

    BdbTreeNodeIterator itrAuth(domainNode) ;
    BdbTreeNode authNode ;
    while (itrAuth.next(authNode)) {
        BdbTreeNodeIterator itrUserName(authNode) ;
        BdbTreeNode userNode ;
        while (itrUserName.next(userNode)) {
            BdbTreeNodeIterator itrCompName(userNode) ;
            BdbTreeNode compNode ;
            while (itrCompName.next(compNode)) {
                // ooMapItr dbItr (compNode.persistent()->children());
                BdbRef(BdbMap) childrenM = compNode.persistent()->children();
                ooMapItr dbItr (childrenM);
                while (dbItr.next()) {
                    const char* dbname = dbItr->name();
                    BdbRef(BdbDBObj) db;
                    if (BdbcSuccess == db.exist(BdbApplicationOrDomain::activeInstance()->fd(), dbname, oocNoOpen))
                        addDb(db.get_DB());
                }
            }
        }
    }

    return _dbs.size();
}

void BdbLocateDb::scanEvent(const BdbEventT& event, d_Boolean scanSubEvents)
{
    checkItem(event.getPersistent());

    if (scanSubEvents) {
        BdbRef(BdbEventTag) tag;

        // ugly hack, while deciding how to access Tag in BdbEventT
        if (BdbcSuccess == ((BdbRef(BdbEvent)&) event.getPersistent())->tag(tag))
            checkItem(tag);

        objectDebug("Event", event.getPersistent());

    // collection that owns the event. The col database is added.

    BdbHandle(BdbPersObj) ownerColl;
    if (BdbcSuccess == 
        ((BdbRef(BdbEvent)&)event.getPersistent())->owner( (BdbHandle(BdbPersObj)&) ownerColl) ) {
      checkItem(ownerColl);
    }

        // Iterate over all headers in the event
        const char** headerKeys ;
        const size_t numberKeys( event.hdrKeys( headerKeys ) ) ;
        for( size_t header( 0 ) ;
             numberKeys != header ;
             header++ ) {
           const BdbGenericHdrT hdr( event.findHeader( headerKeys[ header ] ) ) ;

           BdbRef( BdbPersObj ) hdrR( hdr.getPersistent() ) ;
           BdbCollectRef dbCR(hdrR.get_DB());
           if (InvRefs.find(&dbCR)!=InvRefs.end())
              continue;
           
           // Base not already tested
           else if (ValRefs.find(&dbCR)==ValRefs.end()) {
              if (hdrR.isValid())
                 ValRefs.insert(new BdbCollectRef(dbCR));
              else {
                 InvRefs.insert(new BdbCollectRef(dbCR));
                 continue;
              }
           }
           objectDebug("Header", hdrR);
           checkItem(hdrR);

           iterateOverHeader(hdr);
           
         // cast away const to allow deletion.
         delete [] (char*)(headerKeys[ header ]) ;
        }
        if( 0 != numberKeys ) {
           delete [] headerKeys ;
        }
    }

    // Check the original event
    //  Don't iterate over the subevents
    BdbRef(BdbEvent) origEvt;
    // ugly hack, while deciding how to access Original in BdbEventT
    if (BdbcSuccess != ((BdbRef(BdbEvent)&)event.getPersistent())->original(origEvt))
        return;

    //
    // Changed d_False into d_True in the following line to solve
    // Remedy 4778. MM 2001 03 08
    //
    if (event.getPersistent() != origEvt)
        scanEvent(BdbEventT( origEvt ), d_True);
}

int BdbLocateDb::scan( BdbAbsCollectionT<BdbEventT>* collection, 
                       d_Boolean trustMetaData,
                       d_Boolean updateMetaData )
{
#ifdef BDBSCANDB_TRACE
  cout << "Trying to scan (Tree) collection " << collection->name() << endl;
#endif
  BdbHandle(BdbCollectionP) thePersColl = collection->persistent();
  if ( !BdbIsNull( thePersColl ) ) {
    checkItem( thePersColl );
    
    BdbMetaData theMetaData;
    collection->metaData( theMetaData );
    if ( ! theMetaData.isNull( )  )
      checkItem( theMetaData.persistent() ); // Check also the metadata, if any.
  }
  
  if ( collection->collections() > 0 ) {
    // This collection contains other collections. We assume it's 
    // a tree collection; thus, we recursively check each contained one.    
    BdbCollectionTCollTIterator collItr( *collection );
    BdbAbsCollectionT<BdbEventT>* embeddedColl = 0;
    while ( BdbcSuccess == collItr.next( embeddedColl ) ) {
        scan( embeddedColl, trustMetaData, updateMetaData );
    }
  } else {
    // There are no embedded collections. Assume it's a vector collection
    scanVectorCollection( collection, trustMetaData, updateMetaData );
  }
  return _dbs.size();
}


void
BdbLocateDb::scanVectorCollection(  BdbAbsCollectionT<BdbEventT>* collection, 
                                    d_Boolean trustMetaData,
                                    d_Boolean updateMetaData )
{
  assert( collection->collections() == 0 ); // See note below
  /*
   * NOTE: The previous assertion should _never_ fail. This is because this 
   * function is called from scanCollection, which is expected to check if
   * the collection is a vector collection or not. If this function fails,
   * perhaps there were changes in the implementation of event collections.
   * If so, please contact the pkg coordinator for BdbEventStore.
   */

  BdbStatus result = BdbcError;
#ifdef BDBSCANDB_TRACE
  cout << "Trying to scan Vector collection " << collection->name() << endl;
#endif
  if ( d_True == trustMetaData ) {
    result = useCollMetaData( collection );
  }
  
  if ( BdbcSuccess != result ) {
#ifdef BDBSCANDB_TRACE
    cout << "Not using Metadata. Scanning..." << endl;
#endif
    _theMgr.clear( );
    
    // Iterates over the events
    BdbCollectionTIterator<BdbEventT>* evtItr( collection->getIterator() );
    BdbEventT::ObjyRef nullRef;
    BdbEventT eventT(nullRef, d_True);
    while (BdbcSuccess == evtItr->next(eventT)) {
      scanEvent(eventT);
    }
    delete evtItr ;
    
    if ( d_True == updateMetaData ) {
      /*
       * Update the metadata info
       */
#ifdef BDBSCANDB_TRACE
      cout << "I'm updating the MetaData..." << endl;
#endif
      BdbMetaData meta;
      BdbMode oldMode = BdbEventStore::instance()->change( BdbcUpdate );
      assert( BdbcSuccess == collection->fetchMetaData( meta ) ); // See note below
      /*
       * NOTE: If the previous assertion fails, make sure that the 
       * transaction in which this function is called can be switched to 
       * update mode. This should be trivially enforced by the previous
       * line of code, so this assertion is not really supposed to fail.
       */

      _theMgr.setValidity( d_True );
      assert ( BdbcSuccess == _theMgr.end( meta ) ); // See note below
      /*      
       * NOTE: This operation is not supposed to fail. If it does, maybe the
       * end( ) method cannot acquire a write lock. Check for outstanding locks
       * on the federation.
       */
      BdbEventStore::instance()->change( oldMode, d_True );
    }
  }
}

/*
 * Try to access the collection's metadata. Return BdbcError if
 * metadata are non-existant or invalid.
 */
BdbStatus 
BdbLocateDb::useCollMetaData( BdbAbsCollectionT<BdbEventT>* collection )
{
  BdbMetaData theMetaData;
  BdbStatus result = BdbcError;

  collection->metaData( theMetaData );
  BdbDistMetaDataMgr localMgr( theMetaData );
  if ( d_True == localMgr.valid( ) ) {
    // The metadata are valid. Use them
    vector<int> theDBList;
    localMgr.getDBList( theDBList );    
    for ( size_t i=0; i < theDBList.size( ); i++ ) {
      addDb( theDBList[i] );
    }
    result = BdbcSuccess;
  }
  return result;
}

// Fill the reference object with the reference of the next database
//      and return true
// Return false at the end of the list*/
BdbStatus BdbLocateDb::next(BdbRef(BdbDBObj)& db)
{
    BdbCollectRef* dbCR;
    if (_dbit!=_dbs.end()) {
      dbCR = *_dbit;
      db = dbCR->getDBRef();
      _dbit++;
      return BdbcSuccess;
    }
    
    // No more database in the list
    return BdbcError;
}

// Return the database id of the next invalid database
// Return false at the end of the list
BdbStatus BdbLocateDb::nextInvalid(int& dbid)
{
    BdbCollectRef* dbCR;
    if (_invdbit!=InvRefs.end()) {
      dbCR=*_invdbit;
        dbid = (dbCR->getDBRef()).get_DB();
        _invdbit++;
        return BdbcSuccess;
    }

    // No more database in the list
    return BdbcError;
}

d_Boolean BdbLocateDb::isSelected(const BdbRef(BdbDBObj)& db) const
{
    BdbCollectRef dbCR (db);
    return _dbs.find(&dbCR)!=_dbs.end();
}

// Fill the reference object with the reference of the next container
//      and return true
// Return false at the end of the list
BdbStatus BdbLocateDb::nextContainer(BdbRef(BdbContObj)& cont)
{
    BdbCollectRef* contCR;
    if(_contit!=_conts.end()) {
      contCR=*_contit;
      cont = contCR->getContRef();
      _contit++;
      return BdbcSuccess;
    }

    // No more database in the list
    return BdbcError;
}

d_Boolean BdbLocateDb::isSelected(const BdbRef(BdbContObj)& cont) const
{
    BdbCollectRef contCR (cont);
    return _conts.find(&contCR)!=_conts.end();
}

 

---

BaBar Public Site | SLAC | News | Links | Who's Who | Contact Us

Page Owner: Jacek Becla
Last Update: October 04, 2002