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:
  using Algorithm::Algorithm;
  /*****************************
   ** Public Function Members **
   *****************************/

  StatusCode initialize() override;

  StatusCode reinitialize() override;

  StatusCode start() override;

  StatusCode execute() override;

  StatusCode stop() override;

  StatusCode finalize() override;

  void resetExecuted() override;

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

  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",
                                                    {},
                                                    [this]( auto& ) {
                                                      if ( this->isInitialized() ) this->decodeMemberNames().ignore();

                                                    },
                                                    "member names"};
  Gaudi::Property<std::vector<std::string>> m_branchNames{this,
                                                          "BranchMembers",
                                                          {},
                                                          [this]( auto& ) {
                                                            if ( this->isInitialized() )
                                                              this->decodeBranchMemberNames().ignore();
                                                          },
                                                          "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