---

Sequencer.cpp

Go to the documentation of this file.

//$Header: /nfs/slac/g/glast/ground/cvs/GaudiAlg/src/Sequencer.cpp,v 1.1.1.1 2001/04/18 21:03:30 tlindner Exp $

// Sequencer class
// Implements:
// 1) Common functionality of IInterface
// 2) Default behaviour for the IAlgorithm
//

#include "Sequencer.h"

#include "GaudiKernel/IAlgManager.h"
#include "GaudiKernel/ISvcLocator.h"
#include "GaudiKernel/AlgFactory.h"
#include "GaudiKernel/MsgStream.h"
#include "GaudiKernel/Chrono.h"
#include "GaudiKernel/Stat.h"
#include "GaudiKernel/GaudiException.h"

static const AlgFactory<Sequencer>    Factory;
const IAlgFactory& SequencerFactory = Factory;

Sequencer::Sequencer( const std::string& name, ISvcLocator* pSvcLocator )
: Algorithm( name, pSvcLocator ),
  m_branchFilterPassed( false )
{

    // Create vector of branch algorithms
    m_branchAlgs = new std::vector<Algorithm*>();

    // Declare Sequencer properties with their defaults
    declareProperty( "Members", m_names );
    declareProperty( "BranchMembers", m_branchNames );
    declareProperty( "StopOverride", m_stopOverride=false );

    // Associate action handlers with the "Members" and "BranchMembers" properties
    m_names.declareUpdateHandler      ( &Sequencer::membershipHandler      , this );
    m_branchNames.declareUpdateHandler( &Sequencer::branchMembershipHandler, this );

}

Sequencer::~Sequencer()
{
    delete m_branchAlgs;
}

StatusCode
Sequencer::initialize()
{
    StatusCode result;

    // Set the initialized state. This allows the membership handlers
    // to operate correctly since they are prevented from doing anything
    // until this state is reached.
    setInitialized( );

    // Build the main membership
    result = decodeMemberNames( );
    if ( result.isSuccess( ) ) {

        // Build the branch membership
        result = decodeBranchMemberNames( );
    }
    return result;
}

StatusCode
Sequencer::execute()
{
    StatusCode result = StatusCode::SUCCESS;
    MsgStream log( msgSvc( ), name( ) );

    log << MSG::DEBUG << name( ) << " Sequencer::execute( )" << endreq;

    // Bypass the loop if this sequencer is disabled or has already been executed
    if ( isEnabled( ) && ! isExecuted( ) ) {
        Algorithm* lastAlgorithm;
        result = execute( subAlgorithms( ), m_isInverted, lastAlgorithm );
        if ( result.isSuccess( ) ) {
            bool passed = filterPassed( );
            if ( ! passed && ! isStopOverride( ) ) {

                // Filter failed and stop override not set. Execute the
                // branch if there is one associated with the filter
                // algorithm that failed. Note that the first member on
                // the branch is the failing algorithm and so should
                // be skipped.
                std::vector<Algorithm*>* theAlgs = branchAlgorithms( );
                if ( theAlgs->size( ) > 0 ) {
                    Algorithm* branchAlgorithm = (*theAlgs)[0];
                    if ( lastAlgorithm == branchAlgorithm ) {

                        // Branch specified - Loop over branch members
                        result = execute( branchAlgorithms( ),
                                          m_isBranchInverted,
                                          lastAlgorithm, 1 );
                        if ( result.isSuccess( ) ) {

                            // The final filter passed state will be set true if either
                            // of the main or branches passed, otherwise false.

                            // Save the branch  filter passed state.
                            setBranchFilterPassed( filterPassed( ) );
                        }
                    }
                }
            }
        }

        // Prevent multiple executions of this sequencer for the current event
        setExecuted( true );
   }
    return result;
}

StatusCode
Sequencer::finalize()
{
    // Loop over all branch members calling their finalize functions
    // if they are not disabled. Note that the Algoriithm::sysFinalize
    // function already does this for the main members.
    std::vector<Algorithm*>* subAlgms = branchAlgorithms( );
    std::vector<Algorithm*>::iterator it;
    std::vector<Algorithm*>::iterator itend = subAlgms->end( );
    for (it = subAlgms->begin(); it != itend; it++) {
        Algorithm* theAlgorithm = (*it);
        theAlgorithm->sysFinalize( );
    }
    return StatusCode::SUCCESS;
}

