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

class	DataSetBroker

class	DataSetSampler

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	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_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	SamplingDelayedReader

class	SamplingInputFile

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(

using	ProductsForDataset_t = std::map< std::string, SamplingInputFile::InstanceForID_t >

using	Products_t = std::map< BranchKey, ProductsForDataset_t >

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<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<>
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<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	issue_reports (unsigned count, EventID const &id)

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)

void	dropBranch (TTree *tree, std::string const &branchName)

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)

std::tuple< RunNumber_t, SubRunNumber_t, EventNumber_t >	event_start (std::string const &str_num)

template<typename T >
T	id_for (EventID const &id)

template<>
RunID	id_for< RunID > (EventID const &id)

template<>
SubRunID	id_for< SubRunID > (EventID 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)

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

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.

using art::detail::Products_t = typedef std::map<BranchKey, ProductsForDataset_t>

Definition at line 19 of file DataSetBroker.h.

using art::detail::ProductsForDataset_t = typedef std::map<std::string, SamplingInputFile::InstanceForID_t>

Definition at line 18 of file DataSetBroker.h.

template<typename T >

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

Definition at line 498 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.

12 { FIFO, LIFO };

art::detail::SignalResponseType::LIFO

art::detail::SignalResponseType::FIFO

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

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().

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

template<typename T >

size_t art::detail::call_eventsToSkip ( T & t )

Definition at line 265 of file MixFilter.h.

     {
       return t.eventsToSkip();
     }

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

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

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

noexcept

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

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

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

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

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

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

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

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

bool art::detail::checkProcessNameSelector	(	std::string const &	processNameSelector,
		std::string &	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 cet::for_all(), and cet::sqlite::max().

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 cet::for_all(), and cet::sqlite::max().

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

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

ProductLookup_t art::detail::createProductLookups ( ProductDescriptions const & descriptions )

ViewLookup_t art::detail::createViewLookups ( ProductDescriptions const & descriptions )

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

constexpr const char* art::detail::dflt_spec_pattern ( )

Definition at line 18 of file get_LibraryInfoCollection.h.

References get_LibraryInfoCollection(), submit_syst::pattern, and copy_new_pkl_files::verbose.

Referenced by print_available_plugins().

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

void art::detail::dropBranch	(	TTree *	tree,
		std::string const &	branchName
	)

Referenced by art::RootInputTree::operator bool().

std::tuple<RunNumber_t, SubRunNumber_t, EventNumber_t> art::detail::event_start ( std::string const & str_num )

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.

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

Referenced by 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(), and stan::math::head().

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

EventRange art::detail::full_run_event_range ( )

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

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

Referenced by dflt_spec_pattern().

std::unique_ptr<MetadataCollector> art::detail::get_MetadataCollector ( suffix_type st )

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

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 makeFirstAnaHTMLDatasetPages::description, cet::LibraryManager::getSymbolByLibspec(), and 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
	)

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

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(), cet::LibraryManager::getSymbolByLibspec(), path, resolve_if_present(), and 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
	)

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

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

template<art::suffix_type >

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

Definition at line 56 of file PluginSymbolResolvers.h.

     {
       return {};
     }

template<>

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

template<>

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

template<>

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

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 )

template<typename T >

T art::detail::id_for ( EventID const & id )

template<>

RunID art::detail::id_for< RunID > ( EventID const & id )

inline

Definition at line 121 of file SamplingInputFile.h.

     {
       return id.runID();
     }

template<>

SubRunID art::detail::id_for< SubRunID > ( EventID const & id )

inline

Definition at line 128 of file SamplingInputFile.h.

     {
       return id.subRunID();
     }

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

inline

Definition at line 18 of file PrintFormatting.h.

Referenced by stan::lang::generate_indent(), stan::lang::generate_line_number(), indent0(), indent_1(), indent__2(), fhicl::detail::MaybeDisplayParent::MaybeDisplayParent(), daqdataformats::RawMilliSlice::tprintf(), and daqdataformats::VERSION_NAMESPACE::RawDataBlock::tprintf().

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

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

inline

