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

                 

---

/Framework/src/APPFramework.cc

Go to the documentation of this file.

//--------------------------------------------------------------------------
// File and Version Information:
//      $Id: APPFramework.cc,v 1.97 2002/08/19 19:32:10 desilva Exp $
//
// Description:
//      Class APPFramework. This is the overall framework for the BaBar
//      analysis framework. It controls the creation of sequences and
//      paths and the processing of events.
//
// Environment:
//      Software developed for the BaBar Detector at the SLAC B-Factory.
//
// Author List:
//      David R. Quarrie                Original Author
//      Marc Turcotte                   Introduced Actions '97
//                                      Removed dependency on DbiEvent 6/97
//                                      Enabled/modified other entry  12/97
//                                      Modified for new style begin/end 2/98
//      Marc Turcotte                   Added new style event 2/23
//      Marc Turcotte                   Added Dynamic Dispatch support 3/98
//                                      This work is done in collaboration
//                                      with CLEO.
//      Marc Turcotte                   Introduced AppStopType 3/20/98
//      Marc Turcotte                   Let zero frame thru frame()
//                                      so that null goes to module
//                                      which can have overriden the
//                                      frame() function and be a
//                                      provider instead of a consumer 4/8/98
//      Marc Turcotte                   Introduced ActionControllers 4/14/98
//      Marc Turcotte                   Introduced static _theFrame init 
//                                      4/30/98
//      Marc Turcotte                   Introduced static _theAbsEvent init
//                                      but /* */ it for migration 4/30/98
//      Marc Turcotte                   Introduced theEvent() & zeroTheEvent()
//                                      4/30/98
//      Marc Turcotte                   Merged in R.Kapur's TK interface 5/98
//      Marc Turcotte                   Added _TkInterface init 6/18/98
//      Marc Turcotte                   Modified for AppResult 6/19/98
//      Marc Turcotte                   Added theDispatchStopType to
//                                      signatures 6/23/98
//      Marc Turcotte                   Changed AppResult for AppResult 6/23/98
//      Marc Turcotte                   Changed for new AbsEvent sigs 6/24/98
//      Marc Turcotte                   Migrated setupTheApp from APPMain 
//                                      7/28/98
//      Marc Turcotte                   Introduced non const heap temporaries
//                                      moduleName, pathName and execName 
//                                      copied into for safety reasons. 7/30/98
//      Marc Turcotte                   Added arg list to setupTheApp 8/6/98
//      Marc Turcotte                   Removed call to other(...) from
//                                      continueHandler(...) 9/23/98
//      A. De Silva                     Actions made to work on input & output
//                                      modules. 6/24/99
//
// Copyright Information:
//      Copyright (C) 1994, 1995        Lawrence Berkeley Laboratory
//      Copyright (C) 1997, 1998        University of Texas at Dallas
//
//------------------------------------------------------------------------
#include "Experiment/Experiment.hh"

//-------------------------------
// Collaborating Class Headers --
//-------------------------------
#ifdef CDF
#include "FrameUtil/AppActionTime.hh"
#include "FrameUtil/AppActionHistoDir.hh"
class AbsEvent;
class AppRun;
#else
#include "Framework/AppAction.hh"
#include "AbsEvent/AbsEvent.hh"
#endif
//-----------------------
// This Class's Header --
//-----------------------
#include "Framework/APPFramework.hh"
// note the above header now includes AbsCommandMemento.hh which in 
// turn includes iostream.h.  Including iostream.h is a very heavy thing
// to do and a consequence is that this APPFramework must be ordered after
// the timer stuff. -LSK
#include "Framework/APPExecNode.hh"
#include "Framework/APPPath.hh"
#include "Framework/APPSequence.hh"
#include "Framework/APPInputModule.hh"
#include "Framework/APPOutputModule.hh"
#include "Framework/AppAccountModule.hh"
#include "Framework/AppFileOutputModule.hh"
#include "Framework/APPCommand.hh"
#include "Framework/APPEventsCommand.hh"
#include "Framework/APPModuleCommand.hh"
#include "Framework/APPPathCommand.hh"
#include "Framework/APPSequenceCommand.hh"
#include "Framework/AppActionCommand.hh"
#include "Framework/APPHash.hh"

#include "Framework/APPJob.hh"
#include "Framework/APPRun.hh"

#ifdef CDF
#include "AbsEnv/AbsEnv.hh"
#endif

#include "Framework/AppActionController.hh"

#include "FrameUtil/APPList.hh"
#include "FrameUtil/APPListIterator.hh"

#include "FrameUtil/AbsInterp.hh"

//-------------
// C Headers --
//-------------
#include <assert.h>
#include <stddef.h>
#include <stdio.h>
#include <string.h>
#include <strstream.h>

//---------------
// C++ Headers --
//---------------
#include <iostream.h>

#ifndef CDF
#include "CommonUtils/ComPathNameSearch.hh"
#include "CommonUtils/ComTimeStamp.hh"
#endif

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


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

//-----------------------
// Static Initializers --
//-----------------------

AppFrame*   AppFramework::_theFrame              = 0;
AppStopType AppFramework::_theDispatchStopType   = AppStopType::never_assigned;

/******************************************************

Migration code of 4/30/98 is ready below:

AbsEvent* AppFramework::_theAbsEvent             = 0;

*******************************************************/

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

AppFramework::AppFramework( int argc, char* argv[] )
#ifdef CDF
    : APPNoCloneModule( "Framework/AC++", "Application Framework" ),
#else
    : APPNoCloneModule( "AppFrame", "Application Framework" ),
