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

                 

---

/Framework/src/APPSequence.cc

Go to the documentation of this file.

//--------------------------------------------------------------------------
// File and Version Information:
//      $Id: APPSequence.cc,v 1.32 2001/07/19 15:47:37 bartoldu Exp $
//
// Description:
//      Class APPSequence. This class describes sequences within the BaBar
//      Application Framework.
//
// Environment:
//      Software developed for the BaBar Detector at the SLAC B-Factory.
//
// Author List:
//      David R. Quarrie                Original Author
//      Marc Turcotte                   Introduced Actions       May '97
//      Marc Turcotte                   Removed dependence on RW
//                                      to allow sharing         June '97
//      Marc Turcotte                   Modified for new style begin/end 2/98
//      Marc Turcotte                   Added support for 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                   Let null frame pointer thru 4/8/98
//      Marc Turcotte                   Introduced ActionControllers 4/20/98
//      Marc Turcotte                   Merged in R.Kapur's TK interface 5/15
//      Marc Turcotte                   Modified for AppStatus 6/20/98
//      Marc Turcotte                   Added input/output Frame 6/22/98
//      Marc Turcotte                   Added theDispatchStopType to
//                                      signatures 6/23/98
//      Marc Turcotte                   Changed AppStatus for AppResult 6/23/98
//      Marc Turcotte                   Modified for new sigs 6/24/98
//      Marc Turcotte                   Introduced non const heap temporary
//                                      sequenceName copied into
//                                      for safety reasons. 7/30/98
//      Rainer Bartoldus                Implemented use of before/afterOther()
//                                      actions in other() method. 7/18/2001
//
// Copyright Information:
//      Copyright (C) 1994, 1995        Lawrence Berkeley Laboratory
//      Copyright (C) 1997, 1998        University of Texas at Dallas
//
//------------------------------------------------------------------------
#include "Experiment/Experiment.hh"

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

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

//-------------------------------
// Collaborating Class Headers --
//-------------------------------
#include "Framework/APPFramework.hh"
#include "Framework/APPExecNode.hh"
#include "Framework/APPNameNode.hh"
#include "Framework/AppStopType.hh"
class AppFrame;
#include "Framework/AppActionController.hh"
#include "Framework/APPModule.hh"

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

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

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

APPSequence::APPSequence( 
    const char* const theName, 
    const char* const theDescription )
    : APPExecutable( theName, theDescription )
{
    _execType  = APP_sequence;
    _nodes      = new APPList< APPExecNode* >;
}

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

APPSequence::~APPSequence( )
{
    delete _nodes;
}
    
//--------------
// Operations --
//--------------

AppResult
APPSequence::beginJob( AbsEvent* aRecord ) {
   APPExecNode** node;

   APPListIterator<APPExecNode*> theIterator( *_nodes );
   while ( node = theIterator( ) ) 
   {
      (*node)->target( )->beginJob( aRecord );
      
   }
   return AppResult::OK;
}

AppResult
APPSequence::beginRun( AbsEvent* anEvent ) {

   APPExecNode** node;
   APPExecutable* exec;    
    
   assert( NULL != anEvent );
    
   APPListIterator<APPExecNode*> theIterator( *_nodes );
   while ( node = theIterator( ) ) {
      exec = (*node)->target( );
      if ( exec->isEnabled( ) ) {

         exec->beginRun( anEvent );         
         
      }
   }
   return AppResult::OK;
}

AppResult
APPSequence::inputFrame( AppFrame*& aFrame,
                         AppStopType& theDispatchStopType ) { // Frame input
  return AppResult::OK;
}

AppResult
APPSequence::outputFrame( AppFrame* aFrame ) {                // Frame output
  return AppResult::OK;
}

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

  APPExecNode** node;
  APPExecutable* exec;
  
  setPassed( true ); // Leave potential for an AppMethod to terminate exection, for now...
  
  APPListIterator<APPExecNode*> theIterator( *_nodes );
  
  AppResult theResult = AppResult::OK;
  while ( node = theIterator( ) ) { // Run over the nodes...
    exec = (*node)->target();          // ...get that node's executable
    if ( passed( ) ) {
      if(exec->isEnabled()) {theResult=exec->frame( aFrame, theDispatchStopType );}
      setPassed( exec->passed( ) );
    }
  }
  
  return theResult.value();

}

