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

                 

---

/Framework/src/APPModule.cc

Go to the documentation of this file.

// File and Version Information:
//      $Id: APPModule.cc,v 1.52 2002/03/28 22:04:47 desilva Exp $
//
// Description:
//      Class AppModule. This class describes modules within the BaBar
//      Application Framework.
//
// Environment:
//      Software developed for the BaBar Detector at the SLAC B-Factory.
//
// Author List:
//      David R. Quarrie                Original Author
//      Bob Jacobsen                    Brought into AbsEvent conformance
//      Bob Jacobsen                    _commands must be unowned list
//      P.Murat                         add handling of menu files
//      Marc Turcotte                   Added new style begin<Job/Run>
//                                      Added new style event.
//      Marc Turcotte                   Added execute member function
//                                      to support dynamic dispatch 3/98
//      Marc Turcotte                   Introduced AppStopType 3/20/98
//      Marc Turcotte                   Renamed execute to frame 3/26/98
//      Marc Turcotte                   Modified to pass frames 'round 4/7/98 
//      Marc Turcotte                   Modified to not barf if zero
//                                      frame passes thru meaning someone
//                                      forgot to line up a provider
//                                      in the time ordered series 4/8/98                                    
//      Marc Turcotte                   Added AppActionController 4/13/98
//      Marc Turcotte                   Modified setActionEnabled to set
//                                      Action Controllers. 4/15/98
//      Marc Turcotte                   Removed static init of _theFrame 4/30/98
//      Marc Turcotte                   Merged R.Kapur's TK interface 5/98
//      Marc Turcotte                   Modified for AppStatus 6/20/98
//      Marc Turcotte                   Moved dispatch from frame to here 6/22/98
//      Marc Turcotte                   Added input/output Frame 6/22/98
//      Marc Turcotte                   Added theDispatchStopType to
//                                      signatures 6/23/98
//      Marc Turcotte                   Changed AppStatus to AppResult 6/23/98
//      Marc Turcotte                   Modified for new AbsEvent sigs 6/24/98
//      Marc Turcotte                   Added clone command 8/6/98
//      Marc Turcotte                   Modified used of getStopTypeKey 
//                                      not to cause a leak. 8/21/98
//
// Copyright Information:
//      Copyright (C) 1994, 1995        Lawrence Berkeley Laboratory
//      Copyright (C) 1998              University of Texas at Dallas
//
//------------------------------------------------------------------------
#include "Experiment/Experiment.hh"

//-----------------------
// This Class's Header --
//-----------------------
#include "Framework/APPModule.hh"

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

//-------------------------------
// Collaborating Class Headers --
//-------------------------------
#include "Framework/APPFramework.hh"
#include "Framework/APPEchoCommand.hh"
#include "Framework/APPExitCommand.hh"
#include "Framework/APPHelpCommand.hh"
#include "Framework/AppStopType.hh"
//? #include "Framework/AppRecord.hh"
#include "Framework/AppMethodBase.hh"
#include "Framework/AppMethod.hh"
class AppFrame;
#include "Framework/APPHash.hh"
#include "FrameUtil/AbsInterp.hh"

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

#include <iostream.h>

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

APPMenu   AppModule::moduleMenu;
AbsEvent* AppModule::_theAbsEvent = 0; // <----- TO BE MIGRATED TO AppFramework

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

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

AppModule::AppModule( 
    const char* const theName, 
    const char* const theDescription )
    : APPExecutable( theName, theDescription ), 
      _exit("exit", this),
      _echo("echo", this),
      _help("help", this),
      _show("show", this),
      _sourceFileCmd( "sourceFoundFile", this ),
      _production("production", this, false), 
      _verbose("verbose", this, false),
      _enableFrames("enableFrames", this, false),      
      _menuFileName(NULL ),
      _error   (NULL ),
      _errorLen( 0 )
{
    _execType = APP_module;
    _isInitialized = false;

    
    _commands = new APPList< APPCommand* >;
    _commands->append( &_echo );
    _commands->append( &_exit );
    _commands->append( &_help );
    _commands->append( &_show );
    _commands->append( &_sourceFileCmd);     
    _commands->append( &_verbose );
    _commands->append( &_production );
    _commands->append( &_enableFrames );


    _prompt = new char[strlen( theName )+3];
    strcpy( _prompt, theName );
    strcat( _prompt, "> ");
    
    // Dynamic Dispach Map
    
    _theDynamicDispatchMap = new APPHash < AppMethodBase >;
    
}

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

