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

                 

---

/BdbScribes/BdbConversionManager.cc

Go to the documentation of this file.

#if !defined(BDBCONVERSIONMANAGER_CC)
#define BDBCONVERSIONMANAGER_CC
//--------------------------------------------------------------------------
// File and Version Information:
//      $Id: BdbConversionManager.cc,v 1.17 2002/07/03 05:54:10 ryd Exp $
//
// Description:
//      Class BdbConversionManager
//
// Environment:
//      Software developed for the BaBar Detector at the SLAC B-Factory.
//
// Author List:
//      Simon Patton            Originator
//
// Copyright Information:
//      Copyright (C) 1999      LBNL
//
//------------------------------------------------------------------------

//-----------------------
// This Class's Header --
//-----------------------
#include "BdbScribes/BdbConversionManager.hh"

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

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

//----------------
// BaBar Header --
//----------------
#include "BaBar/BaBar.hh"

//-------------------------------
// Collaborating Class Headers --
//-------------------------------
#include "BdbScribes/BdbGenericScribe.hh"
#include "BdbScribes/BdbEvtObjLocReg.hh"
#include "BdbUtil/Bdb.hh"
#include <vector>
using std::vector;
#include <algorithm>

//------------------------------------
// Collaborating Class Declarations --
//------------------------------------

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

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

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

//----------------
// Constructors --
//----------------

BdbConversionManager::BdbConversionManager( size_t*& aHighestInputCount ,
                                            size_t*& aHighestOutputCount )
   : _inputScribes( new vector< BdbGenericScribe* > ) ,
     _inputRegistry( new BdbEvtObjLocReg( aHighestInputCount ) ) ,
     _outputScribes( new vector< BdbGenericScribe* > ) ,
     _bulkOutputRegistry( new BdbEvtObjLocReg( aHighestOutputCount ,
                                               _inputRegistry ) ),
     _outputRegistry( new BdbEvtObjLocReg( aHighestOutputCount ,
                                           _bulkOutputRegistry ) ),
     _aHighestOutputCount( aHighestOutputCount )
{
}

// BdbConversionManager::BdbConversionManager( const BdbConversionManager& aRhs )
// {
// }

//--------------
// Destructor --
//--------------

BdbConversionManager::~BdbConversionManager()
{
   // Reset all the Scribes as this manager no longer manages them.
   const size_t finishedOutput( _outputScribes->size() ) ;
   for ( size_t outScribeCount( 0 ) ;
         finishedOutput != outScribeCount ;
         ++outScribeCount ) {
      BdbGenericScribe* scribe( (*_outputScribes)[ outScribeCount ] ) ;
      if( std::find(_inputScribes->begin(),_inputScribes->end(),scribe)==_inputScribes->end() ) {
         scribe->reset() ;
         scribe->removeManager( this ) ;
      }
   }
   _outputScribes->clear();
   delete _outputScribes ;
   delete _bulkOutputRegistry ;
   delete _outputRegistry ;

   size_t finishedInput( _inputScribes->size() ) ;
   for ( size_t inScribeCount( 0 ) ;
         finishedInput != inScribeCount;
         ++inScribeCount ) {
      BdbGenericScribe* scribe( (*_inputScribes)[ inScribeCount ] ) ;
      scribe->reset() ;
      scribe->removeManager( this ) ;
   }
   _inputScribes->clear();
   delete _inputScribes ;
   delete _inputRegistry;
}

//-------------
// Operators --
//-------------
    
// const BdbConversionManager& BdbConversionManager::operator=( const BdbConversionManager& aRhs )
// {
// }

//-------------
// Selectors --
//-------------

bool
BdbConversionManager::convertToPersistent( const AbsEvent& aTEvent ,
                                           const BdbAbsPlacementManager& aPlacementManager ,
                                           BdbEventT& aPEvent ,
                                           bool aReplacePersistentMappings,
                                           bool notBulk ) const
{
   bool success( true ) ;

   if ( aReplacePersistentMappings ) {
     _bulkOutputRegistry->setReplaceMode() ;
     _outputRegistry->setReplaceMode() ;
   }

   const size_t finishedOutput( _outputScribes->size() ) ;
   size_t outScribeCount( 0 ) ;
   for ( outScribeCount = 0 ;
         finishedOutput != outScribeCount ;
         ++outScribeCount ) {
     BdbGenericScribe* aScribe = (*_outputScribes)[ outScribeCount ];
     BdbEvtObjLocReg* regToUse = 0;
     bool isBulk = aScribe->isBulk( aPlacementManager );
     if ( isBulk ) regToUse = _bulkOutputRegistry;
     else          regToUse = _outputRegistry;

     if ( !(notBulk && isBulk) ) // check we want to write bulk
       {
         bool result( aScribe->attemptPersistent( aTEvent ,
                                                  aPlacementManager ,
                                                  aPEvent ,
                                                  *regToUse ) ) ;
         // If no failures up until now then update success flag.
         if ( success ) {
           success = result ;
         }
       }
   }

   for ( outScribeCount = 0 ;
         finishedOutput != outScribeCount ;
         ++outScribeCount ) {
     BdbGenericScribe* aScribe = (*_outputScribes)[ outScribeCount ];
     bool isBulk = aScribe->isBulk( aPlacementManager );
     if ( !(notBulk && isBulk) ) // check we want to write bulk
       {
         bool result( (*_outputScribes)[ outScribeCount ]->fillRefs() ) ;

         // If no failures up until now then update success flag.
         if ( success ) {
           success = result ;
         }
       }
   }

   _bulkOutputRegistry->clearReplaceMode() ;
   _outputRegistry->clearReplaceMode() ;

   return( success ) ;
}