AppResult
APPSequence::event( AbsEvent* anEvent )
{
  assert( NULL != anEvent );
  
  setPassed( true );

  APPExecutable* exec;
  APPExecNode** node;
  APPListIterator<APPExecNode*> theIterator( *_nodes );
  APPListIterator<AppActionController*> 
    itr1(*(framework()->actionControllers()));
  AppActionController** anActionController;

  while ( node = theIterator( ) ) {
    exec = (*node)->target(); // Get that node's executable
    if ( passed( ) ) {
      if ( ! (*node)->isExecuted( ) ) { 
        //  The node has not been executed yet; do it now.
        if ( exec->isEnabled( ) ) {

          if ( exec->execType() == APPExecutable::APP_module 
               || exec->execType() == APPExecutable::APP_filter
               || exec->execType() == APPExecutable::APP_input
               || exec->execType() == APPExecutable::APP_output
               || exec->execType() == APPExecutable::APP_noclone
               ) { // poor man's dynamic cast:
            itr1.rewind();
            while ( anActionController=itr1.next() ) {
              (*anActionController)->beforeEvent(exec,anEvent);
            }
          }
          
          exec->event( anEvent );
          
          if ( exec->execType() == APPExecutable::APP_module 
               || exec->execType() == APPExecutable::APP_filter
               || exec->execType() == APPExecutable::APP_input
               || exec->execType() == APPExecutable::APP_output
               || exec->execType() == APPExecutable::APP_noclone
               ) { // poor man's dynamic cast:
            itr1.rewind();
            while ( anActionController=itr1.next() ) {
              (*anActionController)->afterEvent(exec,anEvent);
            }
          }
          
          // This gives the container exec node the pass value of the 
          // last executed containee exec node. If the pass value was reset to
          // false, the execution path would then terminate.
          //
          // Comment by M.Turcotte 12/3/97
          setPassed( exec->passed( ) ); 
  
        }
        
        (*node)->setExecuted( true ); // set node as being executed.
        
      } else { 
        //                   
        // The node has been executed previously. Do not repeat any of
        // the execution. But set the container exec's pass value anyway
        // since you may still want to terminate execution on the fly...
        //
        //               Marc Turcotte, 12/3/97

        if ( exec->isEnabled( ) ) { setPassed( exec->passed( ) ); } 
        
      }  
    }
  }
  return AppResult::OK;
}

AppResult
APPSequence::inputEvent( AbsEvent*& anEvent ) {
  return AppResult::OK;
}

AppResult
APPSequence::outputEvent ( AbsEvent* anEvent ) {
  return AppResult::OK;
}

AppResult
APPSequence::other( AbsEvent* anOther )
{
    assert( NULL != anOther );
    
    APPExecNode** node;
    APPExecutable* exec;
    APPListIterator<APPExecNode*> theIterator( *_nodes );
    APPListIterator<AppActionController*> 
      itr1(*(framework()->actionControllers()));
    AppActionController** anActionController;

    while ( node = theIterator( ) ) {
       if ( ! (*node)->isExecuted( ) ) {
          exec = (*node)->target( );
          if ( exec->isEnabled( ) ) {

            if ( exec->execType() == APPExecutable::APP_module 
                 || exec->execType() == APPExecutable::APP_filter
                 || exec->execType() == APPExecutable::APP_input
                 || exec->execType() == APPExecutable::APP_output
                 || exec->execType() == APPExecutable::APP_noclone
                 ) {
              itr1.rewind();
              while ( anActionController=itr1.next() ) {
                (*anActionController)->beforeOther(exec,anOther);
              }
            }
          
            exec->other( anOther );

            if ( exec->execType() == APPExecutable::APP_module 
                 || exec->execType() == APPExecutable::APP_filter
                 || exec->execType() == APPExecutable::APP_input
                 || exec->execType() == APPExecutable::APP_output
                 || exec->execType() == APPExecutable::APP_noclone
                 ) {
              itr1.rewind();
              while ( anActionController=itr1.next() ) {
                (*anActionController)->afterOther(exec,anOther);
              }
            }
          }
          (*node)->setExecuted( true );
       }
    }
    return AppResult::OK;
}