StatusCode
Sequencer::resetExecuted( )
{
    Algorithm::resetExecuted( );

    // Loop over all members calling their resetExecuted functions
    // if they are not disabled.
    std::vector<Algorithm*>* subAlgms = subAlgorithms( );
    std::vector<Algorithm*>::iterator it;
    std::vector<Algorithm*>::iterator itend = subAlgms->end( );
    for (it = subAlgms->begin(); it != itend; it++) {
        Algorithm* theAlgorithm = (*it);
        theAlgorithm->resetExecuted( );
    }

    // Loop over all branch members calling their resetExecuted functions
    // if they are not disabled.
    subAlgms = branchAlgorithms( );
    itend    = subAlgms->end( );
    for (it = subAlgms->begin(); it != itend; it++) {
        Algorithm* theAlgorithm = (*it);
        theAlgorithm->resetExecuted( );
    }

    // Reset the branch filter passed flag
    m_branchFilterPassed = false;
    return StatusCode::SUCCESS;
}

bool
Sequencer::branchFilterPassed( ) const
{
    return m_branchFilterPassed;
}

StatusCode
Sequencer::setBranchFilterPassed( bool state )
{
    m_branchFilterPassed = state;
    return StatusCode::SUCCESS;
}

bool
Sequencer::isStopOverride( ) const
{
    return m_stopOverride.value( );
}

StatusCode
Sequencer::append( Algorithm* pAlgorithm )
{
    StatusCode result = append( pAlgorithm, subAlgorithms( ) );
    return result;
}

StatusCode
Sequencer::appendToBranch( Algorithm* pAlgorithm )
{
    StatusCode result = append( pAlgorithm, branchAlgorithms( ) );
    return result;
}

StatusCode
Sequencer::createAndAppend( const std::string& type,
                            const std::string& name,
                                            Algorithm*& pAlgorithm )
{
    StatusCode result = createAndAppend( type, name, pAlgorithm, subAlgorithms( ) );
    return result;
}

StatusCode
Sequencer::createAndAppendToBranch( const std::string& type,
                                    const std::string& name,
                                                    Algorithm*& pAlgorithm )
{
    StatusCode result = createAndAppend( type, name, pAlgorithm, branchAlgorithms( ) );
    return result;
}

StatusCode
Sequencer::remove( Algorithm* pAlgorithm )
{
    std::string theName = pAlgorithm->name( );
    StatusCode result = remove( theName );
    return result;
}

StatusCode
Sequencer::remove( const std::string& algname )
{
    StatusCode result = remove( algname, subAlgorithms( ) );
    return result;
}

StatusCode
Sequencer::removeFromBranch( Algorithm* pAlgorithm )
{
    std::string theName = pAlgorithm->name( );
    StatusCode result = removeFromBranch( theName );
    return result;
}

StatusCode
Sequencer::removeFromBranch( const std::string& algname )
{
    StatusCode result = remove( algname, branchAlgorithms( ) );
    return result;
}

std::vector<Algorithm*>*
Sequencer::branchAlgorithms( ) const {
    return m_branchAlgs;
}

StatusCode
Sequencer::decodeMemberNames( )
{
    StatusCode result = StatusCode::SUCCESS;

    // Don't do anything if the Sequencer isn't yet initialized
    if ( isInitialized( ) ) {

        // Decode the membership list
        result = decodeNames( m_names, subAlgorithms( ), m_isInverted );
    }
    return result;
}

void
Sequencer::membershipHandler( Property& /* theProp */ )
{
    decodeMemberNames( );
}

StatusCode
Sequencer::decodeBranchMemberNames( )
{
    StatusCode result = StatusCode::SUCCESS;

    // Don't do anything if the Sequencer isn't yet initialized
    if ( isInitialized( ) ) {

        // Decode the branch membership list
        result = decodeNames( m_branchNames,
                              branchAlgorithms( ),
                              m_isBranchInverted );

    }
    return result;
}