#endif
      _exitRequested  ( false ),
      _theOutputModule( 0 ),
      _isBegun        ( false ),
      _indentLevel    ( 0 ),
      _maxNameLength  ( 0 ),
      _argc           ( argc ),
      _argv           ( argv ),
      _stopRequested  ( false ),
      _eventsCmd( "events"  , this ),
      _moduleCmd( "module"  , this ),
      _pathCmd( "path"    , this ),
      _sequenceCmd( "sequence", this ),
      _configCmd( "config"     , this ),
      _actionCmd("action",this),
      _theAccountModule(0)
  {

    _execType        = APP_framework;
    setFramework ( this );

    _executables     = new APPHash< APPExecutable >;

    _execNodes       = new APPList< APPExecNode* >;
    _modules         = new APPList< AppModule* >;
    _paths           = new APPList< APPPath* >;
    _sequences       = new APPList< APPSequence* >;
    _cloneList       = new APPList< AppCloneRecorder *>;
  
    _inputModules    = new APPList< APPInputModule* >;
    _outputModules   = new APPList< APPOutputModule* >;
    _accountModules    = new APPList< AppAccountModule* >;

    _localInputModule = _theInputModule  =
    new APPInputModule("DummyInput","dummy input module");

    add( _theInputModule );

    _localOutputModule = _theOutputModule = new AppFileOutputModule;
    add( _theOutputModule );

    _defaultPath = new APPPath( "AllPath", "Default (all modules) path" );
    _defaultPath->setEnabled( false );
    add( _defaultPath );

#ifdef CDF
    setPrompt( "AC++> " );
#else
    setPrompt( "> " );
#endif
    commands( )->append(&_eventsCmd);
    commands( )->append(&_moduleCmd);
    commands( )->append(&_pathCmd);
    commands( )->append(&_sequenceCmd);
    commands( )->append(&_configCmd);
    commands( )->append(&_actionCmd);

    _actions = new APPList<AppAction*>; // Holds the list of Actions
    _theActionControllers = new APPList<AppActionController*>;

    // Grab bag of AppMethods. This is not the Module hash table...
    _theAppMethodsGrabBag =  new APPList<AppMethodBase*>;

    // Create an Abstract Interpreter by calling it's class static
    // instance method.  The AbsInterp follows an extension of the
    // singleton pattern.  Note that class statics are similar to globals
    // in that one can gain access to the single instance from anywhere in
    // the program by calling AbsInterp::theInterpreter( ).
    AbsInterp* interp = AbsInterp::theInterpreter( );

#ifdef CDF
    // The AbsEnv is now also a singleton, but for backward compatibility
    // we will maintain the global pointer to it, for a bit longer...
    gblEnv = AbsEnv::theAbsEnv( );
#endif
}

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

AppFramework::~AppFramework( )
{
    delete _executables;

    APPListDeleteAll(*_execNodes);
    delete _execNodes;

    APPListDeleteAll(*_modules, this, "module");
    delete _modules;

    APPListDeleteAll(*_paths, this, "path");
    delete _paths;

    APPListDeleteAll(*_sequences, this, "sequence");
    delete _sequences;

    APPListDeleteAll(*_inputModules, this, "input module");
    delete _inputModules;

    APPListDeleteAll(*_outputModules, this, "output module");
    delete _outputModules;

    APPListDeleteAll(*_accountModules, this, "account module");
    delete _accountModules;

    APPListDeleteAll(*_actions, this, "action");
    delete _actions;

    APPListDeleteAll(*_theActionControllers);
    delete _theActionControllers;

    APPListDeleteAll(*_theAppMethodsGrabBag);
    delete _theAppMethodsGrabBag;
    
    APPListDeleteAll(*_cloneList);
    delete _cloneList;

    // Delete the singletons:
#ifdef CDF
    delete AbsEnv::theAbsEnv( );
#endif
    delete AbsInterp::theInterpreter( );

}

//--------------
// Operations --
//---------------

AbsEvent*
AppFramework::theEvent() const { return _theAbsEvent; }

void AppFramework::zeroTheEvent() {
  if (0 != _theAbsEvent) {
    delete _theAbsEvent;
    _theAbsEvent=0;
  }
}

AppResult
AppFramework::beginJob( AbsEvent* anEvent )
{
    AppModule** mod;
    AbsEvent* nullEvent = 0;

  // Build a list with Input, Output and App Modules all stored
  // as AppModules (common base class)

  APPList<AppModule*> allAsModules;
  buildModuleList( allAsModules, *inputModules() );
  buildModuleList( allAsModules, *outputModules() );
  buildModuleList( allAsModules, *modules() );
  buildModuleList( allAsModules, *accountModules() );

  // Now use that list to give beginJob to those modules

  APPListIterator<AppModule*> iter1( allAsModules );
  APPListIterator<AppActionController*> itr(*actionControllers());
  while ( mod = (AppModule**)iter1( ) ) {
    if ( (*mod)->isEnabled( ) && ! (*mod)->isInitialized( ) ) {
      AppActionController** anActionController;
      itr.rewind();
      while ( anActionController=itr.next() ) {                    
        (*anActionController)->beforeBeginJob(*mod,anEvent);
      }
      (*mod)->beginJob( anEvent );
      (*mod)->setInitialized( );
      itr.rewind();
      while ( anActionController=itr.next() ) {
        (*anActionController)->afterBeginJob(*mod,anEvent);
      }
    }
  }
  
  if ( 0 != theInputModule( ) ) {
    theInputModule( )->beginRun( nullEvent );
  }
  if ( 0 != theOutputModule( ) && theOutputModule()->isEnabled()) {
    theOutputModule( )->beginRun( nullEvent );
  }
  
  return AppResult::OK;
  
}