AppResult
APPSequence::endRun( AbsEvent* anEvent ) {

   APPExecNode** node;
   APPExecutable* exec;
    
   assert( NULL != anEvent );
    
   APPListIterator<APPExecNode*> theIterator( *_nodes );
   while ( node = theIterator( ) ) {
      exec = (*node)->target( );
      if ( exec->isEnabled( ) ) {
         
         exec->endRun(anEvent);
         
      }
   }
   return AppResult::OK;
}

AppResult
APPSequence::endJob( AbsEvent* aRecord ) {

   APPExecNode** node;
    
   APPListIterator<APPExecNode*> theIterator( *_nodes );
   while ( node = theIterator( ) ) {

      (*node)->target( )->endJob( aRecord );  

   }
   return AppResult::OK;
}

AppResult
APPSequence::abortJob( AbsEvent* anEvent ) {

   APPExecNode** node;
    
   APPListIterator<APPExecNode*> theIterator( *_nodes );
   while ( node = theIterator( ) ) {

      (*node)->target( )->abortJob( anEvent );
   }
   return AppResult::OK;
}

//-------------
// Selectors --
//-------------
    
APPExecNode*
APPSequence::head( ) const
{
  if (_nodes->first( ) == 0)
    return 0;
  else {
    return (*_nodes->first( ));
  }

}

void 
APPSequence::report( int mode ) const
{
    APPExecNode** node;
        
    APPExecutable::report( );
    if ( ! _nodes->isEmpty( ) ) {
        framework( )->increaseIndent( );
                APPListIterator<APPExecNode*> theIterator( *_nodes );
                while ( node = theIterator( ) ) {
                        (*node)->target( )->report( (*node)->mode( ) );
                }
                framework( )->decreaseIndent( );
    }
}

bool
APPSequence::passed( ) const
{
    return _passed;
}

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

void
APPSequence::append( 
    const APPNameNode* const aNode, 
    const APPNameNode* const anOther )
{
   APPList< APPExecNode* >* theList;
   APPExecNode** p_otherNode = NULL;
   APPExecNode** p_useNode;
   APPExecNode*  useNode;

   APPExecutable* theExec;
   APPExecutable* theOther;
   
   assert( NULL != framework( ) );
   assert( NULL != aNode );
   
   if ( NULL != ( theExec = framework( )->execFromName( aNode->name( ) ) ) ) {
      theList = framework( )->nodes( );
      APPListIterator<APPExecNode*> iter1( *theList );
      while ( p_useNode = iter1( ) ) {
         if ( (*p_useNode)->target( ) == theExec && 
              (*p_useNode)->mode( )   == aNode->mode( ) ) {
            break;
         }
      }
      if ( NULL == p_useNode ) {
         useNode = new APPExecNode( theExec, aNode->mode( ) );
         p_useNode = &useNode;
         framework( )->add( useNode );
      }
      if ( NULL != anOther ) {
         if ( NULL != ( theOther = 
                        framework( )->execFromName( anOther->name( ) ) ) ) {
            APPListIterator<APPExecNode*> iter2( *_nodes );
            while ( p_otherNode = iter2( ) ) {
               if ( (*p_otherNode)->target( ) == theOther && 
                    (*p_otherNode)->mode( )   == anOther->mode( ) ) {
                  break;
               }
            }
         }
      }
      _nodes->append( p_useNode, p_otherNode );
   }
}

