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

                 

---

/Framework/src/AppOutputCommand.cc

Go to the documentation of this file.

//--------------------------------------------------------------------------
// File and Version Information:
//      $Id: AppOutputCommand.cc,v 1.12 2002/08/03 01:31:05 desilva Exp $
//
// Description:
//      Class AppOutputCommand. Command handler for the "output" command for
//      the standard file output module. Valid subcommands are:
//
//      output clear                            Empty the list of streams
//      output create <stream> [<dest>]         Create stream optionally bound to destination
//      output delete <stream1> [<str2> ..]     Remove stream(s) from list
//      output destination <stream> [<dest>]    Bind stream to destination
//      output disable <stream1> [<str2> ..]    Disable stream(s)
//      output enable  <stream1> [<str2> ..]    Enable stream(s)
//      output help                             Display help information
//      output list                             List current streams/files
//      output paths <stream> <path1>...        Bind <path1> etc. to stream
//      output reset                            Synonym for clear
//      output statistics                       List statistics for each stream
//      output stream <stream> [<dest>]         Synonym for create
//      output wipe-out                         Synonym for clear
//
// Environment:
//      Software developed for the BaBar Detector at the SLAC B-Factory.
//
// Author List:
//      David R. Quarrie                Original Author
//      Marc Turcotte                   Merged in R.Kapur's TK interface
//
// 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/AppOutputCommand.hh"

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

//-------------------------------
// Collaborating Class Headers --
//-------------------------------
#include "Framework/APPFramework.hh"
#include "Framework/AppStreamsOutputModule.hh"
#include "Framework/AppStream.hh"
#include "Framework/APPPath.hh"
#include "FrameUtil/APPList.hh"
#include "FrameUtil/APPListIterator.hh"
#include "FrameUtil/AbsInterp.hh"
#include "FrameUtil/FwkString.hh"

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

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

AppOutputCommand::AppOutputCommand( 
    const char* const theCommand, AppModule* theTarget )
    : APPCommand( theCommand, theTarget )
{
}

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

AppOutputCommand::~AppOutputCommand( )
{
}

//-----------
// Handler --
//-----------

int 
AppOutputCommand::handle( int argc, char* argv[] )
{
    AppStreamsOutputModule* theOutput = (AppStreamsOutputModule*)target( );
    int result = AbsInterp::ERROR;
    
    setArgs( argc, argv );
    if ( 2 <= argc ) {
        result = handleCommand( argc, argv );
        if ( AbsInterp::OK != result ) {
          FwkString txtmsg("invalid command name: ");
          for (int index=0; index < argc; index++ ) {
            txtmsg += " ";
            txtmsg += argv[index];
          }
          theOutput->setError( txtmsg );
        }
    } else {
        theOutput->setError( "wrong # args" );
    }
    return result;
}

void
AppOutputCommand::show( ) const {
}

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

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

int 
AppOutputCommand::handleCommand( int argc, char* argv[] )
{
    int result = AbsInterp::ERROR;

    if        ( 0 == strcmp( argv[1], "clear"    ) || 
                0 == strcmp( argv[1], "reset"    ) ||
                0 == strcmp( argv[1], "wipe"     ) || 
                0 == strcmp( argv[1], "wipe-out" ) ) { 
        result = wipeoutHandler( );
    } else if ( 0 == strcmp( argv[1], "create" ) || 
                0 == strcmp( argv[1], "cr"     ) ||
                0 == strcmp( argv[1], "stream" ) || 
                0 == strcmp( argv[1], "st"     ) ) {
        result = createHandler( );
    } else if ( 0 == strcmp( argv[1], "delete" ) ) {
        result = deleteHandler( );
    } else if ( 0 == strcmp( argv[1], "destination" ) || 
                0 == strcmp( argv[1], "des"         ) ) {
        result = destinationHandler( );
    } else if ( 0 == strcmp( argv[1], "disable" ) || 
                0 == strcmp( argv[1], "dis"     ) ) {
        result = disableHandler( );
    } else if ( 0 == strcmp( argv[1], "enable" ) || 
                0 == strcmp( argv[1], "ena"    ) ) {
        result = enableHandler( );
    } else if ( 0 == strcmp( argv[1], "help" ) || 
                0 == strcmp( argv[1], "he"   ) ) {
        result = helpHandler( );
    } else if ( 0 == strcmp( argv[1], "list" ) || 
                0 == strcmp( argv[1], "li"   ) ) {
        result = listHandler( );
    } else if ( 0 == strcmp( argv[1], "paths" ) ||
                0 == strcmp( argv[1], "path"  ) ) {
        result = pathsHandler( );
    } else if ( 0 == strcmp( argv[1], "statistics" ) || 
                0 == strcmp( argv[1], "stat"       ) ) {
        result = statisticsHandler( );
    }
    return result;
}

