Sequencer.h

Go to the documentation of this file.

#ifndef ALGORITHM_SEQUENCER_H
#define ALGORITHM_SEQUENCER_H

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

class MsgStream;

class GAUDI_API Sequencer: public Algorithm {
 public:

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

    ~Sequencer( ) override = default;

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

    StatusCode initialize( ) override;

    StatusCode reinitialize( ) override;

    StatusCode start( ) override;

    StatusCode execute( ) override;

    StatusCode stop( ) override;

    StatusCode finalize( ) override;

    StatusCode beginRun( ) override;

    StatusCode endRun( ) override;

    void resetExecuted( ) override;


    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 );

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

     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( const 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 );

     // NO COPY / ASSIGNMENT  ALLOWED
    Sequencer( const Sequencer& a ) = delete;
    Sequencer& operator=( const Sequencer& rhs ) = delete;

private:

    /**************************
     ** 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 = false;               // Branch filter passed flag
};

#endif //ALGORITHM_SEQUENCER_H