void
APPSequence::append( 
    const APPExecutable* const anExec, 
    int theMode,
    const APPExecutable* const theOther,
    int otherMode )
{
   APPList< APPExecNode* >* theList;
   APPExecNode** p_aNode = NULL;
   APPExecNode** p_useNode;
   APPExecNode*  useNode;
   assert( NULL != framework( ) );
   assert( NULL != anExec );
   
   theList = framework( )->nodes( );
   APPListIterator<APPExecNode*> iter1( *theList );
   while ( p_useNode = iter1( ) ) {
      if ( (*p_useNode)->target( ) == anExec && (*p_useNode)->mode( ) == theMode ) {
         break;
      }
   }
   if ( NULL == p_useNode ) {
      useNode = new APPExecNode( anExec, theMode );
      p_useNode = &useNode;
      framework( )->add( useNode );
   }
   if ( NULL != theOther ) {
      APPListIterator<APPExecNode*> iter2( *_nodes );
      while ( p_aNode = iter2( ) ) {
         if ( (*p_aNode)->target( ) == theOther && 
              (*p_aNode)->mode( )   == otherMode ) {
            break;
         }
      }
   }
    _nodes->append( p_useNode, p_aNode );
}

void
APPSequence::append( 
    const char* const theName, 
    int theMode,
    const char* const theOther,
    int otherMode )
{
    APPList< APPExecNode* >* theList;
    APPExecNode** p_aNode = NULL;
    APPExecNode** p_useNode;
    APPExecNode*  useNode;
    APPExecutable* theExec;

    assert( NULL != framework( ) );
    assert( NULL != theName );
    
    if ( NULL != ( theExec = framework( )->execFromName( theName ) ) ) {
                theList = framework( )->nodes( );
                APPListIterator<APPExecNode*> iter1( *theList );
                while ( p_useNode = iter1( ) ) {
                        if ( (*p_useNode)->target( ) == theExec && 
                                 (*p_useNode)->mode( )   == theMode ) {
                        break;
                        }
                }
                if ( NULL == p_useNode ) {
                        useNode = new APPExecNode( theExec, theMode );
                        p_useNode = &useNode;
                        framework( )->add( useNode );
                }
                if ( NULL != theOther ) {
                        APPListIterator<APPExecNode*> iter2( *_nodes );
                        while ( p_aNode = iter2( ) ) {
                        if ( (*p_aNode)->target( )->name( ) == theOther &&
                             (*p_aNode)->mode( )            == otherMode ) {
                                        break;
                                }
                        }
                }
                _nodes->append( p_useNode, p_aNode );
    }
}

void
APPSequence::insert( 
    const APPNameNode* const aNode, 
    const APPNameNode* const anOther )
{
   APPList< APPExecNode* >* theList;
   APPExecNode**  p_otherNode = NULL;
   APPExecNode**  p_useNode;
   APPExecNode*   useNode;
   APPExecutable* theExec;
   APPExecutable* theOther;
   
   assert( NULL != framework( ) );
   assert( NULL != aNode );
   
   if ( NULL != ( theExec = framework( )->execFromName( aNode->name( ) ) ) ) {
      theList = framework( )->nodes( );
      APPListIterator<APPExecNode*> iter1( *theList );
      while ( p_useNode = iter1( ) ) {
         if ( (*p_useNode)->target( ) == theExec &&
              (*p_useNode)->mode( )   == aNode->mode( ) ) {
            break;
         }
      }
      if ( NULL == p_useNode ) {
         useNode = new APPExecNode( theExec, aNode->mode( ) );
         p_useNode = &useNode;
         framework( )->add( useNode );
      }
      if ( NULL != anOther ) {
         if ( NULL != ( theOther = 
                        framework( )->execFromName( anOther->name( ) ) ) ) {
            APPListIterator<APPExecNode*> iter2( *_nodes );
            while ( p_otherNode = iter2( ) ) {
               if ( (*p_otherNode)->target( ) == theOther && 
                    (*p_otherNode)->mode( )   == anOther->mode( ) ) {
                  break;
               }
            }
         }
      }
      _nodes->insert( p_useNode, p_otherNode );
   }
}