int 
AppOutputCommand::createHandler( )
{
  AppStreamsOutputModule* theOutput = (AppStreamsOutputModule*)target( );
  AppFramework*           theFrame  = theOutput->framework( );
  AppStream*              theStream;
  char*                   theName;
  char*                   theDestination;
  int index  = 2;
  int result = AbsInterp::ERROR;
  
    if ( NULL != ( theName = getArgument( index ) ) ) {
      if ( validateName( theName ) ) {
        if ( ! theOutput->has( theName ) ) {
          index++;
          theDestination = getArgument( index );
          theStream      = createStream( theName, theDestination );
          theOutput->append( theStream );
          result = AbsInterp::OK;
        } else {
          ostrstream error;
          error << "***** Duplicate stream name: " << theName 
                << " - ignored" << endl;
          char* ptrerr = error.str( );
          theFrame->setError( ptrerr);
          delete [] ptrerr;  // str() freezes underlying array
        }
      }
    }
    return result;
}

int 
AppOutputCommand::deleteHandler( )
{
  AppStreamsOutputModule* theOutput = (AppStreamsOutputModule*)target( );
  AppFramework*           theFrame  = theOutput->framework( );
  char*                   theName;
  AppStream*              theStream;
  ostrstream error;
  int index  = 2;
  int result = AbsInterp::OK;
  
  while ( NULL != ( theName = getArgument( index ) ) ) {
    if ( NULL != ( theStream = theOutput->fetch( theName ) ) ) {
      theOutput->remove( theName );
    } else {
      if ( AbsInterp::OK == result ) {
        error << "***** Unknown stream name(s):";
      }
      error << " " << theName;
      result = AbsInterp::ERROR;
    }
    index++;
  }
  if ( AbsInterp::OK != result ) {
    error << " -ignored" << endl;
    char* ptrerr = error.str( );
    theFrame->setError( ptrerr );
    delete [] ptrerr; // str() freezes underlying array
  }
  return result;
}

int 
AppOutputCommand::destinationHandler( )
{
  AppStreamsOutputModule* theOutput = (AppStreamsOutputModule*)target( );
  AppFramework*           theFrame  = theOutput->framework( );
  AppStream*              theStream;
  char*                   theName;
  int index  = 2;
  int result = AbsInterp::ERROR;
  
  if ( NULL != ( theName = getArgument( index ) ) ) {
    if ( validateName( theName ) ) {
      if ( NULL != ( theStream = theOutput->fetch( theName ) ) ) {
        index++;
        theName = getArgument( index );
        theStream->setDestination( theName );
        result = AbsInterp::OK;
      } else {
        ostrstream error;
        error << "***** Unknown stream name: " << theName <<" - ignored" << endl;
        char* ptrerr = error.str(); 
        theFrame->setError( ptrerr );
        delete [] ptrerr; // str() freezes underlying array
        result = AbsInterp::ERROR;
      }
    }
  }
  return result;
}

int
AppOutputCommand::disableHandler( )
{

  AppStreamsOutputModule* theOutput = (AppStreamsOutputModule*)target( );
  AppFramework*           theFrame  = theOutput->framework( );
  AppStream*              theStream;
  char*                   theName;
  ostrstream error;
  int index  = 2;
  int result = AbsInterp::OK;
  while ( NULL != ( theName = getArgument( index ) ) ) {
    if ( NULL != ( theStream = theOutput->fetch( theName ) ) ) {
      theStream->setEnabled( false );
    } else {
      if ( AbsInterp::OK == result ) {
        error << "***** Unknown stream name(s):";
      }
      error << " " << theName;
      result = AbsInterp::ERROR;
    }
    index++;
  }
  if ( AbsInterp::OK != result ) {
    error << " -ignored" << endl;
    char* ptrerr = error.str( );
    theFrame->setError(ptrerr);
    delete [] ptrerr; // str() freezes underlying array
  }
  return result;
}

