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:
  GaudiSequencer( const std::string& name, ISvcLocator* pSvcLocator );

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

  StatusCode beginRun() override; 
  StatusCode endRun() 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( Gaudi::Details::PropertyBase& theProp );

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

  Gaudi::Property<std::vector<std::string>> m_names = {this, "Members", {}, "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