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

                 

---

/TagDataP/BdbTagConverter.cc

Go to the documentation of this file.

//--------------------------------------------------------------------------
// File and Version Information:
//      $Id: BdbTagConverter.cc,v 1.32 2002/06/17 02:57:59 becla Exp $
//
// Description:
//      Class BdbTagConverter
//
// Environment:
//      Software developed for the BaBar Detector at the SLAC B-Factory.
//
// Author List:
//      Bob Jacobsen            original author
//      Stephen J. Gowdy        Contributor
//      Akbar Mokhtarani        modified from Composite converter
// Copyright Information:
//      Copyright (C) 1997      LBNL
//
//------------------------------------------------------------------------
#include "BaBar/BaBar.hh"

//-----------------------
// This Class's Header --
//-----------------------
#include "TagDataP/BdbTagConverter.hh"

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

//---------------
// C++ Headers --
//---------------
#include <string>
using std::string;
#include <vector>
using std::vector;

//-------------------------------
// Collaborating Class Headers --
//-------------------------------
#include <rw/cstring.h>
#include <rw/tvordvec.h>
#include <rw/tvhset.h>

#include "ErrLogger/ErrLog.hh"
#include "AbsEvent/AbsEvent.hh"
#include "AbsEventTag/AbsEventTag.hh"
#include "AbsEventTag/AbsEventTagBoolIter.hh"
#include "AbsEventTag/AbsEventTagIntIter.hh"
#include "AbsEventTag/AbsEventTagFloatIter.hh"
#include "BdbScribes/BdbEvtObjLocation.hh"
#include "BdbScribes/BdbEvtObjLocReg.hh"
#include "BdbEvent/BdbEventT.hh"
#include "BdbEvent/BdbEvent.hh"
#include "BdbEvent/BdbEventTag.hh"
#include "BdbEventStore/BdbAbsCollectionT.hh"
#include "BdbModules/BdbEventInput.hh"
#include "BdbModules/BdbEventOutput.hh"
#include "HepODBMS/tagdb/HepExplorableDescr.h"
#include "TagDataP/BdbTagTransient.hh"
#include "TagData/TagDescriptor.hh"
#include "TagDataP/TagAttribute.hh"

//-----------------------------------------------------------------------
// Local Macros, Typedefs, Structures, Unions and Forward Declarations --
//-----------------------------------------------------------------------

//              ----------------------------------------
//              -- Public Function Member Definitions --
//              ----------------------------------------

//----------------
// Constructors --
//----------------
BdbTagConverter::BdbTagConverter( const IfdKey & key,
                                  const string& comp,
                                  const string& hdr ,
                                  bool readAllTags,
                                  const vector<string>& tagsToSkip,
                                  bool keepPersistentTag,
                                  bool aUseOriginalDesc ) 
  : BdbAbsConverter( key, comp.c_str(), hdr.c_str() )
  , _readAllTags(readAllTags)
  , _keepPersistentTag(keepPersistentTag)
  , _tagsToSkip(0)
  , _useOriginal( aUseOriginalDesc )
{
  // fill hash table with tags to skip
  // only works if readAllTags is true
  size_t nEntries = tagsToSkip.size();
  if ( _readAllTags && nEntries > 0 ) {
    size_t nBuckets = 3;
    if ( nEntries > 4 ) {
      nBuckets = (int) (nEntries / 1.25); // allow some collisions
    }

    _tagsToSkip = new RWTValHashSet<RWCString>(&RWCString::hash, nBuckets);
    for (size_t i = 0; i<nEntries; i++ ) {
      _tagsToSkip->insert(RWCString(tagsToSkip[i].c_str()));
    }
  }
}

//--------------
// Destructor --
//--------------
BdbTagConverter::~BdbTagConverter()
{
  delete _tagsToSkip;
}

//-------------
// Methods   --
//-------------
    