AppResult
AppFramework::beginRun( AbsEvent* anEvent )
{
  AppModule** mod;

  // Build a list with Input, Output and App Modules all stored
  // as AppModules (common base class)
  APPList<AppModule*> allAsModules;
  buildModuleList( allAsModules, *inputModules() );
  buildModuleList( allAsModules, *modules() );
  buildModuleList( allAsModules, *outputModules() );
  buildModuleList( allAsModules, *accountModules() );

  // Now use that list to give beginRun to those modules

  APPListIterator<AppModule*> iter1( allAsModules );
  APPListIterator<AppActionController*> itr(*actionControllers());
  while ( mod = (AppModule**)iter1( ) ) {
    if ( (*mod)->isEnabled( ) ) {
      AppActionController** anActionController;
      itr.rewind();
      while ( anActionController=itr.next() ) {
        (*anActionController)->beforeBeginRun(*mod,anEvent);
      }
      (*mod)->beginRun( anEvent );
      itr.rewind();
      while ( anActionController=itr.next() ) {
        (*anActionController)->afterBeginRun(*mod,anEvent);
      }
    }
  }

  return AppResult::OK;
  
}

AppResult
AppFramework::frame( AppFrame* aFrame,
                     const AppStopType& theDispatchStopType ) { // Dynamic dispatch

  APPPath** path;

  resetNodes( );          // This will do all the nodes "again" but _no_ standard member functions
                          // will be called; the user is expected to NOT bind those... Beware...
  resetAppMethods(false); // Reset the AppMethods for this event

  APPListIterator<APPPath*> theIterator( *paths( ) );
  AppResult theResult = AppResult::OK;
  while ( path = theIterator( ) ) {
    if ( (*path)->isEnabled( ) ) {
      theResult=(*path)->frame( aFrame, theDispatchStopType );
    }
  }

  return theResult.value();

}

AppResult
AppFramework::accountEvent(AbsEvent*& theEvent)
{
  if ( 0 != theAccountModule( )  && theAccountModule()->isEnabled() ) {
    APPListIterator<AppActionController*> itr1( *actionControllers() );
    AppActionController** anActionController;
    while ( anActionController=itr1.next() ) {
      (*anActionController)->beforeEvent(theAccountModule(),theEvent);
    }
    itr1.rewind();
    theAccountModule( )->accountEvent( theEvent );
    while ( anActionController=itr1.next() ) {
      (*anActionController)->afterEvent(theAccountModule(),theEvent);
    }
  }
  return AppResult::OK;
}


AppResult
AppFramework::outputEvent(AbsEvent* theEvent)
{
  if ( 0 != theOutputModule( )  && theOutputModule()->isEnabled() )    {
    APPListIterator<AppActionController*> itr1( *actionControllers() );
    AppActionController** anActionController;
    while ( anActionController=itr1.next() ) {
      (*anActionController)->beforeEvent(theOutputModule(),theEvent);
    }
    itr1.rewind();
    theOutputModule( )->outputEvent( theEvent );
    while ( anActionController=itr1.next() ) {
      (*anActionController)->afterEvent(theOutputModule(),theEvent);
    }
  }
  return AppResult::OK;
}

AppResult
AppFramework::event( AbsEvent* anEvent )
{
    APPPath** path;

    assert ( 0 != anEvent );

    resetNodes( );

    APPListIterator<APPPath*> theIterator( *paths( ) );
    while ( path = theIterator( ) ) {
                if ( (*path)->isEnabled( ) ) {
                        (*path)->event( anEvent );
                }
    }
    return AppResult::OK;
}

AppResult
AppFramework::other( AbsEvent* anOther )
{

// As per request of Online, make "other run like path" meaning
// that Framework::other(AbsEvent*) should act like
// Framework::event(AbsEvent*) and not be called on disabled modules
// and be called in "path order". M. Turcotte 12/2/97
// This "other" deal will be phased out in favor of
// frames. 6/25/98


    APPPath** path;
    assert ( 0 != anOther );

    resetNodes( );
    APPListIterator<APPPath*> theIterator( *paths( ) );
    while ( path = theIterator( ) ) {
                if ( (*path)->isEnabled( ) ) {
                        (*path)->other( anOther ); // "other" processing...
                }
    }

    return AppResult::OK;

}

AppResult
AppFramework::endRun( AbsEvent* anEvent )
{
  AppModule** mod;
  
  //  Assertion removed because of the use case when the user
  //  ends the run without beginning.
  //  M. Turcotte, UTDallas, 2/13/98
  //
  //    assert ( 0 != anEvent );
  
  // Build a list with Input, Output and App Modules all stored
  // as AppModules (common base class)
  APPList<AppModule*> allAsModules;
  buildModuleList( allAsModules, *modules() );
  buildModuleList( allAsModules, *inputModules() );
  buildModuleList( allAsModules, *outputModules() );
  buildModuleList( allAsModules, *accountModules() );
  
  // Now use that list to give endRun to those modules

  APPListIterator<AppModule*> theIterator( allAsModules );
  APPListIterator<AppActionController*> itr(*actionControllers());
  while ( mod = theIterator( ) ) {
    if ( (*mod)->isEnabled( ) && (*mod)->isInitialized( ) ) {      
      AppActionController** anActionController;      
      itr.rewind();
      while ( anActionController=itr.next() ) {
        (*anActionController)->beforeEndRun(*mod,anEvent);
      }
      (*mod)->endRun( anEvent );      
      itr.rewind();
      while ( anActionController=itr.next() ) {
        (*anActionController)->afterEndRun(*mod,anEvent);
      }
    }
  }   
  return AppResult::OK;

}