void
Sequencer::branchMembershipHandler( Property& /* theProp */ )
{
    decodeBranchMemberNames( );
}

StatusCode
Sequencer::append( Algorithm* pAlgorithm,
                   std::vector<Algorithm*>* theAlgs )
{
    StatusCode result = StatusCode::SUCCESS;

    // Check that the specified algorithm doesn't already exist in the membership list
    std::vector<Algorithm*>::iterator it;
    std::vector<Algorithm*>::iterator itend = theAlgs->end( );
    for (it = theAlgs->begin(); it != itend; it++) {
        Algorithm* theAlgorithm = (*it);
        if ( theAlgorithm == pAlgorithm ) {
            result = StatusCode::FAILURE;
            break;
        }
    }
    if ( result.isSuccess( ) ) {
        theAlgs->push_back( pAlgorithm );
    }
    return result;
}

StatusCode
Sequencer::createAndAppend( const std::string& type,
                                const std::string& name,
                                Algorithm*& pAlgorithm,
                                std::vector<Algorithm*>* theAlgs )
{
    StatusCode result = StatusCode::FAILURE;
    IAlgManager* theAlgMgr;
    result = serviceLocator( )->getService( "ApplicationMgr",
                                            IID_IAlgManager,
                                            (IInterface*&)theAlgMgr );
    if ( result.isSuccess( ) ) {

            IAlgorithm* tmp;
        result = theAlgMgr->createAlgorithm( type, name, tmp );
        if ( result.isSuccess( ) ) {
                try{
                        pAlgorithm = dynamic_cast<Algorithm*>(tmp);
                        theAlgs->push_back( pAlgorithm );       
                } catch(...){
                        result = StatusCode::FAILURE;
                    }
        }
        }
        return result;
}

StatusCode
Sequencer::decodeNames( StringArrayProperty& theNames,
                        std::vector<Algorithm*>* theAlgs,
                        std::vector<bool>& theLogic )
{
    StatusCode result;
    MsgStream log( msgSvc( ), name( ) );
    IAlgManager* theAlgMgr;
    result = serviceLocator( )->getService( "ApplicationMgr",
                                            IID_IAlgManager,
                                            (IInterface*&)theAlgMgr );
    if ( result.isSuccess( ) ) {

        // Clear the existing list of algorithms
        theAlgs->clear( );

        // Build the list of member algorithms from the contents of the
        // theNames list.
        const std::vector<std::string>& theNameVector = theNames.value( );
        std::vector<std::string>::const_iterator it;
        std::vector<std::string>::const_iterator itend = theNameVector.end( );
        for (it = theNameVector.begin(); it != itend; it++) {

            // Parse the name for a syntax of the form:
            //
            // <type>/<name>
            //
            // Where <name> is the algorithm instance name, and <type> is the
            // algorithm class type (being a subclass of Algorithm).
            std::string theName = (*it);
            std::string theType = (*it);
            int slash = (*it).find_first_of( "/" );
            if ( slash > 0 ) {
                theType = (*it).substr( 0, slash );
                theName = (*it).substr( slash+1 );
            }

            // Parse the name for a syntax of the form:
            //
            // <name>:invert
            //
            // Where <name> is the algorithm instance name and ":invert"
            // indicates that the filter passed logic is inverted.
            bool isInverted = false;
            int invert    = theName.find_first_of( ":" );
            if ( invert > 0 ) {
                theName = theName.substr( 0, invert );
                isInverted = true;
            }
            // Check whether the suppied name corresponds to an existing
            // Algorithm object.
            IAlgorithm* theIAlg;
            Algorithm*  theAlgorithm;
            StatusCode status = theAlgMgr->getAlgorithm( theName, theIAlg );
            if ( status.isSuccess( ) ) {
                    try{
                            theAlgorithm = dynamic_cast<Algorithm*>(theIAlg);
                    } catch(...){
                            status = StatusCode::FAILURE;
                    }
                }
            if ( status.isSuccess( ) ) {

                // The specified Algorithm already exists - just append it to the membership list.
                status = append( theAlgorithm, theAlgs );
                if ( status.isSuccess( ) ) {
                    log << MSG::INFO << theName << " already exists - appended to member list" << endreq;
                } else {
                    log << MSG::INFO << theName << " already exists - append failed!!!" << endreq;
                }
            } else {

                // The specified name doesn't exist - create a new object of the specified type
                // and append it to the membership list.
                status = createAndAppend( theType, theName, theAlgorithm, theAlgs );
                if ( status.isSuccess( ) ) {
                    log << MSG::INFO << theName << " doesn't exist - created and appended to member list" << endreq;
                } else {
                    log << MSG::INFO << theName << " doesn't exist - creation failed!!!" << endreq;
                }
            }
            if ( status.isSuccess( ) ) {
                theLogic.push_back( isInverted );
            }
        }

        // Loop over all the membership list calling their initialize functions
        // if they are not disabled. Note that the Algoriithm::sysInitialize
        // function protects this from affecting Algorithms that have already
        // been initialized.
        std::vector<Algorithm*>::iterator ait;
        std::vector<Algorithm*>::iterator aitend = theAlgs->end( );
        for (ait = theAlgs->begin(); ait != aitend; ait++) {
            Algorithm* theAlgorithm = (*ait);
            theAlgorithm->sysInitialize( );
        }

    }
    return result;
}

