art::ProcessingLimits Class Reference

#include "ProcessingLimits.h"

Classes
struct	Config

Public Member Functions
	ProcessingLimits (Config const &config, std::function< input::ItemType()> nextItemType)
input::ItemType	nextItemType ()
InputSource::ProcessingMode	processingMode () const noexcept
int	remainingEvents () const noexcept
int	remainingSubRuns () const noexcept
void	update (EventID const &id)
void	update (SubRunID const &id)

Private Member Functions
bool	allowed_ (input::ItemType) const noexcept

Private Attributes
InputSource::ProcessingMode	processingMode_
int	remainingEvents_
int	remainingSubRuns_
int	reportFrequency_
int	numberOfEventsRead_ {}
std::function< input::ItemType()>	nextItemType_

Detailed Description

Definition at line 11 of file ProcessingLimits.h.

Constructor & Destructor Documentation

art::ProcessingLimits::ProcessingLimits	(	Config const &	config,
		std::function< input::ItemType()>	nextItemType
	)

Definition at line 9 of file ProcessingLimits.cc.

References art::errors::Configuration, art::ProcessingLimits::Config::maxEvents, art::ProcessingLimits::Config::maxSubRuns, art::InputSource::mode(), nextItemType(), nextItemType_, art::ProcessingLimits::Config::processingMode, remainingEvents_, remainingSubRuns_, art::ProcessingLimits::Config::reportFrequency, and reportFrequency_.

    : processingMode_{InputSource::mode(config.processingMode())}
    , remainingEvents_{config.maxEvents()}
    , remainingSubRuns_{config.maxSubRuns()}
    , reportFrequency_{config.reportFrequency()}
    , nextItemType_{std::move(nextItemType)}
  {
    if (reportFrequency_ < 0) {
      throw Exception(errors::Configuration)
        << "reportFrequency has a negative value, which is not meaningful.";
    }
  }

Member Function Documentation

bool art::ProcessingLimits::allowed_ ( input::ItemType  item_type ) const

privatenoexcept

Definition at line 77 of file ProcessingLimits.cc.

References art::input::IsEvent, art::input::IsSubRun, processingMode_, art::InputSource::RunsAndSubRuns, and art::InputSource::RunsSubRunsAndEvents.

Referenced by nextItemType().

  {
    if (processingMode_ == InputSource::RunsSubRunsAndEvents) {
      return true;
    }

    // Events no longer allowed
    if (item_type == input::IsEvent) {
      return false;
    }
    if (processingMode_ == InputSource::RunsAndSubRuns) {
      return true;
    }

    // SubRuns no longer allowed
    return item_type != input::IsSubRun;
  }

input::ItemType art::ProcessingLimits::nextItemType

(

)

Definition at line 25 of file ProcessingLimits.cc.

References allowed_(), art::input::IsStop, nextItemType_, remainingEvents_, and remainingSubRuns_.

Referenced by art::EmptyEvent::nextItemType(), and ProcessingLimits().

  {
    if (remainingEvents_ == 0 || remainingSubRuns_ == 0) {
      return input::IsStop;
    }

    auto item_type = nextItemType_();
    while (not allowed_(item_type)) {
      item_type = nextItemType_();
    }
    return item_type;
  }

InputSource::ProcessingMode art::ProcessingLimits::processingMode ( ) const

noexcept

Definition at line 39 of file ProcessingLimits.cc.

References processingMode_.

  {
    return processingMode_;
  }

int art::ProcessingLimits::remainingEvents ( ) const

noexcept

Definition at line 45 of file ProcessingLimits.cc.

References remainingEvents_.

  {
    return remainingEvents_;
  }

int art::ProcessingLimits::remainingSubRuns ( ) const

noexcept

Definition at line 51 of file ProcessingLimits.cc.

References remainingSubRuns_.

  {
    return remainingSubRuns_;
  }

void art::ProcessingLimits::update

(

EventID const &

id

)

Definition at line 65 of file ProcessingLimits.cc.

References art::detail::issue_reports(), numberOfEventsRead_, remainingEvents_, and reportFrequency_.

Referenced by art::EmptyEvent::readEvent(), and art::EmptyEvent::readSubRun().

  {
    if (remainingEvents_ > 0) {
      --remainingEvents_;
    }
    ++numberOfEventsRead_;
    if ((reportFrequency_ > 0) && !(numberOfEventsRead_ % reportFrequency_)) {
      detail::issue_reports(numberOfEventsRead_, id);
    }
  }

void art::ProcessingLimits::update

(

SubRunID const &

id

)

Definition at line 57 of file ProcessingLimits.cc.

References remainingSubRuns_.

  {
    if (remainingSubRuns_ > 0) {
      --remainingSubRuns_;
    }
  }

Member Data Documentation

std::function<input::ItemType()> art::ProcessingLimits::nextItemType_

private

Definition at line 52 of file ProcessingLimits.h.

Referenced by nextItemType(), and ProcessingLimits().

int art::ProcessingLimits::numberOfEventsRead_ {}

private

Definition at line 51 of file ProcessingLimits.h.

Referenced by update().

InputSource::ProcessingMode art::ProcessingLimits::processingMode_

private

Initial value:

{
      InputSource::RunsSubRunsAndEvents}

Definition at line 46 of file ProcessingLimits.h.

Referenced by allowed_(), and processingMode().

int art::ProcessingLimits::remainingEvents_

private

Definition at line 48 of file ProcessingLimits.h.

Referenced by nextItemType(), ProcessingLimits(), remainingEvents(), and update().

int art::ProcessingLimits::remainingSubRuns_

private

Definition at line 49 of file ProcessingLimits.h.

Referenced by nextItemType(), ProcessingLimits(), remainingSubRuns(), and update().

int art::ProcessingLimits::reportFrequency_

private

Definition at line 50 of file ProcessingLimits.h.

Referenced by ProcessingLimits(), and update().

---

The documentation for this class was generated from the following files:

• art/Framework/Core/ProcessingLimits.h
• art/Framework/Core/ProcessingLimits.cc