art::detail Namespace Reference

Namespaces
	FDS
	FTS

Classes
struct	AggregateTuple
struct	AggregateTuple< 0u >
class	Analyzer
struct	are_cv_compatible
struct	are_handles
class	AssnsBase
class	BcollHelper
struct	CanBeAggregated
struct	CanBeAggregated< cet::map_vector< T > >
struct	CanBeAggregated< CLHEP::Hep2Vector >
struct	CanBeAggregated< CLHEP::Hep3Vector >
struct	CanBeAggregated< CLHEP::HepLorentzVector >
struct	CanBeAggregated< CLHEP::HepMatrix >
struct	CanBeAggregated< CLHEP::HepSymMatrix >
struct	CanBeAggregated< CLHEP::HepVector >
struct	CanBeAggregated< std::array< T, N > >
struct	CanBeAggregated< std::deque< T > >
struct	CanBeAggregated< std::list< T > >
struct	CanBeAggregated< std::map< K, V > >
struct	CanBeAggregated< std::multimap< K, V > >
struct	CanBeAggregated< std::pair< K, V > >
struct	CanBeAggregated< std::set< T > >
struct	CanBeAggregated< std::string >
struct	CanBeAggregated< std::tuple< Args... > >
struct	CanBeAggregated< std::vector< T > >
struct	CanBeAggregated< T, std::enable_if_t< has_aggregate< T >::value > >
struct	CanBeAggregated< T, std::enable_if_t< std::is_arithmetic< T >::value > >
struct	CanBeAggregated< T, std::enable_if_t< std::is_base_of< TH1, T >::value > >
class	collected_exception
struct	config_impl
struct	config_impl< T, std::void_t< typename T::Parameters > >
class	DataCollHelper
struct	default_invocation
struct	default_invocation< R(ARGS...)>
struct	do_call_hasMoreData
struct	do_not_call_hasMoreData
class	EnabledModules
class	EngineCreator
struct	EnsurePointer
struct	EnsurePointer< TO, PFROM * >
struct	EnsurePointer< TO, Ptr< PTRVAL > >
class	ExceptionCollector
class	FileNameComponents
class	FileNamesHandler
class	FileNamesHandler< false >
class	FileNamesHandler< true >
class	FileServiceProxy
class	Filter
struct	get_helper
struct	GetProduct
struct	handle_allowed
struct	handle_allowed< T, std::enable_if_t<!T::service_handle_allowed > >
struct	has_aggregate
struct	has_aggregate< T, enable_if_function_exists_t< void(T::*)(T const &),&T::aggregate > >
struct	has_aggregate< T, enable_if_function_exists_t< void(T::*)(T),&T::aggregate > >
struct	has_beginRun
struct	has_beginRun< T, enable_if_function_exists_t< void(T::*)(Run const &),&T::beginRun > >
struct	has_beginSubRun
struct	has_beginSubRun< T, enable_if_function_exists_t< void(T::*)(SubRun const &),&T::beginSubRun > >
struct	has_endRun
struct	has_endRun< T, enable_if_function_exists_t< void(T::*)(Run &),&T::endRun > >
struct	has_endSubRun
struct	has_endSubRun< T, enable_if_function_exists_t< void(T::*)(SubRun &),&T::endSubRun > >
struct	has_eventsToSkip
struct	has_eventsToSkip< T, enable_if_function_exists_t< size_t(T::*)() const,&T::eventsToSkip > >
struct	has_eventsToSkip< T, enable_if_function_exists_t< size_t(T::*)(),&T::eventsToSkip > >
struct	has_finalizeEvent
struct	has_finalizeEvent< T, enable_if_function_exists_t< void(T::*)(Event &),&T::finalizeEvent > >
struct	has_hasMoreData
struct	has_hasMoreData< T, cet::enable_if_function_exists_t< bool(T::*)() const,&T::hasMoreData > >
struct	has_hasMoreData< T, cet::enable_if_function_exists_t< bool(T::*)(),&T::hasMoreData > >
struct	has_makePartner_member
struct	has_makePartner_member< T, enable_if_function_exists_t< std::unique_ptr< EDProduct >(T::*)( std::type_info const &) const, &T::makePartner > >
struct	has_processEventAuxiliaries
struct	has_processEventAuxiliaries< T, enable_if_function_exists_t< void(T::*)(EventAuxiliarySequence const &), &T::processEventAuxiliaries > >
struct	has_processEventIDs
struct	has_processEventIDs< T, enable_if_function_exists_t< void(T::*)(EventIDSequence const &), &T::processEventIDs > >
struct	has_respondToCloseInputFile
struct	has_respondToCloseInputFile< T, enable_if_function_exists_t< respond_to_file< T >, &T::respondToCloseInputFile > >
struct	has_respondToCloseOutputFiles
struct	has_respondToCloseOutputFiles< T, enable_if_function_exists_t< respond_to_file< T >, &T::respondToCloseOutputFiles > >
struct	has_respondToOpenInputFile
struct	has_respondToOpenInputFile< T, enable_if_function_exists_t< respond_to_file< T >, &T::respondToOpenInputFile > >
struct	has_respondToOpenOutputFiles
struct	has_respondToOpenOutputFiles< T, enable_if_function_exists_t< respond_to_file< T >, &T::respondToOpenOutputFiles > >
struct	has_size_member
struct	has_size_member< T, std::void_t< size_expression_t< T > > >
struct	has_startEvent
struct	has_startEvent< T, enable_if_function_exists_t< void(T::*)(Event const &),&T::startEvent > >
struct	has_three_arg_insert
struct	has_two_arg_insert
class	IPRHelper
class	IPRHelperDef
struct	is_handle
struct	is_handle< T, std::void_t< typename T::HandleTag > >
class	ItemGetter
class	ItemGetter< std::pair< cet::map_vector_key, T >, cet::map_vector< T > >
class	ItemGetter< T, cet::map_vector< T > >
class	LegacyModule
class	LibraryInfo
class	LibraryInfoMatch
class	LinuxMallInfo
struct	maybe_beginJob
struct	maybe_beginJob< DETAIL, enable_if_function_exists_t< void(DETAIL::*)(),&DETAIL::beginJob > >
struct	maybe_endJob
struct	maybe_endJob< DETAIL, enable_if_function_exists_t< void(DETAIL::*)(),&DETAIL::endJob > >
struct	maybe_has_Parameters
struct	maybe_has_Parameters< T, std::void_t< typename T::Parameters > >
struct	maybe_postProcessEvent
struct	maybe_postProcessEvent< DETAIL, enable_if_function_exists_t< void(DETAIL::*)(), &DETAIL::postProcessEvent > >
struct	maybe_postProcessRun
struct	maybe_postProcessRun< DETAIL, enable_if_function_exists_t< void(DETAIL::*)(), &DETAIL::postProcessRun > >
struct	maybe_postProcessSubRun
struct	maybe_postProcessSubRun< DETAIL, enable_if_function_exists_t< void(DETAIL::*)(), &DETAIL::postProcessSubRun > >
struct	maybe_preProcessEvent
struct	maybe_preProcessEvent< DETAIL, enable_if_function_exists_t< void(DETAIL::*)(), &DETAIL::preProcessEvent > >
struct	maybe_preProcessRun
struct	maybe_preProcessRun< DETAIL, enable_if_function_exists_t< void(DETAIL::*)(),&DETAIL::preProcessRun > >
struct	maybe_preProcessSubRun
struct	maybe_preProcessSubRun< DETAIL, enable_if_function_exists_t< void(DETAIL::*)(), &DETAIL::preProcessSubRun > >
struct	maybe_processEventPrincipal
struct	maybe_processEventPrincipal< DETAIL, enable_if_function_exists_t< void(DETAIL::*)(Provenance const &), &DETAIL::processEventProvenance > >
struct	maybe_processRunPrincipal
struct	maybe_processRunPrincipal< DETAIL, enable_if_function_exists_t< void(DETAIL::*)(Provenance const &), &DETAIL::processRunProvenance > >
struct	maybe_processSubRunPrincipal
struct	maybe_processSubRunPrincipal< DETAIL, enable_if_function_exists_t< void(DETAIL::*)(Provenance const &), &DETAIL::processSubRunProvenance > >
class	MessageAccumulator
class	MetadataCollector
class	MetadataCollectorFor
class	MetadataCollectorFor< suffix_type::mfPlugin >
class	MetadataCollectorFor< suffix_type::mfStatsPlugin >
class	MetadataCollectorFor< suffix_type::module >
class	MetadataCollectorFor< suffix_type::plugin >
class	MetadataCollectorFor< suffix_type::service >
class	MetadataCollectorFor< suffix_type::source >
class	MetadataCollectorFor< suffix_type::tool >
class	MetadataSummary
class	MetadataSummaryFor
class	MetadataSummaryFor< suffix_type::mfPlugin >
class	MetadataSummaryFor< suffix_type::mfStatsPlugin >
class	MetadataSummaryFor< suffix_type::module >
class	MetadataSummaryFor< suffix_type::plugin >
class	MetadataSummaryFor< suffix_type::service >
class	MetadataSummaryFor< suffix_type::source >
class	MetadataSummaryFor< suffix_type::tool >
struct	mix_offset
struct	mix_offset< cet::map_vector< P > >
struct	ModuleConfig
struct	ModuleConfigInfo
struct	ModuleGraphInfo
class	ModuleGraphInfoMap
struct	ModuleKeyAndType
struct	ModuleSpec
struct	ModuleThreadingTypeDeducer
struct	ModuleThreadingTypeDeducer< EDAnalyzer >
struct	ModuleThreadingTypeDeducer< EDFilter >
struct	ModuleThreadingTypeDeducer< EDProducer >
struct	ModuleThreadingTypeDeducer< OutputModule >
struct	ModuleThreadingTypeDeducer< ReplicatedAnalyzer >
struct	ModuleThreadingTypeDeducer< ReplicatedFilter >
struct	ModuleThreadingTypeDeducer< ReplicatedOutputModule >
struct	ModuleThreadingTypeDeducer< ReplicatedProducer >
struct	ModuleThreadingTypeDeducer< SharedAnalyzer >
struct	ModuleThreadingTypeDeducer< SharedFilter >
struct	ModuleThreadingTypeDeducer< SharedOutputModule >
struct	ModuleThreadingTypeDeducer< SharedProducer >
struct	ModuleTypeDeducer
struct	ModuleTypeDeducer< EDAnalyzer >
struct	ModuleTypeDeducer< EDFilter >
struct	ModuleTypeDeducer< EDProducer >
struct	ModuleTypeDeducer< OutputModule >
struct	ModuleTypeDeducer< ReplicatedAnalyzer >
struct	ModuleTypeDeducer< ReplicatedFilter >
struct	ModuleTypeDeducer< ReplicatedOutputModule >
struct	ModuleTypeDeducer< ReplicatedProducer >
struct	ModuleTypeDeducer< SharedAnalyzer >
struct	ModuleTypeDeducer< SharedFilter >
struct	ModuleTypeDeducer< SharedOutputModule >
struct	ModuleTypeDeducer< SharedProducer >
struct	OldToNew
struct	PluginConfig
class	PluginMetadata
class	PrincipalProcessor
class	ProcessAndEventSelector
class	ProcessAndEventSelectors
class	Producer
struct	ProductInfo
struct	ProductTypeIDs
struct	ProductTypeIDs< Assns< L, R, D > >
struct	ProductTypeIDs< Assns< L, R, void > >
class	ProvenanceDumperImpl
struct	respondToXXX_function
struct	safe_input_tag
struct	SafeFileNameConfig
class	ServiceCacheEntry
struct	ServiceHelper
struct	ServiceHelper< MyOtherService >
struct	ServiceHelper< MyService >
struct	ServiceHelper< YetAnotherService >
struct	ServiceHelperBase
struct	ServiceImplHelper
struct	ServiceInterfaceHelper
struct	ServiceInterfaceImplHelper
struct	ServiceLGMHelper
struct	ServiceLGRHelper
class	ServiceWrapper
class	ServiceWrapperBase
class	SharedModule
struct	SharedResource_t
class	SharedResources
struct	Summary
struct	three_arg_insert_func
struct	tool_type
struct	tool_type< T, std::enable_if_t< std::is_class< T >::value > >
struct	tool_type< T, std::enable_if_t< std::is_function< T >::value > >
struct	ToolConfig
struct	tuple_element
struct	tuple_element< 0, AssnsNode< L, R, D > >
struct	tuple_element< 1, AssnsNode< L, R, D > >
struct	tuple_element< 2, AssnsNode< L, R, D > >
struct	two_arg_insert_func
struct	TwoArgInsert
struct	TwoArgInsert< cet::map_vector< T > >
class	value_type_helper

