GaudiSequencer.h

Go to the documentation of this file.

#ifndef GAUDISEQUENCER_H
#define GAUDISEQUENCER_H 1

// Include files
// from Gaudi
#include "GaudiAlg/GaudiAlgorithm.h"

// Forward declarations
class ISequencerTimerTool;

class GAUDI_API GaudiSequencer : public GaudiAlgorithm
{
public:
  using GaudiAlgorithm::GaudiAlgorithm;

  StatusCode initialize() override; 
  StatusCode execute() override;    

  bool isSequence() const override final { return true; }

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

private:
  class AlgorithmEntry final
  {
  public:
    AlgorithmEntry( Algorithm* alg ) : m_algorithm( alg ) {}

    void setReverse( bool flag ) { m_reverse = flag; }

    Algorithm* algorithm() const { return m_algorithm; }
    bool       reverse() const { return m_reverse; }
    void setTimer( int nb ) { m_timer = nb; }
    int                timer() const { return m_timer; }

  private:
    Algorithm* m_algorithm = nullptr; 
    bool       m_reverse   = false;   
    int        m_timer     = 0;       
  };

  StatusCode decodeNames();

  void membershipHandler();

  GaudiSequencer( const GaudiSequencer& a ) = delete;
  GaudiSequencer& operator=( const GaudiSequencer& a ) = delete;

  Gaudi::Property<std::vector<std::string>> m_names = {
      this, "Members", {}, &GaudiSequencer::membershipHandler, "list of algorithms"};
  Gaudi::Property<bool> m_sequential   = {this, "Sequential", false, "execute members one at a time"};
  Gaudi::Property<bool> m_modeOR       = {this, "ModeOR", false, "use OR logic instead of AND"};
  Gaudi::Property<bool> m_ignoreFilter = {this, "IgnoreFilterPassed", false, "always continue"};
  Gaudi::Property<bool> m_measureTime  = {this, "MeasureTime", false, "measure time"};
  Gaudi::Property<bool> m_returnOK     = {this, "ReturnOK", false, "forces the sequencer to return a good status"};
  Gaudi::Property<bool> m_shortCircuit = {this, "ShortCircuit", true, "stop processing as soon as possible"};
  Gaudi::Property<bool> m_invert       = {this, "Invert", false, "invert the logic result of the sequencer"};

  std::vector<AlgorithmEntry> m_entries;             
  ISequencerTimerTool*        m_timerTool = nullptr; 
  int                         m_timer;               
};
#endif // GAUDISEQUENCER_H