//-------------
// Operators --
//-------------
// create the persistent object
bool
BdbTagConverter::output( AbsEvent* anEvent,
                         BdbEvtObjLocReg& registry,
                         BdbEventT& aEventT ) const
{
    bool result = true;
    // find the place to attach the object
    BdbHandle(BdbEventTag) thePTagH;
  
    // get the list from the transient event
    AbsEventTag* theTag = Ifd< AbsEventTag >::get( anEvent );

    if ( 0 == theTag ) {

       // nothing to do, return OK
       return true;
    }

    // create the output object and attach to persistent event
    BdbStatus status = ((BdbRef( BdbEvent )&)(aEventT.getPersistent()))->tag( thePTagH );
    if ( ! BdbIsNull( thePTagH ) ) {
      
       ErrMsg( fatal ) << "The persistent Tag already exists for this Event"
                       << ", can not write new data!"
                       << endmsg ;
       ::abort() ;
    }

    BdbRefAny theHint( this->getPrimaryHint() ) ;
    BdbRef( BdbEvent ) eventR( ((BdbRef( BdbEvent )&)(aEventT.getPersistent())) ) ;
    thePTagH = new (theHint) BdbEventTag( eventR );
    assert( ! BdbIsNull( thePTagH ) );

    // Locate the collection that the keys are going to be associated with
    BdbAbsCollectionT<BdbEventT>* theColl( 0 ) ;
    theColl = Ifd< BdbAbsCollectionT< BdbEventT > >::get( anEvent, 
                                                        BdbEventOutput::outputCollectionKey() );
    if ( ( 0 != theColl ) && ( ! theColl->isNull( ) ) ) {
      
        // Create the description if necessary
        theColl->createDescription( theColl->name( ) );
        BdbHandle(HepExplorableDescr) theDesc;
        BdbStatus status = theColl->description( theDesc );

        // Copy contents of the transient tag to the persistent tag. 

        // First define the keys & types
        const char* aKey;

        AbsEventTagBoolIter* boolIter = theTag->boolIter( );
        while ( boolIter->next( ) ) {
            aKey = boolIter->key( );
            TagAttribute<bool> boolKey( aKey, thePTagH, theDesc );
        }
        delete boolIter;

        AbsEventTagIntIter* intIter = theTag->intIter( );
        while ( intIter->next( ) ) {
            aKey = intIter->key( );
            TagAttribute<int> intKey( aKey, thePTagH, theDesc );
        }
        delete intIter;

        AbsEventTagFloatIter* floatIter = theTag->floatIter( );
        while ( floatIter->next( ) ) {
            aKey = floatIter->key( );
            TagAttribute<float> floatKey( aKey, thePTagH, theDesc );
        }
        delete floatIter;

        thePTagH->resize( theDesc );

        // Now define the values & save them in the tag
        bool aBool;
        boolIter = theTag->boolIter( );
        while ( boolIter->next( ) ) {
            aBool = boolIter->value( );
            aKey  = boolIter->key( );
            TagAttribute<bool> boolAttr( aKey, thePTagH, theDesc );
            boolAttr = aBool;
        }
        delete boolIter;

        int anInt;
        intIter = theTag->intIter( );
        while ( intIter->next( ) ) {
            anInt = intIter->value( );
            aKey  = intIter->key( );
            TagAttribute<int> intAttr( aKey, thePTagH, theDesc );
            intAttr = anInt;
        }
        delete intIter;

        float aFloat;
        floatIter = theTag->floatIter( );
        while ( floatIter->next( ) ) {
            aFloat = floatIter->value( );
            aKey   = floatIter->key( );
            TagAttribute<float> floatAttr( aKey, thePTagH, theDesc );
            floatAttr = aFloat;
        }
        delete floatIter;
    }

    // done, return OK
    return true;
}

// connect the persistent objects
bool
BdbTagConverter::fillRefs( AbsEvent* anEvent,
                                  BdbEvtObjLocReg& registry,
                                  BdbEventT& aEventT ) const
{
  bool result = true;
  return result;
}
    
