art::RPManager Class Reference

#include "RPManager.h"

Public Types
using	RPPath_t = std::vector< std::unique_ptr< art::RPWorker >>
using	RPMap_t = std::map< std::string, RPPath_t >
template<typename RET , typename... ARGS>
using	invoke_function_t = RET(art::ResultsProducer::*)(ARGS...)
using	on_rpworker_t = std::function< void(art::RPWorker &)>

Public Member Functions
	RPManager (fhicl::ParameterSet const &ps)
std::size_t	size () const
bool	empty () const
template<typename... ARGS>
void	invoke (invoke_function_t< void, ARGS... > mfunc, ARGS &&...args)
void	for_each_RPWorker (on_rpworker_t wfunc)

Private Member Functions
RPMap_t	makeRPs_ (fhicl::ParameterSet const &ps)

Private Attributes
cet::BasicPluginFactory	pf_
RPMap_t	rpmap_
std::size_t	size_

Detailed Description

Definition at line 24 of file RPManager.h.

Member Typedef Documentation

template<typename RET , typename... ARGS>

using art::RPManager::invoke_function_t = RET (art::ResultsProducer::*)(ARGS...)

Definition at line 30 of file RPManager.h.

using art::RPManager::on_rpworker_t = std::function<void(art::RPWorker&)>

Definition at line 32 of file RPManager.h.

using art::RPManager::RPMap_t = std::map<std::string, RPPath_t>

Definition at line 27 of file RPManager.h.

using art::RPManager::RPPath_t = std::vector<std::unique_ptr<art::RPWorker>>

Definition at line 26 of file RPManager.h.

Constructor & Destructor Documentation

art::RPManager::RPManager

(

fhicl::ParameterSet const &

ps

)

Definition at line 21 of file RPManager.cc.

References fhicl::ParameterSet::get(), fhicl::ParameterSet::id(), art::plugin, and cet::PluginTypeDeducer< art::ResultsProducer >::value.

  : pf_(Suffixes::plugin(), "makeRP")
  , rpmap_(makeRPs_(ps))
  , size_(countProducers(rpmap_))
{}

Member Function Documentation

bool art::RPManager::empty ( void  ) const

inline

Definition at line 59 of file RPManager.h.

References size_.

{
  return size_ == 0ul;
}

void art::RPManager::for_each_RPWorker

(

on_rpworker_t

wfunc

)

Definition at line 76 of file RPManager.h.

References rpmap_, and w.

Referenced by art::RootOutput::beginRun(), art::RootOutput::beginSubRun(), art::RootOutput::doRegisterProducts(), art::RootOutput::endRun(), art::RootOutput::endSubRun(), art::RootOutput::event(), art::RootOutput::readResults(), and art::RootOutput::startEndFile().

{
  for (auto& path : rpmap_) {
    for (auto& w : path.second) {
      wfunc(*w);
    }
  }
}

template<typename... ARGS>

void art::RPManager::invoke	(	invoke_function_t< void, ARGS... >	mfunc,
		ARGS &&...	args
	)

Definition at line 66 of file RPManager.h.

References rpmap_, and w.

Referenced by art::RootOutput::beginJob(), art::RootOutput::endJob(), and art::RootOutput::finishEndFile().

{
  for (auto& path : rpmap_) {
    for (auto& w : path.second) {
      (w->rp().*mfunc)(std::forward<ARGS>(args)...);
    }
  }
}

auto art::RPManager::makeRPs_ ( fhicl::ParameterSet const &  ps )

private

Definition at line 54 of file RPManager.cc.

References art::errors::Configuration, fhicl::ParameterSet::get(), pf_, rpmap_, and util::flags::to_string().

{
  using fhicl::ParameterSet;
  decltype(rpmap_) result;
  auto results = ps.get<ParameterSet>("results", {});
  auto producers = results.get<ParameterSet>("producers", {});
  auto results_keys = results.get_names();
  auto producer_keys = producers.get_names();
  std::map<std::string, std::vector<std::string>> paths;
  std::string const omLabel(ps.get<std::string>("module_label"));
  std::string errMsg;
  if (producer_keys.empty()) {
    if (!results.is_empty()) {
      throw Exception(errors::Configuration)
        << "Parameter set " << omLabel
        << ".results is non-empty, but does not contain\n"
        << "a non-empty producers parameter set.\n";
    }
  } else {
    auto const path_keys_end =
      std::remove(results_keys.begin(), results_keys.end(), "producers");
    auto const& all_labels = producers.get_names();
    std::set<std::string> all_labels_set(all_labels.cbegin(),
                                         all_labels.cend());
    std::map<std::string, std::string> used_labels;
    for (auto path_key = results_keys.begin(); path_key != path_keys_end;
         ++path_key) {
      if (!results.is_key_to_sequence(*path_key)) {
        errMsg += +"Parameter " + omLabel + ".results." + *path_key +
                  " does not describe a sequence (i.e. a path).\n";
      } else {
        auto path = results.get<std::vector<std::string>>(*path_key);
        std::size_t path_index = 0ull;
        for (auto const& l : path) {
          if (all_labels_set.find(l) == all_labels_set.end()) { // Bad label
            errMsg += omLabel + ".results." + *path_key + '[' +
                      std::to_string(path_index) + "] (" + l + ')' +
                      " is not defined in " + omLabel + ".results.producers.\n";
          } else {
            auto const ans = used_labels.emplace(l, *path_key);
            if (!ans.second) { // Duplicate
              errMsg += omLabel + ".results." + *path_key + '[' +
                        std::to_string(path_index) + "] (" + l + ')' +
                        " is a duplicate: previously used in path " +
                        ans.first->second + ".\n";
            }
          }
          ++path_index;
        }
        if (errMsg.empty()) {
          paths.emplace(*path_key, std::move(path));
        }
      }
    }
    if (paths.empty() && (errMsg.empty())) {
      paths.emplace("default_path", all_labels);
    }
  }
  if (!errMsg.empty()) {
    throw Exception(errors::Configuration)
      << "Errors encountered while configuring ResultsProducers:\n"
      << errMsg;
  }
  for (auto const& path : paths) {
    auto ins_res = rpmap_.emplace(path.first, decltype(rpmap_)::mapped_type{});
    std::transform(path.second.cbegin(),
                   path.second.cend(),
                   std::back_inserter(ins_res.first->second),
                   std::bind(&pathLoader,
                             std::ref(pf_),
                             std::cref(producers),
                             std::placeholders::_1,
                             std::cref(omLabel),
                             std::ref(errMsg)));
  }
  if (!errMsg.empty()) {
    throw Exception(errors::Configuration)
      << "Errors encountered while instantiating ResultsProducers:\n"
      << errMsg;
  }
  return result;
}

std::size_t art::RPManager::size ( void  ) const

inline

Definition at line 53 of file RPManager.h.

References size_.

{
  return size_;
}

Member Data Documentation

cet::BasicPluginFactory art::RPManager::pf_

private

Definition at line 45 of file RPManager.h.

Referenced by makeRPs_().

RPMap_t art::RPManager::rpmap_

private

Definition at line 46 of file RPManager.h.

Referenced by for_each_RPWorker(), invoke(), and makeRPs_().

std::size_t art::RPManager::size_

private

Definition at line 47 of file RPManager.h.

Referenced by empty(), and size().

---

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

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