int 
AppOutputCommand::enableHandler( )
{
  AppStreamsOutputModule* theOutput = (AppStreamsOutputModule*)target( );
  AppFramework*           theFrame  = theOutput->framework( );
  AppStream*              theStream;
  char*                   theName;
  ostrstream error;
  int index  = 2;
  int result = AbsInterp::OK;
  while ( NULL != ( theName = getArgument( index ) ) ) {
    if ( NULL != ( theStream = theOutput->fetch( theName ) ) ) {
      theStream->setEnabled( true );
    } else {
      if ( AbsInterp::OK == result ) {
        error << "***** Unknown stream name(s):";
      }
      error << " " << theName;
      result = AbsInterp::ERROR;
    }
    index++;
  }
  if ( AbsInterp::OK != result ) {
    error << " -ignored" << endl;
    char* ptrerr = error.str( );
    theFrame->setError(ptrerr);
    delete [] ptrerr; // str() freezes underlying array
  }
  return result;
}

int 
AppOutputCommand::helpHandler( )
{
    AppStreamsOutputModule* theOutput = (AppStreamsOutputModule*)target( );
    AppFramework*           theFrame  = theOutput->framework( );
    int result = AbsInterp::OK;

    theFrame->partialReport( "output clear                            " );
    theFrame->fullReport("Empty the list of streams" );
    theFrame->partialReport( "output create <stream> [<dest>]         " );
    theFrame->fullReport("Create stream" );
    theFrame->partialReport( "output delete <stream1> [<str2> ..]     " );
    theFrame->fullReport("Remove stream(s) from list" );
    theFrame->partialReport( "output destination <stream> [<dest>]    " );
    theFrame->fullReport("Bind stream to destination" );
    theFrame->partialReport( "output disable <stream1> [<str2> ..]    " );
    theFrame->fullReport("Disable stream(s)" );
    theFrame->partialReport( "output enable  <stream1> [<str2> ..]    " );
    theFrame->fullReport("Enable stream(s)" );
    theFrame->partialReport( "output paths <stream> <path1>...        " );
    theFrame->fullReport("Bind <path1> etc. to stream" );
    theFrame->partialReport( "output reset                            " );
    theFrame->fullReport("Synonym for clear" );
    theFrame->partialReport( "output statistics                       " );
    theFrame->fullReport("List statistics for each stream" );
    theFrame->partialReport( "output stream <stream> [<dest>]         " );
    theFrame->fullReport("Synonym for create" );
    theFrame->partialReport( "output wipe-out                         " );
    theFrame->fullReport("Synonym for clear" );
    return result;
}

int 
AppOutputCommand::listHandler( )
{
    AppStreamsOutputModule* theOutput = (AppStreamsOutputModule*)target( );
    AppFramework*           theFrame  = theOutput->framework( );
    APPList< AppStream* >*  theList   = theOutput->streams( );
    APPList< APPPath* >*    thePaths;
    AppStream**             theStream;
    APPPath**               thePath;
    const char*             theDest;

    if ( ! theList->isEmpty( ) ) {
        APPListIterator<AppStream*> iter1( *theList );
        while ( theStream = iter1( ) ) {
            theFrame->fullReport( "" );
            theFrame->partialReport( (*theStream)->name( ) );
            theFrame->partialReport( ":" );
            if ( ! (*theStream)->isEnabled( ) ) {
                theFrame->partialReport( " (disabled)" );
            }
            theFrame->fullReport( "" );
            theFrame->partialReport( "    " );
            theFrame->partialReport( destinationString( ) );
            theFrame->partialReport( ": " );
            if ( NULL != ( theDest = (*theStream)->destination( ) ) ) {
                theFrame->partialReport( theDest );
            } else {
                theFrame->partialReport( "(none)" );
            }
            theFrame->fullReport("");
            listInformation( *theStream, theFrame );
            theFrame->partialReport( "    Paths: " );
            thePaths = (*theStream)->paths( );
            if ( ! thePaths->isEmpty( ) ) {
                APPListIterator<APPPath*> iter2( *thePaths );
                while ( thePath = iter2( ) ) {
                    theFrame->partialReport( (*thePath)->name( ) );
                    theFrame->partialReport(" ");
                }
            } else {
                theFrame->partialReport( "(none)" );
            }
            theFrame->fullReport(""); 
        }
    } else {
        theFrame->fullReport( "No output streams are defined" );
    }
    return AbsInterp::OK;

}