void
APPSequence::insert( 
    const APPExecutable* const anExec, 
    int theMode,
    const APPExecutable* const theOther,
    int otherMode )
{
   APPList< APPExecNode* >* theList;
   APPExecNode** p_aNode = NULL;
   APPExecNode** p_useNode;
   APPExecNode* useNode;
   assert( NULL != framework( ) );
   assert( NULL != anExec );
   
   theList = framework( )->nodes ( );
   APPListIterator<APPExecNode*> iter1( *theList );
   while ( p_useNode = iter1( ) ) {
      if ( (*p_useNode)->target( ) == anExec && 
           (*p_useNode)->mode( )   == theMode ) {
         break;
      }
   }
   if ( NULL == p_useNode ) {
      useNode = new APPExecNode( anExec, theMode );
      p_useNode = &useNode;
      framework( )->add( useNode );
   }    
   if ( NULL != theOther ) {
      APPListIterator<APPExecNode*> iter2( *_nodes );
      while ( p_aNode = iter2( ) ) {
         if ( (*p_aNode)->target( ) == theOther && 
              (*p_aNode)->mode( )   == otherMode ) {
            break;
         }
      }
   }
   _nodes->insert( p_useNode, p_aNode );
}

void
APPSequence::insert( 
    const char* const theName, 
    int theMode,
    const char* const theOther,
    int otherMode )
{
   APPList< APPExecNode* >* theList;
   APPExecNode** p_aNode = NULL;
   APPExecNode** p_useNode;
   APPExecNode*  useNode;
   APPExecutable* theExec;
   assert( NULL != framework( ) );
   assert( NULL != theName );
    
   if ( NULL != ( theExec = framework( )->execFromName( theName ) ) ) {
      theList = framework( )->nodes ( );
      APPListIterator<APPExecNode*> iter1( *theList );
      while ( p_useNode = iter1( ) ) {
         if ( (*p_useNode)->target( ) == theExec && 
              (*p_useNode)->mode( )   == theMode ) {
            break;
         }
      }
      if ( NULL == p_useNode ) {
         useNode = new APPExecNode( theExec, theMode );
         p_useNode = &useNode;
         framework( )->add( useNode );
      }    
      if ( NULL != theOther ) {
         APPListIterator<APPExecNode*> iter2( *_nodes );
         while ( p_aNode = iter2( ) ) {
            if ( (*p_aNode)->target( )->name( ) == theOther &&
                 (*p_aNode)->mode( )            == otherMode ) {
               break;
            }
         }
      }
      _nodes->insert( p_useNode, p_aNode );
   }
}

void
APPSequence::remove( const APPExecutable* const anExec, int mode )
{
    APPExecNode** node;

    assert( NULL != anExec );
    
        APPListIterator<APPExecNode*> theIterator( *_nodes );
        while ( node = theIterator( ) ) {
        if ( (*node)->target( ) == anExec && (*node)->mode( ) == mode ) {
                        _nodes->remove( (*node) );
                        break;
                }
    }
}

void
APPSequence::remove( const char* const theName, int mode  )
{
    APPExecNode** node;

    assert( NULL != theName );
    
        APPListIterator<APPExecNode*> theIterator( *_nodes );
        while ( node = theIterator( ) ) {
                if ( (*node)->target( )->name( ) == theName &&
                     (*node)->mode( )            == mode ) {
                        _nodes->remove( (*node) );
                        break;
                }
    }
}

void
APPSequence::setPassed( bool flag )
{
    _passed = flag;
}

void
APPSequence::buildNodeList(APPList<APPExecNode*>& destination, 
                           APPList<APPExecNode*>& source){

    APPListIterator<APPExecNode*> itr( source );
    APPExecNode** n;
    APPList<APPExecNode*> node;      
    while( n = itr() ){
      switch( (*n)->target()->execType() ){
      case APPExecutable::APP_module:
      case APPExecutable::APP_filter:
        destination.append( *n );
        break;
      case APPExecutable::APP_sequence:
        APPList<APPExecNode*>* snode = 
          ((APPSequence*)( (*n)->target() ))->nodes();      
        ((APPSequence*) *n)->buildNodeList( node, *snode );
        destination.append( node );
        break;
      }
    }
}

 

---

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

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