art::detail Namespace Reference

Namespaces
	FDS
	FTS

Classes
struct	AggregateTuple
struct	AggregateTuple< 0u >
struct	are_cv_compatible
struct	are_handles
class	AssnsBase
class	BcollHelper
class	CachedProducts
struct	call_beginRun
struct	call_beginSubRun
struct	call_endRun
struct	call_endSubRun
struct	call_finalizeEvent
struct	call_processEventAuxiliaries
struct	call_processEventIDs
struct	call_respondToCloseInputFile
struct	call_respondToCloseOutputFiles
struct	call_respondToOpenInputFile
struct	call_respondToOpenOutputFiles
struct	call_startEvent
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	CPCSentry
class	DataCollHelper
struct	default_invocation
struct	default_invocation< R(ARGS...)>
struct	do_call_hasMoreData
struct	do_call_old_startEvent
struct	do_not_call_beginRun
struct	do_not_call_beginSubRun
struct	do_not_call_endRun
struct	do_not_call_endSubRun
struct	do_not_call_finalizeEvent
struct	do_not_call_hasMoreData
struct	do_not_call_old_startEvent
struct	do_not_call_processEventAuxiliaries
struct	do_not_call_processEventIDs
struct	do_not_call_respondToXXX
struct	do_not_call_startEvent
struct	do_not_setup_eventsToSkip
class	DummyProductCache
struct	EnsurePointer
struct	EnsurePointer< TO, art::Ptr< PTRVAL > >
struct	EnsurePointer< TO, PFROM * >
class	ExceptionCollector
class	FileNameComponents
class	FileNamesHandler
class	FileNamesHandler< false >
class	FileNamesHandler< true >
class	FileServiceProxy
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, enable_if_function_exists_t< bool(T::*)() const,&T::hasMoreData > >
struct	has_hasMoreData< T, 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_old_startEvent
struct	has_old_startEvent< T, enable_if_function_exists_t< void(T::*)(),&T::startEvent > >
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, enable_if_function_exists_t< size_t(T::*)() const,&T::size > >
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
struct	hash_to_size_t
class	InfoDumperInputFile
class	IPRHelper
class	IPRHelperDef
struct	is_handle
struct	is_handle< T, cet::enable_if_type_exists_t< typename T::HandleTag > >
struct	is_instantiation_of_hash
struct	is_instantiation_of_hash< art::Hash< I > >
class	ItemGetter
class	ItemGetter< std::pair< cet::map_vector_key, T >, cet::map_vector< T > >
class	ItemGetter< T, cet::map_vector< T > >
class	KeptProvenance
class	LibraryInfo
class	LibraryInfoMatch
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_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	MetadataCollector
class	MetadataCollectorFor
class	MetadataSummary
class	MetadataSummaryFor
struct	mix_offset
struct	mix_offset< cet::map_vector< P > >
struct	ModuleConfig
class	ModuleConfigInfo
class	ModuleFactory
class	ModuleInPathInfo
struct	ModuleTypeDeducer
struct	ModuleTypeDeducer< art::EDAnalyzer >
struct	ModuleTypeDeducer< art::EDFilter >
struct	ModuleTypeDeducer< art::EDProducer >
struct	ModuleTypeDeducer< art::OutputModule >
struct	PluginConfig
class	PluginMetadata
class	PrincipalProcessor
class	ProcessAndEventSelector
struct	ProductInfo
class	ProvenanceDumperImpl
class	PVSentry
struct	RangeSetInfo
struct	RangeSetsSupported
struct	RangeSetsSupported< InRun >
struct	RangeSetsSupported< InSubRun >
struct	respondToXXX_function
class	RootDirectorySentry
class	ScheduleContextSetter
class	ScheduleTask
class	ServiceCacheEntry
struct	ServiceHelper
struct	ServiceHelperBase
struct	ServiceImplHelper
struct	ServiceInterfaceHelper
struct	ServiceInterfaceImplHelper
struct	ServiceLGMHelper
struct	ServiceLGRHelper
class	ServiceNames
struct	ServicePSMHelper
struct	ServicePSRHelper
class	ServiceWrapper
class	ServiceWrapper< T, art::ServiceScope::PER_SCHEDULE >
class	ServiceWrapperBase
struct	setup_eventsToSkip
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	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	ModuleConfigInfoMap = std::map< std::string, ModuleConfigInfo >
using	WorkerMaker_t = Worker *(WorkerParams const &, ModuleDescription const &)
using	ModuleTypeFunc_t) = ModuleType(
template<typename T >
using	respond_to_file = void(T::*)(FileBlock const &)
using	ServiceCache = std::map< TypeID, detail::ServiceCacheEntry >
typedef std::stack< WrapperBase_ptr >	ServiceStack
using	WrapperBase_ptr = std::shared_ptr< detail::ServiceWrapperBase >

Enumerations
enum	SignalResponseType { SignalResponseType::FIFO, SignalResponseType::LIFO }

Functions
void	print_available_plugins (suffix_type st, bool const verbose, std::string const &spec)
void	print_available_plugins (suffix_type st, bool const verbose)
bool	supports_key (suffix_type st, 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::string	describe (cet::exempt_ptr< fhicl::ConfigurationTable const > pb, std::string const &prefix)
bool	exists_outside_prolog (fhicl::intermediate_table const &config, std::string const &key)
template<typename T >
std::enable_if_t< std::is_convertible< T, std::string >::value, std::string >	fhicl_key (T const &name)
template<typename H , typename... T>
std::enable_if_t< std::is_convertible< H, std::string >::value, std::string >	fhicl_key (H const &hname, T const &...tnames)
void	fillSourceList (std::istream &ifs, std::vector< std::string > &source_list)
constexpr const char *	dflt_spec_pattern ()
LibraryInfoCollection	get_LibraryInfoCollection (suffix_type suffix, std::string const &pattern, bool const verbose=false)
std::unique_ptr< MetadataCollector >	get_MetadataCollector (suffix_type st)
std::unique_ptr< MetadataSummary >	get_MetadataSummary (suffix_type st, LibraryInfoCollection const &coll)
constexpr int	info_success ()
std::regex	regex_for_spec (std::string const &)
void	replace_type (std::string &str, std::string const &spec, std::regex const &r)
template<>
std::string	getType< suffix_type::module > (cet::LibraryManager const &lm, std::string const &fullSpec)
template<>
std::string	getType< suffix_type::plugin > (cet::LibraryManager const &lm, std::string const &fullSpec)
template<>
std::string	getType< suffix_type::tool > (cet::LibraryManager const &lm, std::string const &fullSpec)
template<typename F , typename RT = decltype(std::declval<F>()())>
RT	resolve_if_present (F f, std::string const &caller, RT result)
template<art::suffix_type st>
std::string	getFilePath (cet::LibraryManager const &lm, std::string const &fullspec)
template<art::suffix_type >
std::string	getType (cet::LibraryManager const &, std::string const &)
template<art::suffix_type >
std::unique_ptr< fhicl::ConfigurationTable >	getAllowedConfiguration (cet::LibraryManager const &lm, std::string const &fullSpec, std::string const &name)
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)
bool	get_failureToPut_flag (fhicl::ParameterSet const &scheduler_pset, fhicl::ParameterSet const &module_pset)
void	remove_whitespace (std::string &)
void	parse_path_spec (std::string path_spec, std::pair< std::string, std::string > &output)
void	verifyInstanceName (std::string const &in)
void	verifyFriendlyClassName (std::string const &fcn)
void	memoryReport ()
void	writeSummary (PathManager &pm, bool wantSummary, cet::cpu_timer const &timer)
void	triggerReport (PathsInfo const &endPathsInfo, 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)
void	checkForMissingDictionaries (std::vector< TypeID > const &types) noexcept( false)
RangeSet	rangeSetFromFileIndex (FileIndex const &fileIndex, RunID runID, bool compactRanges)
RangeSet	rangeSetFromFileIndex (FileIndex const &fileIndex, SubRunID subRunID, bool compactRanges)
void	readFileIndex (TFile *file, TTree *metaDataTree, FileIndex *&findexPtr)
template<typename T >
T	readMetadata (TTree *md, bool const requireDict=true)
template<typename T >
bool	readMetadata (TTree *md, T &field, bool const requireDict=true)
RangeSetInfo	resolveRangeSetInfo (sqlite3 *, std::string const &filename, BranchType, unsigned RangeSetID, bool compact)
RangeSet	resolveRangeSet (RangeSetInfo const &rs)
RangeSet	resolveRangeSet (sqlite3 *, std::string const &filename, BranchType, unsigned rangeSetID, bool compact)
Long64_t	GetBasketSize (TObjArray *branches, bool ondisk, bool inclusive)
Long64_t	GetBasketSize (TBranch *b, bool ondisk, bool inclusive)
Long64_t	GetTotalSize (TBranch *br, bool ondisk, bool inclusive)
Long64_t	GetTotalSize (TObjArray *branches, bool ondisk)
Long64_t	GetTotalSize (TTree *t, bool ondisk)
Long64_t	sizeOnDisk (TTree *t)
Long64_t	sizeOnDisk (TBranch *branch, bool inclusive)
void	printBranchSummary (std::ostream &os, TBranch *br)
void	printTreeSummary (std::ostream &os, TTree *t)
bool	shouldFastClone (bool fastCloningSet, bool fastCloning, bool wantAllEvents, ClosingCriteria const &fileProperties)
bool	shouldDropEvents (bool dropAllEventsSet, bool dropAllEvents, bool dropAllSubRuns)
template<typename AUX >
void	mergeAuxiliary (AUX &left, AUX const &right)
template<>
void	mergeAuxiliary (EventAuxiliary &, EventAuxiliary const &)
template<BranchType , typename ID >
RangeSet	makeFullRangeSet (ID const &)
template<>
RangeSet	makeFullRangeSet< InSubRun, SubRunID > (SubRunID const &id)
template<>
RangeSet	makeFullRangeSet< InRun, RunID > (RunID const &id)
template<typename T >
size_t	call_eventsToSkip (T &t)
void	throw_if_invalid (std::string const &)
template<typename H , typename... T>
void	throw_if_invalid (std::string const &msg, H const &h, T const &...t)
template<typename T >
cet::exception &	exceptionContext (ModuleDescription const &md, T const &ip, cet::exception &ex)
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< T, fhicl::ParameterSet const &, ActivityRegistry & >::value, std::shared_ptr< T > >	makeServiceFrom (fhicl::ParameterSet const &ps, ActivityRegistry &areg)
template<typename T >
std::enable_if_t<!std::is_constructible< T, fhicl::ParameterSet const &, ActivityRegistry & >::value, 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)
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)
std::string	bold_fontify (std::string const &s)
InputTag	input_tag (InputTag const &tag)
template<typename T >
InputTag	input_tag (ProductToken< T > const &token)
template<typename T >
InputTag	input_tag (ViewToken< T > const &token)
bool	upcastAllowed (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)
void const *	maybeCastObj (void const *address, std::type_info const &tiFrom, std::type_info const &tiTo)
void	throwPartnerException (std::type_info const &generator, std::type_info const &wanted_wrapper_type)
ProductLookup_t	createProductLookups (ProductDescriptions const &descriptions)
ViewLookup_t	createViewLookups (ProductDescriptions 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}