AppResult
AppFramework::endJob( AbsEvent* anEvent )
{
  AppModule** mod;

 //   This assertion had to be removed because of the use
 //   case when the use just starts up the framework and
 //   then quits without begining...
 //   M. Turcotte, UTDallas, 2/13/98
 //
 //   assert ( 0 != anEvent );  

  // Build a list with Input, Output and App Modules all stored
  // as AppModules (common base class)
  APPList<AppModule*> allAsModules;
  buildModuleList( allAsModules, *modules() );
  buildModuleList( allAsModules, *inputModules() );
  buildModuleList( allAsModules, *outputModules() );
  buildModuleList( allAsModules, *accountModules() );

  // Now use that list to give beginJob to those modules

  APPListIterator<AppModule*> theIterator( allAsModules );
  APPListIterator<AppActionController*> itr(*actionControllers());
  while ( mod = theIterator( ) ) {
    if ( (*mod)->isEnabled( ) && (*mod)->isInitialized( ) ) {     
      AppActionController** anActionController;      
      itr.rewind();
      while ( anActionController=itr.next() ) {
        (*anActionController)->beforeEndJob(*mod,anEvent);
      }
      (*mod)->endJob( anEvent );
      itr.rewind();
      while ( anActionController=itr.next() ) {
        (*anActionController)->afterEndJob(*mod,anEvent);
      }
    }   
  }

  return AppResult::OK;
  
}

AppResult
AppFramework::abortJob( AbsEvent* anEvent )
{
    AppModule** mod;

//  Assertion removed because of a use case when the
//  user aborts without beginning...
//  M. Turcotte, UTDallas, 2/13/98
//
//    assert ( 0 != anEvent );

    APPListIterator<AppModule*> theIterator( *modules( ) );
    while ( mod = theIterator( ) ) {
                if ( (*mod)->isEnabled( ) && (*mod)->isInitialized( ) ) {
                        (*mod)->abortJob( anEvent );
                }
    }
    if ( 0 != theOutputModule( ) && theOutputModule()->isEnabled() ) {
                theOutputModule( )->abortJob( anEvent );
    }

    return AppResult::OK;

}

void
AppFramework::talkTo( )
{
  AbsInterp* interp = AbsInterp::theInterpreter( );
  assert( interp->isInitialized( ) );
  
#ifndef CDF
  interp->runCommandFile((const char*) 
               ComPathNameSearch("Framework/Framework/BaBar_FrameworkRc.tcl"));
#endif
  
  _exitRequested = false;
  enableCommands( );
  
  
  if ( 2 <= _argc )
    {
      interp->runCommandFile( _argv[1] );
    }
  
  while ( ! _exitRequested )
    {
      interp->startInterpLoop( );
    }
#ifdef CDF
  endJob( AbsEnv::theJobRecord( ) );
#else
  // We cannot do this in BaBar since (from gpdf)
  // OEP and OPR jobs do all their event processing after talkTo()
  // endJob( _theAbsEvent );
#endif
  disableCommands( );

}

void
AppFramework::help( int argc, char** argv )
{
   AppModule::help( argc, argv );
   if ( argc == 1 )
   {
      fullReport("");
      fullReport( "For more information on a particular command type '<command> help'." );
      fullReport( "A minimal set to select an input file and run 5 events is:");
      fullReport( "    module talk FileInput");
      fullReport( "      input file <your_file>");
      fullReport( "      exit");
      fullReport( "    ev begin -nev 5");
      fullReport( "    exit");
      fullReport("");
      fullReport("A script can also be specified as the first argument when running the program.");
      fullReport("");
      fullReport( "In addition the following command aliases can also be used." );
      fullReport( "" );
      fullReport( "Alias: Command Equivalent:" );
      AbsInterp* interp = AbsInterp::theInterpreter( );
      interp->simulateInput( "alias" );
   }
}

void
AppFramework::show( int argc, char** argv ) const
{
   AbsInterp* interp = AbsInterp::theInterpreter( );
   FwkString argStr;
   if ( argc > 1 )
   {
      argStr = argv[1];  // Just use first arg.
   }
   else
   {
      argStr = " ";      // No args means show everything
   }
   if (( argc == 1 ) || (argStr == "module"))
   {
      fullReport   ( "**** Listing of all available modules ****" );
      fullReport   ( " " );
      interp->simulateInput( "module list" );
   }
   if (( argc == 1 ) || (argStr == "path"))
   {
      fullReport   ( " " );
      fullReport   ( "**** Listing of all defined paths ****" );
      fullReport   ( " " );
      interp->simulateInput( "path list" );
   }
   if (( argc == 1 ) || (argStr == "par"))
     {
       fullReport   ( " " );
       fullReport   ( "**** Current value of items in the Framework ****");
       fullReport   ( " " );
       APPCommand** command;
       APPListIterator<APPCommand*> theIterator( *commands( ) );
       while ( command = theIterator( ) ) {     
         if ( (*command)->isShowable( ) ) {        
           partialReport( "      " );
           (*command)->show( );
         }
       }      
     }
   if (( argc == 1 ) || (argStr == "timer"))
   {
      APPListIterator<AppAction*> iter( *actions( ) );
      AppAction** anAction;
      while ( anAction=iter( ) )
      {  // The Framework timer action is defualt constructed with this name
         if ( (*anAction)->name( ) == "Timer Action" )
         {
            if ( argc == 1 )
            {
               (*anAction)->report( false );
            }
            else
            {
               (*anAction)->report( true );
            }
         }
      }
   }
}

void
AppFramework::exit( )
{
    _exitRequested = true;
    AbsInterp* interp = AbsInterp::theInterpreter( );
    interp->setDoLoopInterp(false);   // terminate interpreter loop
}

