art::ProcessingOptionsHandler Class Reference

#include "ProcessingOptionsHandler.h"

Inheritance diagram for art::ProcessingOptionsHandler:

Public Member Functions
	ProcessingOptionsHandler (bpo::options_description &desc, bool rethrowDefault)
int	checkOptions (bpo::variables_map const &vm)
int	processOptions (bpo::variables_map const &vm, fhicl::intermediate_table &raw_config)

Private Member Functions
int	doCheckOptions (bpo::variables_map const &vm) override
int	doProcessOptions (bpo::variables_map const &vm, fhicl::intermediate_table &raw_config) override

Private Attributes
bool	rethrowDefault_

Detailed Description

Definition at line 10 of file ProcessingOptionsHandler.h.

Constructor & Destructor Documentation

art::ProcessingOptionsHandler::ProcessingOptionsHandler ( bpo::options_description &  desc, bool  rethrowDefault  )

explicit

Definition at line 51 of file ProcessingOptionsHandler.cc.

References art::add_opt().

  : rethrowDefault_{rethrowDefault}
{

  bpo::options_description processing_options{"Processing options"};
  auto options = processing_options.add_options();
  // Note: tbb wants nthreads to be an int!
  add_opt(options,
          "nthreads",
          bpo::value<int>()->default_value(1),
          "Number of threads to use for event processing (default = 1, 0 = all "
          "cores)");
  add_opt(options,
          "default-exceptions",
          "Some exceptions may be handled differently by default (e.g. "
          "ProductNotFound).");
  add_opt(options, "rethrow-default", "All exceptions default to rethrow.");
  add_opt(options,
          "rethrow-all",
          "All exceptions overridden to rethrow (cf rethrow-default).");
  add_opt(
    options,
    "errorOnFailureToPut",
    bpo::value<bool>()->implicit_value(true, "true"),
    "Global flag that controls the behavior upon failure to 'put' a "
    "product (declared by 'produces') onto the Event.  If 'true', per-module "
    "flags can override the value of the global flag.");
  add_opt(
    options,
    "errorOnMissingConsumes",
    bpo::value<bool>()->implicit_value(true, "true"),
    "If 'true', then an exception will be thrown if any module attempts "
    "to retrieve a product via the 'getBy*' interface without specifying "
    "the appropriate 'consumes<T>(...)' statement in the module constructor.");
  add_opt(
    options,
    "errorOnSIGINT",
    bpo::value<bool>()->implicit_value(true, "true"),
    "If 'true', a signal received from the user yields an art return code "
    "corresponding to an error; otherwise return 0.");
  desc.add(processing_options);
}

Member Function Documentation

int art::OptionsHandler::checkOptions ( bpo::variables_map const &  vm )

inherited

Definition at line 51 of file OptionsHandler.cc.

{
  std::string const thisClass(cet::demangle_symbol(typeid(*this).name()));
  return exceptionCatcher([&vm, this] { return doCheckOptions(vm); },
                          thisClass + "::doCheckOptions()",
                          89);
}

int art::ProcessingOptionsHandler::doCheckOptions ( bpo::variables_map const &  vm )

overrideprivatevirtual

Implements art::OptionsHandler.

Definition at line 97 of file ProcessingOptionsHandler.cc.

References art::errors::Configuration.

{
  if ((vm.count("rethrow-all") + vm.count("rethrow-default") +
       vm.count("no-rethrow-default")) > 1) {
    throw Exception(errors::Configuration)
      << "Options --default-exceptions, --rethrow-all, and --rethrow-default "
         "\n"
      << "are mutually incompatible.\n";
  }

  // No need to check for presence of 'nthreads' since it has a
  // default value.
  if (vm["nthreads"].as<int>() < 0) {
    throw Exception(errors::Configuration)
      << "Option --nthreads must greater than or equal to 0.";
  }
  return 0;
}

int art::ProcessingOptionsHandler::doProcessOptions ( bpo::variables_map const &  vm, fhicl::intermediate_table &  raw_config  )

overrideprivatevirtual

Implements art::OptionsHandler.

Definition at line 117 of file ProcessingOptionsHandler.cc.

References art::detail::fhicl_key(), fhicl::intermediate_table::put(), fhicl::intermediate_table::putEmptySequence(), and rethrowDefault_.

{
  std::string const scheduler_key{"services.scheduler"};

  if (vm.count("rethrow-all") == 1 || vm.count("rethrow-default") == 1 ||
      (rethrowDefault_ && vm.count("default-exceptions") == 0)) {
    raw_config.put(fhicl_key(scheduler_key, "defaultExceptions"), false);
    if (vm.count("rethrow-all") == 1) {
      raw_config.putEmptySequence(fhicl_key(scheduler_key, "IgnoreCompletely"));
      raw_config.putEmptySequence(fhicl_key(scheduler_key, "SkipEvent"));
      raw_config.putEmptySequence(fhicl_key(scheduler_key, "FailModule"));
      raw_config.putEmptySequence(fhicl_key(scheduler_key, "FailPath"));
    }
  }

  fillTable("errorOnFailureToPut",
            fhicl_key(scheduler_key, "errorOnFailureToPut"),
            vm,
            raw_config,
            true);
  fillTable("errorOnMissingConsumes",
            fhicl_key(scheduler_key, "errorOnMissingConsumes"),
            vm,
            raw_config,
            false);
  fillTable("errorOnSIGINT",
            fhicl_key(scheduler_key, "errorOnSIGINT"),
            vm,
            raw_config,
            true);

  auto const nt = vm["nthreads"].as<int>();
  auto const nthreads =
    (nt == 0) ? tbb::task_scheduler_init::default_num_threads() : nt;
  raw_config.put(fhicl_key(scheduler_key, "num_threads"), nthreads);
  return 0;
}

int art::OptionsHandler::processOptions ( bpo::variables_map const &  vm, fhicl::intermediate_table &  raw_config  )

inherited

Definition at line 60 of file OptionsHandler.cc.

Referenced by art::run_art_string_config().

{
  std::string const thisClass(cet::demangle_symbol(typeid(*this).name()));
  return exceptionCatcher(
    [&, this] { return doProcessOptions(vm, raw_config); },
    thisClass + "::doProcessOptions()",
    90);
}

Member Data Documentation

bool art::ProcessingOptionsHandler::rethrowDefault_

private

Definition at line 21 of file ProcessingOptionsHandler.h.

Referenced by doProcessOptions().

---

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

• art/Framework/Art/ProcessingOptionsHandler.h
• art/Framework/Art/ProcessingOptionsHandler.cc