Typedefs
using	LibraryInfoCollection = std::multiset< LibraryInfo >
using	Widths = std::vector< std::size_t >
using	config_const_iterator = std::vector< WorkerInPath::ConfigInfo >::const_iterator
using	path_name_t = std::string
using	module_name_t = std::string
using	names_t = std::vector< std::string >
using	configs_t = std::vector< WorkerInPath::ConfigInfo >
using	name_set_t = std::set< std::string >
using	paths_to_modules_t = std::vector< std::pair< PathSpec, configs_t >>
using	collection_map_t = std::map< module_name_t, ModuleGraphInfo >
using	collection_t = std::vector< collection_map_t::value_type >
using	distance_t = collection_t::difference_type
using	vertex_property = boost::property< boost::vertex_name_t, std::string >
using	edge_property = boost::property< boost::edge_index_t, int, boost::property< boost::edge_name_t, std::string >>
using	graph_property = boost::property< boost::graph_name_t, std::string >
using	Graph = boost::adjacency_list< boost::vecS, boost::vecS, boost::bidirectionalS, vertex_property, edge_property, graph_property >
using	ModuleGraph = boost::subgraph< Graph >
using	Edge = boost::graph_traits< ModuleGraph >::edge_descriptor
using	Vertex = boost::graph_traits< ModuleGraph >::vertex_descriptor
using	keytype_for_name_t = std::map< std::string, ModuleKeyAndType >
using	module_entries_for_ordered_path_t = std::vector< std::pair< PathSpec, std::vector< ModuleSpec >>>
using	module_entries_for_path_t = std::map< std::string, std::vector< ModuleSpec >>
using	modules_for_path_t = std::map< std::string, std::vector< ModuleKeyAndType >>
using	ModuleMaker_t = ModuleBase *(fhicl::ParameterSet const &, ProcessingFrame const &)
using	WorkerFromModuleMaker_t = Worker *(std::shared_ptr< ModuleBase >, ModuleDescription const &, WorkerParams const &)
using	WorkerMaker_t = Worker *(WorkerParams const &, ModuleDescription const &)
using	ModuleTypeFunc_t) = ModuleType(
using	ModuleThreadingTypeFunc_t) = ModuleThreadingType(
template<typename T >
using	Config = typename config_impl< T >::type
template<typename T >
using	respond_to_file = void(T::*)(FileBlock const &)
using	ServiceCache = std::map< TypeID, ServiceCacheEntry >
typedef std::stack< WrapperBase_ptr >	ServiceStack
using	WrapperBase_ptr = std::shared_ptr< ServiceWrapperBase >
using	new_t = std::string
using	old_t = std::string
using	entry_selector_t = std::function< bool(PathSpec const &)>
template<typename T >
using	size_expression_t = decltype(std::declval< T const >().size())

Enumerations
enum	FilterAction { FilterAction::Normal = 0, FilterAction::Ignore = 1, FilterAction::Veto = 2 }
enum	SignalResponseType { SignalResponseType::FIFO, SignalResponseType::LIFO }

Functions
void	print_available_plugins (std::string const &suffix, std::string const &spec, bool verbose)
void	print_available_plugins (std::string const &suffix, bool const verbose)
bool	supports_key (std::string const &suffix, std::string const &spec, std::string const &key)
void	print_description (std::vector< PluginMetadata > const &matches)
void	print_descriptions (std::vector< std::string > const &plugins)
std::tuple< RunNumber_t, SubRunNumber_t, EventNumber_t >	event_start (std::string const &str_num)
bool	exists_outside_prolog (fhicl::intermediate_table const &config, std::string const &key)
template<typename T >
std::enable_if_t< std::is_convertible_v< T, std::string >, std::string >	fhicl_key (T const &name)
template<typename H , typename... T>
std::enable_if_t< std::is_convertible_v< H, std::string >, std::string >	fhicl_key (H const &hname, T const &...tnames)
void	fillSourceList (std::istream &ifs, std::vector< std::string > &source_list)
constexpr char const *	dflt_spec_pattern ()
LibraryInfoCollection	get_LibraryInfoCollection (std::string const &suffix, std::string const &pattern, bool verbose=false)
std::unique_ptr< MetadataCollector >	get_MetadataCollector (std::string const &suffix)
std::unique_ptr< MetadataSummary >	get_MetadataSummary (std::string const &suffix, LibraryInfoCollection const &coll)
constexpr int	info_success ()
std::string	describe (cet::exempt_ptr< fhicl::ConfigurationTable const > pb, std::string const &prefix)
std::string	print_header (LibraryInfo const &li, std::string const &type_spec)
std::string	print_allowed_configuration (LibraryInfo const &li, std::string const &prefix, std::string const &type_spec)
std::regex	regex_for_spec (std::string const &)
void	replace_type (std::string &str, std::string const &spec, std::regex const &r)
bool	output_to_stderr (std::string const &spec)
bool	output_to_stdout (std::string const &spec)
std::string	getFilePath (cet::LibraryManager const &lm, std::string const &fullspec)
std::string	getType (cet::LibraryManager const &lm, std::string const &fullSpec)
std::unique_ptr< fhicl::ConfigurationTable >	getAllowedConfiguration (cet::LibraryManager const &lm, std::string const &fullSpec, std::string const &name)
void	print_config_summary (fhicl::ParameterSet const &pset, std::string const &verbosity, EnabledModules const &enabled_modules)
void	print_table_numbers (fhicl::ParameterSet const &pset, std::string const &header)
void	print_path_numbers (EnabledModules const &enabled_modules)
void	print_path_names (EnabledModules const &enabled_modules)
void	print_service_types (fhicl::ParameterSet const &pset)
void	print_module_types (fhicl::ParameterSet const &pset, std::string const &header)
std::string	indent (std::size_t const i)
std::string	indent0 ()
std::string	indent_1 ()
std::string	indent__2 ()
template<typename T , typename Elem >
std::size_t	columnWidth (T const &coll, std::string const Elem::*cp, std::string const &header)
std::size_t	columnWidth (LibraryInfoCollection const &coll, std::string const &(LibraryInfo::*fp)() const, std::string const &header)
std::size_t	rule_size (Widths const &widths)
std::vector< ModuleSpec >	sequence_to_entries (sequence_t const &seq, bool const allow_nil_entries)
std::vector< art::PathSpec >	path_specs (std::vector< ModuleSpec > const &selection_override_entries, std::string const &path_selection_override)
EnabledModules	prune_config_if_enabled (bool prune_config, bool report_enabled, fhicl::intermediate_table &config)
template<typename T >
std::ostream &	operator<< (std::ostream &os, Analyzer::Table< T > const &t)
std::set< ProductInfo >	consumed_products_for_module (std::string const &current_process, ConsumesInfo::consumables_t::mapped_type const &consumables, std::map< std::string, std::set< ProductInfo >> const &produced_products, std::map< std::string, std::set< std::string >> const &viewable_products, config_const_iterator const config_begin, config_const_iterator const config_it)
std::pair< ModuleGraph, std::string >	make_module_graph (ModuleGraphInfoMap const &modInfos, paths_to_modules_t const &trigger_paths, configs_t const &end_path)
void	make_trigger_path_subgraphs (ModuleGraphInfoMap const &modInfos, paths_to_modules_t const &trigger_paths, ModuleGraph &graph)
void	make_product_dependency_edges (ModuleGraphInfoMap const &modInfos, ModuleGraph &graph)
void	make_path_ordering_edges (ModuleGraphInfoMap const &modInfos, paths_to_modules_t const &paths, ModuleGraph &graph)
void	make_synchronization_edges (ModuleGraphInfoMap const &modInfos, paths_to_modules_t const &trigger_paths, configs_t const &end_path, ModuleGraph &graph)
std::string	verify_no_interpath_dependencies (ModuleGraphInfoMap const &modInfos, ModuleGraph const &graph)
std::string	verify_in_order_dependencies (ModuleGraphInfoMap const &modules, paths_to_modules_t const &trigger_paths)
void	print_module_graph (std::ostream &os, ModuleGraphInfoMap const &modInfos, ModuleGraph const &graph)
void	issue_reports (unsigned count, EventID const &id)
std::ostream &	operator<< (std::ostream &os, ModuleGraphInfo const &info)
ModuleType	module_type (std::string const &full_key)
bool	operator== (ModuleKeyAndType const &a, ModuleKeyAndType const &b) noexcept
bool	operator!= (ModuleKeyAndType const &a, ModuleKeyAndType const &b) noexcept
bool	skip_non_replicated (Worker const &)
void	verifyInstanceName (std::string const &in)
void	verifyFriendlyClassName (std::string const &fcn)
template<typename T , typename Config >
T *	make_module (Config const &config, ProcessingFrame const &frame)
void	memoryReport ()
void	writeSummary (PathManager &pm, bool wantSummary, cet::cpu_timer const &timer)
void	triggerReport (PerScheduleContainer< PathsInfo > const &endPathInfo, PerScheduleContainer< PathsInfo > const &triggerPathsInfo, bool wantSummary)
void	timeReport (cet::cpu_timer const &timer)
FileNameComponents	componentsFromPattern (std::string const &pattern)
void	logFileAction (const char *msg, std::string const &file)
void	validateFileNamePattern (bool do_check, std::string const &pattern)
TypeLabel	type_label_for (TypeID const typeID, std::string const &instance, bool const supportsView, ModuleDescription const &md)
template<typename... T>
void	throw_if_invalid (std::string const &msg, T const &...t)
constexpr bool	range_sets_supported (BranchType const bt)
std::ostream &	operator<< (std::ostream &os, LinuxMallInfo const &info)
void	ensure_only_one_thread (fhicl::ParameterSet const &service_pset)
template<typename T , typename ResultType , typename... Args>
std::function< ResultType(Args...)>	makeWatchFunc (ResultType(T::*slot)(Args...), T &t)
template<typename T , typename ResultType , typename... Args>
std::function< ResultType(Args...)>	makeWatchFunc (ResultType(T::*slot)(Args...) const, T const &t)
template<typename T >
std::enable_if_t< std::is_constructible_v< T, fhicl::ParameterSet const &, ActivityRegistry & >, std::shared_ptr< T > >	makeServiceFrom (fhicl::ParameterSet const &ps, ActivityRegistry &areg)
template<typename T >
std::enable_if_t<!std::is_constructible_v< T, fhicl::ParameterSet const &, ActivityRegistry & >, std::shared_ptr< T > >	makeServiceFrom (fhicl::ParameterSet const &ps, ActivityRegistry &)
template<SignalResponseType STYPE, typename SIGNAL , typename FUNC >
std::enable_if_t< STYPE==SignalResponseType::FIFO >	connect_to_signal (SIGNAL &s, FUNC f)
template<SignalResponseType STYPE, typename SIGNAL , typename FUNC >
std::enable_if_t< STYPE==SignalResponseType::LIFO >	connect_to_signal (SIGNAL &s, FUNC f)
std::map< old_t, new_t >	oldToNewName ()
template<typename T , typename I >
no_tag	has_two_arg_insert_helper (...)
template<typename T , typename I >
yes_tag	has_two_arg_insert_helper (two_arg_insert_func< T, I,&T::insert > *dummy)
template<typename T , typename R , typename O , typename I >
no_tag	has_three_arg_insert_helper (...)
template<typename T , typename R , typename O , typename I >
yes_tag	has_three_arg_insert_helper (three_arg_insert_func< T, R, O, I,&T::insert > *dummy)
template<typename T >
bool	verifyPtrCollection (std::vector< art::PtrVector< T > const * > const &in)
template<typename iterator >
bool	verifyPtrCollection (iterator beg, iterator end, art::ProductID id={}, art::EDProductGetter const *getter=nullptr)
BranchKey	splitToComponents (std::string const &branchName, std::string &errMsg)
bool	checkBranchNameSelector (std::string const &branchNameSelector, std::string &errMsg)
bool	checkBranchNameSelector (BranchKey const &components, std::string &errMsg)
bool	checkFriendlyName (std::string const &friendlyName, std::string &errMsg)
bool	checkFriendlyNameSelector (std::string const &friendlyNameSelector, std::string &errMsg)
bool	checkModuleLabel (std::string const &moduleLabel, std::string &errMsg)
bool	checkModuleLabelSelector (std::string const &moduleLabelSelector, std::string &errMsg)
bool	checkInstanceName (std::string const &instanceName, std::string &errMsg)
bool	checkInstanceNameSelector (std::string const &instanceNameSelector, std::string &errMsg)
bool	checkProcessName (std::string const &processName, std::string &errMsg)
bool	checkProcessNameSelector (std::string const &processNameSelector, std::string &errMsg)
std::vector< std::vector< std::string > >	orderedProcessNamesCollection (ProcessHistoryMap const &pHistMap)
void	remove_whitespace (std::string &str)
bool	has_whitespace (std::string const &str)
template<typename ProdA , typename ProdB , typename Data , typename Tag >
InputTag	input_tag (Tag const &tag)
bool	upcastAllowed (std::type_info const &tiFrom, std::type_info const &tiTo)
void const *	maybeCastObj (void const *address, std::type_info const &tiFrom, std::type_info const &tiTo)
template<typename element_type >
void const *	maybeCastObj (element_type const *address, std::type_info const &tiTo)
template<typename T >
auto	wrapperTypeID ()
void	throwPartnerException (std::type_info const &generator, std::type_info const &wanted_wrapper_type)
ProductLookup_t	createProductLookups (ProductDescriptionsByID const &descriptions)
ViewLookup_t	createViewLookups (ProductDescriptionsByID const &descriptions)
std::string const &	InvalidHash ()
EventRange	full_run_event_range ()
template<typename TO , typename FROM >
constexpr std::enable_if_t< are_cv_compatible< TO, FROM >::value, std::add_pointer_t< std::remove_pointer_t< TO > > >	addr (FROM &from)
template<typename TO , typename FROM >
constexpr std::enable_if_t<!are_cv_compatible< TO, FROM >::value &&are_cv_compatible< FROM, TO >::value, std::add_pointer_t< std::remove_pointer_t< TO > > >	addr (FROM &from)

Variables
template<typename T >
bool constexpr	handle_allowed_v {handle_allowed<T>::value}
SharedResource_t const	LegacyResource {"__legacy__", false}

Typedef Documentation

using art::detail::collection_map_t = typedef std::map<module_name_t, ModuleGraphInfo>

Definition at line 20 of file graph_type_aliases.h.

using art::detail::collection_t = typedef std::vector<collection_map_t::value_type>

Definition at line 21 of file graph_type_aliases.h.

template<typename T >

using art::detail::Config = typedef typename config_impl<T>::type

Definition at line 52 of file ModuleMacros.h.

using art::detail::config_const_iterator = typedef std::vector<WorkerInPath::ConfigInfo>::const_iterator

Definition at line 14 of file consumed_products.h.

using art::detail::configs_t = typedef std::vector<WorkerInPath::ConfigInfo>

Definition at line 17 of file graph_type_aliases.h.

using art::detail::distance_t = typedef collection_t::difference_type

Definition at line 22 of file graph_type_aliases.h.

using art::detail::Edge = typedef boost::graph_traits<ModuleGraph>::edge_descriptor

Definition at line 24 of file ModuleGraph.h.

using art::detail::edge_property = typedef boost::property<boost::edge_index_t, int, boost::property<boost::edge_name_t, std::string>>

Definition at line 15 of file ModuleGraph.h.

using art::detail::entry_selector_t = typedef std::function<bool(PathSpec const&)>

Definition at line 41 of file TriggerNamesService.h.

using art::detail::Graph = typedef boost::adjacency_list<boost::vecS, boost::vecS, boost::bidirectionalS, vertex_property, edge_property, graph_property>

Definition at line 22 of file ModuleGraph.h.

using art::detail::graph_property = typedef boost::property<boost::graph_name_t, std::string>

Definition at line 16 of file ModuleGraph.h.

using art::detail::keytype_for_name_t = typedef std::map<std::string, ModuleKeyAndType>

Definition at line 39 of file ModuleKeyAndType.h.

using art::detail::LibraryInfoCollection = typedef std::multiset<LibraryInfo>

Definition at line 10 of file LibraryInfoCollection.h.

using art::detail::module_entries_for_ordered_path_t = typedef std::vector<std::pair<PathSpec, std::vector<ModuleSpec>>>

Definition at line 41 of file ModuleKeyAndType.h.

using art::detail::module_entries_for_path_t = typedef std::map<std::string, std::vector<ModuleSpec>>

Definition at line 43 of file ModuleKeyAndType.h.

using art::detail::module_name_t = typedef std::string

Definition at line 15 of file graph_type_aliases.h.

using art::detail::ModuleGraph = typedef boost::subgraph<Graph>

Definition at line 23 of file ModuleGraph.h.

using art::detail::ModuleMaker_t = typedef ModuleBase*(fhicl::ParameterSet const&, ProcessingFrame const&)

Definition at line 33 of file ModuleMacros.h.

using art::detail::modules_for_path_t = typedef std::map<std::string, std::vector<ModuleKeyAndType>>

Definition at line 45 of file ModuleKeyAndType.h.

using art::detail::ModuleThreadingTypeFunc_t = typedef ModuleThreadingType(

Definition at line 39 of file ModuleMacros.h.

using art::detail::ModuleTypeFunc_t = typedef ModuleType(

Definition at line 38 of file ModuleMacros.h.

using art::detail::name_set_t = typedef std::set<std::string>

Definition at line 18 of file graph_type_aliases.h.

using art::detail::names_t = typedef std::vector<std::string>

Definition at line 16 of file graph_type_aliases.h.

using art::detail::new_t = typedef std::string

Definition at line 10 of file SAMMetadataTranslators.h.

using art::detail::old_t = typedef std::string

Definition at line 11 of file SAMMetadataTranslators.h.

using art::detail::path_name_t = typedef std::string

Definition at line 14 of file graph_type_aliases.h.

using art::detail::paths_to_modules_t = typedef std::vector<std::pair<PathSpec, configs_t>>

Definition at line 19 of file graph_type_aliases.h.

template<typename T >

using art::detail::respond_to_file = typedef void (T::*)(FileBlock const&)

Definition at line 308 of file MixFilter.h.

using art::detail::ServiceCache = typedef std::map<TypeID, ServiceCacheEntry>

Definition at line 11 of file ServiceCache.h.

typedef std::stack<WrapperBase_ptr> art::detail::ServiceStack

Definition at line 12 of file ServiceStack.h.

template<typename T >

using art::detail::size_expression_t = typedef decltype(std::declval<T const>().size())

Definition at line 42 of file Wrapper.h.

using art::detail::Vertex = typedef boost::graph_traits<ModuleGraph>::vertex_descriptor

Definition at line 25 of file ModuleGraph.h.

using art::detail::vertex_property = typedef boost::property<boost::vertex_name_t, std::string>

Definition at line 11 of file ModuleGraph.h.

using art::detail::Widths = typedef std::vector<std::size_t>

Definition at line 65 of file PrintFormatting.h.

using art::detail::WorkerFromModuleMaker_t = typedef Worker*(std::shared_ptr<ModuleBase>, ModuleDescription const&, WorkerParams const&)

Definition at line 36 of file ModuleMacros.h.

using art::detail::WorkerMaker_t = typedef Worker*(WorkerParams const&, ModuleDescription const&)

Definition at line 37 of file ModuleMacros.h.

using art::detail::WrapperBase_ptr = typedef std::shared_ptr<ServiceWrapperBase>

Definition at line 29 of file ServiceWrapperBase.h.

Enumeration Type Documentation

enum art::detail::FilterAction

strong

Enumerator
Normal
Ignore
Veto

Definition at line 18 of file ModuleKeyAndType.h.

{ Normal = 0, Ignore = 1, Veto = 2 };

enum art::detail::SignalResponseType

strong

Enumerator
FIFO
LIFO

Definition at line 12 of file SignalResponseType.h.

{ FIFO, LIFO };

Function Documentation

template<typename TO , typename FROM >

constexpr std::enable_if_t<are_cv_compatible<TO, FROM>::value, std::add_pointer_t<std::remove_pointer_t<TO> > > art::detail::addr

(

FROM &

from

)

Definition at line 35 of file ensurePointer.h.

    {
      return &from;
    }

template<typename TO , typename FROM >

constexpr std::enable_if_t<!are_cv_compatible<TO, FROM>::value && are_cv_compatible<FROM, TO>::value, std::add_pointer_t<std::remove_pointer_t<TO> > > art::detail::addr

(

FROM &

from

)

Definition at line 44 of file ensurePointer.h.

    {
      return &dynamic_cast<
        std::add_lvalue_reference_t<std::remove_pointer_t<TO>>>(from);
    }

bool art::detail::checkBranchNameSelector	(	std::string const &	branchNameSelector,
		std::string &	errMsg
	)

Definition at line 61 of file branchNameComponentChecking.cc.

{
  errMsg.clear();
  auto components = splitToComponents(branchNameSelector, errMsg);
  return (!errMsg.empty()) || checkBranchNameSelector(components, errMsg);
}

bool art::detail::checkBranchNameSelector	(	BranchKey const &	components,
		std::string &	errMsg
	)

Definition at line 70 of file branchNameComponentChecking.cc.

{
  // Inclusive operation: do all steps.
  bool result =
    checkFriendlyNameSelector(components.friendlyClassName_, errMsg);
  result = checkModuleLabelSelector(components.moduleLabel_, errMsg) && result;
  result = checkInstanceNameSelector(components.productInstanceName_, errMsg) &&
           result;
  result = checkProcessNameSelector(components.processName_, errMsg) && result;
  return result;
}

bool art::detail::checkFriendlyName	(	std::string const &	friendlyName,
		std::string &	errMsg
	)

Definition at line 84 of file branchNameComponentChecking.cc.

{
  return checkBranchNameComponent(
    friendlyName, "friendly name", typeRE, errMsg);
}

bool art::detail::checkFriendlyNameSelector	(	std::string const &	friendlyNameSelector,
		std::string &	errMsg
	)

Definition at line 92 of file branchNameComponentChecking.cc.

{
  return checkBranchNameComponent(
    friendlyNameSelector, "friendly name", typeSelectorRE, errMsg);
}

bool art::detail::checkInstanceName	(	std::string const &	instanceName,
		std::string &	errMsg
	)

Definition at line 115 of file branchNameComponentChecking.cc.

{
  return checkBranchNameComponent(instanceName,
                                  "instance name",
                                  processRE, // sic.
                                  errMsg,
                                  true);
}

bool art::detail::checkInstanceNameSelector	(	std::string const &	instanceNameSelector,
		std::string &	errMsg
	)

Definition at line 126 of file branchNameComponentChecking.cc.

{
  return checkBranchNameComponent(instanceNameSelector,
                                  "instance name",
                                  processSelectorRE, // sic.
                                  errMsg,
                                  true);
}

bool art::detail::checkModuleLabel	(	std::string const &	moduleLabel,
		std::string &	errMsg
	)

Definition at line 100 of file branchNameComponentChecking.cc.

{
  return checkBranchNameComponent(moduleLabel, "module label", labelRE, errMsg);
}

bool art::detail::checkModuleLabelSelector	(	std::string const &	moduleLabelSelector,
		std::string &	errMsg
	)

Definition at line 107 of file branchNameComponentChecking.cc.

{
  return checkBranchNameComponent(
    moduleLabelSelector, "module label", labelSelectorRE, errMsg);
}

bool art::detail::checkProcessName	(	std::string const &	processName,
		std::string &	errMsg
	)

Definition at line 137 of file branchNameComponentChecking.cc.

{
  return checkBranchNameComponent(
    processName, "process name", processRE, errMsg);
}

bool art::detail::checkProcessNameSelector	(	std::string const &	processNameSelector,
		std::string &	errMsg
	)

Definition at line 145 of file branchNameComponentChecking.cc.

{
  return checkBranchNameComponent(
    processNameSelector, "process name", processSelectorRE, errMsg);
}

template<typename T , typename Elem >

std::size_t art::detail::columnWidth	(	T const &	coll,
		std::string const Elem::*	cp,
		std::string const &	header
	)

Definition at line 41 of file PrintFormatting.h.

  {
    std::size_t s{header.size()};
    cet::for_all(
      coll, [&s, cp](auto const& elem) { s = std::max(s, (elem.*cp).size()); });
    return s;
  }

std::size_t art::detail::columnWidth ( LibraryInfoCollection const &  coll, std::string const &(LibraryInfo::*)() const  fp, std::string const &  header  )

inline

Definition at line 52 of file PrintFormatting.h.

  {
    std::size_t s{header.size()};
    cet::for_all(
      coll, [&s, fp](auto const& li) { s = std::max(s, (li.*fp)().size()); });
    return s;
  }

FileNameComponents art::detail::componentsFromPattern

(

std::string const &

pattern

)

Definition at line 62 of file FileNameComponents.cc.

  {
    FileNameComponents result;

    boost::smatch match;
    auto sid = cbegin(pattern), se = cend(pattern);
    while (boost::regex_search(
      sid,
      se,
      match,
      boost::regex{"%(\\d+)?#", boost::regex_constants::ECMAScript})) {
      assert(match.size() == 2);
      // Subexpressions:
      //   0. Entire matched expression
      //   1. Possible fill format digits for numeric substitution.
      result.add(match.prefix(), match[1].str());
      sid = match[0].second;
    }
    // Get remaining characters of filename
    result.setSuffix(std::string(sid, se));
    return result;
  }

template<SignalResponseType STYPE, typename SIGNAL , typename FUNC >

std::enable_if_t<STYPE == SignalResponseType::FIFO> art::detail::connect_to_signal	(	SIGNAL &	s,
		FUNC	f
	)

Definition at line 16 of file SignalResponseType.h.

    {
      s.emplace_back(f);
    }

template<SignalResponseType STYPE, typename SIGNAL , typename FUNC >

std::enable_if_t<STYPE == SignalResponseType::LIFO> art::detail::connect_to_signal	(	SIGNAL &	s,
		FUNC	f
	)

Definition at line 23 of file SignalResponseType.h.

    {
      s.emplace_front(f);
    }

std::set< ProductInfo > art::detail::consumed_products_for_module	(	std::string const &	current_process,
		ConsumesInfo::consumables_t::mapped_type const &	consumables,
		std::map< std::string, std::set< ProductInfo >> const &	produced_products,
		std::map< std::string, std::set< std::string >> const &	viewable_products,
		config_const_iterator const	config_begin,
		config_const_iterator const	config_it
	)

Definition at line 159 of file consumed_products.cc.

{
  auto const& module_name =
    config_it->moduleConfigInfo->modDescription.moduleLabel();
  std::set<ProductInfo> result;
  for (auto const& per_branch_type : consumables) {
    for (auto const& prod_info : per_branch_type) {
      switch (prod_info.consumableType) {
      case ProductInfo::ConsumableType::Product: {
        auto dep = consumes_dependency(config_begin,
                                       config_it,
                                       prod_info,
                                       current_process,
                                       produced_products);
        result.insert(std::move(dep));
        break;
      }
      case ProductInfo::ConsumableType::Many: {
        // Loop through modules on this path, introducing
        // product-lookup dependencies if the type of the product
        // created by the module matches the type requested in the
        // consumesMany call.
        auto const& class_name = prod_info.friendlyClassName;
        for (auto mit = config_begin; mit != config_it; ++mit) {
          auto possible_products = produced_products.find(
            mit->moduleConfigInfo->modDescription.moduleLabel());
          if (possible_products == cend(produced_products)) {
            continue;
          }
          cet::copy_if_all(possible_products->second,
                           inserter(result, begin(result)),
                           [&class_name](auto const& pi) {
                             return class_name == pi.friendlyClassName;
                           });
        }
        break;
      }
      case ProductInfo::ConsumableType::ViewElement: {
        auto dep = consumes_view_dependency(
          prod_info, module_name, current_process, viewable_products);
        result.insert(std::move(dep));
      }
        // No default case to allow compiler to warn.
      }
    }
  }
  return result;
}

art::ProductLookup_t art::detail::createProductLookups

(

ProductDescriptionsByID const &

descriptions

)

Definition at line 68 of file createProductLookups.cc.

{
  // Computing the product lookups does not rely on any ROOT facilities.
  ProductLookup_t result;
  std::vector<PendingBTLEntry> pendingEntries;
  std::unordered_map<ProductID, CheapTag, ProductID::Hash> insertedABVs;
  for (auto const& pr : descriptions) {
    auto const pid = pr.first;
    auto const& pd = pr.second;
    auto const& prodFCN = pd.friendlyClassName();
    auto const& procName = pd.processName();
    result[prodFCN][procName].emplace_back(pid);

    // Additional work only for Assns lookup
    auto const& moduleLabel = pd.moduleLabel();
    auto const& instanceName = pd.productInstanceName();
    auto const& className = pd.producedClassName();

    if (!is_assns(className))
      continue;

    auto const baseName = name_of_assns_base(className);
    if (!baseName.empty()) {
      // We're an Assns<A, B, D>, with a base Assns<A, B>.
      pendingEntries.emplace_back(art::friendlyname::friendlyName(baseName),
                                  moduleLabel,
                                  instanceName,
                                  procName,
                                  pid);
    } else {
      // Add our pid to the list of real Assns<A, B, void>
      // products already registered.
      insertedABVs.emplace(pid, CheapTag{moduleLabel, instanceName, procName});
    }
  }

  auto const iend = insertedABVs.cend();
  // Preserve useful ordering, only inserting if we don't already have
  // a *real* Assns<A, B, void> for that module label / instance name
  // combination.
  std::for_each(
    pendingEntries.cbegin(),
    pendingEntries.cend(),
    [&result, &insertedABVs, iend](auto const& pe) {
      auto& pids = result[pe.fcn()][pe.process()];
      if (pids.empty() ||
          !std::any_of(pids.cbegin(),
                       pids.cend(),
                       [&insertedABVs, &iend, &pe](ProductID const pid) {
                         auto i = insertedABVs.find(pid);
                         return i != iend && pe.ct() == i->second;
                       })) {
        pids.emplace_back(pe.pid());
      }
    });

  return result;
}

art::ViewLookup_t art::detail::createViewLookups

(

ProductDescriptionsByID const &

descriptions

)

Definition at line 5 of file createViewLookups.cc.

{
  // This version stores the list of products that support views.
  ViewLookup_t result;
  for (auto const& pr : descriptions) {
    auto const& pd = pr.second;
    if (!pd.supportsView())
      continue;

    auto const& procName = pd.processName();
    auto const pid = pr.first;

    result[procName].emplace_back(pid);
  }
  return result;
}

std::string art::detail::describe	(	cet::exempt_ptr< fhicl::ConfigurationTable const >	pb,
		std::string const &	prefix
	)

Definition at line 6 of file describe.cc.

{
  std::ostringstream oss;
  if (config == nullptr) {
    oss << "\n" << tab << "[ None provided ]\n";
  } else {
    oss << '\n' << tab << fhicl::detail::optional_parameter_message() << '\n';
    fhicl::detail::PrintAllowedConfiguration pac{oss, false, tab};
    pac.walk_over(*config->parameter_base());
  }
  return oss.str();
}

constexpr char const* art::detail::dflt_spec_pattern

(

)

Definition at line 11 of file get_LibraryInfoCollection.h.

  {
    return "[A-Za-z0-9]+";
  }

void art::detail::ensure_only_one_thread

(

fhicl::ParameterSet const &

service_pset

)

Definition at line 15 of file ensure_only_one_thread.cc.

{
  auto const& globals = *Globals::instance();
  auto const nschedules = globals.nschedules();
  auto const nthreads = globals.nthreads();
  if (nschedules == 1u && nthreads == 1u)
    return;

  auto const service_type = service_pset.get<std::string>("service_type");
  Exception e{errors::Configuration};
  e << "The service '" << service_type << '\'';
  std::string provider;
  if (service_pset.get_if_present("service_provider", provider)) {
    e << " (provider: '" << provider << "')";
  }
  e << " is a legacy service,\n"
    << "which can be used with only one schedule and one thread.\n"
    << "This job uses " << nschedules << maybe_s(nschedules, " schedule")
    << " and " << nthreads << maybe_s(nthreads, " thread") << ".\n"
    << "Please reconfigure your job to use only one schedule/thread.\n";
  throw e;
}

std::tuple< art::RunNumber_t, art::SubRunNumber_t, art::EventNumber_t > art::detail::event_start

(

std::string const &

str_num

)

Definition at line 72 of file event_start.cc.

{
  std::smatch parts;
  auto const success = std::regex_match(event_spec, parts, re_event_id);
  if (!success) {
    throw_configuration_exception(event_spec);
  }

  assert(parts.size() == 4ull);
  // A successful match will populate 'parts' with 5 elements.
  // Consider the following valid specifications:
  //
  //   +-------------+---------+
  //   | User spec.  | '1:0:3' |
  //   +-------------+---------+
  //   | parts[0] == | '1:0:3' |
  //   | parts[1] == |     '1' |
  //   | parts[2] == |     '0' |
  //   | parts[3] == |     '3' |
  //   +-------------+---------+

  auto const run = convert_or_throw<Level::Run>(parts[1], event_spec);
  auto const subrun = convert_or_throw<Level::SubRun>(parts[2], event_spec);
  auto const event = convert_or_throw<Level::Event>(parts[3], event_spec);

  return std::make_tuple(run, subrun, event);
}

bool art::detail::exists_outside_prolog ( fhicl::intermediate_table const &  config, std::string const &  key  )

inline

Definition at line 9 of file exists_outside_prolog.h.

  {
    return config.exists(key) && !config.find(key).in_prolog;
  }

template<typename T >

std::enable_if_t<std::is_convertible_v<T, std::string>, std::string> art::detail::fhicl_key

(

T const &

name

)

Definition at line 12 of file fhicl_key.h.

  {
    return name;
  }

template<typename H , typename... T>

std::enable_if_t<std::is_convertible_v<H, std::string>, std::string> art::detail::fhicl_key	(	H const &	hname,
		T const &...	tnames
	)

Definition at line 19 of file fhicl_key.h.

  {
    std::string const head{hname};
    return head.empty() ? fhicl_key(tnames...) :
                          head + "." + fhicl_key(tnames...);
  }

void art::detail::fillSourceList	(	std::istream &	ifs,
		std::vector< std::string > &	source_list
	)

Definition at line 4 of file fillSourceList.cc.

{
  for (std::string line; std::getline(is, line);) {
    auto const comment_start = line.find('#');
    if (comment_start != std::string::npos)
      line.erase(comment_start);
    if (!line.empty())
      source_list.push_back(line);
  }
}

EventRange art::detail::full_run_event_range

(

)

Definition at line 81 of file RangeSet.cc.

  {
    static EventRange const range{
      IDNumber<Level::SubRun>::invalid(), 0, IDNumber<Level::Event>::invalid()};
    return range;
  }

LibraryInfoCollection art::detail::get_LibraryInfoCollection	(	std::string const &	suffix,
		std::string const &	pattern,
		bool	verbose = false
	)

Definition at line 240 of file get_LibraryInfoCollection.cc.

{
  if (suffix == art::Suffixes::service()) {
    return collection_for_services(pattern, verbose);
  }
  return collection_for_plugins(suffix, pattern, verbose);
}

std::unique_ptr< MetadataCollector > art::detail::get_MetadataCollector

(

std::string const &

suffix

)

Definition at line 15 of file get_MetadataCollector.cc.

{
  if (suffix == art::Suffixes::module()) {
    return std::make_unique<MetadataCollectorFor<suffix_type::module>>();
  }
  if (suffix == art::Suffixes::plugin()) {
    return std::make_unique<MetadataCollectorFor<suffix_type::plugin>>();
  }
  if (suffix == art::Suffixes::service()) {
    return std::make_unique<MetadataCollectorFor<suffix_type::service>>();
  }
  if (suffix == art::Suffixes::source()) {
    return std::make_unique<MetadataCollectorFor<suffix_type::source>>();
  }
  if (suffix == art::Suffixes::tool()) {
    return std::make_unique<MetadataCollectorFor<suffix_type::tool>>();
  }
  if (suffix == art::Suffixes::mfPlugin()) {
    return std::make_unique<MetadataCollectorFor<suffix_type::mfPlugin>>();
  }
  if (suffix == art::Suffixes::mfStatsPlugin()) {
    return std::make_unique<MetadataCollectorFor<suffix_type::mfStatsPlugin>>();
  }
  return std::unique_ptr<MetadataCollector>{nullptr};
}

std::unique_ptr< MetadataSummary > art::detail::get_MetadataSummary	(	std::string const &	suffix,
		LibraryInfoCollection const &	coll
	)

Definition at line 15 of file get_MetadataSummary.cc.

{
  if (suffix == art::Suffixes::module()) {
    return std::make_unique<MetadataSummaryFor<suffix_type::module>>(coll);
  }
  if (suffix == art::Suffixes::plugin()) {
    return std::make_unique<MetadataSummaryFor<suffix_type::plugin>>(coll);
  }
  if (suffix == art::Suffixes::service()) {
    return std::make_unique<MetadataSummaryFor<suffix_type::service>>(coll);
  }
  if (suffix == art::Suffixes::source()) {
    return std::make_unique<MetadataSummaryFor<suffix_type::source>>(coll);
  }
  if (suffix == art::Suffixes::tool()) {
    return std::make_unique<MetadataSummaryFor<suffix_type::tool>>(coll);
  }
  if (suffix == art::Suffixes::mfPlugin()) {
    return std::make_unique<MetadataSummaryFor<suffix_type::mfPlugin>>(coll);
  }
  if (suffix == art::Suffixes::mfStatsPlugin()) {
    return std::make_unique<MetadataSummaryFor<suffix_type::mfStatsPlugin>>(
      coll);
  }
  return std::unique_ptr<MetadataSummary>{nullptr};
}

std::unique_ptr< fhicl::ConfigurationTable > art::detail::getAllowedConfiguration	(	cet::LibraryManager const &	lm,
		std::string const &	fullSpec,
		std::string const &	name
	)

Definition at line 94 of file PluginSymbolResolvers.cc.

  {
    using GetAllowedConfiguration_t =
      std::unique_ptr<fhicl::ConfigurationTable>(std::string const&);

    auto description = [&lm, &fullSpec, &name] {
      GetAllowedConfiguration_t* symbolType{};
      lm.getSymbolByLibspec(fullSpec, "allowed_configuration", symbolType);
      return symbolType(name);
    };

    return resolve_if_present(
      description,
      __func__,
      std::unique_ptr<fhicl::ConfigurationTable>{nullptr});
  }

std::string art::detail::getFilePath	(	cet::LibraryManager const &	lm,
		std::string const &	fullspec
	)

Definition at line 31 of file PluginSymbolResolvers.cc.

  {
    using GetSourceLoc_t = std::string();

    using namespace std::string_literals;
    auto path = [&lm, &fullspec] {
      GetSourceLoc_t* symbolLoc{};
      lm.getSymbolByLibspec(fullspec, "get_source_location", symbolLoc);
      std::string source{symbolLoc()};
      boost::filesystem::path const p{source};
      if (!boost::filesystem::exists(p)) {
        source =
          "/ [ external source ] /" + fullspec + "_" + lm.libType() + ".cc";
      }
      return source;
    };

    return resolve_if_present(path, __func__, "[ not found ]"s);
  }

std::string art::detail::getType	(	cet::LibraryManager const &	lm,
		std::string const &	fullSpec
	)

Definition at line 52 of file PluginSymbolResolvers.cc.

  {
    auto const& suffix = lm.libType();
    if (suffix == Suffixes::module()) {
      using ModuleTypeFunc_t = art::ModuleType();

      auto type = [&lm, &fullSpec] {
        ModuleTypeFunc_t* symbolType{nullptr};
        lm.getSymbolByLibspec(fullSpec, "moduleType", symbolType);
        return to_string(symbolType());
      };

      return resolve_if_present(type, __func__, "[ error ]"s);
    }

    if (suffix == Suffixes::plugin()) {
      using PluginTypeFunc_t = std::string();

      auto type = [&lm, &fullSpec] {
        PluginTypeFunc_t* symbolType{nullptr};
        lm.getSymbolByLibspec(fullSpec, "pluginType", symbolType);
        return symbolType();
      };

      return resolve_if_present(type, __func__, "[ error ]"s);
    }

    if (suffix == Suffixes::tool()) {
      using ToolTypeFunc_t = std::string();

      auto type = [&lm, &fullSpec] {
        ToolTypeFunc_t* symbolType{nullptr};
        lm.getSymbolByLibspec(fullSpec, "toolType", symbolType);
        return symbolType();
      };

      return resolve_if_present(type, __func__, "[ error ]"s);
    }
    return {};
  }

template<typename T , typename R , typename O , typename I >

no_tag art::detail::has_three_arg_insert_helper

(

...

)

template<typename T , typename R , typename O , typename I >

yes_tag art::detail::has_three_arg_insert_helper

(

three_arg_insert_func< T, R, O, I,&T::insert > *

dummy

)

template<typename T , typename I >

no_tag art::detail::has_two_arg_insert_helper

(

...

)

template<typename T , typename I >

yes_tag art::detail::has_two_arg_insert_helper

(

two_arg_insert_func< T, I,&T::insert > *

dummy

)

bool art::detail::has_whitespace

(

std::string const &

str

)

Definition at line 17 of file remove_whitespace.cc.

{
  return str.find_first_of(whitespace_chars) != std::string::npos;
}

std::string art::detail::indent ( std::size_t const  i )

inline

Definition at line 17 of file PrintFormatting.h.

  {
    return std::string(i, ' ');
  }

std::string art::detail::indent0 ( )

inline

Definition at line 22 of file PrintFormatting.h.

  {
    return indent(3);
  }

std::string art::detail::indent_1 ( )

inline

Definition at line 27 of file PrintFormatting.h.

  {
    return indent(4);
  }

std::string art::detail::indent__2 ( )

inline

Definition at line 32 of file PrintFormatting.h.

  {
    return indent(8);
  }

constexpr int art::detail::info_success

(

)

Definition at line 8 of file info_success.h.

  {
    return std::numeric_limits<int>::max();
  }

template<typename ProdA , typename ProdB , typename Data , typename Tag >

InputTag art::detail::input_tag

(

Tag const &

tag

)

Definition at line 30 of file IPRHelper.h.

  {
    static_assert(
      std::is_convertible_v<Tag, InputTag> ||
        std::is_same_v<Tag, ProductToken<Assns<ProdA, ProdB>>> ||
        std::is_same_v<Tag, ProductToken<Assns<ProdA, ProdB, Data>>>,
      "\n\nart error: The input tag or product token provided to the "
      "smart-query object\n"
      "           constructor has a type that conflicts with that of the "
      "smart-query object.\n");
    return safe_input_tag<ProdA, ProdB, Data>(tag).tag;
  }

std::string const & art::detail::InvalidHash

(

)

Definition at line 7 of file Hash.cc.

  {
    static std::string const invalid{cet::MD5Result().compactForm()};
    return invalid;
  }

void art::detail::issue_reports	(	unsigned	count,
		EventID const &	id
	)

Definition at line 29 of file issue_reports.cc.

{
  time_t t = time(0);
  constexpr char tsOutput[] = "dd-Mon-yyyy hh:mm:ss TZN     ";
  constexpr size_t tsmax = (sizeof tsOutput) + 1;
  char ts[tsmax];
  strftime(ts, tsmax, "%d-%b-%Y %H:%M:%S %Z", localtime(&t));
  mf::LogVerbatim{"ArtReport"} << "Begin processing the " << count
                               << suffix(count) << " record. " << id << " at "
                               << ts;
  // At some point we may want to initiate checkpointing here
}

void art::detail::logFileAction	(	const char *	msg,
		std::string const &	file
	)

Definition at line 9 of file logFileAction.cc.

{
  time_t t = time(0);
  char ts[] = "dd-Mon-yyyy hh:mm:ss TZN     ";
  struct tm localtm;
  strftime(
    ts, strlen(ts) + 1, "%d-%b-%Y %H:%M:%S %Z", localtime_r(&t, &localtm));
  mf::LogAbsolute("fileAction") << ts << "  " << msg << '\"' << file << '\"';
}

template<typename T , typename Config >

T* art::detail::make_module	(	Config const &	config,
		ProcessingFrame const &	frame
	)

Definition at line 56 of file ModuleMacros.h.

  {
    if constexpr (ModuleThreadingTypeDeducer<typename T::ModuleType>::value ==
                  ModuleThreadingType::legacy) {
      return new T{config};
    } else {
      return new T{config, frame};
    }
  }

std::pair< ModuleGraph, std::string > art::detail::make_module_graph	(	ModuleGraphInfoMap const &	modInfos,
		paths_to_modules_t const &	trigger_paths,
		configs_t const &	end_path
	)

Definition at line 45 of file graph_algorithms.cc.

{
  auto const nmodules = modInfos.size();
  ModuleGraph module_graph{nmodules};

  make_trigger_path_subgraphs(modInfos, trigger_paths, module_graph);
  make_product_dependency_edges(modInfos, module_graph);
  auto err = verify_no_interpath_dependencies(modInfos, module_graph);
  if (err.empty()) {
    // Cannot currently check intrapath dependencies unless the above
    // check is successful.
    err += verify_in_order_dependencies(modInfos, trigger_paths);
  }

  make_path_ordering_edges(modInfos, trigger_paths, module_graph);
  make_synchronization_edges(modInfos, trigger_paths, end_path, module_graph);

  return std::make_pair(module_graph, err);
}

void art::detail::make_path_ordering_edges	(	ModuleGraphInfoMap const &	modInfos,
		paths_to_modules_t const &	paths,
		ModuleGraph &	graph
	)

Definition at line 112 of file graph_algorithms.cc.

{
  // Make edges corresponding to path ordering
  auto path_label = get(boost::edge_name, graph);
  for (auto const& path : trigger_paths) {
    auto const& modules = path.second;
    if (modules.empty())
      continue;
    auto prev = cbegin(modules);
    auto curr = prev + 1;
    auto const end = cend(modules);
    while (curr != end) {
      auto const pi = modInfos.vertex_index(module_label(*prev));
      auto const ci = modInfos.vertex_index(module_label(*curr));
      auto const edge = add_edge(ci, pi, graph);
      path_label[edge.first] = "path:" + path.first.name;
      prev = curr;
      ++curr;
    }
  }
}

void art::detail::make_product_dependency_edges	(	ModuleGraphInfoMap const &	modInfos,
		ModuleGraph &	graph
	)

Definition at line 97 of file graph_algorithms.cc.

{
  auto edge_label = get(boost::edge_name, graph);
  for (Vertex u{}; u < modInfos.size(); ++u) {
    auto const& modu = modInfos.info(u);
    for (auto const& dep : modu.consumed_products) {
      auto const v = modInfos.vertex_index(dep.label);
      auto const edge = add_edge(u, v, graph);
      edge_label[edge.first] = "prod";
    }
  }
}

void art::detail::make_synchronization_edges	(	ModuleGraphInfoMap const &	modInfos,
		paths_to_modules_t const &	trigger_paths,
		configs_t const &	end_path,
		ModuleGraph &	graph
	)

Definition at line 137 of file graph_algorithms.cc.

{
  auto const source_index = modInfos.vertex_index("input_source");
  auto sync_label = get(boost::edge_name, graph);
  if (!trigger_paths.empty()) {
    auto const tr_index = modInfos.vertex_index("TriggerResults");
    for (auto const& path : trigger_paths) {
      auto const& modules = path.second;
      if (modules.empty()) {
        continue;
      }
      auto const front_index =
        modInfos.vertex_index(module_label(modules.front()));
      auto const back_index =
        modInfos.vertex_index(module_label(modules.back()));
      auto const edge1 = add_edge(front_index, source_index, graph);
      sync_label[edge1.first] = "source:" + path.first.name;
      auto const edge2 = add_edge(tr_index, back_index, graph);
      sync_label[edge2.first] = "sync";
    }
    for (auto const& module : end_path) {
      auto const index = modInfos.vertex_index(module_label(module));
      auto const edge = add_edge(index, tr_index, graph);
      sync_label[edge.first] = "sync";
    }
  } else if (!end_path.empty()) {
    for (auto const& module : end_path) {
      auto const index = modInfos.vertex_index(module_label(module));
      auto const edge = add_edge(index, source_index, graph);
      sync_label[edge.first] = "sync";
    }
  }

  auto constexpr invalid = std::numeric_limits<std::size_t>::max();

  // Now synchronize between previous filters
  for (auto const& path : trigger_paths) {
    auto preceding_filter_index = invalid;
    for (auto const& module : path.second) {
      auto const index = modInfos.vertex_index(module_label(module));
      auto const& info = modInfos.info(index);
      if (preceding_filter_index != invalid) {
        auto const edge = add_edge(index, preceding_filter_index, graph);
        sync_label[edge.first] = "filter:" + path.first.name;
      }
      if (info.module_type == ModuleType::filter) {
        preceding_filter_index = index;
      }
    }
  }

  if (trigger_paths.empty()) {
    return;
  }

  // Synchronize end-path modules if a 'SelectEvents' parameter has
  // been specified.  Treat it as a filter.
  auto const tr_index = modInfos.vertex_index("TriggerResults");
  for (auto const& module : end_path) {
    auto const index = modInfos.vertex_index(module_label(module));
    auto const& info = modInfos.info(index);
    for (auto const& path : info.select_events) {
      auto const edge = add_edge(index, tr_index, graph);
      sync_label[edge.first] = "filter:" + path;
    }
  }
}

void art::detail::make_trigger_path_subgraphs	(	ModuleGraphInfoMap const &	modInfos,
		paths_to_modules_t const &	trigger_paths,
		ModuleGraph &	graph
	)

Definition at line 68 of file graph_algorithms.cc.

{
  std::map<path_name_t, ModuleGraph*> path_graphs;
  auto const source_index = modInfos.vertex_index("input_source");
  for (auto const& path : trigger_paths) {
    auto& path_graph = module_graph.create_subgraph();
    // Always include the source on the path.
    add_vertex(source_index, path_graph);
    path_graphs[path.first.name] = &path_graph;
  }

  auto vertex_names = get(boost::vertex_name_t{}, module_graph);
  for (auto const& pr : modInfos) {
    auto const& module_name = pr.first;
    auto const& info = pr.second;
    if (!is_modifier(info.module_type))
      continue;
    auto const index = modInfos.vertex_index(pr.first);
    for (auto const& path : info.paths) {
      add_vertex(index, *path_graphs.at(path));
    }
    vertex_names[index] = module_name;
  }
}

template<typename T >

std::enable_if_t< std::is_constructible_v<T, fhicl::ParameterSet const&, ActivityRegistry&>, std::shared_ptr<T> > art::detail::makeServiceFrom	(	fhicl::ParameterSet const &	ps,
		ActivityRegistry &	areg
	)

Definition at line 28 of file ServiceWrapper.h.

    {
      static_assert(
        !std::is_base_of_v<ProducingService, T>,
        "\n\nart-error: A service that inherits from art::ProducingService\n"
        "           cannot have a constructor that takes an ActivityRegistry&\n"
        "           argument.  Contact artists@fnal.gov for guidance.\n");
      return std::make_shared<T>(ps, areg);
    }

template<typename T >

std::enable_if_t<!std::is_constructible_v<T, fhicl::ParameterSet const&, ActivityRegistry&>, std::shared_ptr<T> > art::detail::makeServiceFrom	(	fhicl::ParameterSet const &	ps,
		ActivityRegistry &
	)

Definition at line 43 of file ServiceWrapper.h.

    {
      return std::make_shared<T>(ps);
    }

template<typename T , typename ResultType , typename... Args>

std::function<ResultType(Args...)> art::detail::makeWatchFunc	(	ResultType(T::*)(Args...)	slot,
		T &	t
	)

Definition at line 16 of file makeWatchFunc.h.

    {
      return [slot, &t](Args&&... args) -> ResultType {
        return (t.*slot)(std::forward<Args>(args)...);
      };
    }

template<typename T , typename ResultType , typename... Args>

std::function<ResultType(Args...)> art::detail::makeWatchFunc	(	ResultType(T::*)(Args...) const	slot,
		T const &	t
	)

Definition at line 25 of file makeWatchFunc.h.

    {
      return [slot, &t](Args&&... args) -> ResultType {
        return (t.*slot)(std::forward<Args>(args)...);
      };
    }

void const* art::detail::maybeCastObj	(	void const *	address,
		std::type_info const &	tiFrom,
		std::type_info const &	tiTo
	)

template<typename element_type >

void const * art::detail::maybeCastObj ( element_type const *  address, std::type_info const &  tiTo  )

inline

Definition at line 18 of file maybeCastObj.h.

{
  static std::type_info const& tiFrom{typeid(element_type)};
  return maybeCastObj(address, tiFrom, tiTo);
}

void art::detail::memoryReport

(

)

Definition at line 4 of file memoryReportDarwin.cc.

{
  // Not implemented for Darwin
}

ModuleType art::detail::module_type

(

std::string const &

full_key

)

Definition at line 5 of file ModuleKeyAndType.cc.

  {
    if (full_key.find("physics.producers") == 0) {
      return ModuleType::producer;
    } else if (full_key.find("physics.filters") == 0) {
      return ModuleType::filter;
    } else if (full_key.find("physics.analyzers") == 0) {
      return ModuleType::analyzer;
    } else if (full_key.find("outputs") == 0) {
      return ModuleType::output_module;
    }
    return ModuleType::non_art;
  }

std::map<old_t, new_t> art::detail::oldToNewName ( )

inline

Definition at line 14 of file SAMMetadataTranslators.h.

    {
      return {{"fileType", "file_type"},
              {"dataTier", "data_tier"},
              {"streamName", "data_stream"},
              {"runType", "run_type"}};
    }

bool art::detail::operator!= ( ModuleKeyAndType const &  a, ModuleKeyAndType const &  b  )

inlinenoexcept

Definition at line 32 of file ModuleKeyAndType.h.

  {
    return not(a == b);
  }

std::ostream & art::detail::operator<<	(	std::ostream &	os,
		ModuleGraphInfo const &	info
	)

Definition at line 4 of file ModuleGraphInfo.cc.

{
  os << "Module type: " << to_string(info.module_type) << '\n';
  os << "Product dependencies: ";
  for (auto const& dep : info.consumed_products) {
    os << dep << ' ';
  }
  os << "\nPaths: ";
  for (auto const& path : info.paths) {
    os << path << ' ';
  }
  return os;
}

std::ostream& art::detail::operator<< ( std::ostream &  os, LinuxMallInfo const &  info  )

inline

Definition at line 55 of file LinuxMallInfo.h.

    {
      auto const& minfo = info.minfo_;
      os << " HEAP-ARENA [ SIZE-BYTES " << minfo.arena << " N-UNUSED-CHUNKS "
         << minfo.ordblks << " TOP-FREE-BYTES " << minfo.keepcost << " ]"
         << " HEAP-MAPPED [ SIZE-BYTES " << minfo.hblkhd << " N-CHUNKS "
         << minfo.hblks << " ]"
         << " HEAP-USED-BYTES " << minfo.uordblks << " HEAP-UNUSED-BYTES "
         << minfo.fordblks;
      return os;
    }

template<typename T >

std::ostream& art::detail::operator<< ( std::ostream &  os, Analyzer::Table< T > const &  t  )

inline

Definition at line 136 of file Analyzer.h.

  {
    std::ostringstream config;
    t.print_allowed_configuration(config, std::string(3, ' '));
    return os << config.str();
  }

bool art::detail::operator== ( ModuleKeyAndType const &  a, ModuleKeyAndType const &  b  )

inlinenoexcept

Definition at line 26 of file ModuleKeyAndType.h.

  {
    return a.key == b.key && a.type == b.type;
  }

std::vector< std::vector< std::string > > art::detail::orderedProcessNamesCollection

(

ProcessHistoryMap const &

pHistMap

)

Definition at line 74 of file orderedProcessNamesCollection.cc.

{
  std::vector<std::string> all_process_names;
  all_process_names.reserve(histories.size());
  for (auto const& history : histories | ranges::views::values) {
    all_process_names.push_back(stringified_process_names(history));
  }
  cet::sort_all(all_process_names);

  // It is possible for two non-overlapping histories to have the same
  // process name.  We thus need to erase duplicate names.
  auto const e = end(all_process_names);
  auto const new_end = std::unique(begin(all_process_names), e);
  all_process_names.erase(new_end, e);

  auto const collapsed = collapsed_histories(all_process_names);
  return transform_to_final_result(collapsed);
}

bool art::detail::output_to_stderr

(

std::string const &

spec

)

Definition at line 15 of file output_to.cc.

{
  return std::regex_match(spec, re_stderr);
}

bool art::detail::output_to_stdout

(

std::string const &

spec

)

Definition at line 21 of file output_to.cc.

{
  return std::regex_match(spec, re_stdout);
}

std::vector< PathSpec > art::detail::path_specs	(	std::vector< ModuleSpec > const &	selection_override_entries,
		std::string const &	path_selection_override
	)

Definition at line 217 of file prune_configuration.cc.

  {
    auto guidance = [](std::string const& name,
                       std::string const& path_selection_override,
                       std::string const& id_str) {
      std::ostringstream oss;
      oss << "If you would like to repeat the path specification, all "
             "path specifications\n"
             "with the name '"
          << name << "' must be prepended with the same path ID (e.g.):\n\n"
          << "  " << path_selection_override << ": ['" << id_str << ':' << name
          << "', '" << id_str << ':' << name << "', ...]\n\n";
      return oss.str();
    };

    std::map<PathID, std::string> id_to_name;
    std::map<std::string, PathID> name_to_id;
    std::vector<art::PathSpec> result;

    size_t i = 0;
    for (auto it = cbegin(selection_override_entries),
              e = cend(selection_override_entries);
         it != e;
         ++it, ++i) {
      auto const& path = *it;
      auto spec = art::path_spec(path.name);
      if (spec.name == at_nil) {
        continue;
      }

      // Path names with unspecified IDs cannot be reused
      auto const emplacement_result =
        name_to_id.try_emplace(spec.name, spec.path_id);
      bool const name_already_present = not emplacement_result.second;
      auto const emplaced_path_id = emplacement_result.first->second;

      if (name_already_present) {
        if (spec.path_id == art::PathID::invalid()) {
          throw path_exception(path_selection_override, i, path.name)
            << "The path name '" << spec.name
            << "' has already been specified in the " << path_selection_override
            << " sequence.\n"
            << guidance(spec.name,
                        path_selection_override,
                        to_string(emplaced_path_id));
        }
        if (spec.path_id != emplaced_path_id) {
          throw path_exception(path_selection_override, i, path.name)
            << "The path name '" << spec.name
            << "' has already been specified (perhaps implicitly) with a\n"
               "path ID of "
            << to_string(emplaced_path_id) << " (not "
            << to_string(spec.path_id) << ") in the " << path_selection_override
            << " sequence.\n\n"
            << guidance(spec.name,
                        path_selection_override,
                        to_string(emplaced_path_id));
        }
        // Name is already present and the PathID has been explicitly
        // listed and matches what has already been seen.
        continue;
      }

      if (spec.path_id == art::PathID::invalid()) {
        spec.path_id =
          art::PathID{i}; // Use calculated bit number if not specified
        emplacement_result.first->second = spec.path_id;
      }

      // Each ID must have only one name
      if (auto const [it, inserted] =
            id_to_name.try_emplace(spec.path_id, spec.name);
          not inserted) {
        throw path_exception(path_selection_override, i, path.name)
          << "Path ID " << to_string(spec.path_id)
          << " cannot be assigned to path name '" << spec.name
          << "' as it has already been assigned to path name '" << it->second
          << "'.\n";
      }

      result.push_back(std::move(spec));
    }
    return result;
  }

std::string art::detail::print_allowed_configuration	(	LibraryInfo const &	li,
		std::string const &	prefix,
		std::string const &	type_spec
	)

Definition at line 25 of file print_description_blocks.cc.

  {
    std::ostringstream result;
    result << indent_1() << "Allowed configuration\n"
           << indent_1() << "---------------------\n";

    std::string printedConfig{describe(li.allowed_config(), prefix)};
    if (!type_spec.empty()) {
      replace_type(printedConfig, li.short_spec(), regex_for_spec(type_spec));
    }
    result << printedConfig;
    return result.str();
  }

void art::detail::print_available_plugins	(	std::string const &	suffix,
		std::string const &	spec,
		bool	verbose
	)

Definition at line 105 of file AllowedConfiguration.cc.

{
  auto coll = get_LibraryInfoCollection(suffix, spec, verbose);
  if (coll.empty()) {
    cout << "Unable to find any plugins with suffix '" << suffix << "'.\n";
    return;
  }

  auto ms = get_MetadataSummary(suffix, coll);

  cet::HorizontalRule const rule{rule_size(ms->widths())};
  cout << '\n'
       << rule('=') << '\n'
       << ms->header() << '\n'
       << rule('-') << '\n';

  std::size_t i{};
  Duplicates_t duplicates;
  for (auto const& info : coll) {
    auto summary = ms->summary(info, ++i);
    cout << summary.message;
    if (summary.is_duplicate)
      duplicates[info.short_spec()].push_back(info.long_spec());
  }
  cout << rule('=') << "\n\n";

  if (duplicates.empty())
    return;

  duplicates_message(suffix, duplicates);
  cout << '\n';
}

void art::detail::print_available_plugins ( std::string const &  suffix, bool const  verbose  )

inline

Definition at line 83 of file AllowedConfiguration.h.

  {
    print_available_plugins(suffix, dflt_spec_pattern(), verbose);
  }

void art::detail::print_config_summary	(	fhicl::ParameterSet const &	pset,
		std::string const &	verbosity,
		EnabledModules const &	enabled_modules
	)

Definition at line 184 of file print_config_summary.cc.

{
  auto const process_name = pset.get<std::string>("process_name");
  auto const source = pset.get<std::string>("source.module_type");
  auto const services = pset.get<fhicl::ParameterSet>("services");
  auto const physics = pset.get<fhicl::ParameterSet>("physics", {});
  auto const analyzers = physics.get<fhicl::ParameterSet>("analyzers", {});
  auto const filters = physics.get<fhicl::ParameterSet>("filters", {});
  auto const producers = physics.get<fhicl::ParameterSet>("producers", {});
  auto const outputs = pset.get<fhicl::ParameterSet>("outputs", {});

  std::cout << "Process name: " << process_name << '\n'
            << "Source module: " << source << '\n';
  if (verbosity == "brief") {
    print_table_numbers(services, "Services");
    print_table_numbers(producers, "Producers");
    print_table_numbers(filters, "Filters");
    print_table_numbers(analyzers, "Analyzers");
    print_table_numbers(outputs, "Output modules");
    print_path_numbers(enabled_modules);
    return;
  } else if (verbosity == "detailed") {
    print_service_types(services);
    std::cout << '\n' << header_rule('=') << '\n' << "Physics modules\n\n";
    print_table_numbers(producers, "Producers");
    print_table_numbers(filters, "Filters");
    print_table_numbers(analyzers, "Analyzers");
    print_module_types(outputs, "Output modules");
    print_path_names(enabled_modules);
    return;
  } else if (verbosity == "full") {
    print_service_types(services);
    print_module_types(producers, "Producers");
    print_module_types(filters, "Filters");
    print_module_types(analyzers, "Analyzers");
    print_module_types(outputs, "Output modules");
    print_path_names(enabled_modules);
    return;
  }
  throw art::Exception{art::errors::Configuration}
    << "Unrecognized configuration-summary verbosity level: '" << verbosity
    << "'\n";
}

void art::detail::print_description

(

std::vector< PluginMetadata > const &

matches

)

Definition at line 164 of file AllowedConfiguration.cc.

{
  for (auto const& m : matches) {
    cout << m.header() << m.details() << m.allowed_configuration();
    cout << '\n' << fixed_rule('=') << "\n\n";
  }
}

void art::detail::print_descriptions

(

std::vector< std::string > const &

plugins

)

Definition at line 203 of file AllowedConfiguration.cc.

{
  cout << '\n' << fixed_rule('=') << "\n\n";
  for (auto const& spec : specs) {
    auto const [plugin_type, instance_pattern] = parse_specified_plugin(spec);

    auto matches = matchesBySpec(plugin_type, instance_pattern);
    if (matches.empty()) {
      cout << indent0()
           << (instance_pattern.empty() ? "[Missing specification]" :
                                          cet::bold_fontify(instance_pattern))
           << " did not match any plugin";
      cout << (plugin_type.empty() ? "" : " of type '" + plugin_type + "'");
      cout << ".\n";
      cout << '\n' << fixed_rule('=') << "\n\n";
      continue;
    }
    print_description(matches);
  }
}

std::string art::detail::print_header	(	LibraryInfo const &	li,
		std::string const &	type_spec
	)

Definition at line 11 of file print_description_blocks.cc.

  {
    std::ostringstream result;
    std::string const long_spec =
      li.long_spec().empty() ? " [ No alternate specification available ] " :
                               li.long_spec();
    result << indent_1() << type_spec << ": "
           << cet::bold_fontify(li.short_spec()) << " (or \"" << long_spec
           << "\")"
           << "\n\n";
    return result.str();
  }

void art::detail::print_module_graph	(	std::ostream &	os,
		ModuleGraphInfoMap const &	modInfos,
		ModuleGraph const &	graph
	)

Definition at line 484 of file graph_algorithms.cc.

{
  std::set<Vertex> vertices;
  std::map<path_name_t, std::set<EdgePair>> path_edges;
  std::map<path_name_t, std::set<EdgePair>> filter_edges;
  std::set<EdgePair> trigger_path_edges;
  std::map<EdgePair, unsigned> product_edges;
  graph_printer printer{info_map,
                        vertices,
                        path_edges,
                        filter_edges,
                        trigger_path_edges,
                        product_edges};
  boost::depth_first_search(graph, visitor(printer));
  os << "digraph {\n"
     << "  rankdir=BT\n";
  // Vertices
  for (auto const& v : vertices) {
    auto const& name = info_map.name(v);
    auto const& info = info_map.info(v);
    if (name == "input_source") {
      os << "  \"input_source\"[shape=box label=source]";
    } else if (name == "TriggerResults") {
      os << "  \"" << name << '\"';
      os << "[shape=box style=filled fillcolor=black label=\"\" height=0.1 "
            "width=2]";
    } else {
      os << "  \"" << name << '\"';
      if (info.module_type == art::ModuleType::filter) {
        os << "[style=filled fillcolor=pink]";
      }
    }
    os << ";\n";
  }

  // Path edges
  for (auto const& pr : path_edges) {
    auto const& path_name = pr.first;
    for (auto const& edge_pair : pr.second) {
      os << "  \"" << info_map.name(edge_pair.first) << "\" -> \""
         << info_map.name(edge_pair.second) << '\"' << "[label=\"" << path_name
         << "\" color=gray];\n";
    }
  }

  // Filter edges
  for (auto const& pr : filter_edges) {
    auto const& path_name = pr.first;
    for (auto const& edge_pair : pr.second) {
      os << "  \"" << info_map.name(edge_pair.first) << "\" -> \""
         << info_map.name(edge_pair.second) << '\"' << "[label=\"" << path_name
         << "\" color=red];\n";
    }
  }

  // Trigger-path edges
  for (auto const& edge_pair : trigger_path_edges) {
    os << "  \"" << info_map.name(edge_pair.first) << "\" -> \""
       << info_map.name(edge_pair.second) << '\"'
       << "[style=invisible arrowhead=none];\n";
  }

  // Product edges
  for (auto const& pr : product_edges) {
    auto const& edge_pair = pr.first;
    auto const multiplicity = pr.second;
    os << "  \"" << info_map.name(edge_pair.first) << "\" -> \""
       << info_map.name(edge_pair.second) << '\"';
    if (multiplicity > 1) {
      os << "[label=\"" << multiplicity << "\" color=black]";
    }
    os << ";\n";
  }
  os << "}\n";
}

void art::detail::print_module_types	(	fhicl::ParameterSet const &	pset,
		std::string const &	header
	)

Definition at line 147 of file print_config_summary.cc.

{
  std::cout << '\n' << header_rule('=') << "\n";
  print_table_numbers(pset, header);

  auto const names = pset.get_names();
  if (empty(names)) {
    return;
  }

  std::cout << "\n";
  std::string column_1{"Module label"};
  std::string column_2{"module_type"};
  auto column_1_width = size(column_1);
  auto column_2_width = size(column_2);
  for (auto const& name : names) {
    auto const module_type =
      pset.get<std::string>(fhicl_key(name, "module_type"));
    column_1_width = std::max(column_1_width, size(name));
    column_2_width = std::max(column_2_width, size(module_type));
  }

  cet::HorizontalRule const rule_1{column_1_width};
  cet::HorizontalRule const rule_2{column_2_width};
  std::cout << std::left << std::setw(column_1_width) << column_1 << "  "
            << column_2 << '\n'
            << rule_1('-') << "  " << rule_2('-') << '\n';
  for (auto const& name : names) {
    auto const module_type =
      pset.get<std::string>(fhicl_key(name, "module_type"));
    std::cout << std::left << std::setw(column_1_width) << name << "  "
              << module_type << '\n';
  }
}

void art::detail::print_path_names

(

EnabledModules const &

enabled_modules

)

Definition at line 38 of file print_config_summary.cc.

{
  {
    auto const& trigger_paths = enabled_modules.trigger_path_specs();
    std::cout << '\n'
              << header_rule('=') << '\n'
              << "Trigger paths: " << size(trigger_paths) << "\n"
              << (enabled_modules.trigger_paths_override() ?
                    " -> 'trigger_paths' specified\n\n" :
                    "\n");
    if (empty(trigger_paths)) {
      return;
    }

    std::string column_0{"Bit"};
    std::string column_1{"Path name"};
    std::string column_2{"Path size"};

    auto column_1_width = size(column_1);
    for (auto const& pr : trigger_paths) {
      column_1_width = std::max(column_1_width, size(pr.first.name));
    }

    std::cout << column_0 << "  " << std::left << std::setw(column_1_width)
              << column_1 << "  " << column_2 << '\n'
              << "---"
              << "  " << std::string(column_1_width, '-') << "  "
              << std::string(size(column_2), '-') << '\n';
    for (auto const& [path_spec, entries] :
         enabled_modules.trigger_path_specs()) {
      std::cout << std::right << std::setw(3) << to_string(path_spec.path_id)
                << "  " << std::left << std::setw(column_1_width)
                << path_spec.name << "  " << size(entries) << '\n';
    }
  }

  {
    auto const& end_paths = enabled_modules.end_paths();

    std::cout << '\n'
              << header_rule('=') << '\n'
              << "End paths: " << size(end_paths) << '\n'
              << (enabled_modules.end_paths_override() ?
                    " -> 'end_paths' specified\n\n" :
                    "\n");

    if (empty(end_paths)) {
      return;
    }

    std::string column_1{"Path name"};
    std::string column_2{"Path size"};
    auto column_1_width = size(column_1);
    for (auto const& pr : end_paths) {
      column_1_width = std::max(column_1_width, size(pr.first.name));
    }

    std::cout << std::left << std::setw(column_1_width) << column_1 << "  "
              << column_2 << '\n'
              << std::string(column_1_width, '-') << "  "
              << std::string(size(column_2), '-') << '\n';
    for (auto const& [path_spec, entries] : end_paths) {
      std::cout << std::left << std::setw(column_1_width) << path_spec.name
                << "  " << size(entries) << '\n';
    }
  }
}

void art::detail::print_path_numbers

(

EnabledModules const &

enabled_modules

)

Definition at line 24 of file print_config_summary.cc.

{
  std::cout << "Trigger paths: " << size(enabled_modules.trigger_path_specs())
            << '\n'
            << (enabled_modules.trigger_paths_override() ?
                  " -> 'trigger_paths' specified\n" :
                  "")
            << "End paths: " << size(enabled_modules.end_paths()) << '\n'
            << (enabled_modules.end_paths_override() ?
                  " -> 'end_paths' specified\n" :
                  "");
}

void art::detail::print_service_types

(

fhicl::ParameterSet const &

pset

)

Definition at line 107 of file print_config_summary.cc.

{
  std::cout << '\n' << header_rule('=') << '\n';
  print_table_numbers(pset, "Services");
  std::cout << "\n";

  auto const names = pset.get_names();

  std::string column_1{"Service name"};
  auto column_1_width = size(column_1);
  auto column_2_width = std::string::size_type{};
  for (auto const& name : names) {
    auto const service_provider =
      pset.get<std::string>(fhicl_key(name, "service_provider"), {});
    column_1_width = std::max(column_1_width, size(name));
    column_2_width = std::max(column_2_width, size(service_provider));
  }

  cet::HorizontalRule const rule_1{column_1_width};
  if (column_2_width == 0ull) {
    std::cout << column_1 << '\n' << rule_1('-') << '\n';
    for (auto const& name : names) {
      std::cout << std::left << std::setw(column_1_width) << name << '\n';
    }
  } else {
    std::string const column_2{"service_provider"};
    cet::HorizontalRule const rule_2{std::max(column_2_width, size(column_2))};
    std::cout << std::left << std::setw(column_1_width) << column_1 << "  "
              << column_2 << '\n'
              << rule_1('-') << "  " << rule_2('-') << '\n';
    for (auto const& name : names) {
      auto const service_provider =
        pset.get<std::string>(fhicl_key(name, "service_provider"), "-");
      std::cout << std::left << std::setw(column_1_width) << name << "  "
                << service_provider << '\n';
    }
  }
}

void art::detail::print_table_numbers	(	fhicl::ParameterSet const &	pset,
		std::string const &	header
	)

Definition at line 16 of file print_config_summary.cc.

{
  auto const names = pset.get_names();
  std::cout << header << ": " << size(names) << '\n';
}

art::detail::EnabledModules art::detail::prune_config_if_enabled	(	bool	prune_config,
		bool	report_enabled,
		fhicl::intermediate_table &	config
	)

Definition at line 575 of file prune_configuration.cc.

{
  auto const modules = declared_modules(config, module_tables);

  auto paths = all_paths(config);

  auto [trigger_paths, trigger_paths_override] =
    enabled_paths(paths, modules, ModuleCategory::modifier);
  auto [end_paths, end_paths_override] =
    enabled_paths(paths, modules, ModuleCategory::observer);

  auto enabled_modules =
    get_enabled_modules(modules, trigger_paths, ModuleCategory::modifier);
  // C++17 provides the std::map::merge member function, but Clang 7
  // and older does not support it.  Will do it by hand for now, until
  // we have time to handle this properly.
  auto end_path_enabled_modules =
    get_enabled_modules(modules, end_paths, ModuleCategory::observer);
  enabled_modules.insert(begin(end_path_enabled_modules),
                         end(end_path_enabled_modules));

  modules_t unused_modules;
  for (auto const& pr : modules) {
    if (enabled_modules.find(pr.first) == cend(enabled_modules)) {
      unused_modules.insert(pr);
    }
  }

  // Find unused paths
  paths.erase("trigger_paths");
  paths.erase("end_paths");
  for (auto const& pr : trigger_paths) {
    paths.erase(pr.first.name);
  }
  for (auto const& pr : end_paths) {
    paths.erase(pr.first.name);
  }

  // The only paths left are those that are not enabled for execution.
  if (report_enabled && !empty(paths)) {
    std::cerr << "The following paths have not been enabled for execution and "
                 "will be ignored:\n";
    for (auto const& pr : paths) {
      std::cerr << "  " << pr.first << '\n';
    }
  }

  if (report_enabled && !empty(unused_modules)) {
    std::ostringstream os;
    os << "The following module label"
       << ((unused_modules.size() == 1) ? " is" : "s are")
       << " either not assigned to any path,\n"
       << "or " << ((unused_modules.size() == 1ull) ? "it has" : "they have")
       << " been assigned to ignored path(s):\n";
    for (auto const& pr : unused_modules) {
      os << "  " << pr.first << '\n';
    }
    std::cerr << os.str();
  }

  if (prune_config) {
    for (auto const& pr : paths) {
      config.erase(fhicl_key("physics", pr.first));
    }
    for (auto const& pr : unused_modules) {
      config.erase(pr.second);
    }

    // Check if module tables can be removed
    for (auto const& table_name : module_tables) {
      if (not exists_outside_prolog(config, table_name)) {
        continue;
      }
      if (table_t const value = config.find(table_name); empty(value)) {
        config.erase(table_name);
      }
    }

    // Check if top-level physics table can be removed
    if (exists_outside_prolog(config, "physics")) {
      if (table_t const value = config.find("physics"); empty(value)) {
        config.erase("physics");
      }
    }
  }

  // Place 'trigger_paths' as top-level configuration table
  if (trigger_paths_override) {
    std::vector<std::string> explicit_entries;
    cet::transform_all(trigger_paths,
                       back_inserter(explicit_entries),
                       [](auto const& pr) { return to_string(pr.first); });
    config.put("trigger_paths.trigger_paths", explicit_entries);
  }

  return EnabledModules{std::move(enabled_modules),
                        std::move(trigger_paths),
                        std::move(end_paths),
                        trigger_paths_override,
                        end_paths_override};
}

constexpr bool art::detail::range_sets_supported

(

BranchType const

bt

)

Definition at line 10 of file RangeSetsSupported.h.

  {
    return bt == InRun || bt == InSubRun;
  }

std::regex art::detail::regex_for_spec

(

std::string const &

spec

)

Definition at line 6 of file MetadataRegexHelpers.cc.

{
  return std::regex{"(" + spec + "\\s*:\\s*)(:?<string>)"};
}

void art::detail::remove_whitespace

(

std::string &

str

)

Definition at line 11 of file remove_whitespace.cc.

{
  boost::remove_erase_if(str, boost::is_any_of(whitespace_chars));
}

void art::detail::replace_type	(	std::string &	str,
		std::string const &	spec,
		std::regex const &	r
	)

Definition at line 12 of file MetadataRegexHelpers.cc.

{
  str = std::regex_replace(str, r, "$1"s + spec);
}

std::size_t art::detail::rule_size ( Widths const &  widths )

inline

Definition at line 68 of file PrintFormatting.h.

  {
    std::size_t result{indent0().size()};
    for (std::size_t const w : widths)
      result += w;
    return result +=
           (widths.size() - 1) * 4u; // Account for space between columns;
  }

std::vector< ModuleSpec > art::detail::sequence_to_entries	(	sequence_t const &	seq,
		bool const	allow_nil_entries
	)

Definition at line 172 of file prune_configuration.cc.

  {
    std::vector<ModuleSpec> result;
    for (auto const& ev : seq) {
      if (allow_nil_entries and ev.is_a(NIL)) {
        result.push_back({at_nil, FilterAction::Normal});
        continue;
      }
      if (!ev.is_a(STRING)) {
        continue;
      }
      auto mod_spec = ev.to_string();
      if (empty(mod_spec)) {
        continue;
      }
      boost::replace_all(mod_spec, "\"", "");
      auto action = FilterAction::Normal;
      if (mod_spec[0] == '!') {
        action = FilterAction::Veto;
        mod_spec = mod_spec.substr(1);
      } else if (mod_spec[0] == '-') {
        action = FilterAction::Ignore;
        mod_spec = mod_spec.substr(1);
      }

      // Handle remaining '!' or '-' characters
      if (mod_spec.find_first_of("!-") != std::string::npos) {
        throw config_exception("There was an error parsing the entry "s +
                               ev.to_string() + "in a FHiCL sequence.")
          << "The '!' or '-' character may appear as only the first character "
             "in the path entry.\n";
      }
      result.push_back({mod_spec, action});
    }

    if (result.size() != seq.size()) {
      throw config_exception("There was an error parsing the specified entries "
                             "in a FHiCL sequence.")
        << "One of the presented elements is either an empty string or not a "
           "string at all.\n";
    }
    return result;
  }

bool art::detail::skip_non_replicated

(

Worker const &

w

)

Definition at line 6 of file skip_non_replicated.cc.

{
  if (w.scheduleID() == ScheduleID::first()) {
    return false;
  }
  bool const is_replicated{w.description().moduleThreadingType() ==
                           ModuleThreadingType::replicated};
  return !is_replicated;
}

art::BranchKey art::detail::splitToComponents	(	std::string const &	branchName,
		std::string &	errMsg
	)

Definition at line 46 of file branchNameComponentChecking.cc.

{
  std::vector<std::string> parts;
  boost::split(parts, branchName, boost::is_any_of("_"));
  if (parts.size() != 4) {
    errMsg += "Illegal product name specification \"" + branchName + "\".\n";
  }
  return BranchKey(std::move(parts[0]),
                   std::move(parts[1]),
                   std::move(parts[2]),
                   std::move(parts[3]));
}

bool art::detail::supports_key	(	std::string const &	suffix,
		std::string const &	spec,
		std::string const &	key
	)

Definition at line 141 of file AllowedConfiguration.cc.

{
  art::Exception e{art::errors::LogicError, "art::detail::supports_key"};
  auto coll = get_LibraryInfoCollection(suffix, spec);
  if (coll.empty()) {
    throw e << (spec.empty() ? "[Missing specification]" :
                               cet::bold_fontify(spec))
            << " did not match any plugin.\n";
  } else if (coll.size() > 1ull) {
    throw e << cet::bold_fontify(spec) << " matched more than one plugin.\n"
            << "When querying plugin configurations, the plugin specification\n"
            << "must resolve to a unique library.\n";
  }
  if (auto config = coll.begin()->allowed_config()) {
    return fhicl::detail::SearchAllowedConfiguration::supports_key(
      *config->parameter_base(), key);
  }
  return false;
}

template<typename... T>

void art::detail::throw_if_invalid	(	std::string const &	msg,
		T const &...	t
	)

Definition at line 63 of file Handle.h.

    {
      bool const all_valid = true && (... && t.isValid());
      if (!all_valid) {
        throw Exception{art::errors::NullPointerError} << msg << '\n';
      }
    }

void art::detail::throwPartnerException	(	std::type_info const &	generator,
		std::type_info const &	wanted_wrapper_type
	)

Definition at line 6 of file throwPartnerException.cc.

{
  throw Exception(errors::LogicError, "makePartner")
    << "Attempted to make type "
    << cet::demangle_symbol(wanted_wrapper_type.name())
    << " which is not a valid wrapped partner of "
    << cet::demangle_symbol(generator.name())
    << "\nPlease report to the ART framework developers.\n";
}

void art::detail::timeReport

(

cet::cpu_timer const &

timer

)

Definition at line 298 of file writeSummary.cc.

{
  LogPrint("ArtSummary") << "TimeReport "
                         << "---------- Time summary [sec] -------";
  LogPrint("ArtSummary") << "TimeReport " << setprecision(6) << fixed
                         << "CPU = " << timer.cpuTime()
                         << " Real = " << timer.realTime();
}

void art::detail::triggerReport	(	PerScheduleContainer< PathsInfo > const &	endPathInfo,
		PerScheduleContainer< PathsInfo > const &	triggerPathsInfo,
		bool	wantSummary
	)

Definition at line 104 of file writeSummary.cc.

{
  // Checking the first element is sufficient since the path
  // structures are identical across schedules/end-path executors.
  auto observers_enabled = !epis[ScheduleID::first()].paths().empty();

  SummaryCounts total_counts{};
  for (auto const& tpi : tpis) {
    total_counts.total += tpi.totalEvents();
    total_counts.passed += tpi.passedEvents();
    total_counts.failed += tpi.failedEvents();
  }
  // The trigger report (pass/fail etc.):
  // Printed even if summary not requested, per issue #1864.
  LogPrint("ArtSummary") << "TrigReport "
                         << "---------- Event summary -------------";
  LogPrint("ArtSummary") << "TrigReport"
                         << " Events total = " << total_counts.total
                         << " passed = " << total_counts.passed
                         << " failed = " << total_counts.failed;

  if (wantSummary) {
    LogPrint("ArtSummary") << "";
    LogPrint("ArtSummary") << "TrigReport "
                           << "---------- Trigger-path summary ------------";
    LogPrint("ArtSummary") << "TrigReport " << std::right << setw(10)
                           << "Path ID"
                           << " " << std::right << setw(10) << "Run"
                           << " " << std::right << setw(10) << "Passed"
                           << " " << std::right << setw(10) << "Failed"
                           << " " << std::right << setw(10) << "Error"
                           << " "
                           << "Name";
    std::map<PathID, TriggerCounts> counts_per_path{};
    for (auto const& tpi : tpis) {
      for (auto const& path : tpi.paths()) {
        auto& counts = counts_per_path[path.pathID()];
        counts.path_name = path.name(); // No increment!
        counts.run += path.timesRun();
        counts.passed += path.timesPassed();
        counts.failed += path.timesFailed();
        counts.except += path.timesExcept();
      }
    }
    for (auto const& [pathID, counts] : counts_per_path) {
      LogPrint("ArtSummary")
        << "TrigReport " << std::right << setw(10) << to_string(pathID) << " "
        << std::right << setw(10) << counts.run << " " << std::right << setw(10)
        << counts.passed << " " << std::right << setw(10) << counts.failed
        << " " << std::right << setw(10) << counts.except << " "
        << counts.path_name;
    }

    LogPrint("ArtSummary") << "";
    LogPrint("ArtSummary") << "TrigReport "
                           << "---------- End-path summary ---------";
    LogPrint("ArtSummary") << "TrigReport"
                           << " " << std::right << setw(10) << "Run"
                           << " " << std::right << setw(10) << "Success"
                           << " " << std::right << setw(10) << "Error";

    if (observers_enabled) {
      EndPathCounts epCounts{};
      for (auto const& epi : epis) {
        for (auto const& path : epi.paths()) {
          epCounts.run += path.timesRun();
          epCounts.success += path.timesPassed();
          epCounts.except += path.timesExcept();
        }
      }
      LogPrint("ArtSummary")
        << "TrigReport " << std::right << setw(10) << epCounts.run << " "
        << std::right << setw(10) << epCounts.success << " " << std::right
        << setw(10) << epCounts.except;
    }

    std::map<PathSpec, WorkersInPathCounts> counts_per_worker_in_path;
    for (auto const& tpi : tpis) {
      for (auto const& path : tpi.paths()) {
        auto& counts_per_worker = counts_per_worker_in_path[path.pathSpec()];
        if (counts_per_worker.empty() && !path.workersInPath().empty()) {
          counts_per_worker.resize(path.workersInPath().size());
        }
        std::size_t i{};
        for (auto const& workerInPath : path.workersInPath()) {
          auto const* worker = workerInPath.getWorker();
          auto& counts = counts_per_worker[i];
          if (counts.moduleLabel.empty()) {
            counts.moduleLabel = worker->description().moduleLabel();
          }
          counts.visited += workerInPath.timesVisited();
          counts.passed += workerInPath.timesPassed();
          counts.failed += workerInPath.timesFailed();
          counts.except += workerInPath.timesExcept();
          ++i;
        }
      }
    }
    for (auto const& [path_spec, worker_in_path_counts] :
         counts_per_worker_in_path) {
      LogPrint("ArtSummary") << "";
      LogPrint("ArtSummary")
        << "TrigReport "
        << "---------- Modules in path: " << path_spec.name << " ------------";
      LogPrint("ArtSummary")
        << "TrigReport " << std::right << setw(10) << "Path ID"
        << " " << std::right << setw(10) << "Visited"
        << " " << std::right << setw(10) << "Passed"
        << " " << std::right << setw(10) << "Failed"
        << " " << std::right << setw(10) << "Error"
        << " "
        << "Name";
      workersInPathTriggerReport(path_spec.path_id, worker_in_path_counts);
    }
  }

  // Printed even if summary not requested, per issue #1864.
  WorkersInPathCounts endPathWIPCounts;
  for (auto const& epi : epis) {
    for (auto const& path : epi.paths()) {
      if (endPathWIPCounts.empty() && !path.workersInPath().empty()) {
        endPathWIPCounts.resize(path.workersInPath().size());
      }
      std::size_t i{};
      for (auto const& workerInPath : path.workersInPath()) {
        auto const* worker = workerInPath.getWorker();
        auto& counts = endPathWIPCounts[i];
        if (counts.moduleLabel.empty()) {
          counts.moduleLabel = worker->description().moduleLabel();
        }
        counts.visited += worker->timesRun(); // proxy for 'visited'
        counts.passed += worker->timesPassed();
        counts.except += worker->timesExcept();
        ++i;
      }
    }
  }

  if (observers_enabled) {
    LogPrint("ArtSummary") << "";
    LogPrint("ArtSummary") << "TrigReport "
                           << "---------- Modules in End-path ----------";
    LogPrint("ArtSummary") << "TrigReport"
                           << " " << std::right << setw(10) << "Run"
                           << " " << std::right << setw(10) << "Success"
                           << " " << std::right << setw(10) << "Error"
                           << " "
                           << "Name";
    workersInEndPathTriggerReport(endPathWIPCounts);
  }

  if (wantSummary) {
    // This table can arguably be removed since all summary
    // information is better described above.
    LogPrint("ArtSummary") << "";
    LogPrint("ArtSummary") << "TrigReport "
                           << "---------- Module summary ------------";
    LogPrint("ArtSummary") << "TrigReport " << std::right << setw(10)
                           << "Visited"
                           << " " << std::right << setw(10) << "Run"
                           << " " << std::right << setw(10) << "Passed"
                           << " " << std::right << setw(10) << "Failed"
                           << " " << std::right << setw(10) << "Error"
                           << " "
                           << "Name";
    std::map<std::string, ModuleCounts> counts_per_module;
    auto update_counts = [&counts_per_module](auto const& pathInfos) {
      for (auto const& pi : pathInfos) {
        for (auto const& [module_label, module_counts] : pi.workers()) {
          auto& counts = counts_per_module[module_label];
          counts.visited += module_counts->timesVisited();
          counts.run += module_counts->timesRun();
          counts.passed += module_counts->timesPassed();
          counts.failed += module_counts->timesFailed();
          counts.except += module_counts->timesExcept();
        }
      }
    };
    update_counts(tpis);
    update_counts(epis);
    for (auto const& [module_label, module_counts] : counts_per_module) {
      LogPrint("ArtSummary")
        << "TrigReport " << std::right << setw(10) << module_counts.visited
        << " " << std::right << setw(10) << module_counts.run << " "
        << std::right << setw(10) << module_counts.passed << " " << std::right
        << setw(10) << module_counts.failed << " " << std::right << setw(10)
        << module_counts.except << " " << module_label;
    }
  }
}

TypeLabel art::detail::type_label_for ( TypeID const  typeID, std::string const &  instance, bool const  supportsView, ModuleDescription const &  md  )

inline

Definition at line 10 of file type_label_for.h.

  {
    if (md.isEmulatedModule()) {
      return TypeLabel{typeID, instance, supportsView, md.moduleLabel()};
    }
    return TypeLabel{typeID, instance, supportsView, false};
  }

bool art::detail::upcastAllowed	(	std::type_info const &	tiFrom,
		std::type_info const &	tiTo
	)

void art::detail::validateFileNamePattern	(	bool	do_check,
		std::string const &	pattern
	)

Definition at line 7 of file validateFileNamePattern.cc.

{
  if (!do_check)
    return;

  if (std::regex_search(pattern, std::regex("%(\\d*)#"))) {
    return;
  }

  throw Exception{errors::Configuration}
    << "If you have specified the 'fileProperties' table in your "
       "configuration,\n"
    << "then the file pattern '%#' MUST be present in the file name.  For "
       "example:\n"
    << "    " << pattern.substr(0, pattern.find(".root")) << "_%#.root\n"
    << "is a supported file name.  Please change your file name to include "
       "the '%#' pattern.";
}

std::string art::detail::verify_in_order_dependencies	(	ModuleGraphInfoMap const &	modules,
		paths_to_modules_t const &	trigger_paths
	)

Definition at line 296 of file graph_algorithms.cc.

{
  // Precondition: there are no inter-path dependencies
  std::map<module_name_t, name_set_t> illegal_module_orderings;
  for (auto const& module : modInfos) {
    auto const& module_name = module.first;
    auto const module_type = module.second.module_type;
    auto const& module_paths = module.second.paths;
    if (!is_modifier(module_type)) {
      continue;
    }
    if (module_paths.empty()) {
      continue;
    }
    // Only need to check one path since when we call this function,
    // we have already guaranteed that there are no interpath
    // dependencies.
    auto const& first_path_for_module = *cbegin(module_paths);
    auto const& path_it = std::find_if(trigger_paths.cbegin(),
                                       trigger_paths.cend(),
                                       path_matches{first_path_for_module});
    assert(path_it != trigger_paths.cend());
    auto const begin = cbegin(path_it->second);
    auto const end = cend(path_it->second);
    auto const module_position =
      std::find_if(begin, end, module_matches{module_name});
    assert(module_position != end);

    for (auto const& dep : module.second.consumed_products) {
      if (dep.label == "input_source") {
        continue;
      }
      auto const dep_position =
        std::find_if(begin, end, module_matches{dep.label});
      assert(dep_position != end);
      if (dep_position < module_position) {
        continue;
      }
      illegal_module_orderings[module_name].insert(dep.label);
    }
  }

  if (illegal_module_orderings.empty()) {
    return {};
  }

  std::ostringstream oss;
  oss << "\nThe following are module-ordering errors due to declared "
         "data-product dependencies:\n";
  for (auto const& mod : illegal_module_orderings) {
    auto const& module_name = mod.first;
    auto const mod_index = modInfos.vertex_index(module_name);
    auto const& module_paths = modInfos.info(mod_index).paths;
    oss << "  Module " << module_name << " on path"
        << (module_paths.size() == 1ull ? " " : "s ")
        << comma_separated_list(module_paths)
        << " depends on either itself or modules that follow it:\n";
    for (auto const& dep_name : mod.second) {
      auto const dep_index = modInfos.vertex_index(dep_name);
      auto const& on_paths = modInfos.info(dep_index).paths;
      oss << "    Module " << dep_name << " on path"
          << (on_paths.size() == 1ull ? " " : "s ")
          << comma_separated_list(on_paths)
          << (module_name == dep_name ? " (self circularity)" : "") << '\n';
    }
  }
  return oss.str();
}

std::string art::detail::verify_no_interpath_dependencies	(	ModuleGraphInfoMap const &	modInfos,
		ModuleGraph const &	graph
	)

Definition at line 209 of file graph_algorithms.cc.

{
  std::map<Vertex, std::set<Vertex>> illegal_dependencies;
  auto const children_iters = graph.children();
  for (auto ci = children_iters.first, ci_end = children_iters.second;
       ci != ci_end;
       ++ci) {
    auto const& path_graph = *ci;
    auto const vertex_iters = vertices(path_graph);
    for (auto i = vertex_iters.first, end = vertex_iters.second; i != end;
         ++i) {
      auto const gv = path_graph.local_to_global(*i);
      auto const out_edge_iters = out_edges(gv, graph);
      // Verify that the target of each out edge is a member of the
      // same subgraph (which is determined by calling find_vertex).
      // If not, then it is an illegal path specification.
      for (auto ei = out_edge_iters.first, edge_end = out_edge_iters.second;
           ei != edge_end;
           ++ei) {
        auto const tv = target(*ei, graph);
        if (path_graph.find_vertex(tv).second) {
          continue;
        }
        illegal_dependencies[gv].insert(tv);
      }
    }
  }

  if (illegal_dependencies.empty()) {
    return {};
  }

  std::ostringstream oss;
  oss << "\nThe following represent cross-path data-dependency errors:\n"
      << cet::HorizontalRule{60}('-') << '\n';
  for (auto const& mod : illegal_dependencies) {
    auto const mod_index = mod.first;
    auto const& module_name = modInfos.name(mod_index);
    auto const& mod_paths = modInfos.info(mod_index).paths;
    oss << "  Module " << module_name << " on path"
        << (mod_paths.size() == 1ull ? " " : "s ")
        << comma_separated_list(mod_paths) << " depends on\n";
    for (auto const& dep : mod.second) {
      auto const& dep_name = modInfos.name(dep);
      auto const& on_paths = modInfos.info(dep).paths;
      oss << "    Module " << dep_name << " on path"
          << (on_paths.size() == 1ull ? " " : "s ")
          << comma_separated_list(on_paths) << '\n';
    }
  }
  oss << "\nSuch errors occur whenever a module on one path depends on the "
         "data products\n"
      << "from another.  Such dependencies can be subtle--for example, a "
         "module that\n"
      << "uses an event.getManyByType call cannot be shared across paths if "
         "the modules\n"
      << "that precede it in the paths do not give consistent result.  Please "
         "check your\n"
      << "configuration, or email artists@fnal.gov for assistance.\n";
  return oss.str();
}

void art::detail::verifyFriendlyClassName

(

std::string const &

fcn

)

Definition at line 16 of file verify_names.cc.

{
  if (fcn.find('_') != std::string::npos) {
    throw art::Exception(art::errors::LogicError)
      << "Class \"" << fcn
      << "\" is not suitable for use as a product due to the presence of "
      << "underscores which are not allowed anywhere in the class name "
      << "(including namespace and enclosing classes).\n";
  }
}

void art::detail::verifyInstanceName

(

std::string const &

in

)

Definition at line 5 of file verify_names.cc.

{
  if (instanceName.find('_') != std::string::npos) {
    throw art::Exception(art::errors::Configuration)
      << "Instance name \"" << instanceName
      << "\" is illegal: underscores are not permitted in instance names."
      << '\n';
  }
}

template<typename T >

bool art::detail::verifyPtrCollection

(

std::vector< art::PtrVector< T > const * > const &

in

)

Definition at line 202 of file CollectionUtilities.h.

{
  return verifyPtrCollection(in.begin(), in.end());
}

template<typename iterator >

bool art::detail::verifyPtrCollection	(	iterator	beg,
		iterator	end,
		art::ProductID	id = {},
		art::EDProductGetter const *	getter = nullptr
	)

Definition at line 211 of file CollectionUtilities.h.

{
  if (beg == end)
    return true;
  if (!id.isValid()) {
    id = (*beg).id();
  }
  if (!getter) {
    getter = (*beg).productGetter();
  }
  for (iterator i = beg; i != end; ++i) {
    if ((*i) != nullptr &&
        !((*i)->productGetter() && (*i)->productGetter() == getter &&
          (*i)->id().isValid() && (*i)->id() == id)) {
      return false;
    }
  }
  return true;
}

template<typename T >

auto art::detail::wrapperTypeID ( )

inline

Definition at line 9 of file ProductTypeIDs.h.

  {
    return TypeID{typeid(art::Wrapper<T>)};
  }

void art::detail::writeSummary	(	PathManager &	pm,
		bool	wantSummary,
		cet::cpu_timer const &	timer
	)

Definition at line 89 of file writeSummary.cc.

{
  auto const& epis = pm.endPathInfo();
  auto const& tpis = pm.triggerPathsInfo();
  LogPrint("ArtSummary") << "";
  triggerReport(epis, tpis, wantSummary);
  LogPrint("ArtSummary") << "";
  timeReport(jobTimer);
  LogPrint("ArtSummary") << "";
  memoryReport();
}

Variable Documentation

template<typename T >

bool constexpr art::detail::handle_allowed_v {handle_allowed<T>::value}

Definition at line 24 of file ServiceHandleAllowed.h.

SharedResource_t const art::detail::LegacyResource {"__legacy__", false}

Definition at line 33 of file SharedResource.cc.