void
AppFramework::beginHandler( int nEvents )
{
  if (0 != _theAbsEvent) {
    delete _theAbsEvent;
    _theAbsEvent         = 0;
  }
  _theFrame            = 0;
  _theDispatchStopType = AppStopType::never_assigned;

//-----------------------------------------------------------------------
//  This code will not work (for events) until we change the logic of input modules
//  and putting it in would require moving the input call in the main event loop to
//  _after_ the walk and output calls. But if this could be done, it would allow having
//  an event or frame in hand to be handed over to beginJob.
//
//    if ( 0 != theInputModule() ) {
//      if ( _enableFrames.value() ) {
//        AppResult theResult = theInputModule()->inputFrame( _theFrame, _theDispatchStopType ); // Get a frame in...
//      } else {
//        AppResult theResult = theInputModule()->inputEvent( _theAbsEvent );                    // Get an event in...
//      }
//    }
//-----------------------------------------------------------------------

#ifdef CDF
    beginJob( AbsEnv::initJobRecord( ) );
#else
    beginJob( _theAbsEvent );
#endif
    _isBegun = true;

    continueHandler( nEvents );
}

void
AppFramework::continueHandler( int nEvents )
{

  int number=0;
  int numberOfFrames=0;
  
  if ( ! _isBegun ) {    
    if (0 != _theAbsEvent) {
      delete _theAbsEvent;
      _theAbsEvent = 0;
    }
    _theFrame    = 0;
    _theDispatchStopType = AppStopType::never_assigned;
    
//**********************************************************************************************************************
//  This code will not work until we change the logic of input modules in BaBar
//  and putting it in would require moving the input call in the main event loop to
//  _after_ the walk and output calls. But if this could be done, it would allow having
//  an event or frame in hand to be handed over to beginJob.
//
//      _theAbsEvent         = 0;
//      _theFrame            = 0;
//      _theDispatchStopType = AppStopType::never_assigned;
//
//      if ( 0 != theInputModule() ) {
//
//        if ( _enableFrames.value() ) {
//          AppResult theResult = theInputModule()->inputFrame( _theFrame, _theDispatchStopType ); // Get Frame in...
//          number++;
//        } else {
//          AppResult theResult = theInputModule()->inputEvent( _theAbsEvent );                    // Get an event in...
//          number++;
//        }
//
//      }
//**********************************************************************************************************************

#ifdef CDF
    beginJob( AbsEnv::initJobRecord( ) );
#else
    beginJob( _theAbsEvent );
#endif
    _isBegun = true;

  }

  _stopRequested = false;

  //
  // Move frames...
  //
  if ( _enableFrames.value() ) {
    
    numberOfFrames = 0;
    
    do {
      
      AppResult theResult = theInputModule()->inputFrame( _theFrame, _theDispatchStopType ); // Get a frame in...
      numberOfFrames++;
      
      if ( _theFrame!= 0 ) {
        theResult = frame( _theFrame, _theDispatchStopType );  // Walk frame...
        
        if(theResult.value()!=AppResult::OK) {
          fullReport("AppFramework:: Bad result code on return from a frame consumer: != OK");
                     }                            
          
        if ( 0 != theOutputModule( ) && theOutputModule()->isEnabled() ) {
          theOutputModule( )->outputFrame( _theFrame );                                      // Push the frame out...
        }
      }
      
    } while ( ! _stopRequested && ( nEvents <= 0 || numberOfFrames < nEvents ) );
    
  }

  //
  //  Move standard AbsEvent
  //
  
  if ( 0 != theInputModule( ) && !_enableFrames.value() ) {
    
    number = 0;
    
    AppActionController** anActionController;
    APPListIterator<AppActionController*> 
      itr1( *actionControllers() );
    APPListIterator<AppActionController*> 
      itr2( *actionControllers() );
    
    do {
      
      while ( anActionController=itr1.next() ) {
        (*anActionController)->beforeEvent(theInputModule(),_theAbsEvent);
      }
      itr1.rewind();
      AppResult theResult = theInputModule( )->inputEvent( _theAbsEvent,
                                                           _theDispatchStopType );      
      while ( anActionController=itr1.next() ) {
        (*anActionController)->afterEvent(theInputModule(),_theAbsEvent);
      }
      itr1.rewind();
      
      if ( 0 != _theAbsEvent ) {
        
        //
        // Handle the traditional dispatch here
        //
        
        if ( _theDispatchStopType == AppStopType::physics_event ) {
          event( _theAbsEvent );
          number++;
        } else if ( _theDispatchStopType == AppStopType::begin_run ) {
          //  Begin Run
          beginRun( _theAbsEvent );
          
        } else if ( _theDispatchStopType == AppStopType::end_run ) {
          //  End Run
          endRun( _theAbsEvent );
          
        } else {
          //  Other record type
          other( _theAbsEvent );
        }
        outputEvent(_theAbsEvent);
        accountEvent(_theAbsEvent);
      }
    }
    while ( ! _stopRequested && 0 != _theAbsEvent &&
            ( nEvents <= 0 || number < nEvents )      );
    
    if ( 0 == _theAbsEvent ) {
      _isBegun = false;
    }
    
  }
}

void
AppFramework::resetIndent( )
{
    _indentLevel = 0;
}

void
AppFramework::increaseIndent( )
{
    _indentLevel++;
}

void
AppFramework::decreaseIndent( )
{
    if ( _indentLevel > 0 ) {
        _indentLevel--;
    }
}

void
AppFramework::skipToIndent( )
{
  int i;

    for ( i = 0; i < _indentLevel; i++ ) {
                partialReport("    ");
    }
}

void
AppFramework::printName( const char* const theName, int mode )
{
  size_t i;
  size_t len;
  
  partialReport(theName);
  len = strlen( theName );
  if ( 0 != mode ) {
    ostrstream bufstream;
    bufstream << mode << '\0';
    partialReport(" (");
    char* bufptr = bufstream.str();
    partialReport(bufptr);
    partialReport(")");
    len = len + 4;
    delete [] bufptr;  // str() freezes underlying array
  }
  for ( i = len - 4; i < _maxNameLength; i++ ) {
    partialReport(" ");
  }
}

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