// create the transient objects
bool
BdbTagConverter::input( AbsEvent* anEvent,
                        BdbEvtObjLocReg& registry,
                        BdbEventT& aEventT ) const
{
    bool result = false;
    BdbAbsCollectionT<BdbEventT>* theColl;
    BdbHandle(HepExplorableDescr) theDesc;
    BdbHandle(BdbEventTag) theTag;
  
    // locate the input object
    BdbStatus status = ((BdbRef( BdbEvent )&)(aEventT.getPersistent()))->tag( theTag );
    if ( ! BdbIsNull( theTag ) ) {

      // Check whether a transient tag already exists within the
      // event. If it does, it is not bound to the persistent
      // tag. This is a policy decision that needs to be reviewed
      AbsEventTag* transient = Ifd<AbsEventTag>::get( anEvent );
      if ( 0 == transient ) {
          
        // No transient tag exists within the event. Create it and
        // bind it to the persistent tag & descriptor.
          
        // Locate the collection that the keys are associated with
        theColl = 
          Ifd<BdbAbsCollectionT<BdbEventT> >::get( anEvent, 
                                              BdbEventInput::inputCollectionKey( ) );
        if ( ! theColl->isNull( ) ) {

          // Get tag descriptor from persistent event wrapper
          theDesc = aEventT.getCurrentTagDescr();
          if( _useOriginal ) {
             theDesc = aEventT.getOriginalTagDescr();
             if( theDesc.isNull() ) {
                ErrMsg( warning ) << "Can not assertain correct descriptor"
                                  << " for the tag, will used default!"
                                  << endmsg ;
             }
          }

          assert( ! BdbIsNull( theDesc ) );

          if ( _readAllTags ) {
            // fill in all tags
            transient = new TagTransient();

            size_t i;
            size_t offset;
            d_Boolean aBool;
            int       anInt;
            float     aFloat;
            HepExplorableFieldType type;

            size_t max = theDesc->noOfFields( );
            RWCString aName;
            for ( i = 0; i < max; i++ ) {
              aName = theDesc->getFieldNameById  ( i );
              if ( _tagsToSkip != 0 && _tagsToSkip->contains(aName) ) {
                // kill this tag
                continue;
              }

              type = theDesc->getFieldTypeById( i );
              switch( type ) {
              case eTypeBool:
              case eTypePackedBool:
                {
                  TagAttribute<bool> boolAttr(aName, theTag, theDesc);
                  aBool = boolAttr;
                  transient->putBool( aBool, aName );
                }
                break;
              case eTypeLong:
                {
                  TagAttribute<int> longAttr(aName, theTag, theDesc);
                  anInt = longAttr;
                  transient->putInt( anInt, aName );
                }
                break;
              case eTypeFloat:   
                {
                  TagAttribute<float> floatAttr(aName, theTag, theDesc);
                  aFloat = floatAttr;
                  transient->putFloat( aFloat, aName );
                }
                break;
              }
            }
          } else {
            transient = new BdbTagTransient( theTag, theDesc );
          }

          bool stat = Ifd<AbsEventTag>::put( anEvent, transient );
          assert( stat );
          
          // merge with defaults in TagDescriptor
          TagDescriptor* descriptor = TagDescriptor::instance();
          if ( !descriptor->processProxies(anEvent) ) {
            ErrMsg(error) << "Failed to declare all deferred tags" << endmsg;
          }
          descriptor->lock();
          result = transient->merge(descriptor, _keepPersistentTag);

          // lock the tag 
          if ( _readAllTags) static_cast<TagTransient*>(transient)->lock();

        }
      }
    }
    return result;
}

// connect the transient objects together
bool
BdbTagConverter::fillPointers( AbsEvent* anEvent,
                                      BdbEvtObjLocReg& registry,
                                      BdbEventT& aEventT ) const
{
  return true;
}
    
bool
BdbTagConverter::operator==( const BdbTagConverter& l ) const
{
  return this == & l; 
}

//-------------
// Selectors --
//-------------
    
//-------------
// Modifiers --
//-------------

//              -----------------------------------------------
//              -- Static Data & Function Member Definitions --
//              -----------------------------------------------

//              -------------------------------------------
//              -- Protected Function Member Definitions --
//              -------------------------------------------

int
BdbTagConverter::numberOfHintsRequired() const
{
   return ( 1 );
}

//              -----------------------------------------
//              -- Private Function Member Definitions --
//              -----------------------------------------

//              -----------------------------------
//              -- Internal Function Definitions --
//              -----------------------------------

 

---

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

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