#include "Path.h"

Public Types
using	State = hlt::HLTState

using	WorkersInPath = std::vector< WorkerInPath >

using	size_type = WorkersInPath::size_type

using	TrigResPtr = cet::exempt_ptr< HLTGlobalStatus >

Public Member Functions
	Path (int bitpos, std::string const &path_name, WorkersInPath &&workers, TrigResPtr pathResults, ActionTable const &actions, ActivityRegistry &reg, bool isEndPath)

template<typename T >
void	process (typename T::MyPrincipal &)

int	bitPosition () const

std::string const &	name () const

void	clearCounters ()

std::size_t	timesRun () const

std::size_t	timesPassed () const

std::size_t	timesFailed () const

std::size_t	timesExcept () const

State	state () const

auto const &	workersInPath () const

void	findEventModifiers (std::vector< std::string > &foundLabels) const

void	findEventObservers (std::vector< std::string > &foundLabels) const

Private Member Functions
void	findByModifiesEvent (bool modifies, std::vector< std::string > &foundLabels) const

bool	handleWorkerFailure (cet::exception const &e, int nwrwue, bool isEvent)

void	recordUnknownException (int nwrwue, bool isEvent)

void	recordStatus (int nwrwue, bool isEvent)

void	updateCounters (bool succeed, bool isEvent)

Private Attributes
std::size_t	timesRun_ {}

std::size_t	timesPassed_ {}

std::size_t	timesFailed_ {}

std::size_t	timesExcept_ {}

State	state_ {hlt::Ready}

int	bitpos_

std::string	name_

TrigResPtr	trptr_

ActivityRegistry &	actReg_

ActionTable const &	act_table_

WorkersInPath	workers_

bool	isEndPath_

Detailed Description

Definition at line 32 of file Path.h.

Member Typedef Documentation

using art::Path::size_type = WorkersInPath::size_type

Definition at line 37 of file Path.h.

using art::Path::State = hlt::HLTState

Definition at line 34 of file Path.h.

using art::Path::TrigResPtr = cet::exempt_ptr<HLTGlobalStatus>

Definition at line 38 of file Path.h.

using art::Path::WorkersInPath = std::vector<WorkerInPath>

Definition at line 36 of file Path.h.

Constructor & Destructor Documentation

art::Path::Path	(	int	bitpos,
		std::string const &	path_name,
		WorkersInPath &&	workers,
		TrigResPtr	pathResults,
		ActionTable const &	actions,
		ActivityRegistry &	reg,
		bool	isEndPath
	)

Definition at line 15 of file Path.cc.

References act_table_, actReg_, isEndPath_, name_, trptr_, and workers_.

     : bitpos_{bitpos}
     , name_{path_name}
     , trptr_{pathResults}
     , actReg_{areg}
     , act_table_{actions}
     , workers_{std::move(workers)}
     , isEndPath_{isEndPath}
   {}

Member Function Documentation

int art::Path::bitPosition ( ) const

inline

Definition at line 52 of file Path.h.

References bitpos_.

Referenced by process().

   {
     return bitpos_;
   }

void art::Path::clearCounters ( )

Definition at line 101 of file Path.cc.

References timesExcept_, timesFailed_, timesPassed_, timesRun_, w, and workers_.

Referenced by name().

   {
     timesRun_ = timesPassed_ = timesFailed_ = timesExcept_ = 0;
     for_all(workers_, [](auto& w) { w.clearCounters(); });
   }

void art::Path::findByModifiesEvent	(	bool	modifies,
		std::vector< std::string > &	foundLabels
	)		const

private

Definition at line 120 of file Path.cc.

References w, and workers_.

Referenced by findEventModifiers(), findEventObservers(), and workersInPath().

   {
     for (auto const& w : workers_) {
       if (w.modifiesEvent() == modifies) {
         foundLabels.push_back(w.label());
       }
     }
   }

void art::Path::findEventModifiers ( std::vector< std::string > & foundLabels ) const

Definition at line 108 of file Path.cc.

References findByModifiesEvent().

Referenced by workersInPath().

   {
     findByModifiesEvent(true, foundLabels);
   }

void art::Path::findEventObservers ( std::vector< std::string > & foundLabels ) const

Definition at line 114 of file Path.cc.

References findByModifiesEvent().

Referenced by workersInPath().

   {
     findByModifiesEvent(false, foundLabels);
   }

bool art::Path::handleWorkerFailure	(	cet::exception const &	e,
		int	nwrwue,
		bool	isEvent
	)

private

Definition at line 32 of file Path.cc.

References act_table_, art::hlt::Exception, art::actions::FailModule, art::actions::FailPath, art::ActionTable::find(), name_, recordStatus(), art::actions::Rethrow, art::errors::ScheduleExecutionFailure, state_, and timesExcept_.