int 
AppOutputCommand::pathsHandler( )
{
  AppStreamsOutputModule* theOutput = (AppStreamsOutputModule*)target( );
  AppFramework*           theFrame  = theOutput->framework( );
  AppStream*              theStream;
  APPPath*                thePath;
  char*                   theName;
  bool add   = true;
  int index  = 2;
  
  int result = AbsInterp::OK;
  
  
  if ( NULL != ( theName = getArgument( index ) ) ) {
    if ( NULL != ( theStream = theOutput->fetch( theName ) ) ) {
      index++;
      while ( NULL != ( theName = getArgument( index ) ) ) {
        if (        0 == strcmp( theName, "-add"    ) ||
                    0 == strcmp( theName, "-a"      ) ) {
          add = true;
        } else if ( 0 == strcmp( theName, "-remove" ) ||
                    0 == strcmp( theName, "-r"      ) ) {
          add = false;
        } else {
          if ( NULL != ( thePath = theFrame->fetchPath( theName ) ) ) {
            if ( add ) {
              theStream->append( thePath );
            } else {
              theStream->remove( thePath );
            }
          } else {
            theFrame->setError("unknown path name");
            result = AbsInterp::ERROR;
          }
        }
        index++;
      }
    } else {
      ostrstream error;
      error << "***** Unknown stream name: " << theName <<" - ignored" << endl;
      char* ptrerr = error.str();
      theFrame->setError(ptrerr);
      delete [] ptrerr; // str() freezes underlying array
      result = AbsInterp::ERROR;
    }
  } else {
    theFrame->setError("no arguments supplied");
    result = AbsInterp::ERROR;
  }
  return result;
}

int 
AppOutputCommand::statisticsHandler( )
{
  AppStreamsOutputModule* theOutput = (AppStreamsOutputModule*)target( );
  AppFramework*           theFrame  = theOutput->framework( );
  APPList< AppStream* >*  theList   = theOutput->streams( );
  APPList< APPPath* >*    thePaths;
  AppStream**             theStream;
  
  if ( ! theList->isEmpty( ) ) {
    APPListIterator<AppStream*> iter1( *theList );
    while ( theStream = iter1( ) ) {
      theFrame->fullReport( "" );
      theFrame->partialReport( (*theStream)->name( ) );
      theFrame->partialReport( ":   " );
      ostrstream stream;
      stream << (*theStream)->events( ) << '\0';
      char* bufptr = stream.str( );
      theFrame->partialReport( bufptr );
      delete [] bufptr; // str() freezes underlying array
      theFrame->fullReport( " events" );
      statisticsInformation( *theStream, theFrame );
    }
  } else {
    theFrame->fullReport( "No output streams are defined" );
  }
  return AbsInterp::OK;
  
}

int 
AppOutputCommand::wipeoutHandler( ) {
    AppStreamsOutputModule* theOutput = (AppStreamsOutputModule*)target( );
    theOutput->wipeout( );
    return AbsInterp::OK;
}

void 
AppOutputCommand::listInformation( AppStream* theStream, AppFramework* theFrame )
{
}

void 
AppOutputCommand::statisticsInformation( AppStream* theStream, AppFramework* theFrame )
{
}

void 
AppOutputCommand::dumpState(AppConfigRecorder* r) {

  char* var[10];
  AppStreamsOutputModule* theOutput = (AppStreamsOutputModule*)target( );
  if (theOutput->streams( ) != 0) {
    APPListIterator<AppStream*> theIterator( *theOutput->streams( ) );
    AppStream** theStream;
    var[0] = "output";
    while (theStream = theIterator()) {
      
      // create the stream
      var[1] = "create";
      var[2] = const_cast<char*>((*theStream)->name());
      if ((*theStream)->destination() != 0) {
        var[3] = const_cast<char*>((*theStream)->destination());
        r->store(4, var);
      } else {
        r->store(3, var);
      }
      
      // enable or disable stream
      if ((*theStream)->isEnabled()) {
        var[1] = "enable";
      } else {
        var[1] = "disable";
      }
      var[2] = const_cast<char*>((*theStream)->name());
      r->store(3, var);
      
      // paths bound to this stream
      APPPath** thePath;
      APPListIterator<APPPath*> itsPaths(*(*theStream)->paths()); 
      while (thePath = itsPaths()) {
        var[1] = "paths";
        var[2] = const_cast<char*>((*theStream)->name());
        var[3] = const_cast<char*>((*thePath)->name());
        r->store(4, var);
      }
    }
  }
} 

void 
AppOutputCommand::restoreState(char* argv[]) {
  int i=0;
  while(argv[i]){
    i++;
  }
  int argc = i;
  int rval = handle(argc, argv);
}

 

---

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

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