Sequencer.h

Go to the documentation of this file.

/***********************************************************************************\
* (c) Copyright 1998-2019 CERN for the benefit of the LHCb and ATLAS collaborations *
*                                                                                   *
* This software is distributed under the terms of the Apache version 2 licence,     *
* copied verbatim in the file "LICENSE".                                            *
*                                                                                   *
* In applying this licence, CERN does not waive the privileges and immunities       *
* granted to it by virtue of its status as an Intergovernmental Organization        *
* or submit itself to any jurisdiction.                                             *
\***********************************************************************************/
#ifndef ALGORITHM_SEQUENCER_H
#define ALGORITHM_SEQUENCER_H
 
// Include files
#include <Gaudi/Property.h>
#include <Gaudi/Sequence.h>
 
#include <mutex>
 
class MsgStream;
 
class GAUDI_API Sequencer : public Gaudi::Sequence {
public:
  using Gaudi::Sequence::Sequence;
  /*****************************
   ** Public Function Members **
   *****************************/
 
  StatusCode initialize() override;
 
  StatusCode reinitialize() override;
 
  StatusCode start() override;
 
  StatusCode execute( const EventContext& ctx ) const override;
 
  StatusCode stop() override;
 
  StatusCode finalize() override;
 
  bool branchFilterPassed( const EventContext& ctx ) const;
 
  void setBranchFilterPassed( const EventContext& ctx, bool state ) const;
 
  virtual bool isStopOverride() const;
 
  StatusCode append( Gaudi::Algorithm* pAlgorithm );
 
  StatusCode appendToBranch( Gaudi::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
                              Gaudi::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
                                      Gaudi::Algorithm*& pAlgorithm // Set to point to the newly created algorithm
                                                                    // object
  );
 
  StatusCode remove( Gaudi::Algorithm* pAlgorithm );
  StatusCode remove( const std::string& name );
  StatusCode removeFromBranch( Gaudi::Algorithm* pAlgorithm );
  StatusCode removeFromBranch( const std::string& name );
 
  const std::vector<Gaudi::Algorithm*>& branchAlgorithms() const;
  std::vector<Gaudi::Algorithm*>&       branchAlgorithms();
 
  StatusCode decodeMemberNames();
 
  StatusCode decodeBranchMemberNames();
 
protected:
  StatusCode append( Gaudi::Algorithm* pAlgorithm, std::vector<Gaudi::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
                              Gaudi::Algorithm*& pAlgorithm, // Set to point to the newly created algorithm object
                              std::vector<Gaudi::Algorithm*>& theAlgs );
 
  StatusCode decodeNames( Gaudi::Property<std::vector<std::string>>& theNames, std::vector<Gaudi::Algorithm*>& theAlgs,
                          std::vector<bool>& theLogic );
 
  StatusCode execute( const EventContext& ctx, const std::vector<Gaudi::Algorithm*>& theAlgs,
                      const std::vector<bool>& theLogic, Gaudi::Algorithm*& lastAlgorithm,
                      std::size_t first = 0 ) const;
 
  StatusCode executeMember( Gaudi::Algorithm* theAlgorithm, const EventContext& context ) const;
 
  StatusCode remove( const std::string& algname, std::vector<Gaudi::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<Gaudi::Algorithm*> m_branchAlgs;       // Branch algorithms
  std::vector<bool>              m_isBranchInverted; // Branch Member logic inverted list
 
  mutable std::mutex                                m_branchFilterMutex;
  mutable std::map<EventContext::ContextID_t, bool> m_branchFilterPassed; // Branch filter passed flag
};
 
#endif // ALGORITHM_SEQUENCER_H