Referenced by process().

   {
     bool should_continue{true};
 
     // there is no support as of yet for specific paths having
     // different exception behavior
 
     // If not processing an event, always rethrow.
     actions::ActionCodes action =
       (isEvent ? act_table_.find(e.root_cause()) : actions::Rethrow);
     assert(action != actions::FailModule);
     switch (action) {
       case actions::FailPath: {
         should_continue = false;
         mf::LogWarning(e.category())
           << "Failing path " << name_ << ", due to exception, message:\n"
           << e.what() << "\n";
         break;
       }
       default: {
         if (isEvent)
           ++timesExcept_;
         state_ = art::hlt::Exception;
         recordStatus(nwrwue, isEvent);
         throw art::Exception{
           errors::ScheduleExecutionFailure, "Path: ProcessingStopped.", e}
           << "Exception going through path " << name_ << "\n";
       }
     }
 
     return should_continue;
   }

std::string const& art::Path::name ( ) const

inline

Definition at line 57 of file Path.h.

References clearCounters(), and name_.

   {
     return name_;
   }

template<typename T >

void art::Path::process ( typename T::MyPrincipal & ep )

Definition at line 129 of file Path.h.

References actReg_, bitPosition(), e, evd::details::end(), art::Event, handleWorkerFailure(), isEndPath_, name_, art::hlt::Ready, recordStatus(), recordUnknownException(), state_, timesRun_, updateCounters(), and workers_.

 {
   int nwrwue{-1}; // numWorkersRunWithoutUnhandledException
   T::prePathSignal(actReg_, name_);
 
   if (T::level == Level::Event) {
     ++timesRun_;
   }
   state_ = hlt::Ready;
 
   bool should_continue{true};
   CurrentProcessingContext cpc{&name_, bitPosition(), isEndPath_};
 
   for (auto it = workers_.begin(), end = workers_.end();
        it != end && should_continue;
        ++it) {
     ++nwrwue;
     try {
       cpc.activate(nwrwue, it->getWorker()->descPtr());
       should_continue = it->runWorker<T>(ep, &cpc);
     }
     catch (cet::exception& e) {
       // handleWorkerFailure may throw a new exception.
       should_continue =
         handleWorkerFailure(e, nwrwue, T::level == Level::Event);
     }
     catch (...) {
       recordUnknownException(nwrwue, T::level == Level::Event);
       throw;
     }
   }
   updateCounters(should_continue, T::level == Level::Event);
   recordStatus(nwrwue, T::level == Level::Event);
   HLTPathStatus const status(state_, nwrwue);
   T::postPathSignal(actReg_, name_, status);
 }

void art::Path::recordStatus	(	int	nwrwue,
		bool	isEvent
	)

private

Definition at line 79 of file Path.cc.

References bitpos_, state_, and trptr_.

Referenced by handleWorkerFailure(), process(), and recordUnknownException().

   {
     if (isEvent && trptr_) {
       (*trptr_)[bitpos_] = HLTPathStatus(state_, nwrwue);
     }
   }

void art::Path::recordUnknownException	(	int	nwrwue,
		bool	isEvent
	)

private

Definition at line 68 of file Path.cc.

References art::hlt::Exception, name_, recordStatus(), state_, and timesExcept_.

Referenced by process().

   {
     mf::LogError("PassingThrough")
       << "Exception passing through path " << name_ << "\n";
     if (isEvent)
       ++timesExcept_;
     state_ = art::hlt::Exception;
     recordStatus(nwrwue, isEvent);
   }

State art::Path::state ( ) const

inline

Definition at line 85 of file Path.h.

References state_.

   {
     return state_;
   }

std::size_t art::Path::timesExcept ( ) const

inline

Definition at line 80 of file Path.h.

References timesExcept_.

   {
     return timesExcept_;
   }

std::size_t art::Path::timesFailed ( ) const

inline

Definition at line 75 of file Path.h.

References timesFailed_.

   {
     return timesFailed_;
   }

std::size_t art::Path::timesPassed ( ) const

inline

Definition at line 70 of file Path.h.

References timesPassed_.

   {
     return timesPassed_;
   }

std::size_t art::Path::timesRun ( ) const

inline

Definition at line 65 of file Path.h.

References timesRun_.

   {
     return timesRun_;
   }

void art::Path::updateCounters	(	bool	succeed,
		bool	isEvent
	)

private

Definition at line 87 of file Path.cc.

References art::hlt::Fail, art::hlt::Pass, state_, timesFailed_, and timesPassed_.

Referenced by process().

   {
     if (success) {
       if (isEvent)
         ++timesPassed_;
       state_ = art::hlt::Pass;
     } else {
       if (isEvent)
         ++timesFailed_;
       state_ = art::hlt::Fail;
     }
   }