AppModule::~AppModule( )
{
    delete _commands;
    
    if ( NULL != _prompt ) {
        delete [] _prompt;
    }
    if ( NULL != _error ) {
        delete [] _error;
    }
    
    if ( NULL != _menuFileName ) {
        delete [] _menuFileName;
    }
  
    delete _theDynamicDispatchMap; // delete the dispatch map

}

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

AppResult
AppModule::beginJob( AbsEvent* anEvent ){
  return AppResult::OK;
}

AppResult
AppModule::beginRun( AbsEvent* anEvent)
{
  return AppResult::OK;
}

AppResult
AppModule::frame( AppFrame* aFrame,
                  const AppStopType& theDispatchStopType) {  // Dynamic dispatch 
  
  AppResult theResult = AppResult::OK;  
  
  if ( aFrame!=0 ) { // Zero frames go nowhere...
    
    char* theStopTypeKey = theDispatchStopType.getStopTypeKey();     
    if((_theDynamicDispatchMap->has(theStopTypeKey))==true) 
    {// there is there a binding
      AppMethodBase* theMethod = _theDynamicDispatchMap->fetch(theStopTypeKey);
      theResult=theMethod->execute(aFrame); // then just deliver the frame to the binding...
    }
    delete [] theStopTypeKey;
    
  } else {
   
   fullReport("AppModule:: Error: You are moving a null Frame pointer.");
  
  }
  
  return theResult.value(); 

}

AppResult
AppModule::event( AbsEvent* anEvent )
{
    return AppResult::OK;
}

AppResult
AppModule::other( AbsEvent* anEvent )
{
    return AppResult::OK;
}

AppResult
AppModule::endRun( AbsEvent* anEvent) {
    return AppResult::OK;
}

AppResult
AppModule::endJob( AbsEvent* anEvent){
    return AppResult::OK;
}

AppResult
AppModule::abortJob( AbsEvent* anEvent ){
    return AppResult::OK;
}

void
AppModule::talkTo( )
{
    enableCommands( );
}

#ifndef CDF
// for the Framework migration.  Will be removed soon.
void
AppModule::help( )
{
}
void 
AppModule::show()
{
}
#endif

void
AppModule::help( int argc, char** argv )
{
  // default behavior, unless overridden, is to list commands
  // available in this module
  partialReport( "Command(s) available in the \"");
  partialReport( name() );
  fullReport("\" module:\n" );

  APPCommand** command;
  APPListIterator<APPCommand*> theIterator( *commands( ) );
  while ( command = theIterator( ) ) 
  {
     if ( argc == 1 ) // Describe the whole list of commands
     {
        partialReport( "      " );
        partialReport((*command)->command() ) ;
        if ( strlen( (*command)->command() ) < 10 )
        {
           partialReport("\t\t");
        }
        else
        {
           partialReport("\t"); 
        }
        fullReport((*command)->description( ).c_str( ));
     }
     else  // Describe the one they asked for
     {
        if ( strcmp( (*command)->command( ), argv[1] ) == 0 )
        {
           partialReport( "      " );
           partialReport((*command)->command() ) ;
           partialReport("\t");
           fullReport((*command)->description( ).c_str( ));
        }
     }
  }
}

void
AppModule::show( int argc, char** argv ) const
{
  // default behavior, unless overridden, is to display the
  // current values of commands available in this module
  partialReport( "Current value of item(s) in the \"");
  partialReport( name() );
  fullReport("\" module:\n" );

  APPCommand** command;
  APPListIterator<APPCommand*> theIterator( *commands( ) );
  while ( command = theIterator( ) ) 
  {
     if ( argc == 1 ) // Show the whole list of showable commands
     {
        if ( (*command)->isShowable( ) )
        {
           partialReport( "      " );
           (*command)->show( );
        }
     }
     else  // Show the one they asked for
     {
        if ( strcmp( (*command)->command( ), argv[1] ) == 0 )
        {
           partialReport( "      " );
           (*command)->show( );
        }
     }
  }
}

