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 "GaudiKernel/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