bool
BdbConversionManager::convertToTransient( const BdbEventT& aPEvent ,
                                          AbsEvent& aTEvent ) const
{
   bool success( true ) ;

   const size_t finishedInput( _inputScribes->size() ) ;
   size_t inScribeCount( 0 ) ;
   for ( inScribeCount = 0 ;
         finishedInput != inScribeCount ;
         ++inScribeCount ) {
      bool result ( (*_inputScribes)[ inScribeCount ]->attemptTransient( aPEvent ,
                                                                         aTEvent ,
                                                                         *_inputRegistry ) ) ;

      // If no failures up until now then update success flag.
      if ( success ) {
         success = result ;
      }
      
   }

   for ( inScribeCount = 0 ;
         finishedInput != inScribeCount ;
         ++inScribeCount ) {
      bool result( (*_inputScribes)[ inScribeCount ]->fillPointers() ) ;

      // If no failures up until now then update success flag.
      if ( success ) {
         success = result ;
      }
   }
   return( success ) ;
}

bool
BdbConversionManager::outputRequired() const
{
   return( 0 != _outputScribes->size() ) ;
}

bool
BdbConversionManager::inputRequired() const
{
   return( 0 != _inputScribes->size() ) ;
}

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

void
BdbConversionManager::addScribeForOutput( BdbGenericScribe& aScribe )
{
   _outputScribes->push_back( &aScribe ) ;
   aScribe.addManager( this ) ;
}

void
BdbConversionManager::removeScribeForOutput( BdbGenericScribe& aScribe )
{
  vector< BdbGenericScribe* >::iterator pos=std::find(_outputScribes->begin(),_outputScribes->end(), &aScribe);
  if (pos!=_outputScribes->end()){
   _outputScribes->erase(pos) ;
  }
  if( std::find(_inputScribes->begin(),_inputScribes->end(),&aScribe )==_inputScribes->end() ) {
    aScribe.removeManager( this ) ;
  }
}

void
BdbConversionManager::addScribeForInput( BdbGenericScribe& aScribe )
{
   _inputScribes->push_back( &aScribe ) ;
   aScribe.addManager( this ) ;
}

void
BdbConversionManager::removeScribeForInput( BdbGenericScribe& aScribe )
{
  vector< BdbGenericScribe* >::iterator pos=std::find(_inputScribes->begin(),_inputScribes->end(), &aScribe);
  if (pos!=_inputScribes->end()){
   _inputScribes->erase(pos) ;
  }
   if( std::find(_outputScribes->begin(),_outputScribes->end(),&aScribe )==_outputScribes->end() ) {
      aScribe.removeManager( this ) ;
   }
}

bool
BdbConversionManager::resetOutputRegistry( BdbCMResetLevel resetLevel,
                                           const BdbAbsPlacementManager& placement )
{
  assert( resetLevel == full || resetLevel == partial );

  // Delete old registry
  delete _outputRegistry;
  _outputRegistry = 0;

  if ( resetLevel == full )
    {
      // Delete old registry
      delete _bulkOutputRegistry;
      _bulkOutputRegistry = 0;

      // Create new one
      _bulkOutputRegistry = new BdbEvtObjLocReg( _aHighestOutputCount,
                                                 _inputRegistry );
      assert( _bulkOutputRegistry != 0 );

      // As we've reset the output registry we also need to reset the output
      // scribes
      size_t i=0, length=_outputScribes->size();
      for ( i=0; i<length; i++ ) (*_outputScribes)[i]->reset();
    }
  else
    {
      // As we've reset the output registry we also need to reset the output
      // scribes which are used at the micro/mini level
      size_t i=0, length=_outputScribes->size();
      for ( i=0; i<length; i++ )
        {
          BdbGenericScribe* aScribe = (*_outputScribes)[i];
          if ( !aScribe->isBulk( placement ) ) aScribe->reset();
        }
    }

  // Create new one
  _outputRegistry = new BdbEvtObjLocReg( _aHighestOutputCount,
                                         _bulkOutputRegistry );
  assert( _outputRegistry != 0 );

  return true;
}

#endif // BDBCONVERSIONMANAGER_CC

 

---

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

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