AppModule* 
AppModule::clone(const char* cloneName) {
  partialReport("cloning to ");
  partialReport(cloneName);
  partialReport(" has not been implemented by ");
  partialReport(this->name());
  partialReport(" user module...\n");
  return 0;
}

bool
AppModule::verbose() const
{
  return _verbose.value();
}

bool
AppModule::production() const
{
  return _production.value();
}

bool
AppModule::isShowable( ) const 
{
   return true; 
}

void AppModule::menuHandler(char* menu, char* command, int argc, char** argv) {
  partialReport(" -------------------- menuHandler entered module : "); 
  fullReport(this->name());
  partialReport("menu    = ");
  fullReport(menu);
  partialReport("command = ");
  fullReport(command);
  partialReport(" N(argv) = ");
  ostrstream strbuff;
  strbuff << argc << '\0';
  fullReport(strbuff.str());
  for (int i=0; i<argc; i++) {
    fullReport(argv[i]);
  }
}

void
AppModule::exit( )
{
    disableCommands( );
    framework( )->enableCommands( );
}

void
AppModule::disableCommands( )
{
   APPCommand** command;
   APPListIterator<APPCommand*> theIterator( *commands( ) );
   while ( command = theIterator( ) ) {
      (*command)->disable( );
   }
}

void
AppModule::enableCommands( )
{
    APPCommand** command;
    APPListIterator<APPCommand*> theIterator( *commands( ) );
    while ( command = theIterator( ) ) 
    {
      (*command)->enable( );
    }
    AbsInterp* interp = AbsInterp::theInterpreter( );
    interp->setCommandPrompt( prompt( ) );
}

//-------------
// Selectors --
//-------------
    
APPList< APPCommand* >* 
AppModule::commands ( ) const
{
    return _commands;
}

bool
AppModule::isInitialized( ) const
{
    return _isInitialized;
}

bool
AppModule::passed( ) const
{
    return true;
}

char*
AppModule::prompt( ) const
{
    return _prompt;
}

char* 
AppModule::menuFileName( ) const {
    return _menuFileName;
}

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

void 
AppModule::setError( const char* const theError )
{
        if ( NULL != theError ) {
                if ( _errorLen < strlen( theError )+1 ) {
                        if ( NULL != _error ) {
                                delete [] _error;
                        }
                        _errorLen = strlen( theError )+1;
                        _error    = new char[_errorLen];
                }
                strcpy( _error, theError );
        } else {
                if ( NULL != _error ) {
                        delete [] _error;
                        _error    = NULL;
                        _errorLen = 0;
                }
        }
        AbsInterp* interp = AbsInterp::theInterpreter( );
        interp->setResult( _error );
}

void 
AppModule::setInitialized( )
{
    _isInitialized = true;
}
    
void 
AppModule::setPrompt( const char* const thePrompt )
{
    if ( NULL != _prompt ) {
                delete [] _prompt;
                _prompt = NULL;
    }
    if ( NULL != thePrompt ) {
                _prompt = new char[strlen( thePrompt )+1];
                strcpy( _prompt, thePrompt );
    }
}
//
// Provide a means to bind a derived module's method to a particular frame state
//
void AppModule::bindMethodToState(const AppStopType& aStopType,
                                  const AppMethodBase* const aMethod) {
  // 
  // Make an entry in the hash table of AppMethodBase pointers indexed by the Frame State.
  //
  
  char* aStopTypeKey = aStopType.getStopTypeKey();
  
  assert(_theDynamicDispatchMap->add(aStopTypeKey,aMethod)==true); // cannot fail...    
  partialReport("AppModule: ");
  partialReport(name());
  partialReport(" added this hash key: ");
  fullReport(aStopTypeKey);
  
  delete [] aStopTypeKey;
                              
}

APPHash < AppMethodBase >* AppModule::dynamicDispatchMap() {
  return _theDynamicDispatchMap;
}

void AppModule::setMenuFileName(const char* const filename )
{
  if (! filename) return;
  if (_menuFileName) {
    delete _menuFileName;
  }
  _menuFileName = new char[strlen(filename)+1];
  strcpy(_menuFileName,filename);
}

 

---

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

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