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

                 

---

/Framework/src/APPSequenceCommand.cc

Go to the documentation of this file.

//--------------------------------------------------------------------------
// File and Version Information:
//      $Id: APPSequenceCommand.cc,v 1.25 2002/03/28 22:04:47 desilva Exp $
//
// Description:
//      Class APPSequenceCommand. Command handler for the "sequence" command 
//      for the BaBar Application Framework. Valid subcommands are:
//
//      sequence append <seq> <mod1> [<seq1>..] Append module(s)/sequence(s)
//      sequence create <seq> <mod1> [<seq2>..] Create a new sequence
//      sequence delete  <seq>                  Delete a sequence
//      sequence disable <seq1> [<path2> ..]    Disable sequence(s)
//      sequence enable  <seq1> [<path2> ..]    Enable sequence(s)
//      sequence help                           Show help for this command
//      sequence insert <seq> <mod1> [<seq1>..] Insert module(s)/sequence(s)
//      sequence list                           List sequence
//      sequence remove <seq> <mod1> [<seq1>..] Remove module(s)/sequence(s)
//
// Environment:
//      Software developed for the BaBar Detector at the SLAC B-Factory.
//
// Author List:
//      David R. Quarrie                Original Author
//      Marc Turcotte                   Merged in TK interface 5/15/98
//      Marc Turcotte                   Improved error reporting to
//                                      name already in use. 7/1/98
//      Marc Turcotte                   Added wrap around TK calls. 8/24/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/APPSequenceCommand.hh"

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

//-------------------------------
// Collaborating Class Headers --
//-------------------------------
#include "Framework/APPFramework.hh"
#include "Framework/APPModule.hh"
#include "Framework/APPSequence.hh"
#include "Framework/APPExecNode.hh"
#include "Framework/APPNameNode.hh"
#include "FrameUtil/AbsInterp.hh"

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

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

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

APPSequenceCommand::APPSequenceCommand( 
   const char* const theCommand,  AppModule* theTarget )
    : APPBasicCommand( theCommand, theTarget )
{
}

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

APPSequenceCommand::~APPSequenceCommand( )
{
}


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

int 
APPSequenceCommand::appendHandler( )
{
    AppFramework*  theFrame = (AppFramework*)target( );
    APPNameNode*   theNode = NULL;
    APPNameNode*   otherNode = NULL;
    char*          theName;
    APPExecutable* theExec;
    APPExecutable* theOther = NULL;
    APPSequence*   theSeq;
    int index  = firstIndex;
    int result = AbsInterp::ERROR;
    
    if ( NULL != ( theName = getArgument( index ) ) ) {
      if ( NULL != ( theSeq = fetchSeq( theFrame, theName ) ) ) {
        index++;
        while( NULL != ( theName = getArgument( index ) ) ) {
          if ( 0 == strcmp( theName, "-after" ) || 
               0 == strcmp( theName, "-a"     ) ) {
            index++;
            if ( NULL != otherNode ) {
              delete otherNode;
            }
            otherNode = getNameNode( &index );
            if ( NULL != otherNode ) {
              theOther = theFrame->execFromName( otherNode->name( ) );
            }
          }
          if ( NULL != theNode) {
            delete theNode;
          }
          if ( NULL != ( theNode = getNameNode( &index ) ) ) { 
            theExec = theFrame->execFromName( theNode->name( ) );
            if ( NULL != theExec ) {
              if ( NULL == theOther ) {
                theSeq->append( theExec, theNode->mode( ) );
              } else {
                theSeq->append( 
                               theExec, 
                               theNode->mode( ),
                               theOther, otherNode->mode( ) );
                // Setup the just appended node to be append after
                delete otherNode;
                otherNode = theNode;
                theNode = 0;
                theOther  = theExec;
              }
            } else {
              FwkString theSeqName(theName);
              FwkString theTrailer(": unknown name");
              FwkString theMessage=theSeqName+theTrailer;
              theFrame->setError( theMessage.c_str() );
            }
          }
        }
        if ( NULL != theNode ) {
          delete theNode;
        }
        if ( NULL != otherNode ) {
          delete otherNode;
        }
        result = AbsInterp::OK;
      } else {
        FwkString  theSeqName(theName);
        FwkString theTrailer(": unknown name");
        FwkString theMessage=theSeqName+theTrailer;
        theFrame->setError( theMessage.c_str() );          
      }
    } else {
      theFrame->setError( "no name specified" );
    }
    return result;
}

