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

                 

---

/BdbModules/BdbAbsLoad.cc

Go to the documentation of this file.

//--------------------------------------------------------------------------
// File and Version Information:
//      $Id: BdbAbsLoad.cc,v 1.2 2002/06/21 19:13:36 ryd Exp $
//
// Description:
//      Class BdbAbsLoad
//
// Environment:
//      Software developed for the BaBar Detector at the SLAC B-Factory.
//
// Author List:
//      Stephen J. Gowdy        Originator
//
// Copyright Information:
//      Copyright (C) 1997      University of Edinburgh
//
//------------------------------------------------------------------------
#include "BaBar/BaBar.hh"

//-----------------------
// This Class's Header --
//-----------------------

#include "BdbModules/BdbAbsLoad.hh"

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

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

//-------------------------------
// Collaborating Class Headers --
//-------------------------------

#include <algorithm>
#include <vector>
using std::vector;
#include "BbrStdUtils/BbrCollectionUtils.hh"


#include "BdbConverters/BdbConverterScribe.hh"
#include "BdbConverters/BdbAbsConverter.hh"
#include "BdbScribes/BdbConversionManager.hh"
#include "AbsEvent/AbsEvent.hh"
#include "ProxyDict/Ifd.hh"
#include "ErrLogger/ErrLog.hh"

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

static const char rscid[] = "$Id: BdbAbsLoad.cc,v 1.2 2002/06/21 19:13:36 ryd Exp $";

// Note when this class moves into BdbModules this should move
// into the BdbEventMerge module, and this class should reference that
// function.
const IfdStrKey&
BdbAbsLoad::primaryKey()
{
   static IfdStrKey* key = new IfdStrKey( "None" ) ;
   return( *key ) ;
}

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

//----------------
// Constructors --
//----------------
BdbAbsLoad::BdbAbsLoad( const char* const theName, 
                        const char* const theDescription )
  : AppModule( theName, theDescription ),
    _keyToSecondaryEvent( "keyToSecondaryEvent" ,
                          this ,
                          primaryKey().asString() ) ,
    _scribes( new vector< BdbGenericScribe* > ) ,
    _inputScribes( new vector< BdbGenericScribe* > ) ,
    _outputScribes( new vector< BdbGenericScribe* > ) ,
    _adaptedConverters( new vector< BdbConverterScribe* > )
{
   commands()->append( &_keyToSecondaryEvent ) ;
}

//--------------
// Destructor --
//--------------
BdbAbsLoad::~BdbAbsLoad()
{
  // Clean ourselves up
  delete _outputScribes ;
  delete _inputScribes ;
  std::for_each(_scribes->begin(),_scribes->end(),babar::Collection::DeleteObject());
  
  delete _scribes ;

  delete _adaptedConverters ;
}

//-------------
// Methods   --
//-------------
    
//-------------
// Operators --
//-------------
    
//-------------
// Selectors --
//-------------

BdbConverterScribe*
BdbAbsLoad::findConverterScribe( BdbAbsConverter* aConverter )
{
   // This should normally be called during "beginJob" therefore
   // a linear search should be sufficient. Moreover if the requested
   // BdbAbsConverter has already been adapted it is probably the last
   // (or one of the last) so a reverse search should locate it most
   // efficiently!
   BdbConverterScribe* result( 0 ) ;
   size_t adaptorIndex( _adaptedConverters->size() ) ;
   while( ( 0 != adaptorIndex ) &&
          ( 0 == result ) ) {
      --adaptorIndex ;
      if( (*_adaptedConverters)[ adaptorIndex ]->adaptsConverter( aConverter ) ) {
         result = (*_adaptedConverters)[ adaptorIndex ] ;
      }
   }

   return( result ) ;
}

//-------------
// Modifiers --
//-------------