Definition at line 23 of file PrintFormatting.h.

References indent().

Referenced by 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 cet::sqlite::max().

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

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

inline

Definition at line 21 of file IPRHelper.h.

References getGoodRuns4SAM::tag.

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 ( )

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

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

Referenced by art::SamplingInput::readEvent().

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

Referenced by art::RootOutput::doOpenFile(), art::RootOutput::finishEndFile(), and art::TFileService::maybeSwitchFiles_().

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 nd_projection_maker::ps, and T.

     {
       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=(), nd_projection_maker::ps, 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.

References runNovaSAM::args, T, and confusionMatrixTree::t.

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.

References runNovaSAM::args, and confusionMatrixTree::t.

     {
       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 ( )

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().

51 {}

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

inline

Definition at line 55 of file LinuxMallInfo.h.

References art::detail::LinuxMallInfo::minfo_.

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

std::vector<std::vector<std::string> > art::detail::orderedProcessNamesCollection ( ProcessHistoryMap const & pHistMap )

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

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

Referenced by print_available_plugins().

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(), findDuplicateFiles::key, overlay_prestage_def::matches, 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 )

Referenced by print_available_plugins().

void art::detail::print_descriptions ( std::vector< std::string > const & plugins )

Referenced by print_available_plugins().

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

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

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

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

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

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

inline

Definition at line 21 of file readFileIndex.h.

References art::FileIndex::addEntryOnLoad(), getBrightness::br, compare_h5_caf::branch, art::couldNotFindTree(), art::rootNames::fileIndexTreeName(), art::errors::FileReadError, art::input::getEntry(), and MECModelEnuComparisons::i.

     {
 
       if (auto branch = metaDataTree->GetBranch(
             rootNames::metaBranchRootName<FileIndex>())) {
         branch->SetAddress(&findexPtr);
         input::getEntry(branch, 0);
         branch->ResetAddress();
       } 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_);
         }
         {
           auto br = fileIndexTree->GetBranch(
             rootNames::metaBranchRootName<FileIndex::Element>());
           br->ResetAddress();
         }
       }
     }

template<typename T >

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

Definition at line 14 of file readMetadata.h.

References ana::assert(), compare_h5_caf::branch, art::input::getEntry(), and T.

     {
       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->ResetAddress();
       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 compare_h5_caf::branch, art::input::getEntry(), std::swap(), and T.

     {
       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->ResetAddress();
       std::swap(mdField, field);
       return true;
     }

std::regex art::detail::regex_for_spec ( std::string const & )

void art::detail::remove_whitespace ( std::string & )

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

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 om::cout, e, allTimeWatchdog::endl, MakeMiniprodValidationCuts::f, and fillBadChanDBTables::result.

Referenced by getAllowedConfiguration(), and getFilePath().

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

RangeSet art::detail::resolveRangeSet ( RangeSetInfo const & rs )

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

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

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

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

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

inline

Definition at line 70 of file PrintFormatting.h.

References indent0(), fillBadChanDBTables::result, submit_hadd::u, and w.

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

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

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

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

Long64_t art::detail::sizeOnDisk ( TTree * t )

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

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

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

Referenced by print_available_plugins().

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

inline

Definition at line 63 of file Handle.h.

References T.

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

64 {}

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 a, b, art::disjoint_ranges(), make_syst_table_plots::h, art::errors::NullPointerError, art::overlapping_ranges(), art::range_of_validity(), art::same_ranges(), T, and throw_if_invalid().

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

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

void art::detail::timeReport ( cet::cpu_timer const & timer )

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

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
	)

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

void art::detail::verifyFriendlyClassName ( std::string const & fcn )

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

void art::detail::verifyInstanceName ( std::string const & in )

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

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 febshutoff_auto::end, and MECModelEnuComparisons::i.

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

Variable Documentation

template<typename T >

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

Definition at line 25 of file ServiceHandleAllowed.h.

Namespaces

Classes

Typedefs

Enumerations

Functions

Variables

Typedef Documentation

Enumeration Type Documentation

Function Documentation

Variable Documentation