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

  StatusCode decodeBranchMemberNames();

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( Gaudi::Property<std::vector<std::string>>& 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;

public:
  std::ostream& toControlFlowExpression( std::ostream& os ) const override;

private:
  /**************************
   ** Private Data Members **
   **************************/

  Gaudi::Property<std::vector<std::string>> m_names{this, "Members", {}, "member names"};
  Gaudi::Property<std::vector<std::string>> m_branchNames{this, "BranchMembers", {}, "branch member names"};
  Gaudi::Property<bool> m_stopOverride{this, "StopOverride", false, "stop on filter failure override"};

  std::vector<bool> m_isInverted;       // Member logic inverted list
  std::vector<Algorithm*> m_branchAlgs; // Branch algorithms
  std::vector<bool> m_isBranchInverted; // Branch Member logic inverted list

  bool m_branchFilterPassed = false; // Branch filter passed flag
};

#endif // ALGORITHM_SEQUENCER_H