void
BdbAbsLoad::addScribeForInput( BdbGenericScribe* aScribe )
{
   // If already added for input do nothing.
   if( std::find(_inputScribes->begin(),_inputScribes->end(),
                 aScribe )!=_inputScribes->end() ) {
      ErrMsg( warning ) << name()
                        << ": Attempting to add Scribe For Input more than"
                        << " once.\n"
                        << "\tWill ignore this attempt."
                        << endmsg ;
      return ;
   }
   _inputScribes->push_back( aScribe ) ;

   // If not already owned by this class, add to list of owned Scribes.
   if( std::find(_scribes->begin(),_scribes->end(), aScribe )==_scribes->end() ) {
      _scribes->push_back( aScribe ) ;
   }
}

void
BdbAbsLoad::addScribeForOutput( BdbGenericScribe* aScribe )
{
   // If already added for output do nothing.
   if( std::find(_outputScribes->begin(),_outputScribes->end(),
                 aScribe )!=_outputScribes->end() ) {
      ErrMsg( warning ) << name()
                        << ": Attempting to add Scribe For Output more than"
                        << " once.\n"
                        << "\tWill ignore this attempt."
                        << endmsg ;
      return ;
   }
   _outputScribes->push_back( aScribe ) ;

   // If not already owned by this class, add to list of owned Scribes.
   if( std::find(_scribes->begin(),_scribes->end(), aScribe )==_scribes->end() ) {
      _scribes->push_back( aScribe ) ;
   }
}


void
BdbAbsLoad::addConverter( BdbAbsConverter* aConverter )
{
// This can be infered from the "useForInput" and "useForOutput" functionns.
}

void
BdbAbsLoad::useForInput( BdbAbsConverter* aConverter )
{
   BdbConverterScribe* adaptedVersion( findConverterScribe( aConverter ) ) ;

   // If Converter has not been adapted make necessary adaptor.
   if( 0 == adaptedVersion ) {
      adaptedVersion = new BdbConverterScribe( aConverter ) ;
      _adaptedConverters->push_back( adaptedVersion ) ;
   }

   addScribeForInput( adaptedVersion ) ;
}

void
BdbAbsLoad::useForOutput( BdbAbsConverter* aConverter )
{
   BdbConverterScribe* adaptedVersion( findConverterScribe( aConverter ) ) ;

   // If Converter has not been adapted make necessary adaptor.
   if( 0 == adaptedVersion ) {
      adaptedVersion = new BdbConverterScribe( aConverter ) ;
      _adaptedConverters->push_back( adaptedVersion ) ;
   }

   addScribeForOutput( adaptedVersion ) ;
}

AppResult
BdbAbsLoad::event( AbsEvent* anEvent )
{
   if ( _verbose.value() ) {
      ErrMsg( trace ) << name()
                      << " event"
                      << endmsg ;
   }

   AbsEvent* eventToUse( anEvent ) ;

   // If key is set to a secondary event get that event
   if( primaryKey() != _keyToSecondaryEvent.value() ) {
      eventToUse = Ifd< AbsEvent >::get( anEvent ,
                                         _keyToSecondaryEvent.value() ) ;
   }

   // Get conversion manager from transient event
  BdbConversionManager* conversionManager( 0 ) ;
  conversionManager = Ifd< BdbConversionManager >::get( eventToUse ) ;
  if ( 0 == conversionManager ) {
      ErrMsg( fatal ) << name()
                      << ": failed to find ConversionManager in Event."
                      << endmsg ;
      ::abort() ;
  }

  // If there are no Scribes registered for input finish.
  if( ( _inputScribes->empty() ) &&
      ( _outputScribes->empty() ) ){
     return AppResult::OK ;
  }

  // Otherwise add scribes to ConversionManager
  size_t finishedInput( _inputScribes->size() ) ;
  for( size_t inputIndex( 0 ) ;
       finishedInput != inputIndex ;
       ++inputIndex ) {
     conversionManager->addScribeForInput( *((*_inputScribes)[ inputIndex ]) ) ;
  }

  size_t finishedOutput( _outputScribes->size() ) ;
  for( size_t outputIndex( 0 ) ;
       finishedOutput != outputIndex ;
       ++outputIndex ) {
     conversionManager->addScribeForOutput( *((*_outputScribes)[ outputIndex ]) ) ;
  }

  return AppResult::OK ;
}

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

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

//              -----------------------------------------
//              -- 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