Sequencer.h

Go to the documentation of this file.

// $Header: /tmp/svngaudi/tmp.jEpFh25751/Gaudi/GaudiAlg/GaudiAlg/Sequencer.h,v 1.4 2008/06/02 14:22:04 marcocle Exp $
#ifndef ALGORITHM_SEQUENCER_H
#define ALGORITHM_SEQUENCER_H

// Include files
#include "GaudiKernel/Algorithm.h"
#include "GaudiKernel/Property.h"

class MsgStream;

class Sequencer : public Algorithm {
 public:

    Sequencer( const std::string& name, // The path object's name
                   ISvcLocator* svcloc      // A pointer to a service location service
              );

    virtual ~Sequencer( );

    /*****************************
     ** Public Function Members **
     *****************************/

    virtual StatusCode initialize( );

    virtual StatusCode reinitialize( );

    virtual StatusCode start( );

    virtual StatusCode execute( );
    
    virtual StatusCode stop( );

    virtual StatusCode finalize( );
    
    virtual StatusCode beginRun( );

    virtual StatusCode endRun( );

    void resetExecuted( );

    virtual bool branchFilterPassed( ) const;

    virtual StatusCode setBranchFilterPassed( bool state );

    virtual bool isStopOverride( ) const;

    StatusCode append( Algorithm* pAlgorithm );

    StatusCode appendToBranch( Algorithm* pAlgorithm );

     StatusCode createAndAppend(
            const std::string& type,  // The concrete algorithm class of the algorithm
            const std::string& name,  // The name to be given to the algorithm
            Algorithm*& pAlgorithm    // Set to point to the newly created algorithm object
        );

     StatusCode createAndAppendToBranch(
            const std::string& type,  // The concrete algorithm class of the algorithm
            const std::string& name,  // The name to be given to the algorithm
            Algorithm*& pAlgorithm    // Set to point to the newly created algorithm object
        );

    StatusCode remove( Algorithm* pAlgorithm );
    StatusCode remove( const std::string& name );
    StatusCode removeFromBranch( Algorithm* pAlgorithm );
    StatusCode removeFromBranch( const std::string& name );

    std::vector<Algorithm*>* branchAlgorithms( ) const;

     StatusCode decodeMemberNames( );

     void       membershipHandler( Property& theProp );

     StatusCode decodeBranchMemberNames( );

     void       branchMembershipHandler( Property& theProp );

protected:

    StatusCode append( Algorithm* pAlgorithm,
                       std::vector<Algorithm*>* theAlgs );

     StatusCode createAndAppend(
            const std::string& type,  // The concrete algorithm class of the algorithm
            const std::string& name,  // The name to be given to the algorithm
            Algorithm*& pAlgorithm,    // Set to point to the newly created algorithm object
            std::vector<Algorithm*>* theAlgs
        );

    StatusCode decodeNames( StringArrayProperty& theNames,
                            std::vector<Algorithm*>* theAlgs,
                            std::vector<bool>& theLogic );

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

    StatusCode executeMember( Algorithm* theAlgorithm );

    StatusCode remove( const std::string& algname, std::vector<Algorithm*>* theAlgs );

private:

    /******************************
     ** Private Function Members **
     ******************************/

    Sequencer( const Sequencer& a );

    Sequencer& operator=( const Sequencer& rhs );

    /**************************
     ** Private Data Members **
     **************************/

    StringArrayProperty m_names;             // Member names
    std::vector<bool> m_isInverted;          // Member logic inverted list
    StringArrayProperty m_branchNames;       // Branch Member names
    std::vector<Algorithm*>* m_branchAlgs;   // Branch algorithms
    std::vector<bool> m_isBranchInverted;    // Branch Member logic inverted list
    BooleanProperty m_stopOverride;          // Stop on filter failure Override flag
    bool m_branchFilterPassed;               // Branch filter passed flag
};

#endif //ALGORITHM_SEQUENCER_H