APPExecutable*
AppFramework::fetch( const char* const aName ) const
{

    assert ( 0 != aName );

    return _executables->fetch( aName );
}

AppModule*
AppFramework::fetchModule( const char* const aName ) const
{
    APPExecutable* anExec;
    APPExecutable* theExec = 0;

    assert ( 0 != aName );

    if ( 0 != (anExec = _executables->fetch( aName ) )) {
      theExec = APPExecutable::narrow( anExec, APPExecutable::APP_module );
      if ( 0 == theExec ) {
        theExec = APPExecutable::narrow( anExec,
                                         APPExecutable::APP_filter );
      }
      if ( 0 == theExec ) {
        theExec = APPExecutable::narrow( anExec,
                                         APPExecutable::APP_input );
      }
      if ( 0 == theExec ) {
        theExec = APPExecutable::narrow( anExec,
                                         APPExecutable::APP_output );
      }
      if ( 0 == theExec ) {
        theExec = APPExecutable::narrow( anExec,
                                         APPExecutable::APP_account );
      }
    }
    return (AppModule*)theExec;
}

APPPath*
AppFramework::fetchPath( const char* const aName ) const
{
    APPExecutable* anExec;

    assert ( 0 != aName );

    if ( 0 != (anExec = _executables->fetch( aName ) )) {
        anExec = APPExecutable::narrow( anExec, APPExecutable::APP_path );
    }
    return (APPPath*)anExec;
}

APPSequence*
AppFramework::fetchSequence( const char* const aName ) const
{
    APPExecutable* anExec;

    assert ( 0 != aName );

    if ( 0 != (anExec = _executables->fetch( aName ) )) {
        anExec = APPExecutable::narrow( anExec, APPExecutable::APP_sequence );
    }
    return (APPSequence*)anExec;
}

bool
AppFramework::has( const char* const aName ) const
{

    assert ( 0 != aName );

    return ( _executables->has( aName ) );
}

bool
AppFramework::hasModule( const char* const aName ) const
{
    APPExecutable* anExec;
    APPExecutable* theExec = 0;

    assert ( 0 != aName );

    if ( 0 != (anExec = _executables->fetch( aName ) )) {
        theExec = APPExecutable::narrow( anExec, APPExecutable::APP_module );
                if ( 0 == theExec ) {
                        theExec = APPExecutable::narrow( anExec,
                        APPExecutable::APP_filter );
                }
    }
    return ( 0 != theExec );
}

bool
AppFramework::hasPath( const char* const aName ) const
{
    APPExecutable* anExec;

    assert ( 0 != aName );

    if ( 0 != (anExec = _executables->fetch( aName ) )) {
        anExec = APPExecutable::narrow( anExec, APPExecutable::APP_path );
    }
    return ( 0 != anExec );
}

bool
AppFramework::hasSequence( const char* const aName ) const
{
    APPExecutable* anExec;

    assert ( 0 != aName );

    if ( 0 != (anExec = _executables->fetch( aName ) )) {
        anExec = APPExecutable::narrow( anExec, APPExecutable::APP_sequence );
    }
    return ( 0 != anExec );
}

APPExecutable*
AppFramework::execFromName( const char* const theName ) const
{
    APPExecutable* theExec;
    theExec = fetchModule( theName );
    if ( 0 == theExec ) {
                theExec = fetchSequence( theName );
    }
    return theExec;
}

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

void
AppFramework::setBegun( bool state )
{
    _isBegun = state;
}

void
AppFramework::setTheAccountModule (AppAccountModule* thatOne)
{
  APPListIterator<AppAccountModule*> iter(*accountModules());
  AppAccountModule** aMod;
  while (aMod = iter()) {
    if (*aMod == thatOne) {
      _theAccountModule = thatOne;
      break;
    }
  }
}

bool
AppFramework::setAccountModule( const char* const aName )
{
  APPExecutable*  anExec;
  AppAccountModule* theAccount;
  bool result = false;

  if ( 0 != ( anExec = fetchModule( aName )) ) {
    if ( 0 != ( theAccount = (AppAccountModule*) 
                APPExecutable::narrow( anExec, APPExecutable::APP_account ) ) )
      {
        if ( 0 != _theAccountModule ) {
          if ( _theAccountModule != theAccount ) {
            if ( _theAccountModule->isInitialized( ) ) {}
            _theAccountModule->setEnabled( false );
          }
        }
        _theAccountModule = theAccount;
        _theAccountModule->setEnabled( true );
        result = true;
      }
  }
  return result;
}

bool
AppFramework::setInputModule( const char* const aName )
{
    APPExecutable*  anExec;
    APPInputModule* theInput;
    bool result = false;

    if ( 0 != ( anExec = fetchModule( aName )) ) {
       if ( 0 != ( theInput = (APPInputModule*)APPExecutable::narrow( anExec,
                                                                      APPExecutable::APP_input ) ) ) 
       {
          if ( 0 != _theInputModule ) {
             if ( _theInputModule != theInput ) {
                if ( _theInputModule->isInitialized( ) ) {}
                _theInputModule->setEnabled( false );
             }
          }
          _theInputModule = theInput;
          _theInputModule->setEnabled( true );
          result = true;
       }
    }
    return result;
}

void
AppFramework::setTheInputModule (APPInputModule* thatOne)
{
  APPListIterator<APPInputModule*> iter(*inputModules());
  APPInputModule** aMod;
  while (aMod = iter()) {
    if (*aMod == thatOne) {
      _theInputModule = thatOne;
      break;
    }
  }
}