int 
APPSequenceCommand::createHandler( )
{
    AppFramework*  theFrame = (AppFramework*)target( );
    APPNameNode*   theNode;
    char*          theName;
    APPExecutable* theExec;
    APPSequence*       theSeq = NULL;
    int index  = firstIndex;
    int result = AbsInterp::ERROR;
    
    if ( NULL != ( theName = getArgument( index ) ) ) {
       if ( NULL != ( theSeq = newSeq( theFrame, theName ) ) ) {
            index++;
            while( NULL != ( theNode = getNameNode( &index ) ) ) { // new happens
                theExec = theFrame->execFromName( theNode->name( ) );
                if ( NULL != theExec ) {
                    theSeq->append( theExec, theNode->mode( ) );
                } else {
                   FwkString theSeqName(theName);
                   FwkString theTrailer(": unknown name");
                   FwkString theMessage=theSeqName+theTrailer;
                   theFrame->setError( theMessage.c_str() );            
                }
                delete theNode;
            }
            result = AbsInterp::OK;
        } else {
           FwkString theSeqName(theName);
           FwkString theTrailer(": name already in use");
           FwkString theMessage=theSeqName+theTrailer;
           theFrame->setError( theMessage.c_str() );
        }
    } else {
        theFrame->setError( "no name specified" );
    }
    return result;
}

int 
APPSequenceCommand::deleteHandler( )
{
    AppFramework* theFrame = (AppFramework*)target( );
    char*         theName;
    APPSequence*      theSeq;
    int index  = firstIndex;
    int result = AbsInterp::ERROR;
    
    while ( NULL != ( theName = getArgument( index ) ) ) {
        if ( NULL != ( theSeq = fetchSeq( theFrame, theName ) ) ) {
            theFrame->remove( theSeq );
            delete theSeq; // ownership is given up by APPFramework
            result = AbsInterp::OK;
        } else {
           FwkString theSeqName(theName);
           FwkString theTrailer(": unknown name");
           FwkString theMessage=theSeqName+theTrailer;
           theFrame->setError( theMessage.c_str() );        
        }
        index++;
    }
    return result;
}

int 
APPSequenceCommand::disableHandler( )
{
  AppFramework* theFrame = (AppFramework*)target( );
  char*         theName;
  APPSequence*      theSeq;
  int index  = firstIndex;
  int result = AbsInterp::ERROR;
  
  while ( NULL != ( theName = getArgument( index ) ) ) {

    if ( NULL != ( theSeq = fetchSeq( theFrame, theName ) ) ) {
      theSeq->setEnabled( false );
      result = AbsInterp::OK;
      
    } else if ( 0 == strcmp(theName, "all") ) {
      APPList< APPSequence* >* sequences;
      sequences = fetchSeqs( theFrame );
      if ( ! sequences->isEmpty( ) ) {
        APPSequence** aSeq;
        APPListIterator<APPSequence*> theIterator( *sequences );
        while ( aSeq = theIterator( ) ) {
          (*aSeq)->setEnabled( false );
          result = AbsInterp::OK;         
        }
      }
      
    } else {
      FwkString theSeqName(theName);
      FwkString theTrailer(": unknown name");
      FwkString theMessage=theSeqName+theTrailer;
      theFrame->setError( theMessage.c_str() );         
      result = AbsInterp::ERROR;
      return result;                   
    }
        
    index++;  
  }
  return result;
}