Typedef Documentation

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

Definition at line 12 of file LibraryInfoCollection.h.

using art::detail::ModuleConfigInfoMap = typedef std::map<std::string, ModuleConfigInfo>

Definition at line 23 of file ModuleConfigInfo.h.

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

Definition at line 37 of file ModuleMacros.h.

template<typename T >

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

Definition at line 519 of file MixFilter.h.

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

Definition at line 11 of file ServiceCache.h.

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

Definition at line 10 of file ServiceStack.h.

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

Definition at line 67 of file PrintFormatting.h.

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

Definition at line 36 of file ModuleMacros.h.

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

Definition at line 19 of file ServiceWrapperBase.h.

Enumeration Type Documentation

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.

References fhicl::detail::atom::value().

    {
      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);
    }

std::string art::detail::bold_fontify ( std::string const &  s )

inline

Definition at line 9 of file bold_fontify.h.

Referenced by art::ServiceDirector::addSystemService(), art::detail::ServiceCacheEntry::makeAndCacheService(), art::PathsInfo::makeWorker_(), print_descriptions(), mf::StartMessageFacility(), and supports_key().

    {
      return "\033[1m" + s + "\033[0m";
    }

template<typename T >

size_t art::detail::call_eventsToSkip

(

T &

t

)

Definition at line 272 of file MixFilter.h.

    {
      return t.eventsToSkip();
    }

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

Definition at line 61 of file branchNameComponentChecking.cc.

References splitToComponents().