bool
AppFramework::setOutputModule( const char* const aName )
{
    APPExecutable*   anExec;
    APPOutputModule* theOutput;
    bool result = false;

    if ( 0 != ( anExec = fetchModule( aName )) ) {
       if ( 0 != ( theOutput = (APPOutputModule*)APPExecutable::narrow( anExec,
                                                                        APPExecutable::APP_output ) ) ) 
       {
          if ( 0 != _theOutputModule ) {
             if ( _theOutputModule != theOutput ) {
                if ( _theOutputModule->isInitialized( ) ) {}
                _theOutputModule->setEnabled( false );
             }
          }
          _theOutputModule = theOutput;
          _theOutputModule->setEnabled( true );
          result = true;
       }
    }
    return result;
}

void
AppFramework::add( const APPExecNode* const aNode )
{

    assert ( 0 != aNode );

    _execNodes->append( (APPExecNode*)aNode );
}

void
/* !!!
   F_createTree( _theFileNode );
*/
AppFramework::add( AppModule* const aModule )
{
  
  assert ( 0 != aModule );
  
  if ( _executables->add( aModule->name( ), aModule ) ) {
    _modules->append( aModule );
    aModule->setFramework( this );
    if (_defaultPath != 0) _defaultPath->append( aModule );
    if ( strlen( aModule->name( ) ) > _maxNameLength ) {
      _maxNameLength = strlen( aModule->name( ) );
    }
  } else {
    if (verbose() ) {
      partialReport( "Module " );
      partialReport( aModule->name( ) );
      fullReport   ( " already exists" );
    }
    delete aModule;
  }
}

void
AppFramework::add( AppAccountModule* const aModule )
{

  assert ( 0 != aModule );

  if ( _executables->add( aModule->name( ), aModule ) ) {
    _accountModules->append( aModule );
    aModule->setFramework( this );
    if ( strlen( aModule->name( ) ) > _maxNameLength ) {
      _maxNameLength = strlen( aModule->name( ) );
    }
  } else {
    if (verbose() ) {
      partialReport( "Module " );
      partialReport( aModule->name( ) );
      fullReport   ( " already exists" );
    }
  }
}

void
AppFramework::add( APPInputModule* const aModule )
{

  assert ( 0 != aModule );
  
  if ( _executables->add( aModule->name( ), aModule ) ) {
    _inputModules->append( aModule );
    aModule->setFramework( this );
    if ( strlen( aModule->name( ) ) > _maxNameLength ) {
      _maxNameLength = strlen( aModule->name( ) );
    }
  } else {
    if (verbose() ) {
      partialReport( "Module " );
      partialReport( aModule->name( ) );
      fullReport   ( " already exists" );
    }
    delete aModule;
  }
}

void
AppFramework::add( APPOutputModule* const aModule )
{
  
  assert ( 0 != aModule );
  
  if ( _executables->add( aModule->name( ), aModule ) ) {
    _outputModules->append( aModule );
    aModule->setFramework( this );
    if ( strlen( aModule->name( ) ) > _maxNameLength ) {
      _maxNameLength = strlen( aModule->name( ) );
    }
  } else {
    if (verbose() ) {
      partialReport( "Module " );
      partialReport( aModule->name( ) );
      fullReport   ( " already exists" );
    }
    delete aModule;
  }
}

void
AppFramework::add( APPPath* const aPath )
{
  
  assert ( 0 != aPath );
  
  if ( _executables->add( aPath->name( ), aPath ) ) {
    _paths->append( aPath );
    aPath->setFramework( this );
    if ( strlen( aPath->name( ) ) > _maxNameLength ) {
      _maxNameLength = strlen( aPath->name( ) );
    }
  } else {
    partialReport( "Path " );
    partialReport( aPath->name( ) );
    fullReport   ( " already exists" );
    delete aPath;
  }
}

void
AppFramework::add( APPSequence* const aSequence )
{
  
  assert ( 0 != aSequence );
  
  if ( _executables->add( aSequence->name( ), aSequence ) ) {
    _sequences->append( aSequence );
    aSequence->setFramework( this );
    if ( strlen( aSequence->name( ) ) > _maxNameLength ) {
      _maxNameLength = strlen( aSequence->name( ) );
    }
  } else {
    partialReport( "Sequence " );
    partialReport( aSequence->name( ) );
    fullReport   ( " already exists" );
    delete aSequence;
  }
}
void
AppFramework::add( AppCloneRecorder* const aRecorder )
{

  assert ( 0 != aRecorder );
  _cloneList->append(aRecorder);
}
void
AppFramework::remove( const APPExecNode* const aNode )
{
  
  assert ( 0 != aNode );
  
  _execNodes->remove( (APPExecNode*)aNode );
}

void
AppFramework::remove( const AppModule* const aModule )
{
  
  assert ( 0 != aModule );
  
  _modules->remove( (AppModule*)aModule );
  _executables->remove( aModule->name( ) );
}

void
AppFramework::remove( const AppAccountModule* const aModule )
{

  assert ( 0 != aModule );

  _modules->remove( (AppAccountModule*)aModule );
  _executables->remove( aModule->name( ) );
}

void
AppFramework::remove( const APPInputModule* const aModule )
{
  
  assert ( 0 != aModule );
  
  _modules->remove( (APPInputModule*)aModule );
  _executables->remove( aModule->name( ) );
}

void
AppFramework::remove( const APPOutputModule* const aModule )
{
  
  assert ( 0 != aModule );

    _modules->remove( (APPOutputModule*)aModule );
    _executables->remove( aModule->name( ) );
}

void
AppFramework::remove( const APPPath* const aPath )
{

    assert ( 0 != aPath );

    if (aPath == _defaultPath) _defaultPath = 0;  

    _paths->remove( (APPPath*)aPath );
    _executables->remove( aPath->name( ) );
}