StatusCode
Sequencer::execute( std::vector<Algorithm*>* theAlgs,
                    std::vector<bool>& theLogic,
                    Algorithm*& lastAlgorithm,
                    unsigned int first )
{
    StatusCode result = StatusCode::SUCCESS;

    // Loop over all algorithms calling their execute functions if they
    // are (a) not disabled, and (b) aren't already executed. Note that
    // in the latter case the filter state is still examined. Terminate
    // the loop if an algorithm indicates that it's filter didn't pass.
    unsigned int size = theAlgs->size( );
    for (unsigned int i = first; i < size; i++) {
        lastAlgorithm = (*theAlgs)[i];
        result = executeMember( lastAlgorithm );
        if ( result.isSuccess( ) ) {

            // Take the filter passed status of this algorithm as my own status.
            // Note that we take into account inverted logic.
            bool passed = lastAlgorithm->filterPassed( );
            bool isInverted = theLogic[i];
            if ( isInverted ) {
                passed = ! passed;
            }
            setFilterPassed( passed );

            // The behaviour when the filter fails depends on the StopOverride property.
            // The default action is to stop processing, but this default can be
            // overridden by setting the "StopOverride" property to true.
            if ( ! isStopOverride( ) ) {
                if ( ! passed ) break;
            }
        } else {
            break;
        }
    }
    return result;
}

StatusCode
Sequencer::executeMember( Algorithm* theAlgorithm )
{
    StatusCode result = StatusCode::SUCCESS;
    if ( theAlgorithm->isEnabled( ) ) {
        if ( ! theAlgorithm->isExecuted( ) ) {
            result = theAlgorithm->sysExecute( );

            // Set the executed state of the algorithm.
            // I think this should be done by the algorithm itself, but just in case...
            theAlgorithm->setExecuted( true );
        }
    }
    return result;
}

StatusCode
Sequencer::remove( const std::string& algname, std::vector<Algorithm*>* theAlgs )
{
    MsgStream log( msgSvc( ), name( ) );
    StatusCode result = StatusCode::FAILURE;

    // Test that the algorithm exists in the member list
    std::vector<Algorithm*>::iterator it;
    std::vector<Algorithm*>::iterator itend = theAlgs->end( );
    for (it = theAlgs->begin(); it != itend; it++) {
        Algorithm* theAlgorithm = (*it);
        if ( theAlgorithm->name( ) == algname ) {

            // Algorithm with specified name exists in the algorithm list - remove it
            // THIS ISN'T IMPLEMENTED YET!!!!
            log << MSG::INFO <<"Sequencer::remove( ) isn't implemented yet!!!!!" << endreq;
            result = StatusCode::SUCCESS;
            break;
        }
    }
    return result;
}

---