int 
APPSequenceCommand::enableHandler( )
{
  AppFramework* theFrame = (AppFramework*)target( );
  char*         theName;
  APPSequence*      theSeq;
  int index  = firstIndex;
  int result = AbsInterp::ERROR;
  
  while ( NULL != ( theName = getArgument( index ) ) ) {
    
    if ( NULL != ( theSeq = fetchSeq( theFrame, theName ) ) ) {
      theSeq->setEnabled( true );
      result = AbsInterp::OK;
      
    } else if ( 0 == strcmp(theName, "all") ) {
      APPList< APPSequence* >* sequences;
      sequences = fetchSeqs( theFrame );
      if ( ! sequences->isEmpty( ) ) {
        APPListIterator<APPSequence*> theIterator( *sequences );
        APPSequence** aSeq;
        while ( aSeq = theIterator( ) ) {
          (*aSeq)->setEnabled( true );
          result = AbsInterp::OK;
        }         
      }
      
    } else {
      FwkString theSeqName(theName);
      FwkString theTrailer(": unknown name");
      FwkString theMessage=theSeqName+theTrailer;
      theFrame->setError( theMessage.c_str() );         
      result = AbsInterp::ERROR;
      return result;         
    }
    index++;
  }
  return result;
}

int 
APPSequenceCommand::helpHandler( )
{
  AppFramework* theFrame = (AppFramework*)target( );
  
  APPBasicCommand::helpHandler( );
  
  theFrame->partialReport( "  append <seq> [-a(fter) <mod/seq>] "); 
  theFrame->fullReport("<mod1/seq1> [<mod2/seq2> ..]");
  theFrame->partialReport( "                                        " ); 
  theFrame->fullReport("Append module(s)/sequence(s)");  
  
  theFrame->partialReport( "  create <seq> [<mod1/seq1> ..]         " );
  theFrame->fullReport("Create a new sequence");
  
  theFrame->partialReport( "  delete <seq1> [<seq2> ..]             " );
  theFrame->fullReport("Delete sequence(s)");
  
  theFrame->partialReport( "  disable <seq1> [<seq2> ..]            " );
  theFrame->fullReport("Disable sequence(s)*");
  
  theFrame->partialReport( "  enable <seq1> [<seq2> ..]             " );
  theFrame->fullReport("Enable sequence(s)*");
  
  theFrame->partialReport( "  help                                  " );
  theFrame->fullReport("Show available commands");
  
  theFrame->partialReport( "  insert <seq> [-b(efore) <mod/seq>] " );
  theFrame->fullReport("<mod1/seq1> [<mod2/seq2> ..]");
  theFrame->partialReport( "                                        " ); 
  theFrame->fullReport("Insert module(s)/sequence(s)");
  
  theFrame->partialReport( "  list                                  " );
  theFrame->fullReport("List sequence(s)");
  
  theFrame->fullReport( "  remove <seq> <mod1/seq1> [<mod2/seq2> ..] " );
  theFrame->partialReport( "                                        " ); 
  theFrame->fullReport("Remove module(s)/sequence(s)");
  
  theFrame->fullReport(" ");
  theFrame->fullReport("* = 'all' can be used in place of <seq1>.");

  return AbsInterp::OK;
  
}