void
AppFramework::remove( const APPSequence* const aSequence )
{

    assert ( 0 != aSequence );

    _sequences->remove( (APPSequence*)aSequence );
    _executables->remove( aSequence->name( ) );

    // deleted (nestled) sequences have to be removed 
    APPListIterator <APPSequence*> iterSeq(*_sequences);
    APPSequence** aSeq;
    while (aSeq = iterSeq()) {
      (*aSeq)->remove(aSequence);
    }
    APPListIterator <APPPath*> iterPath(*_paths);
    APPPath** aPath;
    while (aPath = iterPath()) {
      (*aPath)->remove(aSequence);
    }

}

void
AppFramework::resetAppMethods(bool toThis) {

   AppMethodBase** anAppMethod;

   APPListIterator<AppMethodBase*> itr(*appMethods());  // use the grab bag...
   while ( anAppMethod=itr.next() ) {
           (*anAppMethod)->reset(false); }              // reset 'em all
}

void
AppFramework::resetNodes( )
{
    APPExecNode** node;

        APPListIterator<APPExecNode*> theIterator( *nodes( ) );
        while ( node = theIterator( ) ) {
                (*node)->setExecuted( false );
    }
}
#ifdef CDF
void
AppFramework::addCDFrequiredActions( )
{
   // Default construct the CDF non-optional actions
   AppAction* histAction  = new AppActionHistoDir;
   AppAction* timerAction = new AppActionTime;
   // Append them to the framework's list
   actions( )->append( histAction );
   actions( )->append( timerAction );
}
#endif
//
// Return unowned pointer to user builder
//
AppUserBuild*
AppFramework::appBuilder(){
  return _theAppUserBuild;
}

//
// Do any lingering App setup here that the User should
// not be bothered with.
//

void
AppFramework::setupTheApp(AppUserBuild* build )
{
  AbsInterp* absInterp = AbsInterp::theInterpreter(); 
  _theAppUserBuild = build; 

  // Create the Actions Controllers
  APPListIterator<AppAction*> itr( *actions( ) );
  AppAction** anAction;
  while ( anAction = itr( ) ) {
    actionControllers( )->append( new AppActionController( *anAction ) );
  }

  // Build a list with Input, Output and App Modules all stored
  // as AppModules (common base class)

  APPList<AppModule*> allAsModules;
  buildModuleList( allAsModules, *inputModules() );
  buildModuleList( allAsModules, *outputModules() );
  buildModuleList( allAsModules, *modules() );
  buildModuleList( allAsModules, *accountModules() );

  // Now use that list to check if commands are redefined ...

  APPListIterator<AppModule*> modIter( allAsModules );
  AppModule** mod;
  disableCommands(); // Framework's
  while ( mod = (AppModule**)modIter( ) ) {
    APPCommand** aCommand;
    APPListIterator<APPCommand*> cmdIter( *((*mod)->commands()) );
    while ( aCommand = cmdIter( ) ) {
      if ( absInterp->existsCommand((*aCommand)->command()) ) {
        partialReport("Error : Redefining command ");
        partialReport((*aCommand)->command());
        partialReport(" in target ");
        fullReport((*mod)->name());
        assert(0);
      } 
      else {
        (*aCommand)->enable();
      }      
    }
    cmdIter.rewind();
    while ( aCommand = cmdIter( ) ) {
      (*aCommand)->disable();
    }
  }
  enableCommands(); // Framework's
}

// These methods iterate over a source list of specific kinds of modules and append them
// to the destination list as their base class, AppModule.  The Destination should not
// own the modules on it.  No protection from duplication is attempted.

void
AppFramework::buildModuleList( APPList<AppModule*>& destination ,
                               APPList<AppAccountModule*>& source ) {

  APPListIterator<AppAccountModule*> itr( source );
  AppModule** m;
  while ( m  = (AppModule**) itr( ) ) {
    destination.append( *m );
  }
  return;
}

void
AppFramework::buildModuleList( APPList<AppModule*>& destination , 
                               APPList<APPInputModule*>& source ) {
   
    APPListIterator<APPInputModule*> itr( source );
    AppModule** m;
    while ( m  = (AppModule**) itr( ) ) {
      destination.append( *m );
    }                 
    return;
}

void
AppFramework::buildModuleList( APPList<AppModule*>& destination , 
                               APPList<APPOutputModule*>& source ) {
   
    APPListIterator<APPOutputModule*> itr( source );
    AppModule** m;
    while ( m  = (AppModule**) itr( ) ) {
      destination.append( *m );
    }                 
    return;
}

void
AppFramework::buildModuleList( APPList<AppModule*>& destination , 
                               APPList<AppModule*>& source ) {
   
    destination.append( source );

    return;
}

//
// CXX template instantiations
//
#if defined(__DECCXX) || defined(CDF)
template class APPHash< APPExecutable >;
#endif // __DECCXX

// This function is for use only by Framework.
// Here, Item is always a pointer and has a name() method.
template <class Item>
void APPListDeleteAll( APPList<Item> & alist, AppFramework* theFrame, 
                       const char* itemType) {
#ifdef CDF
  APPListDeleteAll(alist);
#else
  // order of deletion is important, especially for modules which 
  // have dtors calling other modules.  (order is first in, last deleted.)
  Item *p_item;  
  while ( p_item = alist.last() ) {
    Item temp_item = *p_item; 
    FwkString identity = (*p_item)->name();       
    alist.remove(p_item) ;        
    if (theFrame->verbose()) {
      theFrame->partialReport( ComTimeStamp() );
      theFrame->partialReport( " Before dtor of " );
      theFrame->partialReport( itemType );
      theFrame->partialReport( " " );
      theFrame->fullReport( identity );
    }
    delete temp_item ;            
    if (theFrame->verbose()) {
      theFrame->partialReport( ComTimeStamp() );
      theFrame->partialReport( " After  dtor of " );
      theFrame->partialReport( itemType );
      theFrame->partialReport( " " );
      theFrame->fullReport(identity);
    }
  }
#endif
}

 

---

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

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