{
  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.

References checkFriendlyNameSelector(), checkInstanceNameSelector(), checkModuleLabelSelector(), checkProcessNameSelector(), art::BranchKey::friendlyClassName_, art::BranchKey::moduleLabel_, art::BranchKey::processName_, and art::BranchKey::productInstanceName_.

{
  // 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;
}

void art::detail::checkForMissingDictionaries ( std::vector< TypeID > const &  types )

noexcept

Definition at line 5 of file checkForMissingDictionaries.cc.

Referenced by art::MixOp< PROD, OPROD >::initializeBranchInfo().

{
  root::DictionaryChecker checker;
  for (auto const& tid : types) {
    checker.checkDictionaries(tid.className());
  }
  checker.reportMissingDictionaries();
}

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.

Referenced by checkBranchNameSelector().

{
  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.

Referenced by checkBranchNameSelector().

{
  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.

Referenced by checkBranchNameSelector().

{
  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.

Referenced by checkBranchNameSelector().

{
  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 42 of file PrintFormatting.h.

References max, and s.

Referenced by art::FileDumperOutput::printPrincipal().

    {
      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 54 of file PrintFormatting.h.

References max, and s.

    {
      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 63 of file FileNameComponents.cc.

References art::detail::FileNameComponents::add(), and art::detail::FileNameComponents::setSuffix().

Referenced by art::PostCloseFileRenamer::applySubstitutions().

    {
      FileNameComponents result;

      boost::smatch match;
      auto si = cbegin(pattern), se = cend(pattern);
      while (boost::regex_search(
        si,
        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());
        si = match[0].second;
      }
      // Get remaining characters of filename
      result.setSuffix(std::string(si, 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);
    }

art::ProductLookup_t art::detail::createProductLookups

(

ProductDescriptions const &

descriptions

)

Definition at line 98 of file createProductLookups.cc.

References art::friendlyname::friendlyName(), art::is_assns(), and art::name_of_assns_base().

Referenced by art::ProductTable::ProductTable().

{
  // 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& pd : descriptions) {
    auto const& prodFCN = pd.friendlyClassName();
    auto const& procName = pd.processName();
    auto const pid = pd.productID();
    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

(

ProductDescriptions const &

descriptions

)

Definition at line 5 of file createViewLookups.cc.

Referenced by art::ProductTable::ProductTable().

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

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

    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.

References fhicl::detail::optional_parameter_message(), and fhicl::detail::ParameterWalker< C >::walk_over().

Referenced by geo::part::Partition< Data >::data(), and geo::part::Partition< Data >::describe().

{
  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 const char* art::detail::dflt_spec_pattern

(

)

Definition at line 18 of file get_LibraryInfoCollection.h.

References get_LibraryInfoCollection().

Referenced by print_available_plugins().

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

template<typename T >

cet::exception & art::detail::exceptionContext	(	ModuleDescription const &	md,
		T const &	ip,
		cet::exception &	ex
	)

Definition at line 208 of file Worker.h.

References art::ModuleDescription::moduleLabel(), and art::ModuleDescription::moduleName().

Referenced by art::Worker::doWork().

{
  iEx << iMD.moduleName() << "/" << iMD.moduleLabel() << " " << ip.id() << "\n";
  return iEx;
}

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

inline

Definition at line 10 of file exists_outside_prolog.h.

References fhicl::intermediate_table::exists(), fhicl::intermediate_table::find(), and fhicl::extended_value::in_prolog.

Referenced by art::BasicOutputOptionsHandler::doCheckOptions(), art::BasicOutputOptionsHandler::doProcessOptions(), art::BasicPostProcessor::doProcessOptions(), art::DebugOptionsHandler::doProcessOptions(), and art::FileCatalogOptionsHandler::doProcessOptions().

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

template<typename T >

std::enable_if_t<std::is_convertible<T, std::string>::value, std::string> art::detail::fhicl_key

(

T const &

name

)

Definition at line 13 of file fhicl_key.h.

References fhicl::detail::atom::value().

Referenced by art::ProcessingOptionsHandler::doProcessOptions(), art::BasicOutputOptionsHandler::doProcessOptions(), art::DebugOptionsHandler::doProcessOptions(), art::FileCatalogOptionsHandler::doProcessOptions(), and fhicl_key().

    {
      return name;
    }

template<typename H , typename... T>

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

Definition at line 20 of file fhicl_key.h.

References fhicl_key().

    {
      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.

Referenced by art::BasicSourceOptionsHandler::processSourceListArg_().

{
  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 38 of file RangeSet.cc.

Referenced by art::RangeSet::forRun(), and art::RangeSet::is_full_run().

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

bool art::detail::get_failureToPut_flag	(	fhicl::ParameterSet const &	scheduler_pset,
		fhicl::ParameterSet const &	module_pset
	)

Definition at line 9 of file get_failureToPut_flag.cc.

References fhicl::ParameterSet::get().

Referenced by art::EDProducer::doBeginJob(), and art::EDFilter::doBeginJob().

  {
    bool const global_flag{scheduler_pset.get<bool>("errorOnFailureToPut")};
    bool const local_flag{module_pset.get<bool>("errorOnFailureToPut", true)};
    return !global_flag ? global_flag :
                          local_flag; // global flag set to 'false' always wins
  }

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

Definition at line 223 of file get_LibraryInfoCollection.cc.

References art::mfPlugin, art::mfStatsPlugin, art::module, art::plugin, art::service, art::source, and art::tool.

Referenced by dflt_spec_pattern(), print_available_plugins(), and supports_key().

{
  switch (st) {
    case suffix_type::module:
      return getCollection<suffix_type::module>(pattern, verbose);
    case suffix_type::service:
      return getCollection<suffix_type::service>(pattern, verbose);
    case suffix_type::source:
      return getCollection<suffix_type::source>(pattern, verbose);
    case suffix_type::plugin:
      return getCollection<suffix_type::plugin>(pattern, verbose);
    case suffix_type::tool:
      return getCollection<suffix_type::tool>(pattern, verbose);
    case suffix_type::mfPlugin:
      return getCollection<suffix_type::mfPlugin>(pattern, verbose);
    case suffix_type::mfStatsPlugin:
      return getCollection<suffix_type::mfStatsPlugin>(pattern, verbose);
      // No default - allow compiler to warn if missing suffix_type.
  }
  return {};
}

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

(

suffix_type

st

)

Definition at line 15 of file get_MetadataCollector.cc.

References art::mfPlugin, art::mfStatsPlugin, art::module, art::plugin, art::service, art::source, and art::tool.

{
  switch (st) {
    case suffix_type::module:
      return std::make_unique<MetadataCollectorFor<suffix_type::module>>();
    case suffix_type::plugin:
      return std::make_unique<MetadataCollectorFor<suffix_type::plugin>>();
    case suffix_type::service:
      return std::make_unique<MetadataCollectorFor<suffix_type::service>>();
    case suffix_type::source:
      return std::make_unique<MetadataCollectorFor<suffix_type::source>>();
    case suffix_type::tool:
      return std::make_unique<MetadataCollectorFor<suffix_type::tool>>();
    case suffix_type::mfPlugin:
      return std::make_unique<MetadataCollectorFor<suffix_type::mfPlugin>>();
    case suffix_type::mfStatsPlugin:
      return std::make_unique<
        MetadataCollectorFor<suffix_type::mfStatsPlugin>>();
      // No default -- allow compiler to warn if missing suffix_type.
  }
  return std::unique_ptr<MetadataCollector>{nullptr};
}

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

Definition at line 15 of file get_MetadataSummary.cc.

References art::mfPlugin, art::mfStatsPlugin, art::module, art::plugin, art::service, art::source, and art::tool.

Referenced by print_available_plugins().

{
  switch (st) {
    case suffix_type::module:
      return std::make_unique<MetadataSummaryFor<suffix_type::module>>(coll);
    case suffix_type::service:
      return std::make_unique<MetadataSummaryFor<suffix_type::service>>(coll);
    case suffix_type::source:
      return std::make_unique<MetadataSummaryFor<suffix_type::source>>(coll);
    case suffix_type::plugin:
      return std::make_unique<MetadataSummaryFor<suffix_type::plugin>>(coll);
    case suffix_type::tool:
      return std::make_unique<MetadataSummaryFor<suffix_type::tool>>(coll);
    case suffix_type::mfPlugin:
      return std::make_unique<MetadataSummaryFor<suffix_type::mfPlugin>>(coll);
    case suffix_type::mfStatsPlugin:
      return std::make_unique<MetadataSummaryFor<suffix_type::mfStatsPlugin>>(
        coll);
      // No default -- let compiler warn if missing type.
  }
  return std::unique_ptr<MetadataSummary>{nullptr};
}

template<art::suffix_type >

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

Definition at line 73 of file PluginSymbolResolvers.h.

References resolve_if_present().

    {
      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});
    }

Long64_t art::detail::GetBasketSize	(	TObjArray *	branches,
		bool	ondisk,
		bool	inclusive
	)

Definition at line 11 of file rootFileSizeTools.cc.

References n.

Referenced by GetBasketSize(), and GetTotalSize().

{
  Long64_t result = 0;
  size_t n = branches->GetEntries();
  for (size_t i = 0; i < n; ++i) {
    result +=
      GetBasketSize(static_cast<TBranch*>(branches->At(i)), ondisk, inclusive);
  }
  return result;
}

Long64_t art::detail::GetBasketSize	(	TBranch *	b,
		bool	ondisk,
		bool	inclusive
	)

Definition at line 23 of file rootFileSizeTools.cc.

References GetBasketSize().

{
  Long64_t result = 0;
  if (b) {
    if (ondisk && b->GetZipBytes() > 0) {
      result = b->GetZipBytes();
    } else {
      result = b->GetTotBytes();
    }
    if (inclusive) {
      result += GetBasketSize(b->GetListOfBranches(), ondisk, true);
    }
    return result;
  }
  return result;
}

template<art::suffix_type st>

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

Definition at line 34 of file PluginSymbolResolvers.h.

References art::Suffixes::get(), resolve_if_present(), s, and art::source.

    {
      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 + "_" +
                   Suffixes::get(st) + ".cc";
        }
        return source;
      };

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

Long64_t art::detail::GetTotalSize	(	TBranch *	br,
		bool	ondisk,
		bool	inclusive
	)

Definition at line 41 of file rootFileSizeTools.cc.

References f, and GetBasketSize().

Referenced by GetTotalSize(), and sizeOnDisk().

{
  TMemFile f("buffer", "CREATE");
  if (br->GetTree()->GetCurrentFile()) {
    f.SetCompressionSettings(
      br->GetTree()->GetCurrentFile()->GetCompressionSettings());
  }
  f.WriteObject(br, "thisbranch");
  TKey* key = f.GetKey("thisbranch");
  Long64_t size;
  if (ondisk)
    size = key->GetNbytes();
  else
    size = key->GetObjlen();
  return GetBasketSize(br, ondisk, inclusive) + size;
}

Long64_t art::detail::GetTotalSize	(	TObjArray *	branches,
		bool	ondisk
	)

Definition at line 59 of file rootFileSizeTools.cc.

References GetTotalSize(), and n.

{
  Long64_t result = 0;
  size_t n = branches->GetEntries();
  for (size_t i = 0; i < n; ++i) {
    result +=
      GetTotalSize(static_cast<TBranch*>(branches->At(i)), ondisk, true);
  }
  return result;
}

Long64_t art::detail::GetTotalSize	(	TTree *	t,
		bool	ondisk
	)

Definition at line 71 of file rootFileSizeTools.cc.

References f, and GetBasketSize().

{
  TKey* key = 0;
  if (t->GetDirectory()) {
    key = t->GetDirectory()->GetKey(t->GetName());
  }
  Long64_t ondiskSize = 0;
  Long64_t totalSize = 0;
  if (key) {
    ondiskSize = key->GetNbytes();
    totalSize = key->GetObjlen();
  } else {
    TMemFile f("buffer", "CREATE");
    if (t->GetCurrentFile()) {
      f.SetCompressionSettings(t->GetCurrentFile()->GetCompressionSettings());
    }
    f.WriteTObject(t);
    key = f.GetKey(t->GetName());
    ondiskSize = key->GetNbytes();
    totalSize = key->GetObjlen();
  }
  if (t->GetBranchRef()) {
    if (ondisk) {
      ondiskSize += GetBasketSize(t->GetBranchRef(), true, true);
    } else {
      totalSize += GetBasketSize(t->GetBranchRef(), false, true);
    }
  }
  if (ondisk) {
    return ondiskSize + GetBasketSize(t->GetListOfBranches(),
                                      /* ondisk */ true,
                                      /* inclusive */ true);
  } else {
    return totalSize + GetBasketSize(t->GetListOfBranches(),
                                     /* ondisk */ false,
                                     /* inclusive */ true);
  }
}

template<art::suffix_type >

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

Definition at line 56 of file PluginSymbolResolvers.h.

Referenced by cosmic::CosmicTrackTagger::produce().

    {
      return {};
    }

template<>

std::string art::detail::getType< suffix_type::module >	(	cet::LibraryManager const &	lm,
		std::string const &	fullSpec
	)

Definition at line 12 of file PluginSymbolResolvers.cc.

References resolve_if_present(), s, and art::to_string().

    {
      using ModuleTypeFunc_t = art::ModuleType();

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

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

template<>

std::string art::detail::getType< suffix_type::plugin >	(	cet::LibraryManager const &	lm,
		std::string const &	fullSpec
	)

Definition at line 28 of file PluginSymbolResolvers.cc.

References resolve_if_present(), and s.

    {
      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);
    }

template<>

std::string art::detail::getType< suffix_type::tool >	(	cet::LibraryManager const &	lm,
		std::string const &	fullSpec
	)

Definition at line 44 of file PluginSymbolResolvers.cc.

References resolve_if_present(), and s.

    {
      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);
    }

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

)

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

inline

Definition at line 18 of file PrintFormatting.h.

Referenced by geo::PlaneGeo::ActiveArea(), lar_cluster3d::ClusterPathFinder::breakIntoTinyBits(), lar_cluster3d::VoronoiPathFinder::breakIntoTinyBits(), lar_cluster3d::ClusterPathFinder::buildConvexHull(), lar_cluster3d::VoronoiPathFinder::buildConvexHull(), recob::Trajectory::Direction(), recob::TrackTrajectory::Direction(), recob::PointCharge::dump(), lar::example::CheatTrack::dump(), sim::OpDetBacktrackerRecord::Dump(), sim::SimChannel::Dump(), sim::DumpSimPhotons::DumpElement(), sim::DumpMCShowers::DumpMCShower(), sim::DumpMCTracks::DumpMCTrack(), sim::DumpOpDetBacktrackerRecords::DumpOpDetBacktrackerRecord(), recob::dumper::DumpPCAxis(), sim::DumpSimPhotonsLite::DumpPhoton(), sim::DumpSimChannels::DumpSimChannel(), detsim::DumpOpDetWaveforms::DumpWaveform(), mf::service::ELdestination::emitToken(), recob::TrajectoryPointFlags::fromHit(), geo::CryostatGeo::ID(), indent0(), indent_1(), indent__2(), geo::WireGeo::isParallelTo(), geo::GeometryCore::MaterialName(), fhicl::detail::MaybeDisplayParent::MaybeDisplayParent(), geo::OpDetGeo::Node(), geo::AuxDetGeo::NSensitiveVolume(), rndm::details::RangeCheckHelper< seed_t >::operator()(), geo::part::PartitionBase::PartitionBase(), geo::GeometryCore::Print(), lar::debug::printBacktrace(), lar_pandora::LArPandoraEventDump::PrintParticle(), calo::LinearEnergyAlg::setup(), geo::AuxDetSensitiveGeo::toLocalCoords(), and geo::TPCGeo::toLocalCoords().

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

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

inline

Definition at line 23 of file PrintFormatting.h.

References indent().

Referenced by print_descriptions(), and rule_size().

    {
      return indent(3);
    }

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

inline

Definition at line 28 of file PrintFormatting.h.

References indent().

    {
      return indent(4);
    }

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

inline

Definition at line 33 of file PrintFormatting.h.

References indent().

    {
      return indent(8);
    }

constexpr int art::detail::info_success

(

)

Definition at line 9 of file info_success.h.

References max.

Referenced by art::BasicOptionsHandler::doCheckOptions(), main(), and art::run_art_common_().

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

InputTag art::detail::input_tag ( InputTag const &  tag )

inline

Definition at line 21 of file IPRHelper.h.

Referenced by art::FindMany< ProdB, void >::FindMany(), art::FindMany< ProdB, Data >::FindMany(), art::FindManyP< ProdB, void >::FindManyP(), art::FindManyP< ProdB, Data >::FindManyP(), art::FindOne< ProdB, void >::FindOne(), art::FindOne< ProdB, Data >::FindOne(), art::FindOneP< ProdB, void >::FindOneP(), and art::FindOneP< ProdB, Data >::FindOneP().

    {
      return tag;
    }

template<typename T >

InputTag art::detail::input_tag ( ProductToken< T > const &  token )

inline

Definition at line 28 of file IPRHelper.h.

References art::ProductToken< T >::inputTag_.

    {
      return token.inputTag_;
    }

template<typename T >

InputTag art::detail::input_tag ( ViewToken< T > const &  token )

inline

Definition at line 35 of file IPRHelper.h.

References art::ViewToken< Element >::inputTag_.

    {
      return token.inputTag_;
    }

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

(

)

Definition at line 7 of file Hash.cc.

Referenced by art::Hash< I >::fixup(), and art::Hash< I >::isValid().

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

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

Definition at line 9 of file logFileAction.cc.

References mf::FlushMessageLog().

Referenced by art::RootInputFileSequence::closeFile_(), art::RootOutput::doOpenFile(), art::RootOutput::finishEndFile(), art::RootInputFileSequence::initFile(), art::TFileService::maybeSwitchFiles_(), and art::RootInputFileSequence::openSecondaryFile().

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

template<BranchType , typename ID >

RangeSet art::detail::makeFullRangeSet

(

ID const &

)

Referenced by mergeAuxiliary().

template<>

RangeSet art::detail::makeFullRangeSet< InRun, RunID > ( RunID const &  id )

inline

Definition at line 65 of file RootInputTree.h.

References art::RangeSet::forRun().

    {
      return RangeSet::forRun(id);
    }

template<>

RangeSet art::detail::makeFullRangeSet< InSubRun, SubRunID > ( SubRunID const &  id )

inline

Definition at line 58 of file RootInputTree.h.

References art::RangeSet::forSubRun().

    {
      return RangeSet::forSubRun(id);
    }

template<typename T >

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

Definition at line 46 of file ServiceWrapper.h.

References fhicl::detail::atom::value().

    {
      static_assert(
        !std::is_base_of<ProducingService, T>::value,
        "\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<T, fhicl::ParameterSet const&, ActivityRegistry&>::value, std::shared_ptr<T> > art::detail::makeServiceFrom	(	fhicl::ParameterSet const &	ps,
		ActivityRegistry &
	)

Definition at line 61 of file ServiceWrapper.h.

References art::detail::ServiceWrapper< T, SCOPE >::operator=(), and art::detail::ServiceWrapper< T, SCOPE >::ServiceWrapper().

    {
      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.

Referenced by art::GlobalSignal< SRTYPE, ResultType(Args...)>::watch(), art::LocalSignal< STYPE, ResultType(Args...)>::watch(), and art::LocalSignal< STYPE, ResultType(Args...)>::watchAll().

    {
      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)...);
      };
    }

template<typename element_type >

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

inline

Definition at line 21 of file maybeCastObj.h.

Referenced by art::getElementAddresses(), and art::setPtr().

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

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

void art::detail::memoryReport

(

)

Definition at line 4 of file memoryReportDarwin.cc.

Referenced by writeSummary().

{
  // Not implemented for Darwin
}

template<typename AUX >

void art::detail::mergeAuxiliary	(	AUX &	left,
		AUX const &	right
	)

Definition at line 43 of file RootInputTree.h.

Referenced by art::RootInputTree::fillAux().

    {
      left.mergeAuxiliary(right);
    }

template<>

void art::detail::mergeAuxiliary ( EventAuxiliary &  , EventAuxiliary const &    )

inline

Definition at line 50 of file RootInputTree.h.

References makeFullRangeSet().

    {}

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

(

ProcessHistoryMap const &

pHistMap

)

Definition at line 12 of file orderedProcessNamesCollection.cc.

References art::isAncestor().

Referenced by art::detail::InfoDumperInputFile::print_branchIDLists(), and art::detail::InfoDumperInputFile::print_process_history().

{
  std::vector<std::vector<std::string>> result;

  std::vector<ProcessHistory const*> collapsed_histories;
  // Collapsed histories are histories that do not overlap with any
  // others.  For example, of the following process histories:
  //
  //     1: [A]
  //     2: [A,B]
  //     3: [A,B,C]
  //     4: [A,D]
  //
  // The collapsed histories are 3 and 4 since 1 and 2 are subsets of
  // 3.  In otherwords, 3 and 4 are the only histories that do not
  // have descendants.
  //
  // Since the ordering of the histories is determined by a hashed
  // value, we must compare each history in pairs to determine which
  // histories do not have descendants.
  for (auto const& hist_i : histories) {
    bool found_descendent{false};
    for (auto const& hist_j : histories) {
      if (isAncestor(hist_i.second, hist_j.second)) {
        found_descendent = true;
        break;
      }
    }
    if (!found_descendent) {
      collapsed_histories.push_back(&hist_i.second);
    }
  }

  for (auto const history : collapsed_histories) {
    std::vector<std::string> process_names;
    cet::transform_all(*history,
                       std::back_inserter(process_names),
                       [](auto const& config) { return config.processName(); });
    result.push_back(std::move(process_names));
  }

  return result;
}

void art::detail::parse_path_spec	(	std::string	path_spec,
		std::pair< std::string, std::string > &	output
	)

Definition at line 17 of file parse_path_spec.cc.

References remove_whitespace().

Referenced by art::EventObserverBase::init_().

{
  detail::remove_whitespace(path);
  auto const pos = path.find(":");
  if (pos == string::npos) {
    pname_path = std::make_pair("", path);
    return;
  }
  pname_path = make_pair(path.substr(0, pos), path.substr(pos + 1));
}

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

Definition at line 82 of file AllowedConfiguration.cc.

References get_LibraryInfoCollection(), get_MetadataSummary(), and rule_size().

Referenced by art::BasicOptionsHandler::doCheckOptions(), and print_available_plugins().

{
  auto coll = get_LibraryInfoCollection(st, spec, verbose);
  if (coll.empty())
    return;

  auto ms = get_MetadataSummary(st, coll);

  cet::HorizontalRule const rule{rule_size(ms->widths())};
  cout << "\n"
       << rule('=') << "\n\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 << "\n" << rule('=') << "\n\n";

  if (duplicates.empty())
    return;

  duplicates_message(st, duplicates);
  cout << "\n\n";
}

void art::detail::print_available_plugins ( suffix_type  st, bool const  verbose  )

inline

Definition at line 85 of file AllowedConfiguration.h.

References dflt_spec_pattern(), print_available_plugins(), print_description(), print_descriptions(), and supports_key().

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

void art::detail::print_description

(

std::vector< PluginMetadata > const &

matches

)

Definition at line 138 of file AllowedConfiguration.cc.

References art::errors::Configuration, and art::Suffixes::print().

Referenced by print_available_plugins(), and print_descriptions().

{
  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 178 of file AllowedConfiguration.cc.

References bold_fontify(), indent0(), and print_description().

Referenced by art::BasicOptionsHandler::doCheckOptions(), and print_available_plugins().

{
  cout << '\n' << fixed_rule('=') << "\n\n";
  for (auto const& spec : specs) {
    std::string plugin_type{}, instance_pattern{};
    std::tie(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]" :
                                          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);
  }
}

void art::detail::printBranchSummary	(	std::ostream &	os,
		TBranch *	br
	)

Definition at line 129 of file rootFileSizeTools.cc.

References n, and sizeOnDisk().

{
  os << "The branch \"" << br->GetName() << "\" takes " << sizeOnDisk(br, true)
     << " bytes on disk\n";
  size_t n = br->GetListOfBranches()->GetEntries();
  for (size_t i = 0; i < n; ++i) {
    TBranch* subbr = static_cast<TBranch*>(br->GetListOfBranches()->At(i));
    os << "  It's sub-branch \"" << subbr->GetName() << "\" takes "
       << sizeOnDisk(subbr, true) << " bytes on disk\n";
  }
}

void art::detail::printTreeSummary	(	std::ostream &	os,
		TTree *	t
	)

Definition at line 142 of file rootFileSizeTools.cc.

References n, and sizeOnDisk().

{
  os << "The TTree \"" << t->GetName() << "\" takes " << sizeOnDisk(t)
     << " bytes on disk\n";
  size_t n = t->GetListOfBranches()->GetEntries();
  for (size_t i = 0; i < n; ++i) {
    TBranch* br = static_cast<TBranch*>(t->GetListOfBranches()->At(i));
    os << "  It's branch \"" << br->GetName() << "\" takes "
       << sizeOnDisk(br, true) << " bytes on disk\n";
  }
}

RangeSet art::detail::rangeSetFromFileIndex	(	FileIndex const &	fileIndex,
		RunID	runID,
		bool	compactRanges
	)

Definition at line 123 of file rangeSetFromFileIndex.cc.

References evd::details::begin(), evd::details::end(), and art::RunID::run().

Referenced by art::RootInputTree::fillAux(), and art::detail::InfoDumperInputFile::print_range_sets().

{
  auto const run = runID.run();
  auto const begin = std::cbegin(fileIndex);
  auto const end = std::cend(fileIndex);

  RangeSet rangeSet{run};

  // Loop through SubRuns in Run
  auto subrun_begin = std::find_if(begin, end, next_subrun_in_run{runID});
  if (subrun_begin == end) {
    // Run has no entries -- early bail out
    return rangeSet;
  }

  auto const run_end = std::find_if(subrun_begin, end, end_of_run{runID});
  while (subrun_begin != run_end) {
    auto const subRunID = subrun_begin->eventID_.subRunID();
    auto rs = rangeSetFromFileIndex(fileIndex, subRunID, compactRanges);
    if (rs.is_valid()) {
      rangeSet.merge(rs);
    }
    auto subrun_end = std::find_if(subrun_begin, end, end_of_subrun{subRunID});
    subrun_begin = subrun_end;
  }

  return rangeSet;
}

RangeSet art::detail::rangeSetFromFileIndex	(	FileIndex const &	fileIndex,
		SubRunID	subRunID,
		bool	compactRanges
	)

Definition at line 74 of file rangeSetFromFileIndex.cc.

References evd::details::begin(), evd::details::end(), art::FileIndex::Element::eventID_, art::SubRunID::run(), art::SubRunID::runID(), and art::SubRunID::subRun().

{
  RangeSet rangeSet{subRunID.run()};
  auto begin = std::cbegin(fileIndex);
  auto end = std::cend(fileIndex);

  auto subrun_begin =
    std::find_if(begin, end, next_subrun_in_run{subRunID.runID()});
  if (subrun_begin == end) {
    // SubRun does not exist in the provided fileIndex
    return rangeSet;
  }

  auto event_it =
    std::find_if(subrun_begin, end, next_event_in_subrun{subRunID});
  if (event_it == end) {
    // SubRun has no event entries entries
    return rangeSet;
  }

  auto const& eid = event_it->eventID_;
  auto event_end =
    std::find_if_not(event_it, end, next_event_in_subrun{subRunID});

  if (compactRanges) {
    auto const count = std::distance(event_it, event_end);
    if (count < 1) {
      // Should never get here, and should probably throw
      return rangeSet;
    }

    auto const subrun = subRunID.subRun();
    auto const ebegin = eid.event();
    auto const eend = (count == 1) ?
                        eid.next().event() :
                        std::prev(event_end)->eventID_.next().event();
    rangeSet.emplace_range(subrun, ebegin, eend);
    return rangeSet;
  }

  std::for_each(event_it, event_end, [&rangeSet](auto const& element) {
    rangeSet.update(element.eventID_);
  });
  return rangeSet;
}

void art::detail::readFileIndex ( TFile *  file, TTree *  metaDataTree, FileIndex *&  findexPtr  )

inline

Definition at line 20 of file readFileIndex.h.

References art::FileIndex::addEntryOnLoad(), art::couldNotFindTree(), art::rootNames::fileIndexTreeName(), art::errors::FileReadError, and art::input::getEntry().

Referenced by art::detail::InfoDumperInputFile::InfoDumperInputFile(), and art::MixHelper::openAndReadMetaData_().

    {

      if (auto branch = metaDataTree->GetBranch(
            rootNames::metaBranchRootName<FileIndex>())) {
        branch->SetAddress(&findexPtr);
        input::getEntry(branch, 0);
        branch->SetAddress(nullptr);
      } else {
        std::unique_ptr<TTree> fileIndexTree{static_cast<TTree*>(
          file->Get(rootNames::fileIndexTreeName().c_str()))};
        if (!fileIndexTree)
          throw Exception{errors::FileReadError}
            << couldNotFindTree(rootNames::fileIndexTreeName());

        FileIndex::Element element;
        auto elemPtr = &element;
        fileIndexTree->SetBranchAddress(
          rootNames::metaBranchRootName<FileIndex::Element>(), &elemPtr);
        for (size_t i{0}, sz = fileIndexTree->GetEntries(); i != sz; ++i) {
          input::getEntry(fileIndexTree.get(), i);
          findexPtr->addEntryOnLoad(elemPtr->eventID_, elemPtr->entry_);
        }
        fileIndexTree->SetBranchAddress(
          rootNames::metaBranchRootName<FileIndex::Element>(), nullptr);
      }
    }

template<typename T >

T art::detail::readMetadata	(	TTree *	md,
		bool const	requireDict = true
	)

Definition at line 13 of file readMetadata.h.

References art::input::getEntry().

Referenced by art::detail::InfoDumperInputFile::InfoDumperInputFile(), and art::MixHelper::openAndReadMetaData_().

    {
      auto branch = md->GetBranch(art::rootNames::metaBranchRootName<T>());
      assert(branch != nullptr);

      auto mdField = requireDict ? root::getObjectRequireDict<T>() : T{};
      auto field_ptr = &mdField;
      branch->SetAddress(&field_ptr);
      input::getEntry(branch, 0);
      branch->SetAddress(nullptr);
      return mdField;
    }

template<typename T >

bool art::detail::readMetadata	(	TTree *	md,
		T &	field,
		bool const	requireDict = true
	)

Definition at line 28 of file readMetadata.h.

References art::input::getEntry().

    {
      auto branch = md->GetBranch(art::rootNames::metaBranchRootName<T>());
      if (branch == nullptr) {
        return false;
      }

      auto mdField = requireDict ? root::getObjectRequireDict<T>() : T{};
      auto field_ptr = &mdField;
      branch->SetAddress(&field_ptr);
      input::getEntry(branch, 0);
      branch->SetAddress(nullptr);
      std::swap(mdField, field);

      return true;
    }

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 &

s

)

Definition at line 10 of file parse_path_spec.cc.

Referenced by parse_path_spec().

{
  s.erase(remove(s.begin(), s.end(), ' '), s.end());
  s.erase(remove(s.begin(), s.end(), '\t'), s.end());
}

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

Definition at line 12 of file MetadataRegexHelpers.cc.

References s.

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

template<typename F , typename RT = decltype(std::declval<F>()())>

RT art::detail::resolve_if_present	(	F	f,
		std::string const &	caller,
		RT	result
	)

Definition at line 20 of file PluginSymbolResolvers.h.

References e, and f.

Referenced by getAllowedConfiguration(), getFilePath(), getType< suffix_type::module >(), getType< suffix_type::plugin >(), and getType< suffix_type::tool >().

    {
      try {
        result = f();
      }
      catch (cet::exception const& e) {
        std::cout << "In: " << caller << std::endl;
        std::cout << e.what() << std::endl;
      }
      return result;
    }

art::RangeSet art::detail::resolveRangeSet

(

RangeSetInfo const &

rs

)

Definition at line 99 of file resolveRangeSet.cc.

References art::detail::RangeSetInfo::is_invalid(), art::detail::RangeSetInfo::ranges, and art::detail::RangeSetInfo::run.

Referenced by art::RootInputTree::fillAux(), art::RootDelayedReader::getProduct_(), art::detail::InfoDumperInputFile::getRangeSet(), and resolveRangeSet().

{
  if (rsi.is_invalid()) {
    return RangeSet::invalid();
  }
  return RangeSet{rsi.run, rsi.ranges};
}

art::RangeSet art::detail::resolveRangeSet	(	sqlite3 *	db,
		std::string const &	filename,
		BranchType	bt,
		unsigned	rangeSetID,
		bool	compact
	)

Definition at line 108 of file resolveRangeSet.cc.

References resolveRangeSet(), and resolveRangeSetInfo().

{
  auto const& rsInfo =
    resolveRangeSetInfo(db, filename, bt, rangeSetID, compact);
  return resolveRangeSet(rsInfo);
}

art::detail::RangeSetInfo art::detail::resolveRangeSetInfo	(	sqlite3 *	db,
		std::string const &	filename,
		BranchType	bt,
		unsigned	RangeSetID,
		bool	compact
	)

Definition at line 50 of file resolveRangeSet.cc.

References art::BranchTypeToString(), max, and util::flags::to_string().

Referenced by art::RootInputTree::fillAux(), art::detail::InfoDumperInputFile::getRangeSet(), and resolveRangeSet().

{
  // Invalid rangeSetID check
  if (rangeSetID == std::numeric_limits<unsigned>::max())
    return RangeSetInfo::invalid();

  sqlite3_stmt* stmt{nullptr};
  std::string const run_ddl{
    "SELECT Run FROM " + BranchTypeToString(bt) +
    "RangeSets WHERE rowid==" + std::to_string(rangeSetID) + ";"};
  auto rc = sqlite3_prepare_v2(db, run_ddl.c_str(), -1, &stmt, nullptr);
  successful_prepare(rc, filename, run_ddl);

  rc = sqlite3_step(stmt);
  auto const r = static_cast<RunNumber_t>(sqlite3_column_int(stmt, 0));
  rc = sqlite3_finalize(stmt);
  successful_finalize(rc, sqlite3_errmsg(db), filename);

  std::string const result_column_begin{compact ? "min(begin)" : "begin"};
  std::string const result_column_end{compact ? "max(end)" : "end"};
  std::string const maybe_suffix{compact ? " GROUP BY SubRun" : ""};
  std::string const ddl{
    "SELECT SubRun," + result_column_begin + ',' + result_column_end +
    " FROM EventRanges WHERE rowid IN"
    "(SELECT EventRangesID FROM " +
    BranchTypeToString(bt) + "RangeSets_EventRanges WHERE RangeSetsID==" +
    std::to_string(rangeSetID) + ')' + maybe_suffix + ';'};
  rc = sqlite3_prepare_v2(db, ddl.c_str(), -1, &stmt, nullptr);
  successful_prepare(rc, filename, ddl);

  std::vector<EventRange> ranges;
  while ((rc = sqlite3_step(stmt)) == SQLITE_ROW) {
    ranges.emplace_back(sqlite3_column_int(stmt, 0),
                        sqlite3_column_int(stmt, 1),
                        sqlite3_column_int(stmt, 2));
  }
  successful_step(rc, sqlite3_errmsg(db), filename);

  rc = sqlite3_finalize(stmt);
  successful_finalize(rc, sqlite3_errmsg(db), filename);

  return RangeSetInfo{r, std::move(ranges)};
}

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

inline

Definition at line 70 of file PrintFormatting.h.

References indent0(), and w.

Referenced by print_available_plugins().

    {
      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;
    }

bool art::detail::shouldDropEvents	(	bool	dropAllEventsSet,
		bool	dropAllEvents,
		bool	dropAllSubRuns
	)

Definition at line 51 of file rootOutputConfigurationTools.cc.

References art::errors::Configuration.

Referenced by art::RootOutput::RootOutput().

{
  if (!dropAllSubRuns)
    return dropAllEvents;

  if (dropAllEventsSet && !dropAllEvents) {
    throw art::Exception(errors::Configuration)
      << "\nThe following FHiCL specification is illegal\n\n"
      << "   dropAllEvents  : false \n"
      << "   dropAllSubRuns : true  \n\n"
      << "[1] Both can be 'true', "
      << "[2] both can be 'false', or "
      << "[3] 'dropAllEvents : true' and 'dropAllSubRuns : false' "
      << "is allowed.\n\n";
  }
  return true;
}

bool art::detail::shouldFastClone	(	bool	fastCloningSet,
		bool	fastCloning,
		bool	wantAllEvents,
		ClosingCriteria const &	fileProperties
	)

Definition at line 23 of file rootOutputConfigurationTools.cc.

References art::ClosingCriteria::granularity(), and art::Granularity::InputFile.

Referenced by art::RootOutputFile::beginInputFile(), and art::RootOutput::RootOutput().

{
  bool result{fastCloning};
  mf::LogInfo("FastCloning")
    << "Initial fast cloning configuration "
    << (fastCloningSet ? "(user-set): " : "(from default): ") << std::boolalpha
    << fastCloning;

  if (fastCloning && !wantAllEvents) {
    result = false;
    mf::LogWarning("FastCloning")
      << "Fast cloning deactivated due to presence of\n"
      << "event selection configuration.";
  }
  if (fastCloning && maxCriterionSpecified(cc) &&
      cc.granularity() < Granularity::InputFile) {
    result = false;
    mf::LogWarning("FastCloning")
      << "Fast cloning deactivated due to request to allow\n"
      << "output file switching at an Event, SubRun, or Run boundary.";
  }
  return result;
}

Long64_t art::detail::sizeOnDisk

(

TTree *

t

)

Definition at line 111 of file rootFileSizeTools.cc.

References GetTotalSize().

Referenced by art::RootSizeOnDisk::fillLevel2(), printBranchSummary(), printTreeSummary(), and art::RootSizeOnDisk::RootSizeOnDisk().

{
  // Return the size on disk on this TTree.

  return GetTotalSize(t, true);
}

Long64_t art::detail::sizeOnDisk	(	TBranch *	branch,
		bool	inclusive
	)

Definition at line 119 of file rootFileSizeTools.cc.

References GetTotalSize().

{
  // Return the size on disk on this branch.
  // If 'inclusive' is true, include also the size
  // of all its sub-branches.

  return GetTotalSize(branch, true, inclusive);
}

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

Definition at line 46 of file branchNameComponentChecking.cc.

Referenced by checkBranchNameSelector().

{
  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	(	suffix_type	st,
		std::string const &	spec,
		std::string const &	key
	)

Definition at line 116 of file AllowedConfiguration.cc.

References bold_fontify(), e, get_LibraryInfoCollection(), art::errors::LogicError, and fhicl::detail::SearchAllowedConfiguration::supports_key().

Referenced by art::BasicOutputOptionsHandler::doProcessOptions(), and print_available_plugins().

{
  art::Exception e{art::errors::LogicError, "art::detail::has_key"};
  auto coll = get_LibraryInfoCollection(st, spec);
  if (coll.empty()) {
    throw e << (spec.empty() ? "[Missing specification]" : bold_fontify(spec))
            << " did not match any plugin.\n";
  } else if (coll.size() > 1ull) {
    throw e << 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;
}

void art::detail::throw_if_invalid ( std::string const &  )

inline

Definition at line 63 of file Handle.h.

Referenced by art::ValidHandle< T >::swap(), throw_if_invalid(), and art::SummedValue< T >::update().

    {}

template<typename H , typename... T>

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

Definition at line 68 of file Handle.h.

References art::disjoint_ranges(), art::errors::NullPointerError, art::overlapping_ranges(), art::range_of_validity(), art::same_ranges(), throw_if_invalid(), and fhicl::detail::atom::value().

    {
      if (!h.isValid())
        throw Exception{art::errors::NullPointerError} << msg << '\n';
      throw_if_invalid(msg, t...);
    }

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

Definition at line 6 of file throwPartnerException.cc.

References art::errors::LogicError.

Referenced by art::Assns< L, R, void >::makePartner_(), and art::Assns< L, R, D >::makePartner_().

{
  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 190 of file writeSummary.cc.

Referenced by writeSummary().

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

void art::detail::triggerReport	(	PathsInfo const &	endPathsInfo,
		PathsInfo const &	triggerPathsInfo,
		bool	wantSummary
	)

Definition at line 72 of file writeSummary.cc.

References art::PathsInfo::failedEvents(), art::PathsInfo::passedEvents(), art::PathsInfo::pathPtrs(), art::right(), art::PathsInfo::totalEvents(), and art::PathsInfo::workers().

Referenced by writeSummary().

{
  // 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 = " << tpi.totalEvents()
                         << " passed = " << tpi.passedEvents()
                         << " failed = " << tpi.failedEvents();
  if (wantSummary) {
    LogPrint("ArtSummary") << "";
    LogPrint("ArtSummary") << "TrigReport "
                           << "---------- Path   Summary ------------";
    LogPrint("ArtSummary") << "TrigReport " << right << setw(10) << "Trig Bit#"
                           << " " << right << setw(10) << "Run"
                           << " " << right << setw(10) << "Passed"
                           << " " << right << setw(10) << "Failed"
                           << " " << right << setw(10) << "Error"
                           << " "
                           << "Name";
    for (auto const& path : tpi.pathPtrs()) {
      LogPrint("ArtSummary")
        << "TrigReport " << right << setw(5) << 1 << right << setw(5)
        << path->bitPosition() << " " << right << setw(10) << path->timesRun()
        << " " << right << setw(10) << path->timesPassed() << " " << right
        << setw(10) << path->timesFailed() << " " << right << setw(10)
        << path->timesExcept() << " " << path->name();
    }
    LogPrint("ArtSummary") << "";
    LogPrint("ArtSummary") << "TrigReport "
                           << "-------End-Path   Summary ------------";
    LogPrint("ArtSummary") << "TrigReport " << right << setw(10) << "Trig Bit#"
                           << " " << right << setw(10) << "Run"
                           << " " << right << setw(10) << "Success"
                           << " " << right << setw(10) << "Error"
                           << " "
                           << "Name";
    for (auto const& path : epi.pathPtrs()) {
      LogPrint("ArtSummary")
        << "TrigReport " << right << setw(5) << 0 << right << setw(5)
        << path->bitPosition() << " " << right << setw(10) << path->timesRun()
        << " " << right << setw(10) << path->timesPassed() << " " << right
        << setw(10) << path->timesExcept() << " " << path->name();
    }
    for (auto const& path : tpi.pathPtrs()) {
      LogPrint("ArtSummary") << "";
      LogPrint("ArtSummary")
        << "TrigReport "
        << "---------- Modules in Path: " << path->name() << " ------------";
      LogPrint("ArtSummary")
        << "TrigReport " << right << setw(10) << "Trig Bit#"
        << " " << right << setw(10) << "Visited"
        << " " << right << setw(10) << "Passed"
        << " " << right << setw(10) << "Failed"
        << " " << right << setw(10) << "Error"
        << " "
        << "Name";
      workersInPathTriggerReport(1, path->bitPosition(), path->workersInPath());
    }
  }

  // Printed even if summary not requested, per issue #1864.
  for (auto const& path : epi.pathPtrs()) {
    LogPrint("ArtSummary") << "";
    LogPrint("ArtSummary") << "TrigReport "
                           << "------ Modules in End-Path: " << path->name()
                           << " ------------";
    LogPrint("ArtSummary") << "TrigReport " << right << setw(10) << "Trig Bit#"
                           << " " << right << setw(10) << "Run"
                           << " " << right << setw(10) << "Success"
                           << " " << right << setw(10) << "Error"
                           << " "
                           << "Name";
    workersInEndPathTriggerReport(
      0, path->bitPosition(), path->workersInPath());
  }

  if (wantSummary) {
    // This table can arguably be removed since all summary
    // information is better described aboved.
    LogPrint("ArtSummary") << "";
    LogPrint("ArtSummary") << "TrigReport "
                           << "---------- Module Summary ------------";
    LogPrint("ArtSummary") << "TrigReport " << right << setw(10) << "Visited"
                           << " " << right << setw(10) << "Run"
                           << " " << right << setw(10) << "Passed"
                           << " " << right << setw(10) << "Failed"
                           << " " << right << setw(10) << "Error"
                           << " "
                           << "Name";

    for (auto const& val : tpi.workers()) {
      LogPrint("ArtSummary")
        << "TrigReport " << right << setw(10) << val.second->timesVisited()
        << " " << right << setw(10) << val.second->timesRun() << " " << right
        << setw(10) << val.second->timesPassed() << " " << right << setw(10)
        << val.second->timesFailed() << " " << right << setw(10)
        << val.second->timesExcept() << " " << val.first;
    }

    for (auto const& val : epi.workers()) {
      // Instead of timesVisited(), which is confusing for the user
      // for end-path modules, we just report timesRun() as a proxy
      // for visited.
      LogPrint("ArtSummary")
        << "TrigReport " << right << setw(10) << val.second->timesVisited()
        << " " << right << setw(10) << val.second->timesRun() << " " << right
        << setw(10) << val.second->timesPassed() << " " << right << setw(10)
        << val.second->timesFailed() << " " << right << setw(10)
        << val.second->timesExcept() << " " << val.first;
    }
  }
}

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

Referenced by art::DataViewImpl::removeNonViewableMatches_().

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

Definition at line 7 of file validateFileNamePattern.cc.

References art::errors::Configuration.

Referenced by art::RootOutput::RootOutput(), and art::TFileService::TFileService().

{
  if (!do_check)
    return;

  if (!std::regex_search(pattern, std::regex("%(\\d*)#")))
    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.";
}

void art::detail::verifyFriendlyClassName

(

std::string const &

fcn

)

Definition at line 16 of file verify_names.cc.

References art::errors::LogicError.

Referenced by art::ProductRegistryHelper::produces(), and art::ProductRegistryHelper::reconstitutes().

{
  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.

References art::errors::Configuration.

Referenced by art::ProductRegistryHelper::produces(), and art::ProductRegistryHelper::reconstitutes().

{
  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 204 of file CollectionUtilities.h.

References in.

Referenced by art::flattenCollections(), and art::detail::mix_offset< cet::map_vector< P > >::offset().

{
  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 213 of file CollectionUtilities.h.

References evd::details::end().

{
  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;
}

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

Definition at line 55 of file writeSummary.cc.

References art::PathManager::endPathInfo(), memoryReport(), timeReport(), art::PathManager::triggerPathsInfo(), and triggerReport().

Referenced by art::EventProcessor::endJob().

{
  // Still only assuming one schedule. Will need to loop when we get around to
  // it.
  auto const& epi = pm.endPathInfo();
  auto const& tpi = pm.triggerPathsInfo(ScheduleID::first());
  LogPrint("ArtSummary") << "";
  triggerReport(epi, tpi, 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 27 of file ServiceHandleAllowed.h.