int 
APPSequenceCommand::insertHandler( )
{
  AppFramework*  theFrame = (AppFramework*)target( );
  APPNameNode*   theNode=0;
  APPNameNode*   otherNode =0;
  char*          theName=0;
  APPExecutable* theExec=0;
  APPExecutable* theOther =0;
  APPSequence*   theSeq=0;
  APPExecNode*   first=0;
  int index  = firstIndex;
  int result = AbsInterp::ERROR;
  
  if ( 0 != ( theName = getArgument( index ) ) ) {
    if ( 0 != ( theSeq = fetchSeq( theFrame, theName ) ) ) {
      index++;
      while( 0 != ( theName = getArgument( index ) ) ) {
        if ( 0 == strcmp( theName, "-before" ) || 
             0 == strcmp( theName, "-b"      ) ) {
          index++;
          if ( 0 != otherNode ) {
            delete otherNode;
          }
          otherNode = getNameNode( &index );
          if ( 0 != otherNode ) {
            theOther = theFrame->execFromName( otherNode->name( ) );
          }
        }
        if ( 0 != ( theNode = getNameNode( &index ) ) ) {
          theExec = theFrame->execFromName( theNode->name( ) );
          if ( 0 != theExec ) {
            first = theSeq->head( );
            if ( 0 == theOther ) {
              if (0 != first) { 
                theOther  =first->target( );
                otherNode = new APPNameNode (
                                             theOther->name( ),
                                             first->mode( ) );
              }
            }
            if (0 != first) {
              theSeq->insert( 
                             theExec, 
                             theNode->mode( ),
                             theOther, otherNode->mode( ) );
            }
            else {
              theSeq->insert(theExec, theNode->mode());
            }
          } else {
            FwkString theSeqName(theName);
            FwkString theTrailer(": unknown name");
            FwkString theMessage=theSeqName+theTrailer;
            theFrame->setError( theMessage.c_str() );           
          }
        }
        delete theNode;
      }
      if ( 0 != otherNode ) {
        delete otherNode;
      }
      result = AbsInterp::OK;
    } else {
      FwkString theSeqName(theName);
      FwkString theTrailer(": unknown name");
      FwkString theMessage=theSeqName+theTrailer;
      theFrame->setError( theMessage.c_str() );         
    }
  } else {
    theFrame->setError( "no name specified" );
  }
  return result;
}

int 
APPSequenceCommand::listHandler( )
{
    AppFramework* theFrame = (AppFramework*)target( );
    APPSequence**  seq;
    APPList< APPSequence* >* sequences;
    
    sequences = fetchSeqs( theFrame );
    if ( ! sequences->isEmpty( ) ) {
                APPListIterator<APPSequence*> theIterator( *sequences );
                while ( seq = theIterator( ) ) {
                        (*seq)->report( );
                }
    } else {
                theFrame->fullReport( "     None defined" );
    }
    return AbsInterp::OK;
}

int 
APPSequenceCommand::removeHandler( )
{
    AppFramework*  theFrame = (AppFramework*)target( );
    APPNameNode*   theNode;
    char*          theName;
    APPExecutable* theExec;
    APPSequence*   theSeq;
    int index  = firstIndex;
    int result = AbsInterp::ERROR;
    
    if ( NULL != ( theName = getArgument( index ) ) ) {
        if ( NULL != ( theSeq = fetchSeq( theFrame, theName ) ) ) {
           index++;
           while( NULL != ( theNode = getNameNode( &index ) ) ) {
              theExec = theFrame->execFromName( theNode->name( ) );
              if ( NULL != theExec ) {
                 theSeq->remove( theExec, theNode->mode( ) );
              } else {
                 FwkString theSeqName(theName);
                 FwkString theTrailer(": unknown name");
                 FwkString theMessage=theSeqName+theTrailer;
                 theFrame->setError( theMessage.c_str() );        
              }
              delete theNode;
           }
           result = AbsInterp::OK;
        } else {
           FwkString theSeqName(theName);
           FwkString theTrailer(": name already in use");
           FwkString theMessage=theSeqName+theTrailer;
           theFrame->setError( theMessage.c_str() );            
        }
    } else {
        theFrame->setError( "no name specified" );
    }
    return result;
}

APPSequence* 
APPSequenceCommand::fetchSeq( 
    AppFramework* theFrame, 
    const char* const theName )
{
    return theFrame->fetchSequence( theName );
}

APPSequence* 
APPSequenceCommand::newSeq( 
    AppFramework* theFrame, 
    const char* const theName )
{
    APPSequence* result = NULL;
    if ( ! theFrame->has( theName ) ) {
                result = new APPSequence( theName, NULL );
                theFrame->add( result );
    }
    return result;
}

APPList< APPSequence* >* 
APPSequenceCommand::fetchSeqs( AppFramework* theFrame )
{
    return theFrame->sequences( );
}

FwkString 
APPSequenceCommand::description( ) const
{
   return "Command used to create, modify and control sequences";
}

void
APPSequenceCommand::show( ) const 
{
}
bool
APPSequenceCommand::isShowable( ) const 
{
   return false; 
}

 

---

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

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