Namespaces
	actions

	compatibility

	detail

	errors

	ExceptionDetail

	fp_detail

	friendlyname

	hlt

	input

	InputSourceFactory

	productstatus

	PtrRemapperDetail

	rootNames

	stats

Classes
class	ActionTable

class	ActivityRegistry

class	AndHelper

class	Assns

class	Assns< L, R, void >

struct	AssnsNode

class	BasicOptionsHandler

class	BasicOutputOptionsHandler

class	BasicPostProcessor

class	BasicSourceOptionsHandler

class	BlockingPrescaler

class	BoolCache

class	BranchChildren

class	BranchDescription

class	BranchID

struct	BranchKey

struct	CannotGetView

class	CatalogInterface

class	ClosedRangeSetHandler

class	ClosingCriteria

struct	Compare_Run_SubRun_EventEntry

class	ComparePtrs

class	ComposedSelectorWrapper

class	const_AssnsIter

class	ConstPtrCache

class	ConsumesCollector

class	ConsumesInfo

class	DatabaseConnection

class	DataFlow

class	DebugOptionsHandler

struct	DebugTasksValue

struct	DebugValue

class	DelayedReader

struct	DoMakePartner

struct	DoNotMakePartner

struct	DoNotSetPtr

struct	DoSetPtr

class	EDAnalyzer

class	EDFilter

class	EDProducer

class	EDProduct

class	EDProductGetter

class	EmptyEvent

class	EmptyEventTimestampPlugin

class	EndPathExecutor

class	Event

class	EventAuxiliary

class	EventID

class	EventIDFilter

class	EventIDMatcher

class	EventPrincipal

struct	EventProcessHistoryID

class	EventProcessor

class	EventRange

class	EventSelector

class	ExecutionCounts

class	FileBlock

class	FileCatalog

class	FileCatalogItem

class	FileCatalogMetadata

class	FileCatalogMetadataPlugin

class	FileCatalogOptionsHandler

class	FileDumperOutput

struct	FileFormatVersion

class	FileIndex

class	FileProperties

class	FileStatsCollector

class	FileTransfer

class	FindMany

class	FindMany< ProdB, void >

class	FindManyP

class	FindManyP< ProdB, void >

class	FindOne

class	FindOne< ProdB, void >

class	FindOneP

class	FindOneP< ProdB, void >

class	FloatingPointControl

struct	FragmentSemantic

struct	FullSemantic

class	Globals

class	GlobalSignal

class	GlobalSignal< SRTYPE, ResultType(Args...)>

class	GlobalTaskGroup

class	Granularity

class	Group

class	GroupQueryResult

class	GroupSelector

class	GroupSelectorRules

class	Handle

struct	has_getView

struct	enable_if_function_exists_t< void(T::)(std::vector< void const > &), &T::getView >

struct	has_mapped_type

struct	has_mapped_type< T, std::void_t< typename T::mapped_type > >

struct	has_setPtr

struct	has_setPtr< cet::map_vector< T > >

struct	has_setPtr< std::deque< T, A > >

struct	has_setPtr< std::list< T, A > >

struct	has_setPtr< std::set< T, A > >

struct	has_setPtr< std::vector< bool, A > >

struct	has_setPtr< std::vector< T, A > >

struct	has_value_type

struct	has_value_type< T, std::void_t< typename T::value_type > >

class	Hash

class	History

class	HLTGlobalStatus

class	HLTPathStatus

struct	IDNumber

struct	IDNumber< Level::Event >

struct	IDNumber< Level::Run >

struct	IDNumber< Level::SubRun >

class	InputFileCatalog

class	InputSource

struct	InputSourceDescription

class	InputSourceMutexSentry

class	InputTag

class	InputTagListSelector

struct	key_traits

struct	key_traits< std::pair< U, V > >

struct	key_traits< std::string >

class	LocalSignal

class	LocalSignal< STYPE, ResultType(Args...)>

class	MallocOptionSetter

struct	MallocOpts

class	MatchAllSelector

struct	MaybeGetView

struct	MaybeGetView< cet::map_vector< T > >

struct	MaybeGetView< std::deque< T, A > >

struct	MaybeGetView< std::list< T, A > >

struct	MaybeGetView< std::set< T, A > >

struct	MaybeGetView< std::vector< bool, A > >

struct	MaybeGetView< std::vector< T, A > >

struct	MaybeGetView< T, std::enable_if_t< has_getView< T >::value > >

class	MaybeIncrementCounts

class	MaybeIncrementCounts< Level::Event, T >

class	MemoryTracker

class	MFStatusUpdater

struct	MinimalToolConfig

class	MixFilter

class	MixFilterTable

class	MixHelper

class	MixIOPolicy

class	MixOp

class	MixOpBase

class	Modifier

class	ModuleBase

class	ModuleContext

class	ModuleDescription

class	ModuleLabelSelector

class	NoDelayedReader

class	NotHelper

class	Observer

class	OpenRangeSetHandler

class	OptionsHandler

class	OrHelper

class	OutputFileInfo

class	OutputHandle

class	OutputModule

struct	OutputModuleDescription

class	OutputWorker

struct	ParameterSetBlob

class	Parentage

class	Path

class	PathContext

class	PathID

class	PathManager

class	PathsInfo

struct	PathSpec

class	PerScheduleContainer

class	PostCloseFileRenamer

class	Prescaler

struct	prevent_recursion

struct	prevent_recursion< Sampled< T > >

class	Principal

class	PrincipalBase

class	ProcessConfiguration

class	ProcessHistory

class	ProcessingFrame

class	ProcessingLimits

class	ProcessingOptionsHandler

class	ProcessNameSelector

class	ProcessTag

class	ProdToProdMapBuilder

class	ProducerTable

class	ProducesCollector

class	ProducingService

class	ProducingServiceSignals

class	ProductID

class	ProductInfo

class	ProductInserter

class	ProductInstanceNameSelector

class	ProductProvenance

class	ProductPtr

struct	ProductRegistry

class	ProductRegistryHelper

class	ProductRetriever

struct	ProductTable

class	ProductTables

class	ProductToken

class	Provenance

class	ProvenanceCheckerOutput

class	ProvenanceDumper

class	ProvenanceDumper< DETAIL, std::void_t< typename DETAIL::Config > >

struct	ProvenanceDumperConfig

struct	ProvenanceDumperConfig< DETAIL, std::void_t< typename DETAIL::Config > >

class	Ptr

class	PtrMaker

class	PtrRemapper

class	PtrVector

class	PtrVectorBase

class	PutHandle

class	RandomNumberGenerator

class	RandomNumberSaver

struct	RangedFragmentSemantic

class	RangeSet

class	RangeSetHandler

class	RefCore

class	ReplicatedAnalyzer

class	ReplicatedFilter

class	ReplicatedProducer

class	Results

class	ResultsAuxiliary

class	ResultsPrincipal

class	ResultsProducer

class	RNGsnapshot

class	RPManager

struct	RPParams

class	RPWorker

class	RPWorkerT

class	Run

class	RunAuxiliary

class	RunID

class	RunPrincipal

class	Sampled

struct	SampledEventInfo

struct	SampledInfo

class	Schedule

class	ScheduleContext

class	ScheduleID

class	ScheduleIteration

class	Scheduler

class	Selector

class	SelectorBase

class	SelectorByFunction

class	ServiceHandle

class	ServiceRegistry

class	ServicesManager

class	ServiceTable

class	SharedAnalyzer

class	SharedException

class	SharedFilter

class	SharedProducer

class	SortInvalidFirst

class	Source

struct	Source_generator

struct	Source_wantFileServices

class	SourceHelper

class	SourceTable

class	SubRun

class	SubRunAuxiliary

class	SubRunID

class	SubRunPrincipal

class	Suffixes

class	SummedValue

struct	SupportsView

struct	value

struct	SupportsView< T, std::enable_if_t< has_mapped_type< T >::value > >

class	thread_safe_registry_via_id

class	Timestamp

class	TimeTracker

class	ToolConfigTable

class	Tracer

class	Transient

class	TriggerNamesService

class	TriggerPathsExecutor

class	TriggerResultInserter

class	TriggerResults

class	TrivialFileDelivery

class	TrivialFileTransfer

struct	tuple_element

struct	tuple_element< I, AssnsNode< L, R, D > >

class	TypeID

class	TypeLabel

class	UpdateOutputCallbacks

class	ValidHandle

class	View

class	ViewToken

class	Worker

class	WorkerInPath

struct	WorkerParams

class	WorkerT

struct	WrappedTypeID

class	Wrapper

Typedefs
using	OptionsHandlers = std::vector< std::unique_ptr< art::OptionsHandler >>

using	ProductListUpdatedCallback = std::function< void(ProductTables const &)>

using	module_label_t = std::string

using	WorkerMap = std::map< std::string, std::unique_ptr< Worker >>

using	MixOpList = std::vector< std::unique_ptr< MixOpBase >>

template<typename PROD , typename OPROD = PROD>
using	MixFunc = std::function< bool(std::vector< PROD const * > const &, OPROD &, PtrRemapper const &)>

using	SpecProdList = std::vector< std::shared_ptr< EDProduct const >>

using	EventIDIndex = std::map< FileIndex::EntryNumber_t, EventID >

using	SubRunIDIndex = std::map< SubRunID, FileIndex::EntryNumber_t >

using	RunIDIndex = std::map< SubRunID, FileIndex::EntryNumber_t >

using	EventIDSequence = std::vector< EventID >

using	EntryNumberSequence = std::vector< FileIndex::EntryNumber_t >

using	EventAuxiliarySequence = std::vector< EventAuxiliary >

using	DataFlowDumper = ProvenanceDumper< DataFlow >

using	CountingStatistics = ExecutionCounts< stats::Visited, stats::Run, stats::Passed, stats::Failed, stats::ExceptionThrown >

using	group_ptr_t = cet::exempt_ptr< Group >

using	exception_ptr_t = std::shared_ptr< art::Exception const >

using	ProcessConfigurationRegistry = thread_safe_registry_via_id< ProcessConfigurationID, ProcessConfiguration >

using	ProcessConfigurationMap = ProcessConfigurationRegistry::collection_type

using	ProcessHistoryRegistry = thread_safe_registry_via_id< ProcessHistoryID, ProcessHistory >

using	Selections = ProductDescriptionsByID

using	SelectionsArray = std::array< Selections, NumBranchTypes >

template<typename T >
using	tool_return_type = typename detail::tool_type< T >::return_type

template<std::size_t I, typename Node >
using	tuple_element_t = typename tuple_element< I, Node >::type

using	product_typeids_t = std::map< product_metatype, TypeID >

using	ProductDescriptions = std::vector< BranchDescription >

using	ProductDescriptionsByID = std::map< ProductID, BranchDescription >

using	BranchIDList = std::vector< BranchID::value_type >

using	BranchIDLists = std::vector< BranchIDList >

template<Level L>
using	IDNumber_t = typename IDNumber< L >::type

using	EventNumber_t = IDNumber_t< Level::Event >

using	SubRunNumber_t = IDNumber_t< Level::SubRun >

using	RunNumber_t = IDNumber_t< Level::Run >

using	ParameterSetMap = std::map< fhicl::ParameterSetID, ParameterSetBlob >

using	ParentageID = Hash< ParentageType >

using	ParentageRegistry = thread_safe_registry_via_id< ParentageID, Parentage >

using	ProcessConfigurations = std::vector< ProcessConfiguration >

using	ProcessConfigurationID = Hash< ProcessConfigurationType >

using	ProcessHistoryMap = std::map< ProcessHistoryID const, ProcessHistory >

using	ProcessHistoryID = Hash< ProcessHistoryType >

using	ProductList = std::map< BranchKey, BranchDescription >

using	ProductProvenances = std::vector< ProductProvenance >

using	ProductStatus = unsigned char

using	ReleaseVersion = std::string

using	SampledRunInfo = std::map< std::string, SampledInfo< RunID >>

using	SampledSubRunInfo = std::map< std::string, SampledInfo< SubRunID >>

using	TimeValue_t = std::uint64_t

using	ProcessLookup = std::map< std::string, std::vector< ProductID >>

using	ViewLookup_t = ProcessLookup

using	TypeLabelLookup_t = std::map< TypeLabel, BranchDescription >

using	ProductLookup_t = std::map< std::string, ProcessLookup >

using	AvailableProducts_t = std::unordered_set< ProductID, ProductID::Hash >

using	Exception = cet::coded_exception< errors::ErrorCodes, ExceptionDetail::translate >

Enumerations
enum	OutputFileStatus { OutputFileStatus::Open, OutputFileStatus::Switching, OutputFileStatus::Closed }

enum	product_creation_mode { product_creation_mode::produces, product_creation_mode::reconstitutes }

enum	FileCatalogStatus { FileCatalogStatus::SUCCESS, FileCatalogStatus::NO_MORE_FILES, FileCatalogStatus::DELIVERY_ERROR, FileCatalogStatus::TRANSFER_ERROR }

enum	BranchActionType { BranchActionBegin, BranchActionEnd, BranchActionProcess }

enum	FileDisposition { FileDisposition::PENDING = -1, FileDisposition::TRANSFERRED, FileDisposition::CONSUMED, FileDisposition::SKIPPED, FileDisposition::INCOMPLETE }

enum	ServiceScope { ServiceScope::LEGACY, ServiceScope::SHARED }

enum	ModuleType { ModuleType::non_art, ModuleType::producer, ModuleType::filter, ModuleType::analyzer, ModuleType::output_module, ModuleType::producing_service }

enum	ModuleThreadingType { ModuleThreadingType::illegal, ModuleThreadingType::legacy, ModuleThreadingType::shared, ModuleThreadingType::replicated }

enum	suffix_type : std::size_t { suffix_type::module, suffix_type::plugin, suffix_type::service, suffix_type::source, suffix_type::tool, suffix_type::mfPlugin, suffix_type::mfStatsPlugin }

enum	Transition { Transition::BeginJob, Transition::EndJob, Transition::BeginFile, Transition::EndFile, Transition::BeginRun, Transition::EndRun, Transition::BeginSubRun, Transition::EndSubRun, Transition::BeginEvent, Transition::EndEvent }

enum	Verbosity { Silent = 0, Concise = 2, Normal = 5, Detailed = 10 }

enum	Direction : int { Direction::Forward = 1, Direction::Reverse = -1 }

enum	BranchType { InEvent, InSubRun, InRun, InResults, NumBranchTypes }

enum	HashedTypes { ModuleDescriptionType, ParameterSetType, ProcessHistoryType, ProcessConfigurationType, EntryDescriptionType, ParentageType }

enum	Persistable { Persistable::Yes, Persistable::No }

enum	Level { Level::Job = 0, Level::InputFile, Level::Run, Level::SubRun, Level::Event, Level::NumNestingLevels, Level::ReadyToAdvance }

enum	product_metatype { product_metatype::Normal, product_metatype::LeftRight = Normal, product_metatype::RightLeft, product_metatype::LeftRightData, product_metatype::RightLeftData }

Functions
bool	find_config (std::string const &filename, std::string const &search_path_spec, std::string &full_path)

int	run_art (int argc, char **argv, bpo::options_description &all_desc, OptionsHandlers &&handlers)

bool	is_glob (std::string const &pattern)

std::string	glob2reg (std::string pattern)

std::vector< std::vector< std::string >::const_iterator >	regexMatch (std::vector< std::string > const &strings, std::string const &pattern)

std::ostream &	operator<< (std::ostream &os, const GroupSelector &gs)

	MFSU_0_ARG_UPDATER_DEFN (PostBeginJob)

	MFSU_0_ARG_UPDATER_DEFN (PostEndJob)

	MFSU_1_ARG_UPDATER_DEFN (PostSourceConstruction)

	MFSU_1_ARG_UPDATER_DEFN (PreSourceEvent)

	MFSU_2_ARG_UPDATER_DEFN (PostSourceEvent)

	MFSU_0_ARG_UPDATER_DEFN (PreSourceSubRun)

	MFSU_1_ARG_UPDATER_DEFN (PostSourceSubRun)

	MFSU_0_ARG_UPDATER_DEFN (PreSourceRun)

	MFSU_1_ARG_UPDATER_DEFN (PostSourceRun)

	MFSU_0_ARG_UPDATER_DEFN (PreOpenFile)

	MFSU_1_ARG_UPDATER_DEFN (PostOpenFile)

	MFSU_0_ARG_UPDATER_DEFN (PreCloseFile)

	MFSU_0_ARG_UPDATER_DEFN (PostCloseFile)

	MFSU_2_ARG_UPDATER_DEFN (PreProcessEvent)

	MFSU_2_ARG_UPDATER_DEFN (PostProcessEvent)

	MFSU_1_ARG_UPDATER_DEFN (PreBeginRun)

	MFSU_1_ARG_UPDATER_DEFN (PostBeginRun)

	MFSU_2_ARG_UPDATER_DEFN (PreEndRun)

	MFSU_1_ARG_UPDATER_DEFN (PostEndRun)

	MFSU_1_ARG_UPDATER_DEFN (PreBeginSubRun)

	MFSU_1_ARG_UPDATER_DEFN (PostBeginSubRun)

	MFSU_2_ARG_UPDATER_DEFN (PreEndSubRun)

	MFSU_1_ARG_UPDATER_DEFN (PostEndSubRun)

	MFSU_1_ARG_UPDATER_DEFN (PreProcessPath)

	MFSU_2_ARG_UPDATER_DEFN (PostProcessPath)

	MFSU_1_ARG_UPDATER_DEFN (PrePathBeginRun)

	MFSU_2_ARG_UPDATER_DEFN (PostPathBeginRun)

	MFSU_1_ARG_UPDATER_DEFN (PrePathEndRun)

	MFSU_2_ARG_UPDATER_DEFN (PostPathEndRun)

	MFSU_1_ARG_UPDATER_DEFN (PrePathBeginSubRun)

	MFSU_2_ARG_UPDATER_DEFN (PostPathBeginSubRun)

	MFSU_1_ARG_UPDATER_DEFN (PrePathEndSubRun)

	MFSU_2_ARG_UPDATER_DEFN (PostPathEndSubRun)

	MFSU_1_ARG_UPDATER_DEFN (PreModuleConstruction)

	MFSU_1_ARG_UPDATER_DEFN (PostModuleConstruction)

	MFSU_2_ARG_UPDATER_DEFN (PostBeginJobWorkers)

	MFSU_1_ARG_UPDATER_DEFN (PreModuleBeginJob)

	MFSU_1_ARG_UPDATER_DEFN (PostModuleBeginJob)

	MFSU_1_ARG_UPDATER_DEFN (PreModuleEndJob)

	MFSU_1_ARG_UPDATER_DEFN (PostModuleEndJob)

	MFSU_1_ARG_UPDATER_DEFN (PreModule)

	MFSU_1_ARG_UPDATER_DEFN (PostModule)

	MFSU_1_ARG_UPDATER_DEFN (PreModuleBeginRun)

	MFSU_1_ARG_UPDATER_DEFN (PostModuleBeginRun)

	MFSU_1_ARG_UPDATER_DEFN (PreModuleEndRun)

	MFSU_1_ARG_UPDATER_DEFN (PostModuleEndRun)

	MFSU_1_ARG_UPDATER_DEFN (PreModuleBeginSubRun)

	MFSU_1_ARG_UPDATER_DEFN (PostModuleBeginSubRun)

	MFSU_1_ARG_UPDATER_DEFN (PreModuleEndSubRun)

	MFSU_1_ARG_UPDATER_DEFN (PostModuleEndSubRun)

std::ostream &	operator<< (std::ostream &os, Granularity const &b)

std::ostream &	operator<< (std::ostream &os, OutputFileStatus const ofs)

template<typename UserConfig , typename ImplicitConfig >
std::ostream &	operator<< (std::ostream &os, ProducerTable< UserConfig, ImplicitConfig > const &t)

template<>
void	EventProcessor::begin< Level::Job > ()

template<>
void	EventProcessor::begin< Level::InputFile > ()

template<>
void	EventProcessor::begin< Level::Run > ()

template<>
void	EventProcessor::begin< Level::SubRun > ()

template<>
void	EventProcessor::finalize< Level::SubRun > ()

template<>
void	EventProcessor::finalize< Level::Run > ()

template<>
void	EventProcessor::finalize< Level::InputFile > ()

template<>
void	EventProcessor::finalize< Level::Job > ()

template<>
void	EventProcessor::finalizeContainingLevels< Level::SubRun > ()

template<>
void	EventProcessor::finalizeContainingLevels< Level::Event > ()

template<>
void	EventProcessor::recordOutputModuleClosureRequests< Level::Run > ()

template<>
void	EventProcessor::recordOutputModuleClosureRequests< Level::SubRun > ()

template<>
void	EventProcessor::recordOutputModuleClosureRequests< Level::Event > ()

ostream &	operator<< (ostream &os, FileProperties const &fp)

std::ostream &	operator<< (std::ostream &, MixHelper::Mode)

RangeSet	rangeSetFor (RunPrincipal const &rp)

RangeSet	rangeSetFor (SubRunPrincipal const &srp)

template<typename T , typename P >
std::enable_if_t<!detail::range_sets_supported(P::branch_type)>	put_product_in_principal (std::unique_ptr< T > &&product, P &principal, std::string const &module_label, std::string const &instance_name={})

template<typename T , typename P >
std::enable_if_t< detail::range_sets_supported(P::branch_type)>	put_product_in_principal (std::unique_ptr< T > &&product, P &principal, std::string const &module_label, std::string const &instance_name={}, RangeSet &&rs=RangeSet::invalid())

static void	markAncestors (ProductProvenance const &iInfo, EventPrincipal &e, std::map< ProductID, bool > &oMap, std::set< ProductID > &oMapperMissing)

std::optional< GroupQueryResult >	resolve_unique_product (std::vector< cet::exempt_ptr< art::Group >> const &product_groups, art::WrappedTypeID const &wrapped)

std::vector< GroupQueryResult >	resolve_products (std::vector< cet::exempt_ptr< art::Group >> const &groups, art::TypeID const &wrapped_type)

template<class T >
void	swap (Handle< T > &a, Handle< T > &b)

template<class T >
void	swap (ValidHandle< T > &a, ValidHandle< T > &b)

template<class T >
void	convert_handle (GroupQueryResult const &, Handle< T > &)

template<class T >
std::enable_if_t< detail::is_handle_v< T >, RangeSet const & >	range_of_validity (T const &h)

template<class T , class U >
std::enable_if_t< detail::are_handles_v< T, U >, bool >	same_ranges (T const &a, U const &b)

template<class T , class U >
std::enable_if_t< detail::are_handles_v< T, U >, bool >	disjoint_ranges (T const &a, U const &b)

template<class T , class U >
std::enable_if_t< detail::are_handles_v< T, U >, bool >	overlapping_ranges (T const &a, U const &b)

void	swap (OutputHandle &a, OutputHandle &b)

bool	operator< (ProductInfo const &a, ProductInfo const &b)

ostream &	operator<< (ostream &os, ProductInfo::ConsumableType const ct)

ostream &	operator<< (ostream &os, ProductInfo const &info)

template<typename PROD >
std::ostream &	operator<< (std::ostream &os, Handle< PROD > const &h)

bool	operator== (Provenance const &a, Provenance const &b) noexcept

ostream &	operator<< (ostream &os, Provenance const &p)

template<typename A , typename B >
std::enable_if_t< is_selector< A > &&is_selector< B >, AndHelper< A, B > >	operator&& (A const &a, B const &b)

template<typename A , typename B >
std::enable_if_t< is_selector< A > &&is_selector< B >, OrHelper< A, B > >	operator\|\| (A const &a, B const &b)

template<typename A >
std::enable_if_t< is_selector< A >, NotHelper< A > >	operator! (A const &a)

template<class T , class U >
bool	same_ranges (SummedValue< T > const &a, SummedValue< U > const &b)

template<class T , class U >
bool	disjoint_ranges (SummedValue< T > const &a, SummedValue< U > const &b)

template<class T , class U >
bool	overlapping_ranges (SummedValue< T > const &a, SummedValue< U > const &b)

std::string	translateFileDeliveryStatus (FileDeliveryStatus stat)

std::string	translateFileDisposition (FileDisposition fd)

std::string	translateFileTransferStatus (FileTransferStatus stat)

constexpr bool	is_legacy (ServiceScope const scope) noexcept

constexpr bool	is_shared (ServiceScope const scope) noexcept

template<typename T >
std::ostream &	operator<< (std::ostream &os, ServiceTable< T > const &t)

template<typename CONTAINER >
void	concatContainers (CONTAINER &out, CONTAINER const &in)

template<typename COLLECTION >
void	flattenCollections (std::vector< COLLECTION const * > const &in, COLLECTION &out)

template<typename COLLECTION , typename OFFSETS >
void	flattenCollections (std::vector< COLLECTION const * > const &in, COLLECTION &out, OFFSETS &offsets)

template<typename T >
void	flattenCollections (std::vector< PtrVector< T > const * > const &in, PtrVector< T > &out)

template<typename T , typename OFFSETS >
void	flattenCollections (std::vector< PtrVector< T > const * > const &in, PtrVector< T > &out, OFFSETS &offsets)

bool	operator< (EventProcessHistoryID const &lh, EventProcessHistoryID const &rh)

std::ostream &	operator<< (std::ostream &os, ModuleDescription const &p)

bool	is_modifier (ModuleType const mt)

bool	is_observer (ModuleType const mt)

std::string	to_string (ModuleType const mt)

std::pair< std::string, std::string >	split_process_and_path_names (std::string path_spec)

PathSpec	path_spec (std::string const &path_spec)

std::vector< PathSpec >	path_specs (std::vector< std::string > const &path_spec_strs)

std::string	to_string (PathID const id)

std::string	to_string (PathSpec const &spec)

std::ostream &	operator<< (std::ostream &os, PathSpec const &spec)

auto	to_tuple (PathSpec const &spec) noexcept

bool	operator== (PathSpec const &a, PathSpec const &b)

bool	operator< (PathSpec const &a, PathSpec const &b)

void	ensureTable (fhicl::intermediate_table &table, std::string const &fhicl_spec)

void	printArtException (cet::exception const &e, char const *prog)

void	printBadAllocException (char const *prog)

void	printStdException (std::exception const &e, char const *prog)

void	printUnknownException (char const *prog)

template<typename T >
std::enable_if_t< std::is_class< T >::value, tool_return_type< T > >	make_tool (fhicl::ParameterSet const &pset)

template<typename T >
std::enable_if_t< std::is_function< T >::value, tool_return_type< T > >	make_tool (fhicl::ParameterSet const &pset, std::string const &function_tool_type)

template<typename T , typename TableConfig >
tool_return_type< T >	make_tool (TableConfig const &tc, std::string const &function_tool_type)

std::ostream &	operator<< (std::ostream &ost, const MallocOpts &opts)

std::string	parent_path (std::string const &path)

std::ostream &	operator<< (std::ostream &os, suffix_type const st)

template<typename T1 , typename T2 >
std::enable_if_t< std::is_same< T1, T2 >::value\|\|std::is_base_of< T1, T2 >::value\|\|std::is_base_of< T2, T1 >::value, bool >	pointersEqual (T1 t1, T2 t2)

template<typename T1 , typename T2 >
std::enable_if_t<!std::is_same< T1, T2 >::value &&!std::is_base_of< T1, T2 >::value &&!std::is_base_of< T2, T1 >::value, bool >	pointersEqual (T1 , T2 )

constexpr auto	fullRun ()

constexpr auto	fullSubRun ()

constexpr auto	runFragment ()

constexpr auto	subRunFragment ()

auto	runFragment (RangeSet const &rs)

auto	subRunFragment (RangeSet const &rs)

bool	operator!= (ScheduleID const left, ScheduleID const right) noexcept

bool	operator<= (ScheduleID const left, ScheduleID const right) noexcept

bool	operator> (ScheduleID const left, ScheduleID const right) noexcept

bool	operator>= (ScheduleID const left, ScheduleID const right) noexcept

ostream &	operator<< (ostream &os, ScheduleID const sid)

std::string	unique_filename (std::string stem, std::string extension=".root")

void	setupSignals (bool want_sigint_enabled)

std::string const &	getReleaseVersion ()

template<typename A , typename B , typename D , typename F >
void	for_each_group (art::Assns< A, B, D > const &assns, F func)
	Helper functions to access associations in order. More...

template<typename A , typename B , typename D , typename F >
void	for_each_group_with_left (art::Assns< A, B, D > const &assns, F func)

template<typename A , typename B , typename D , typename F >
void	for_each_pair (art::Assns< A, B, D > const &assns, F func)

template<Direction Dir>
constexpr int	signed_one ()

template<Direction Dir>
constexpr auto	index_for_dereferencing (std::size_t const i)

template<typename L , typename R , typename D , Direction Dir>
constexpr auto const &	left (const_AssnsIter< L, R, D, Dir > const &a, const_AssnsIter< L, R, D, Dir > const &b)

template<typename L , typename R , typename D , Direction Dir>
constexpr auto const &	right (const_AssnsIter< L, R, D, Dir > const &a, const_AssnsIter< L, R, D, Dir > const &b)

template<typename T , typename L , typename R , typename D >
auto const &	get (AssnsNode< L, R, D > const &r)

template<typename Collection >
void	getElementAddresses (Collection const &coll, std::type_info const &iToType, std::vector< unsigned long > const &indices, std::vector< void const * > &oPtr)

template<typename T >
void	getElementAddresses (cet::map_vector< T > const &obj, std::type_info const &iToType, std::vector< unsigned long > const &indices, std::vector< void const * > &oPtr)

ostream &	operator<< (ostream &ost, const HLTGlobalStatus &hlt)

std::ostream &	operator<< (std::ostream &ost, HLTGlobalStatus const &hlt)

template<typename H >
	ProductPtr (H) -> ProductPtr< typename H::element_type >

template<typename T , typename U >
std::enable_if_t< std::is_same_v< T, U >\|\|std::is_base_of_v< T, U >\|\|std::is_base_of_v< U, T >, bool >	operator== (ProductPtr< T > const &lhs, ProductPtr< U > const &rhs)

template<typename T , typename U >
std::enable_if_t< std::is_same_v< T, U >\|\|std::is_base_of_v< T, U >\|\|std::is_base_of_v< U, T >, bool >	operator!= (ProductPtr< T > const &lhs, ProductPtr< U > const &rhs)

template<typename T , typename U >
std::enable_if_t< std::is_same_v< T, U >\|\|std::is_base_of_v< T, U >\|\|std::is_base_of_v< U, T >, bool >	operator< (ProductPtr< T > const &lhs, ProductPtr< U > const &rhs)

template<typename T >
std::ostream &	operator<< (std::ostream &os, ProductPtr< T > const &p)

template<typename T , typename U >
std::enable_if_t< std::is_same_v< T, U >\|\|std::is_base_of_v< T, U >\|\|std::is_base_of_v< U, T >, bool >	operator== (Ptr< T > const &lhs, Ptr< U > const &rhs)

template<typename T , typename U >
std::enable_if_t< std::is_same_v< T, U >\|\|std::is_base_of_v< T, U >\|\|std::is_base_of_v< U, T >, bool >	operator!= (Ptr< T > const &lhs, Ptr< U > const &rhs)

template<typename T , typename U >
std::enable_if_t< std::is_same_v< T, U >\|\|std::is_base_of_v< T, U >\|\|std::is_base_of_v< U, T >, bool >	operator< (Ptr< T > const &lhs, Ptr< U > const &rhs)

template<typename T , typename H >
void	fill_ptr_vector (std::vector< Ptr< T >> &ptrs, H const &h)

template<typename T , typename H >
void	fill_ptr_list (std::list< Ptr< T >> &ptrs, H const &h)

template<typename T >
std::ostream &	operator<< (std::ostream &os, Ptr< T > const &p)

template<typename H , typename T >
	Ptr (H, T) -> Ptr< detail::not_map_vector_t< typename H::element_type >>

template<typename T >
void	swap (PtrVector< T > &, PtrVector< T > &)

void	swap (RefCore &lhs, RefCore &rhs)

constexpr bool	operator== (RefCore const &lhs, RefCore const &rhs) noexcept

constexpr bool	operator!= (RefCore const &lhs, RefCore const &rhs) noexcept

constexpr bool	operator< (RefCore const &lhs, RefCore const &rhs) noexcept

auto	sampled_from (std::string process_name)

template<class COLLECTION >
void	setPtr (COLLECTION const &coll, std::type_info const &iToType, unsigned long iIndex, void const *&oPtr)

template<typename T >
void	setPtr (cet::map_vector< T > const &obj, std::type_info const &iToType, unsigned long iIndex, void const *&oPtr)

template<typename T >
void const *	address_of (T const &t) noexcept

template<typename T >
void const *	address_of_second (typename cet::map_vector< T >::value_type const &t) noexcept

void	swap (TriggerResults &lhs, TriggerResults &rhs)

bool	operator< (BranchDescription const &a, BranchDescription const &b)

bool	combinable (BranchDescription const &a, BranchDescription const &b)

bool	operator== (BranchDescription const &a, BranchDescription const &b)

std::ostream &	operator<< (std::ostream &os, BranchDescription const &p)

std::ostream &	operator<< (std::ostream &os, BranchKey const &bk)

bool	operator< (BranchKey const &a, BranchKey const &b)

bool	operator== (BranchKey const &a, BranchKey const &b)

bool	operator!= (BranchKey const &a, BranchKey const &b)

std::string const &	BranchTypeToString (BranchType const bt)

std::string const &	BranchTypeToProductTreeName (BranchType const bt)

std::string const &	BranchTypeToMetaDataTreeName (BranchType const bt)

std::string const &	BranchTypeToAuxiliaryBranchName (BranchType const bt)

std::string const &	productProvenanceBranchName (BranchType const bt)

std::string const &	BranchTypeToMajorIndexName (BranchType const bt)

std::string const &	BranchTypeToMinorIndexName (BranchType const bt)

std::ostream &	operator<< (std::ostream &os, BranchType const branchType)

template<typename F >
void	for_each_branch_type (F f)

std::string	canonicalProductName (std::string const &friendlyClassName, std::string const &moduleLabel, std::string const &productInstanceName, std::string const &processName)

std::ostream &	operator<< (std::ostream &os, BranchID const &id)

std::ostream &	operator<< (std::ostream &os, EventAuxiliary const &p)

std::ostream &	operator<< (std::ostream &, const EventAuxiliary &)

std::ostream &	operator<< (std::ostream &os, EventID const &iID)

ostream &	operator<< (ostream &os, EventRange const &r)

bool	operator== (FileFormatVersion const &a, FileFormatVersion const &b)

bool	operator!= (FileFormatVersion const &a, FileFormatVersion const &b)

std::ostream &	operator<< (std::ostream &os, FileFormatVersion const &ff)

bool	operator< (FileIndex::Element const &lh, FileIndex::Element const &rh)

bool	operator> (FileIndex::Element const &lh, FileIndex::Element const &rh)

bool	operator>= (FileIndex::Element const &lh, FileIndex::Element const &rh)

bool	operator<= (FileIndex::Element const &lh, FileIndex::Element const &rh)

bool	operator== (FileIndex::Element const &lh, FileIndex::Element const &rh)

bool	operator!= (FileIndex::Element const &lh, FileIndex::Element const &rh)

bool	operator== (FileIndex const &lh, FileIndex const &rh)

bool	operator!= (FileIndex const &lh, FileIndex const &rh)

ostream &	operator<< (ostream &os, FileIndex::Element const &el)

ostream &	operator<< (ostream &os, FileIndex const &fileIndex)

template<int I>
void	swap (Hash< I > &a, Hash< I > &b)

template<int I>
std::ostream &	operator<< (std::ostream &os, Hash< I > const &h)

template<Level L = Level::Event>
constexpr bool	is_valid (IDNumber_t< L > const id) noexcept

std::ostream &	operator<< (std::ostream &os, ParameterSetBlob const &blob)

ostream &	operator<< (ostream &os, Parentage const &)

bool	operator== (Parentage const &a, Parentage const &b)

bool	operator!= (Parentage const &a, Parentage const &b)

bool	operator!= (ProcessConfiguration const &a, ProcessConfiguration const &b)

bool	operator< (ProcessConfiguration const &a, ProcessConfiguration const &b)

bool	operator== (ProcessConfiguration const &a, ProcessConfiguration const &b)

std::ostream &	operator<< (std::ostream &os, ProcessConfiguration const &pc)

void	swap (ProcessHistory &a, ProcessHistory &b)

bool	operator== (ProcessHistory const &a, ProcessHistory const &b)

bool	operator!= (ProcessHistory const &a, ProcessHistory const &b)

bool	isAncestor (ProcessHistory const &a, ProcessHistory const &b)

bool	isDescendant (ProcessHistory const &a, ProcessHistory const &b)

ostream &	operator<< (ostream &ost, ProcessHistory const &ph)

std::ostream &	operator<< (std::ostream &os, ProductID const id)

ProductDescriptions	make_product_descriptions (ProductList const &productList)

ostream &	operator<< (ostream &os, ProductProvenance const &p)

bool	operator== (ProductProvenance const &a, ProductProvenance const &b) noexcept

bool	operator!= (ProductProvenance const &a, ProductProvenance const &b) noexcept

bool	operator< (ProductProvenance const &a, ProductProvenance const &b) noexcept

bool	operator== (RangeSet const &l, RangeSet const &r)

bool	same_ranges (RangeSet const &l, RangeSet const &r)

bool	disjoint_ranges (RangeSet const &l, RangeSet const &r)

void	throw_if_not_disjoint (RunNumber_t const rn, EventRange const &left, EventRange const &right) noexcept(false)

bool	overlapping_ranges (RangeSet const &l, RangeSet const &r)

ostream &	operator<< (ostream &os, RangeSet const &rs)

std::ostream &	operator<< (std::ostream &os, ResultsAuxiliary const &p)

ostream &	operator<< (ostream &os, const RunAuxiliary &p)

std::ostream &	operator<< (std::ostream &os, art::RunID const &iID)

std::ostream &	operator<< (std::ostream &os, SampledEventInfo const &eventInfo)

ostream &	operator<< (ostream &os, SubRunAuxiliary const &p)

std::ostream &	operator<< (std::ostream &os, SubRunID const &iID)

std::string	to_iso_string_assuming_unix_epoch (Timestamp const &ts)

bool	operator< (TypeLabel const &a, TypeLabel const &b)

std::ostream &	operator<< (std::ostream &os, TypeLabel const &tl)

template<typename WANTED_POINTER , typename InputIterator >
WANTED_POINTER	ensurePointer (InputIterator it)

bool	operator!= (InputTag const &left, InputTag const &right)

void	decode (std::any const &a, InputTag &tag)

ostream &	operator<< (ostream &os, InputTag const &tag)

constexpr auto	underlying_value (Level const l) noexcept

constexpr auto	highest_level () noexcept

constexpr auto	level_up (Level const l) noexcept

constexpr auto	most_deeply_nested_level () noexcept

constexpr auto	level_down (Level const l) noexcept

constexpr bool	is_above_most_deeply_nested_level (Level const l) noexcept

constexpr bool	is_most_deeply_nested_level (Level const l) noexcept

constexpr bool	is_highest_level (Level const l) noexcept

constexpr bool	is_level_contained_by (Level const l1, Level const l2) noexcept

std::ostream &	operator<< (std::ostream &os, Level const l)

bool	operator> (TypeID const &a, TypeID const &b)

bool	operator!= (TypeID const &a, TypeID const &b)

void	swap (TypeID &left, TypeID &right)

ostream &	operator<< (ostream &os, TypeID const &tid)

string	name_of_template_arg (string const &template_instance, size_t desired_arg)

string	name_of_assns_partner (string assns_type_name)

string	name_of_assns_base (string assns_type_name)

string	name_of_unwrapped_product (string const &wrapped_name)

bool	is_instantiation_of (std::string const &type_name, std::string const &template_name)

bool	is_instantiation_of (TypeID const &tid, std::string const &template_name)

bool	is_assns (std::string const &type_name)

bool	is_assns (TypeID const &tid)

std::string	uniform_type_name (std::type_info const &tid)

std::string	uniform_type_name (std::string name)

std::string	wrappedClassName (std::string const &className)

std::string const &	getCanvasReleaseVersion ()

Variables
template<typename T >
constexpr bool	is_selector

template<typename T >
detail::SharedResource_t	SharedResource {typeid(T).name(), true}

DebugTasksValue	debugTasks

std::atomic< int >	shutdown_flag {0}

DebugValue	debugit

Detailed Description

An art event visitor component takes a reference to an art::Event object. Components with this interface will typically implement a sink or a source WCT interface.

Note, this is a Wire Cell Toolkit Interface class which depends on external types so is not kept in wire-cell-iface. See that package for in-toolkit WCT interfaces.

https://github.com/WireCell/wire-cell-iface/tree/master/inc/WireCellIface

A wcls::MainTool is a main entry point to the WCT from LS

See the WCLS_tool as the likely only implementation.

Fixme: maybe need to pick a less generic name for this tool?

Typedef Documentation

using art::AvailableProducts_t = typedef std::unordered_set<ProductID, ProductID::Hash>

Definition at line 24 of file type_aliases.h.

using art::BranchIDList = typedef std::vector<BranchID::value_type>

Definition at line 17 of file BranchIDList.h.

using art::BranchIDLists = typedef std::vector<BranchIDList>

Definition at line 18 of file BranchIDList.h.

using art::CountingStatistics = typedef ExecutionCounts<stats::Visited, stats::Run, stats::Passed, stats::Failed, stats::ExceptionThrown>

Definition at line 85 of file ExecutionCounts.h.

using art::DataFlowDumper = typedef ProvenanceDumper<DataFlow>

Definition at line 25 of file DataFlowDumper_module.cc.

using art::EntryNumberSequence = typedef std::vector<FileIndex::EntryNumber_t>

Definition at line 27 of file MixTypes.h.

using art::EventAuxiliarySequence = typedef std::vector<EventAuxiliary>

Definition at line 28 of file MixTypes.h.

using art::EventIDIndex = typedef std::map<FileIndex::EntryNumber_t, EventID>

Definition at line 23 of file MixTypes.h.

using art::EventIDSequence = typedef std::vector<EventID>

Definition at line 26 of file MixTypes.h.

using art::EventNumber_t = typedef IDNumber_t<Level::Event>

Definition at line 118 of file IDNumber.h.

using art::Exception = typedef cet::coded_exception<errors::ErrorCodes, ExceptionDetail::translate>

Definition at line 66 of file Exception.h.

using art::exception_ptr_t = typedef std::shared_ptr<art::Exception const>

Definition at line 22 of file GroupQueryResult.h.

using art::group_ptr_t = typedef cet::exempt_ptr<Group>

Definition at line 21 of file GroupQueryResult.h.

template<Level L>

using art::IDNumber_t = typedef typename IDNumber<L>::type

Definition at line 109 of file IDNumber.h.

template<typename PROD , typename OPROD = PROD>

using art::MixFunc = typedef std::function< bool(std::vector<PROD const*> const&, OPROD&, PtrRemapper const&)>

Definition at line 19 of file MixTypes.h.

using art::MixOpList = typedef std::vector<std::unique_ptr<MixOpBase>>

Definition at line 22 of file MixIOPolicy.h.

using art::module_label_t = typedef std::string

Definition at line 26 of file WorkerInPath.h.

using art::OptionsHandlers = typedef std::vector<std::unique_ptr<art::OptionsHandler>>

Definition at line 10 of file OptionsHandlers.h.

using art::ParameterSetMap = typedef std::map<fhicl::ParameterSetID, ParameterSetBlob>

Definition at line 10 of file ParameterSetMap.h.

using art::ParentageID = typedef Hash<ParentageType>

Definition at line 8 of file ParentageID.h.

using art::ParentageRegistry = typedef thread_safe_registry_via_id<ParentageID, Parentage>

Definition at line 9 of file ParentageRegistry.h.

using art::ProcessConfigurationID = typedef Hash<ProcessConfigurationType>

Definition at line 8 of file ProcessConfigurationID.h.

using art::ProcessConfigurationMap = typedef ProcessConfigurationRegistry::collection_type

Definition at line 18 of file ProcessConfigurationRegistry.h.

using art::ProcessConfigurationRegistry = typedef thread_safe_registry_via_id<ProcessConfigurationID, ProcessConfiguration>

Definition at line 17 of file ProcessConfigurationRegistry.h.

using art::ProcessConfigurations = typedef std::vector<ProcessConfiguration>

Definition at line 49 of file ProcessConfiguration.h.

using art::ProcessHistoryID = typedef Hash<ProcessHistoryType>

Definition at line 8 of file ProcessHistoryID.h.

using art::ProcessHistoryMap = typedef std::map<ProcessHistoryID const, ProcessHistory>

Definition at line 143 of file ProcessHistory.h.

using art::ProcessHistoryRegistry = typedef thread_safe_registry_via_id<ProcessHistoryID, ProcessHistory>

Definition at line 23 of file ProcessHistoryRegistry.h.

using art::ProcessLookup = typedef std::map<std::string, std::vector<ProductID>>

Definition at line 17 of file type_aliases.h.

using art::product_typeids_t = typedef std::map<product_metatype, TypeID>

Definition at line 10 of file types.h.

using art::ProductDescriptions = typedef std::vector<BranchDescription>

Definition at line 289 of file BranchDescription.h.

using art::ProductDescriptionsByID = typedef std::map<ProductID, BranchDescription>

Definition at line 290 of file BranchDescription.h.

using art::ProductList = typedef std::map<BranchKey, BranchDescription>

Definition at line 15 of file ProductList.h.

using art::ProductListUpdatedCallback = typedef std::function<void(ProductTables const&)>

Definition at line 54 of file UpdateOutputCallbacks.h.

using art::ProductLookup_t = typedef std::map<std::string, ProcessLookup>

Definition at line 23 of file type_aliases.h.

using art::ProductProvenances = typedef std::vector<ProductProvenance>

Definition at line 53 of file ProductProvenance.h.

using art::ProductStatus = typedef unsigned char

Definition at line 6 of file ProductStatus.h.

using art::ReleaseVersion = typedef std::string

Definition at line 7 of file ReleaseVersion.h.

using art::RunIDIndex = typedef std::map<SubRunID, FileIndex::EntryNumber_t>

Definition at line 25 of file MixTypes.h.

using art::RunNumber_t = typedef IDNumber_t<Level::Run>

Definition at line 120 of file IDNumber.h.

using art::SampledRunInfo = typedef std::map<std::string, SampledInfo<RunID>>

Definition at line 38 of file SampledInfo.h.

using art::SampledSubRunInfo = typedef std::map<std::string, SampledInfo<SubRunID>>

Definition at line 39 of file SampledInfo.h.

using art::Selections = typedef ProductDescriptionsByID

Definition at line 11 of file Selections.h.

using art::SelectionsArray = typedef std::array<Selections, NumBranchTypes>

Definition at line 12 of file Selections.h.

using art::SpecProdList = typedef std::vector<std::shared_ptr<EDProduct const>>

Definition at line 21 of file MixTypes.h.

using art::SubRunIDIndex = typedef std::map<SubRunID, FileIndex::EntryNumber_t>

Definition at line 24 of file MixTypes.h.

using art::SubRunNumber_t = typedef IDNumber_t<Level::SubRun>

Definition at line 119 of file IDNumber.h.

using art::TimeValue_t = typedef std::uint64_t

Definition at line 8 of file Timestamp.h.

template<typename T >

using art::tool_return_type = typedef typename detail::tool_type<T>::return_type

Definition at line 14 of file make_tool.h.

template<std::size_t I, typename Node >

using art::tuple_element_t = typedef typename tuple_element<I, Node>::type

Definition at line 56 of file AssnsNode.h.

using art::TypeLabelLookup_t = typedef std::map<TypeLabel, BranchDescription>

Definition at line 20 of file type_aliases.h.

using art::ViewLookup_t = typedef ProcessLookup

Definition at line 18 of file type_aliases.h.

using art::WorkerMap = typedef std::map<std::string, std::unique_ptr<Worker>>

Definition at line 11 of file WorkerMap.h.

Enumeration Type Documentation

enum art::BranchActionType

Enumerator
BranchActionBegin
BranchActionEnd
BranchActionProcess

Definition at line 7 of file BranchActionType.h.

                         {
     BranchActionBegin,  // 0
     BranchActionEnd,    // 1
     BranchActionProcess // 2
   };

enum art::BranchType

Enumerator
InEvent
InSubRun
InRun
InResults
NumBranchTypes

Definition at line 20 of file BranchType.h.

20 { InEvent, InSubRun, InRun, InResults, NumBranchTypes };

art::NumBranchTypes

Definition: BranchType.h:20

art::InResults

Definition: BranchType.h:20

art::InEvent

Definition: BranchType.h:20

art::InSubRun

Definition: BranchType.h:20

art::InRun

Definition: BranchType.h:20

enum art::Direction : int

strong

Enumerator
Forward
Reverse

Definition at line 12 of file types.h.

12 : int { Forward = 1, Reverse = -1 };

art::Direction::Forward

tca::Reverse

void Reverse(PFPStruct &pfp)

Definition: PFPUtils.cxx:2354

enum art::FileCatalogStatus

strong

Enumerator
SUCCESS
NO_MORE_FILES
DELIVERY_ERROR
TRANSFER_ERROR

Definition at line 23 of file InputFileCatalog.h.

                                {
     SUCCESS,
     NO_MORE_FILES,
     DELIVERY_ERROR,
     TRANSFER_ERROR
   };

enum art::FileDisposition

strong

Enumerator
PENDING
TRANSFERRED
CONSUMED
SKIPPED
INCOMPLETE

Definition at line 14 of file FileDisposition.h.

                               {
   PENDING = -1,
   TRANSFERRED,
   CONSUMED,
   SKIPPED,
   INCOMPLETE
 };

enum art::HashedTypes

Enumerator
ModuleDescriptionType
ParameterSetType
ProcessHistoryType
ProcessConfigurationType
EntryDescriptionType
ParentageType

Definition at line 11 of file HashedTypes.h.

                    {
     ModuleDescriptionType, // Obsolete
     ParameterSetType,
     ProcessHistoryType,
     ProcessConfigurationType,
     EntryDescriptionType, // Obsolete
     ParentageType
   };

enum art::Level

strong

Enumerator
Job
InputFile
Run
SubRun
Event
NumNestingLevels
ReadyToAdvance

Definition at line 13 of file Level.h.

                    {
     Job = 0,
     InputFile,
     Run,
     SubRun,
     Event,
     NumNestingLevels,
     ReadyToAdvance
   };

enum art::ModuleThreadingType

strong

Enumerator
illegal
legacy
shared
replicated

Definition at line 19 of file ModuleType.h.

19 { illegal, legacy, shared, replicated };

art::ModuleThreadingType::illegal

art::ModuleThreadingType::legacy

art::ModuleThreadingType::shared

art::ModuleThreadingType::replicated

enum art::ModuleType

strong

Enumerator
non_art
producer
filter
analyzer
output_module
producing_service

Definition at line 11 of file ModuleType.h.

                         {
     non_art,
     producer,
     filter,
     analyzer,
     output_module,
     producing_service
   };

enum art::OutputFileStatus

strong

Enumerator
Open
Switching
Closed

Definition at line 8 of file OutputFileStatus.h.

8 { Open, Switching, Closed };

art::OutputFileStatus::Open

art::OutputFileStatus::Switching

art::OutputFileStatus::Closed

enum art::Persistable

strong

Enumerator
Yes
No

Definition at line 5 of file Persistable.h.

5 { Yes, No };

art::Persistable::Yes

art::Persistable::No

enum art::product_creation_mode

strong

Enumerator
produces
reconstitutes

Definition at line 38 of file ProductRegistryHelper.h.

38 { produces, reconstitutes };

art::product_creation_mode::produces

art::product_creation_mode::reconstitutes

enum art::product_metatype

strong

Enumerator
Normal
LeftRight
RightLeft
LeftRightData
RightLeftData

Definition at line 5 of file product_metatype.h.

                               {
     Normal,
     LeftRight = Normal,
     RightLeft,
     LeftRightData,
     RightLeftData
   };

enum art::ServiceScope

strong

Enumerator
LEGACY
SHARED

Definition at line 7 of file ServiceScope.h.

7 { LEGACY, SHARED };

art::ServiceScope::SHARED

art::ServiceScope::LEGACY

enum art::suffix_type : std::size_t

strong

Enumerator
module
plugin
service
source
tool
mfPlugin
mfStatsPlugin

Definition at line 59 of file PluginSuffixes.h.

                          : std::size_t {
     module,
     plugin,
     service,
     source,
     tool,
     mfPlugin,
     mfStatsPlugin
   };

enum art::Transition

strong

Enumerator
BeginJob
EndJob
BeginFile
EndFile
BeginRun
EndRun
BeginSubRun
EndSubRun
BeginEvent
EndEvent

Definition at line 7 of file Transition.h.

enum art::Verbosity

Enumerator
Silent
Concise
Normal
Detailed

Definition at line 5 of file Verbosity.h.

5 { Silent = 0, Concise = 2, Normal = 5, Detailed = 10 };

art::Detailed

Definition: Verbosity.h:5

art::Concise

Definition: Verbosity.h:5

art::Normal

Definition: Verbosity.h:5

art::Silent

Definition: Verbosity.h:5

Function Documentation

template<typename T >

void const* art::address_of ( T const & t )

noexcept

Definition at line 123 of file traits.h.

   {
     return &t;
   }

template<typename T >

void const* art::address_of_second ( typename cet::map_vector< T >::value_type const & t )

noexcept

Definition at line 130 of file traits.h.

   {
     return &t.second;
   }

std::string const & art::BranchTypeToAuxiliaryBranchName ( BranchType const bt )

Definition at line 83 of file BranchType.cc.

   {
     return select(
       bt,
       {&eventAuxiliary, &subRunAuxiliary, &runAuxiliary, &resultsAuxiliary});
   }

std::string const & art::BranchTypeToMajorIndexName ( BranchType const bt )

Definition at line 101 of file BranchType.cc.

   {
     return select(bt, {&eventMajorIndex, &subRunMajorIndex, &runMajorIndex});
   }

std::string const & art::BranchTypeToMetaDataTreeName ( BranchType const bt )

Definition at line 77 of file BranchType.cc.

   {
     return select(bt, {&eventMeta, &subRunMeta, &runMeta, &resultsMeta});
   }

std::string const & art::BranchTypeToMinorIndexName ( BranchType const bt )

Definition at line 107 of file BranchType.cc.

   {
     return select(bt, {&eventMinorIndex, &subRunMinorIndex, &runMinorIndex});
   }

std::string const & art::BranchTypeToProductTreeName ( BranchType const bt )

Definition at line 71 of file BranchType.cc.

   {
     return select(bt, {&events, &subRuns, &runs, &resultsTree});
   }

std::string const & art::BranchTypeToString ( BranchType const bt )

Definition at line 65 of file BranchType.cc.

Referenced by art::ConsumesInfo::assemble_consumes_statement(), operator<<(), and art::FileDumperOutput::printPrincipal().

   {
     return select(bt, {&event, &subRun, &run, &results});
   }

std::string art::canonicalProductName	(	std::string const &	friendlyClassName,
		std::string const &	moduleLabel,
		std::string const &	productInstanceName,
		std::string const &	processName
	)

Definition at line 9 of file canonicalProductName.cc.

Referenced by art::BranchKey::branchName(), art::BranchDescription::fluffTransients_(), art::ProductInserter::getProductDescription_(), art::ProductRetriever::getProductID_(), art::ProductID::invalid(), art::MixOp< Prod, OProd >::outgoingProductID(), and put_product_in_principal().

 {
   std::string result;
   result.reserve(friendlyClassName.size() + moduleLabel.size() +
                  productInstanceName.size() + processName.size() + 4);
   result += friendlyClassName;
   result += underscore;
   result += moduleLabel;
   result += underscore;
   result += productInstanceName;
   result += underscore;
   result += processName;
   result += period;
   // It is *absolutely* needed to have the trailing period on the branch
   // name, as this gives instruction to ROOT to split this branch in the
   // modern (v4+) way vs the old way (v3-).
 
   return result;
 }

bool art::combinable	(	BranchDescription const &	a,
		BranchDescription const &	b
	)

Definition at line 315 of file BranchDescription.cc.

References art::BranchDescription::branchType(), art::BranchDescription::friendlyClassName(), art::BranchDescription::moduleLabel(), art::BranchDescription::processName(), art::BranchDescription::producedClassName(), art::BranchDescription::productID(), and art::BranchDescription::productInstanceName().

Referenced by art::OutputModule::doSelectProducts(), and art::Principal::fillGroup().

   {
     return (a.branchType() == b.branchType()) &&
            (a.processName() == b.processName()) &&
            (a.producedClassName() == b.producedClassName()) &&
            (a.friendlyClassName() == b.friendlyClassName()) &&
            (a.productInstanceName() == b.productInstanceName()) &&
            (a.moduleLabel() == b.moduleLabel()) &&
            (a.productID() == b.productID());
   }

template<typename CONTAINER >

void art::concatContainers	(	CONTAINER &	out,
		CONTAINER const &	in
	)

Definition at line 254 of file CollectionUtilities.h.

References art::detail::TwoArgInsert< CONTAINER >::concatenate().

Referenced by flattenCollections().

 {
   if constexpr (detail::has_two_arg_insert<CONTAINER>::value) {
     detail::TwoArgInsert<CONTAINER>::concatenate(out, in);
   } else {
     static_assert(detail::has_three_arg_insert<CONTAINER>);
     out.insert(out.end(), in.begin(), in.end());
   }
 }

template<class T >

void art::convert_handle	(	GroupQueryResult const &	orig,
		Handle< T > &	result
	)

Definition at line 280 of file Handle.h.

References art::Handle< T >::swap().

 {
   Handle<T> h{orig};
   result.swap(h);
 }

void art::decode	(	std::any const &	a,
		InputTag &	tag
	)

Definition at line 117 of file InputTag.cc.

References fhicl::detail::decode(), fhicl::detail::is_sequence(), and tmp.

   {
     if (fhicl::detail::is_sequence(a)) {
       vector<string> tmp;
       fhicl::detail::decode(a, tmp);
       if (tmp.size() == 2) {
         tag = {tmp[0], tmp[1]};
       } else if (tmp.size() == 3) {
         tag = {tmp[0], tmp[1], tmp[2]};
       } else {
         ostringstream errmsg;
         errmsg << "When converting to InputTag by a sequence, FHiCL entries "
                   "must follow the convention:\n\n"
                << "  [ label, instance ], or\n"
                << "  [ label, instance, process_name ].\n\n";
         errmsg << "FHiCL entries provided: [ ";
         for (auto ca = tmp.begin(); ca != tmp.cend(); ++ca) {
           errmsg << *ca;
           if (ca != tmp.cend() - 1) {
             errmsg << ", ";
           }
         }
         errmsg << " ]";
         throw length_error(errmsg.str());
       }
     } else {
       string tmp;
       fhicl::detail::decode(a, tmp);
       tag = tmp;
     }
   }

template<class T , class U >

std::enable_if_t<detail::are_handles_v<T, U>, bool> art::disjoint_ranges	(	T const &	a,
		U const &	b
	)

Referenced by disjoint_ranges(), art::RangeSet::emplace_range(), overlapping_ranges(), art::ValidHandle< T >::productGetter(), art::detail::throw_if_invalid(), and art::SummedValue< sumdata::POTSummary >::update_impl().

template<class T , class U >

bool art::disjoint_ranges	(	SummedValue< T > const &	a,
		SummedValue< U > const &	b
	)

Definition at line 193 of file SummedValue.h.

References disjoint_ranges(), and art::SummedValue< T >::rangeOfValidity().

   {
     return disjoint_ranges(a.rangeOfValidity(), b.rangeOfValidity());
   }

bool art::disjoint_ranges	(	RangeSet const &	l,
		RangeSet const &	r
	)

Definition at line 414 of file RangeSet.cc.

References art::RangeSet::collapse(), art::RangeSet::empty(), art::RangeSet::has_disjoint_ranges(), art::RangeSet::is_valid(), art::RangeSet::ranges(), and art::RangeSet::run().

   {
     if (!(l.is_valid() && r.is_valid())) {
       return false;
     }
     if (!l.has_disjoint_ranges() || !r.has_disjoint_ranges())
       return false;
 
     if (l.run() != r.run())
       return true;
 
     // If we get here, the run numbers of both ranges are guaranteed to
     // be the same.
 
     // Empty RangeSets are disjoint wrt. other RangeSets.  Must handle
     // this case separately than l == r case.
     if (l.empty() || r.empty())
       return true;
 
     // If we get this far, then neither RangeSet is empty.
     if (l == r)
       return false;
 
     RangeSet ltmp{l};
     RangeSet rtmp{r};
     auto const& lranges = ltmp.collapse().ranges();
     auto const& rranges = rtmp.collapse().ranges();
 
     std::vector<EventRange> merged;
     std::merge(lranges.begin(),
                lranges.end(),
                rranges.begin(),
                rranges.end(),
                back_inserter(merged));
 
     return disjoint(merged);
   }

template<typename WANTED_POINTER , typename InputIterator >

WANTED_POINTER art::ensurePointer ( InputIterator it )

inline

Definition at line 77 of file ensurePointer.h.

References art::errors::LogicError.

Referenced by art::detail::IPRHelper< ProdA, ProdB, Data, DATACOLL, EVENT >::operator()().

     {
   static_assert(std::is_pointer_v<WANTED_POINTER>,
                 "Supplied template argument is not a pointer.");
   return detail::EnsurePointer<
     WANTED_POINTER,
     typename std::iterator_traits<InputIterator>::value_type>{}(*it);
 }
 catch (std::bad_cast&) {
   throw Exception(errors::LogicError, "ensurePointer")
     << "Iterator value type "
     << cet::demangle_symbol(
          typeid(typename std::iterator_traits<InputIterator>::value_type)
            .name())
     << " and wanted pointer type "
     << cet::demangle_symbol(typeid(WANTED_POINTER).name())
     << " are incompatible.\n";
 }

void art::ensureTable	(	fhicl::intermediate_table &	table,
		std::string const &	fhicl_spec
	)

Definition at line 6 of file ensureTable.cc.

References fhicl::intermediate_table::exists(), and fhicl::intermediate_table::putEmptyTable().

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

 {
   if (!table.exists(name)) {
     table.putEmptyTable(name);
   }
 }

template<>

void art::EventProcessor::begin< Level::InputFile > ( )

inline

Definition at line 294 of file EventProcessor.cc.

References art::EventProcessor::openInputFile().

   {
     openInputFile();
   }

template<>

void art::EventProcessor::begin< Level::Job > ( )

inline

Definition at line 286 of file EventProcessor.cc.

References art::EventProcessor::beginJob(), and art::EventProcessor::timer_.

   {
     timer_->start();
     beginJob();
   }

template<>

void art::EventProcessor::begin< Level::Run > ( )

Definition at line 301 of file EventProcessor.cc.

References art::EventProcessor::beginRun(), art::EventProcessor::finalizeRunEnabled_, art::EventProcessor::handleEmptyRuns_, and art::EventProcessor::readRun().

   {
     readRun();
 
     // We only enable run finalization if reading was successful.
     // This appears to be a design weakness.
     finalizeRunEnabled_ = true;
     if (handleEmptyRuns_) {
       beginRun();
     }
   }

template<>

void art::EventProcessor::begin< Level::SubRun > ( )

Definition at line 315 of file EventProcessor.cc.

References art::EventProcessor::beginRunIfNotDoneAlready(), art::EventProcessor::beginSubRun(), art::EventProcessor::finalizeSubRunEnabled_, art::EventProcessor::handleEmptySubRuns_, art::EventProcessor::readSubRun(), and art::EventProcessor::runPrincipal_.

   {
     assert(runPrincipal_);
     assert(runPrincipal_->runID().isValid());
     readSubRun();
 
     // We only enable subrun finalization if reading was successful.
     // This appears to be a design weakness.
     finalizeSubRunEnabled_ = true;
     if (handleEmptySubRuns_) {
       beginRunIfNotDoneAlready();
       beginSubRun();
     }
   }

template<>

void art::EventProcessor::finalize< Level::InputFile > ( )

Definition at line 376 of file EventProcessor.cc.

References art::EventProcessor::closeAllFiles(), art::EventProcessor::closeInputFile(), Job, and art::EventProcessor::nextLevel_.

   {
     if (nextLevel_.load() == Level::Job) {
       closeAllFiles();
     } else {
       closeInputFile();
     }
   }

template<>

void art::EventProcessor::finalize< Level::Job > ( )

Definition at line 387 of file EventProcessor.cc.

References art::EventProcessor::endJob(), and art::EventProcessor::timer_.

   {
     endJob();
     timer_->stop();
   }

template<>

void art::EventProcessor::finalize< Level::Run > ( )

Definition at line 354 of file EventProcessor.cc.

References art::EventProcessor::beginRunCalled_, art::EventProcessor::endRun(), art::EventProcessor::finalizeRunEnabled_, art::EventProcessor::openSomeOutputFiles(), art::EventProcessor::runPrincipal_, art::EventProcessor::setRunAuxiliaryRangeSetID(), and art::EventProcessor::writeRun().

   {
     if (!finalizeRunEnabled_) {
       return;
     }
 
     assert(runPrincipal_);
     if (runPrincipal_->runID().isFlush()) {
       return;
     }
 
     openSomeOutputFiles();
     setRunAuxiliaryRangeSetID();
     if (beginRunCalled_) {
       endRun();
     }
     writeRun();
     finalizeRunEnabled_ = false;
   }

template<>

void art::EventProcessor::finalize< Level::SubRun > ( )

Definition at line 332 of file EventProcessor.cc.

References art::EventProcessor::beginSubRunCalled_, art::EventProcessor::endSubRun(), art::EventProcessor::finalizeSubRunEnabled_, art::EventProcessor::openSomeOutputFiles(), art::EventProcessor::setSubRunAuxiliaryRangeSetID(), art::EventProcessor::subRunPrincipal_, and art::EventProcessor::writeSubRun().

   {
     if (!finalizeSubRunEnabled_) {
       return;
     }
 
     assert(subRunPrincipal_);
     if (subRunPrincipal_->subRunID().isFlush()) {
       return;
     }
 
     openSomeOutputFiles();
     setSubRunAuxiliaryRangeSetID();
     if (beginSubRunCalled_) {
       endSubRun();
     }
     writeSubRun();
     finalizeSubRunEnabled_ = false;
   }

template<>

void art::EventProcessor::finalizeContainingLevels< Level::Event > ( )

Definition at line 402 of file EventProcessor.cc.

   {
     finalize<Level::SubRun>();
     finalize<Level::Run>();
   }

template<>

void art::EventProcessor::finalizeContainingLevels< Level::SubRun > ( )

Definition at line 395 of file EventProcessor.cc.

   {
     finalize<Level::Run>();
   }

template<>

void art::EventProcessor::recordOutputModuleClosureRequests< Level::Event > ( )

Definition at line 424 of file EventProcessor.cc.

References art::Granularity::Event, art::EventProcessor::main_schedule(), and art::Schedule::recordOutputClosureRequests().

   {
     main_schedule().recordOutputClosureRequests(Granularity::Event);
   }

template<>

void art::EventProcessor::recordOutputModuleClosureRequests< Level::Run > ( )

Definition at line 410 of file EventProcessor.cc.

References art::EventProcessor::main_schedule(), art::Schedule::recordOutputClosureRequests(), and art::Granularity::Run.

   {
     main_schedule().recordOutputClosureRequests(Granularity::Run);
   }

template<>

void art::EventProcessor::recordOutputModuleClosureRequests< Level::SubRun > ( )

Definition at line 417 of file EventProcessor.cc.

References art::EventProcessor::main_schedule(), art::Schedule::recordOutputClosureRequests(), and art::Granularity::SubRun.

   {
     main_schedule().recordOutputClosureRequests(Granularity::SubRun);
   }

template<typename T , typename H >

void art::fill_ptr_list	(	std::list< Ptr< T >> &	ptrs,
		H const &	h
	)

Definition at line 316 of file Ptr.h.

   {
     for (std::size_t i = 0, sz = h->size(); i != sz; ++i) {
       ptrs.emplace_back(h, i);
     }
   }

template<typename T , typename H >

void art::fill_ptr_vector	(	std::vector< Ptr< T >> &	ptrs,
		H const &	h
	)

Definition at line 306 of file Ptr.h.

   {
     for (std::size_t i = 0, sz = h->size(); i != sz; ++i) {
       ptrs.emplace_back(h, i);
     }
   }

bool art::find_config	(	std::string const &	filename,
		std::string const &	search_path_spec,
		std::string &	full_path
	)

Definition at line 13 of file find_config.cc.

References e.

 {
   try {
     cet::search_path sp(search_path_spec);
     if (!sp.find_file(filename, full_path)) {
       return false;
     }
   }
   catch (cet::exception const& e) {
     if (e.root_cause() == "getenv") {
       // Assume file is findable as specified.
       full_path = filename;
     } else {
       throw;
     }
   }
   return true;
 }

template<typename COLLECTION >

void art::flattenCollections	(	std::vector< COLLECTION const * > const &	in,
		COLLECTION &	out
	)

Definition at line 267 of file CollectionUtilities.h.

References concatContainers().

 {
   typename COLLECTION::size_type total_size = 0;
   for (auto collptr : in) {
     if (collptr != nullptr) {
       total_size += collptr->size();
     }
   }
   out.reserve(total_size);
   for (auto collptr : in) {
     if (collptr != nullptr) {
       concatContainers(out, *collptr);
     }
   }
 }

template<typename COLLECTION , typename OFFSETS >

void art::flattenCollections	(	std::vector< COLLECTION const * > const &	in,
		COLLECTION &	out,
		OFFSETS &	offsets
	)

Definition at line 287 of file CollectionUtilities.h.

References in, and art::detail::mix_offset< C >::offset().

 {
   offsets.clear();
   offsets.reserve(in.size());
   typename COLLECTION::size_type current_offset{};
   for (auto collptr : in) {
     if (collptr == nullptr)
       continue;
 
     auto const delta = detail::mix_offset<COLLECTION>::offset(*collptr);
     offsets.push_back(current_offset);
     current_offset += delta;
   }
   flattenCollections<COLLECTION>(in, out); // 1.
 }

template<typename T >

void art::flattenCollections	(	std::vector< PtrVector< T > const * > const &	in,
		PtrVector< T > &	out
	)

Definition at line 308 of file CollectionUtilities.h.

References in, art::errors::LogicError, and art::detail::verifyPtrCollection().

 {
   // Extra checks are required to verify that the PtrVectors are
   // compatible.
   if (!detail::verifyPtrCollection(in)) {
     throw Exception(errors::LogicError)
       << "Attempt to flatten incompatible PtrVectors "
       << "referring to different ProductIDs.\n";
   }
   flattenCollections<PtrVector<T>>(in, out); // 1
 }

template<typename T , typename OFFSETS >

void art::flattenCollections	(	std::vector< PtrVector< T > const * > const &	in,
		PtrVector< T > &	out,
		OFFSETS &	offsets
	)

Definition at line 324 of file CollectionUtilities.h.

References in, art::errors::LogicError, and art::detail::verifyPtrCollection().

 {
   // Extra checks are required to verify that the PtrVectors are
   // compatible.
   if (!detail::verifyPtrCollection(in)) {
     throw Exception(errors::LogicError)
       << "Attempt to flatten incompatible PtrVectors "
       << "referring to different ProductIDs.\n";
   }
   flattenCollections<PtrVector<T>>(in, out, offsets); // 2.
 }

template<typename F >

void art::for_each_branch_type ( F f )

Definition at line 38 of file BranchType.h.

References f, InEvent, and NumBranchTypes.

Referenced by art::OutputModule::doSelectProducts(), art::ProducesCollector::fillDescriptions(), and art::ProductRegistryHelper::registerProducts().

   {
     for (std::underlying_type<BranchType>::type i{InEvent}; i < NumBranchTypes;
          ++i) {
       auto const bt = static_cast<BranchType>(i);
       f(bt);
     }
   }

template<typename A , typename B , typename D , typename F >

void art::for_each_group	(	art::Assns< A, B, D > const &	assns,
		F	func
	)

Helper functions to access associations in order.

Template Parameters

A	type of association being read
F	type of functor to be called on each associated group

Parameters

assns	the association being read
func	functor to be called on each associated group

This function takes two input arguments, a constant reference to the association data product itself (assns), and the function (func) to be operated on each of the group of associated objects. This function represents the association data product as a range of ranges representing the right hand side in the collection, hence the function provided as the second argument should assume that it will be operating on a range of art::Ptr to the associated data products grouped by the data product they are associated with.

Example: assuming that a module with input tag stored in fTrackTag has created associations of each track to its hits, the total charge for each track can be extracted by:

auto assns = art::getValidHandle<art::Assns<recob::Track, recob::Hit>>
  (fTrackTag);
std::vector<double> totalCharge;
art::for_each_group(*assns,
  [&totalCharge](auto hits)
    {
      double total = 0.;
      for (auto iHit = begin(hits); iHit != end(hits); ++iHit)
        total += (*iHit)->Integral();
      totalCharge.push_back(total);
    }
  );

A number of important points need to be realised about this example:

the requirements of this function translate, for this example, into:
- at the creation of the associations data product, for each track the complete sequence of hits must be associated, one hit after the other (via addSingle); if the order of the hits is relevant (it is not in this specific example), hits must be associated in that order
- each track must have at least one associated hit;
- the original association has to be stored with recob::Track as left key and recob::Hit as right key;
we use here a lambda function as func; any object behaving as a function and able to accept the range of hits as its only argument will work just as well;
func will be called once for every track (but if a track has no associated hit, that track will be skipped, and if a track appears in more than one association sequence, like in (T1,H1) (T1,H2) (T2,H4) (T1,H3), then that track will appear as many times);
func does not return any value: the results are accumulated in a new sequence;
func receives a range of art pointers (art::Ptr<recob::Hit>) which needs to be navigated with the begin()/end() free functions (don't specify their namespace: C++ will figure out!); double dereferencing is needed: the first (*iHit) will turn the range iterator into the pointed art::Ptr<recob::Hit>, and the second ((...)->Integral()) accesses the recob::Hit pointed by the art pointer;
func does not know which track the hits are associated to, and it assumes that the first sequence of hits is associated to the first track (so that its total charge will be available in totalCharge[0]), the second sequence to the second track (totalCharge[1]) and so on.

Therefore, for a assns sequence like

(T1,H1) (T1,H2) (T2,H4) (T2,H6) (T1,H5)

the function for_each_group() will execute two calls:

func({ H1, H2 })
func({ H4, H6, H5 })

dealing with the hits associated to T1 first, and T2 next.

Definition at line 111 of file AssnsAlgorithms.h.

References a1, a2, and util::values().

Referenced by util::for_each_associated_group().

   {
     ::ranges::for_each(assns | ::ranges::views::all |
                          ::ranges::views::chunk_by([](auto a1, auto a2) {
                            return a1.first == a2.first;
                          }) |
                          ::ranges::views::transform([](auto pairs) {
                            return pairs | ::ranges::views::values;
                          }),
                        func);
   }

template<typename A , typename B , typename D , typename F >

void art::for_each_group_with_left	(	art::Assns< A, B, D > const &	assns,
		F	func
	)

Definition at line 141 of file AssnsAlgorithms.h.

References util::begin(), for_each_pair(), left(), and util::values().

   {
     for_each_pair(assns, [&func](auto rng) {
       auto rights = rng | ::ranges::views::values;
       auto lefts = rng | ::ranges::views::keys;
       auto const& left = **::ranges::begin(lefts);
       func(left, rights);
     });
   }

template<typename A , typename B , typename D , typename F >

void art::for_each_pair	(	art::Assns< A, B, D > const &	assns,
		F	func
	)

Definition at line 153 of file AssnsAlgorithms.h.

References a1, and a2.

Referenced by for_each_group_with_left().

   {
     ::ranges::for_each(assns | ::ranges::views::all |
                          ::ranges::views::chunk_by([](auto a1, auto a2) {
                            return a1.first == a2.first;
                          }),
                        func);
   }

constexpr auto art::fullRun ( )

constexpr auto art::fullSubRun ( )

Definition at line 27 of file ProductSemantics.h.

   {
     return FullSemantic<Level::SubRun>{};
   }

template<typename T , typename L , typename R , typename D >

auto const & art::get ( AssnsNode< L, R, D > const & r )

Definition at line 115 of file AssnsNode.h.

References r.

   {
     return detail::get_helper<L, R, D>::template get_element<T>(r);
   }

std::string const & art::getCanvasReleaseVersion ( )

Definition at line 6 of file GetReleaseVersion.cc.

                                               {
     static std::string const releaseVersion{""};
     return releaseVersion;
   }

template<typename Collection >

void art::getElementAddresses	(	Collection const &	coll,
		std::type_info const &	iToType,
		std::vector< unsigned long > const &	indices,
		std::vector< void const * > &	oPtr
	)

Definition at line 68 of file getElementAddresses.h.

References art::detail::maybeCastObj().

Referenced by art::Wrapper< T >::do_getElementAddresses().

 {
   oPtr.reserve(indices.size());
   for (auto const index : indices) {
     auto it = coll.cbegin();
     advance(it, index);
     oPtr.push_back(detail::maybeCastObj(
       detail::GetProduct<Collection>::address(it), iToType));
   }
 }

template<typename T >

void art::getElementAddresses	(	cet::map_vector< T > const &	obj,
		std::type_info const &	iToType,
		std::vector< unsigned long > const &	indices,
		std::vector< void const * > &	oPtr
	)

Definition at line 84 of file getElementAddresses.h.

References art::detail::value_type_helper::look_past_pair(), art::detail::maybeCastObj(), art::detail::value_type_helper::starts_with_pair(), and uniform_type_name().

 {
   detail::value_type_helper vh;
   std::string const wanted_type =
     uniform_type_name(cet::demangle_symbol(iToType.name()));
   static size_t const pos = vh.look_past_pair<T>();
   oPtr.reserve(indices.size());
   if ((pos < wanted_type.size()) && vh.starts_with_pair(wanted_type, pos)) {
     // Want value_type.
     for (auto const index : indices) {
       auto it = obj.find(cet::map_vector_key{index});
       auto ptr = (it == obj.cend()) ? nullptr : &*it;
       oPtr.push_back(detail::maybeCastObj(ptr, iToType));
     }
   } else {
     // Want mapped_type.
     for (auto const index : indices) {
       auto ptr = obj.getOrNull(cet::map_vector_key{index});
       oPtr.push_back(detail::maybeCastObj(ptr, iToType));
     }
   }
 }

std::string const & art::getReleaseVersion ( )

Definition at line 4 of file GetReleaseVersion.cc.

Referenced by art::BasicOptionsHandler::BasicOptionsHandler(), art::BasicOptionsHandler::doCheckOptions(), art::EventProcessor::EventProcessor(), art::PathManager::loadModuleThreadingType_(), art::PathManager::loadModuleType_(), art::InputSourceFactory::make(), art::PathManager::makeModule_(), art::PathManager::makeTriggerResultsInserter_(), and art::PathManager::moduleInformation_().

 {
   static std::string const releaseVersion("3.14.04");
   return releaseVersion;
 }

std::string art::glob2reg ( std::string pattern )

Definition at line 17 of file RegexMatch.cc.

Referenced by regexMatch().

   {
     cet::replace_all(pattern, "*", ".*");
     cet::replace_all(pattern, "?", ".");
     return pattern;
   }

constexpr auto art::highest_level ( )

noexcept

Definition at line 32 of file Level.h.

Referenced by art::EventProcessor::advanceItemType(), is_highest_level(), art::EventProcessor::levelsToProcess(), and art::EventProcessor::readAndProcessAsync().

   {
     return Level{0};
   }

template<Direction Dir>

constexpr auto art::index_for_dereferencing ( std::size_t const i )

Definition at line 85 of file AssnsIter.h.

References Forward.

   {
     return (Dir == Direction::Forward) ? i : i - 1;
   }

constexpr bool art::is_above_most_deeply_nested_level ( Level const l )

noexcept

Definition at line 56 of file Level.h.

References most_deeply_nested_level(), and underlying_value().

   {
     return underlying_value(l) < underlying_value(most_deeply_nested_level());
   }

bool art::is_assns ( std::string const & type_name )

inline

Definition at line 66 of file TypeID.h.

References is_instantiation_of().

Referenced by art::detail::createProductLookups(), is_assns(), name_of_assns_base(), and name_of_assns_partner().

   {
     using namespace std::string_literals;
     return is_instantiation_of(type_name, "art::Assns"s);
   }

bool art::is_assns ( TypeID const & tid )

inline

Definition at line 73 of file TypeID.h.

References art::TypeID::className(), is_assns(), name_of_assns_base(), name_of_assns_partner(), name_of_template_arg(), name_of_unwrapped_product(), operator!=(), operator<<(), operator>(), and art::TypeID::swap().

   {
     return is_assns(tid.className());
   }

bool art::is_glob ( std::string const & pattern )

Definition at line 11 of file RegexMatch.cc.

Referenced by art::EventSelector::data_for().

   {
     return pattern.find_first_of("*?") != std::string::npos;
   }

constexpr bool art::is_highest_level ( Level const l )

noexcept

Definition at line 68 of file Level.h.

References highest_level().

   {
     return l == highest_level();
   }

bool art::is_instantiation_of	(	std::string const &	type_name,
		std::string const &	template_name
	)

inline

Definition at line 53 of file TypeID.h.

Referenced by is_assns(), is_instantiation_of(), and name_of_unwrapped_product().

   {
     return type_name.find(template_name + '<') == 0ull;
   }

bool art::is_instantiation_of	(	TypeID const &	tid,
		std::string const &	template_name
	)

inline

Definition at line 60 of file TypeID.h.

References art::TypeID::className(), and is_instantiation_of().

   {
     return is_instantiation_of(tid.className(), template_name);
   }

constexpr bool art::is_legacy ( ServiceScope const scope )

noexcept

Definition at line 10 of file ServiceScope.h.

References LEGACY.

   {
     return scope == ServiceScope::LEGACY;
   }

constexpr bool art::is_level_contained_by	(	Level const	l1,
		Level const	l2
	)

noexcept

Definition at line 74 of file Level.h.

References underlying_value().

   {
     return underlying_value(l1) > underlying_value(l2);
   }

bool art::is_modifier ( ModuleType const mt )

inline

Definition at line 22 of file ModuleType.h.

References filter, and producer.

Referenced by art::detail::make_trigger_path_subgraphs(), and art::detail::verify_in_order_dependencies().

   {
     return (mt == ModuleType::producer) || (mt == ModuleType::filter);
   }

constexpr bool art::is_most_deeply_nested_level ( Level const l )

noexcept

Definition at line 62 of file Level.h.

References most_deeply_nested_level().

   {
     return l == most_deeply_nested_level();
   }

bool art::is_observer ( ModuleType const mt )

inline

Definition at line 28 of file ModuleType.h.

References analyzer, and output_module.

Referenced by art::PathManager::fillSelectEventsDeps_().

   {
     return (mt == ModuleType::analyzer) || (mt == ModuleType::output_module);
   }

constexpr bool art::is_shared ( ServiceScope const scope )

noexcept

Definition at line 15 of file ServiceScope.h.

References SHARED.

   {
     return scope == ServiceScope::SHARED;
   }

template<Level L = Level::Event>

constexpr bool art::is_valid ( IDNumber_t< L > const id )

noexcept

Definition at line 113 of file IDNumber.h.

Referenced by art::RangeSet::invalidChecksum(), art::EventRange::is_full_subRun(), art::EventRange::is_valid(), and lar::sparse_vector< float >::void_range().

   {
     return id != IDNumber<L>::invalid();
   }

bool art::isAncestor	(	ProcessHistory const &	a,
		ProcessHistory const &	b
	)

Definition at line 255 of file ProcessHistory.cc.

References art::ProcessHistory::data(), and art::ProcessHistory::size().

Referenced by isDescendant().

   {
     if (a.size() >= b.size()) {
       return false;
     }
     for (auto itA = a.data().cbegin(),
               itB = b.data().cbegin(),
               itAEnd = a.data().cend();
          itA != itAEnd;
          ++itA, ++itB) {
       if (*itA != *itB) {
         return false;
       }
     }
     return true;
   }

bool art::isDescendant	(	ProcessHistory const &	a,
		ProcessHistory const &	b
	)

Definition at line 273 of file ProcessHistory.cc.

References isAncestor().

   {
     return isAncestor(b, a);
   }

template<typename L , typename R , typename D , Direction Dir>

constexpr auto const& art::left	(	const_AssnsIter< L, R, D, Dir > const &	a,
		const_AssnsIter< L, R, D, Dir > const &	b
	)

Definition at line 94 of file AssnsIter.h.

References Forward.

Referenced by art::Assns< L, R, void >::addMany(), recob::TrackTrajectory::AtLeastValidTrajectoryPoints(), lar_cluster3d::ConvexHullPathFinder::breakClusterAtBigGap(), lar_cluster3d::ConvexHullPathFinder::breakClusterByKinks(), lar_cluster3d::ConvexHullPathFinder::breakClusterByKinksTrial(), lar_cluster3d::ConvexHullPathFinder::breakClusterByMaxDefect(), lar_cluster3d::ConvexHullPathFinder::breakClusterInHalf(), lar_cluster3d::ClusterPathFinder::breakIntoTinyBits(), lar_cluster3d::VoronoiPathFinder::breakIntoTinyBits(), lar_cluster3d::StandardHit3DBuilder::BuildChannelStatusVec(), lar_cluster3d::ClusterPathFinder::buildConvexHull(), lar_cluster3d::VoronoiPathFinder::buildConvexHull(), lar_cluster3d::ConvexHullPathFinder::buildConvexHull(), lar_cluster3d::MSTPathFinder::buildConvexHull(), lar_cluster3d::kdTree::BuildKdTree(), lar_cluster3d::ClusterPathFinder::buildVoronoiDiagram(), lar_cluster3d::VoronoiPathFinder::buildVoronoiDiagram(), voronoi2d::VoronoiDiagram::ComputeFaceArea(), fhicl::detail::ValidateThenSet::delegated_parameter(), evdb_tool::DrawGausHits::Draw(), art::RangeSet::emplace_range(), cluster::TrajCluster::endJob(), lar_cluster3d::ClusterParamsBuilder::FillClusterParams(), evgen::NDKGen::FillHistograms(), evgen::GENIEGen::FillHistograms(), lar_cluster3d::MinSpanTreeAlg::FindBestPathInCluster(), lar_cluster3d::MSTPathFinder::FindBestPathInCluster(), voronoi2d::VoronoiDiagram::findBoundingBox(), lar_cluster3d::SnippetHit3DBuilder::findGoodHitPairs(), lar_cluster3d::StandardHit3DBuilder::findGoodTriplets(), lar_cluster3d::SnippetHit3DBuilder::findGoodTriplets(), reco_tool::CandHitDerivative::findHitCandidates(), reco_tool::CandHitMorphological::findHitCandidates(), reco_tool::WaveformTools::findPeaks(), for_each_group_with_left(), mf::service::ELdestination::formSummary(), evgb::GENIEHelper::GENIEHelper(), voronoi2d::VoronoiDiagram::getConvexHull(), reco_tool::WaveformTools::getTruncatedMeanRMS(), art::TimeTracker::logToDestination_(), lar_cluster3d::Cluster3D::MakeAndSavePCAPoints(), lar_cluster3d::ClusterMergeAlg::ModifyClusters(), operator!=(), shims::operator!=(), art::const_AssnsIter< L, R, D, Dir >::operator<(), util::flags::operator<(), operator<=(), art::const_AssnsIter< L, R, D, Dir >::operator<=(), shims::operator==(), operator>(), art::const_AssnsIter< L, R, D, Dir >::operator>(), operator>=(), art::const_AssnsIter< L, R, D, Dir >::operator>=(), lar_cluster3d::ConvexHullPathFinder::orderHitsAlongEdge(), lar_cluster3d::PrincipalComponentsAlg::PCAAnalysis_3D(), art::detail::print_module_types(), art::detail::print_path_names(), art::detail::print_service_types(), nutools::dbi::Table::PrintColumns(), reco::shower::ShowerElementHolder::PrintElements(), lar_pandora::LArPandoraEventDump::PrintProperty(), reco::shower::ShowerProducedPtrsHolder::PrintPtrs(), hit::GausHitFinder::produce(), boost::python::detail::proxy_group< Proxy >::replace(), lar_content::LArPcaHelper::RunPca(), lar_cluster3d::MinSpanTreeAlg::RunPrimsAlgorithm(), lar_cluster3d::MSTPathFinder::RunPrimsAlgorithm(), sort_pred2(), lar_cluster3d::VoronoiPathFinder::subDivideCluster(), art::MemoryTracker::summary_(), throw_if_not_disjoint(), cluster::HoughTransformCounters< KEY, COUNTER, SIZE, ALLOC, SUBCOUNTERS >::unchecked_add_range_max(), and cluster::HoughTransformCounters< KEY, COUNTER, SIZE, ALLOC, SUBCOUNTERS >::unchecked_set_range().

   {
     return (Dir == Direction::Forward) ? a : b;
   }

constexpr auto art::level_down ( Level const l )

noexcept

Definition at line 50 of file Level.h.

References underlying_value().

   {
     return Level{underlying_value(l) + 1};
   }

constexpr auto art::level_up ( Level const l )

noexcept

Definition at line 38 of file Level.h.

References underlying_value().

Referenced by most_deeply_nested_level().

   {
     return Level{underlying_value(l) - 1};
   }

art::ProductDescriptions art::make_product_descriptions ( ProductList const & productList )

Definition at line 5 of file ProductList.cc.

References util::values().

 {
   using namespace ::ranges;
   return productList | views::values | to<ProductDescriptions>();
 }

template<typename T >

std::enable_if_t<std::is_class<T>::value, tool_return_type<T> > art::make_tool ( fhicl::ParameterSet const & pset )

Definition at line 18 of file make_tool.h.

References art::errors::Configuration, e, fhicl::ParameterSet::get(), art::Suffixes::tool(), and value.

   {
     cet::BasicPluginFactory factory{Suffixes::tool(), "makeTool"};
     std::string const libspec{pset.get<std::string>("tool_type")};
     tool_return_type<T> result;
     try {
       result = detail::tool_type<T>::make_plugin(factory, libspec, pset);
     }
     catch (cet::exception const& e) {
       throw Exception(errors::Configuration, "make_tool: ", e)
         << "Exception caught while processing plugin spec: " << libspec << '\n';
     }
     return result;
   }

template<typename T >

std::enable_if_t<std::is_function<T>::value, tool_return_type<T> > art::make_tool	(	fhicl::ParameterSet const &	pset,
		std::string const &	function_tool_type
	)

Definition at line 35 of file make_tool.h.

References art::errors::Configuration, e, fhicl::ParameterSet::get(), and art::Suffixes::tool().

   {
     cet::BasicPluginFactory factory{
       Suffixes::tool(), "toolFunction", "toolType"};
     std::string const libspec{pset.get<std::string>("tool_type")};
     tool_return_type<T> result;
     try {
       result = detail::tool_type<T>::make_plugin(
         factory, libspec, pset, function_tool_type);
     }
     catch (cet::exception const& e) {
       throw Exception(errors::Configuration, "make_tool: ", e)
         << "Exception caught while processing plugin spec: " << libspec << '\n';
     }
     return result;
   }

template<typename T , typename TableConfig >

tool_return_type<T> art::make_tool	(	TableConfig const &	tc,
		std::string const &	function_tool_type
	)

Definition at line 55 of file make_tool.h.

   {
     if constexpr (std::is_class_v<T>) {
       return make_tool<T>(tc.get_PSet());
     } else if (std::is_function_v<T>) {
       return make_tool<T>(tc.get_PSet(), function_tool_type);
     }
   }

static void art::markAncestors	(	ProductProvenance const &	iInfo,
		EventPrincipal &	e,
		std::map< ProductID, bool > &	oMap,
		std::set< ProductID > &	oMapperMissing
	)

static

Definition at line 51 of file ProvenanceCheckerOutput_module.cc.

References art::Principal::branchToProductProvenance(), art::ProductProvenance::parentage(), and art::Parentage::parents().

Referenced by art::ProvenanceCheckerOutput::write().

   {
     for (art::ProductID const parent : iInfo.parentage().parents()) {
       // Don't look for parents if we've previously looked at the parents
       if (oMap.find(parent) == oMap.end()) {
         // use side effect of calling operator[] which is if the item isn't
         // there it will add it as 'false'
         oMap[parent];
         cet::exempt_ptr<ProductProvenance const> pInfo =
           e.branchToProductProvenance(parent);
         if (pInfo.get()) {
           markAncestors(*pInfo, e, oMap, oMapperMissing);
         } else {
           oMapperMissing.insert(parent);
         }
       }
     }
   }

art::MFSU_0_ARG_UPDATER_DEFN ( PostBeginJob )

Definition at line 83 of file MFStatusUpdater.cc.

References mf::SetIteration(), and mf::SetModuleName().

   {
     mf::SetModuleName("PostBeginJob"s);
     mf::SetIteration("BeforeEvents"s);
   }

art::MFSU_0_ARG_UPDATER_DEFN ( PostEndJob )

Definition at line 89 of file MFStatusUpdater.cc.

References mf::SetModuleName().

   {
     mf::SetModuleName("PostEndJob"s);
   }

art::MFSU_0_ARG_UPDATER_DEFN ( PreSourceSubRun )

Definition at line 110 of file MFStatusUpdater.cc.

References mf::SetModuleName().

   {
     mf::SetModuleName("SourceSubRun"s);
   }

art::MFSU_0_ARG_UPDATER_DEFN ( PreSourceRun )

Definition at line 120 of file MFStatusUpdater.cc.

References mf::SetModuleName().

   {
     mf::SetModuleName("SourceRun"s);
   }

art::MFSU_0_ARG_UPDATER_DEFN ( PreOpenFile )

Definition at line 130 of file MFStatusUpdater.cc.

References mf::SetModuleName().

   {
     mf::SetModuleName("OpenFile"s);
   }

art::MFSU_0_ARG_UPDATER_DEFN ( PreCloseFile )

Definition at line 140 of file MFStatusUpdater.cc.

References mf::SetModuleName().

   {
     mf::SetModuleName("CloseFile"s);
   }

art::MFSU_0_ARG_UPDATER_DEFN ( PostCloseFile )

Definition at line 145 of file MFStatusUpdater.cc.

References mf::SetModuleName().

   {
     mf::SetModuleName("PostCloseFile"s);
   }

art::MFSU_1_ARG_UPDATER_DEFN ( PostSourceConstruction )

Definition at line 94 of file MFStatusUpdater.cc.

References mf::SetIteration(), and mf::SetModuleName().

   {
     mf::SetModuleName("PostSourceConstruction"s);
     mf::SetIteration("SourceConstruction"s);
   }

art::MFSU_1_ARG_UPDATER_DEFN ( PreSourceEvent )

Definition at line 100 of file MFStatusUpdater.cc.

References mf::SetModuleName().

   {
     mf::SetModuleName("SourceEvent"s);
   }

art::MFSU_1_ARG_UPDATER_DEFN ( PostSourceSubRun )

Definition at line 115 of file MFStatusUpdater.cc.

References mf::SetModuleName().

   {
     mf::SetModuleName("PostSourceSubRun"s);
   }

art::MFSU_1_ARG_UPDATER_DEFN ( PostSourceRun )

Definition at line 125 of file MFStatusUpdater.cc.

References mf::SetModuleName().

   {
     mf::SetModuleName("PostSourceRun"s);
   }

art::MFSU_1_ARG_UPDATER_DEFN ( PostOpenFile )

Definition at line 135 of file MFStatusUpdater.cc.

References mf::SetModuleName().

   {
     mf::SetModuleName("PostOpenFile"s);
   }

art::MFSU_1_ARG_UPDATER_DEFN ( PreBeginRun )

Definition at line 163 of file MFStatusUpdater.cc.

References mf::SetIteration(), and mf::SetModuleName().

   {
     mf::SetModuleName("BeginRun"s);
     std::ostringstream os;
     os << arg1.id();
     mf::SetIteration(os.str());
   }

art::MFSU_1_ARG_UPDATER_DEFN ( PostBeginRun )

Definition at line 171 of file MFStatusUpdater.cc.

References mf::SetModuleName().

   {
     mf::SetModuleName("PostBeginRun"s);
   }

art::MFSU_1_ARG_UPDATER_DEFN ( PostEndRun )

Definition at line 184 of file MFStatusUpdater.cc.

References mf::SetModuleName().

   {
     mf::SetModuleName("PostEndRun"s);
   }

art::MFSU_1_ARG_UPDATER_DEFN ( PreBeginSubRun )

Definition at line 189 of file MFStatusUpdater.cc.

References mf::SetIteration(), and mf::SetModuleName().

   {
     mf::SetModuleName("BeginSubRun"s);
     std::ostringstream os;
     os << arg1.id();
     mf::SetIteration(os.str());
   }

art::MFSU_1_ARG_UPDATER_DEFN ( PostBeginSubRun )

Definition at line 197 of file MFStatusUpdater.cc.

References mf::SetModuleName().

   {
     mf::SetModuleName("PostBeginSubRun"s);
   }

art::MFSU_1_ARG_UPDATER_DEFN ( PostEndSubRun )

Definition at line 210 of file MFStatusUpdater.cc.

References mf::SetModuleName().

   {
     mf::SetModuleName("PostEndSubRun"s);
   }

art::MFSU_1_ARG_UPDATER_DEFN ( PreProcessPath )

Definition at line 215 of file MFStatusUpdater.cc.

References mf::SetModuleName().

   {
     mf::SetModuleName("ProcessPath "s + arg1.pathName());
   }

art::MFSU_1_ARG_UPDATER_DEFN ( PrePathBeginRun )

Definition at line 225 of file MFStatusUpdater.cc.

References mf::SetModuleName().

   {
     mf::SetModuleName("PathBeginRun "s + arg1);
   }

art::MFSU_1_ARG_UPDATER_DEFN ( PrePathEndRun )

Definition at line 235 of file MFStatusUpdater.cc.

References mf::SetModuleName().

   {
     mf::SetModuleName("PathEndRun "s + arg1);
   }

art::MFSU_1_ARG_UPDATER_DEFN ( PrePathBeginSubRun )

Definition at line 245 of file MFStatusUpdater.cc.

References mf::SetModuleName().

   {
     mf::SetModuleName("PathBeginSubRun "s + arg1);
   }

art::MFSU_1_ARG_UPDATER_DEFN ( PrePathEndSubRun )

Definition at line 255 of file MFStatusUpdater.cc.

References mf::SetModuleName().

   {
     mf::SetModuleName("PathEndSubRun "s + arg1);
   }

art::MFSU_1_ARG_UPDATER_DEFN ( PreModuleConstruction )

Definition at line 265 of file MFStatusUpdater.cc.

References mf::SetIteration(), and mf::SetModuleName().

   {
     mf::SetModuleName(arg1.moduleName() + ":"s + arg1.moduleLabel() +
                       "@Construction"s);
     mf::SetIteration("ModuleConstruction"s);
   }

art::MFSU_1_ARG_UPDATER_DEFN ( PostModuleConstruction )

Definition at line 272 of file MFStatusUpdater.cc.

References mf::SetModuleName().

   {
     mf::SetModuleName(arg1.moduleName() + ":"s + arg1.moduleLabel() +
                       "@Construction"s);
   }

art::MFSU_1_ARG_UPDATER_DEFN ( PreModuleBeginJob )

Definition at line 283 of file MFStatusUpdater.cc.

References mf::SetIteration(), and mf::SetModuleName().

   {
     mf::SetModuleName(arg1.moduleName() + ":"s + arg1.moduleLabel() +
                       "@BeginJob"s);
     mf::SetIteration("ModuleBeginJob"s);
   }

art::MFSU_1_ARG_UPDATER_DEFN ( PostModuleBeginJob )

Definition at line 290 of file MFStatusUpdater.cc.

References mf::SetModuleName().

   {
     mf::SetModuleName(arg1.moduleName() + ":"s + arg1.moduleLabel() +
                       "@BeginJob"s);
   }

art::MFSU_1_ARG_UPDATER_DEFN ( PreModuleEndJob )

Definition at line 296 of file MFStatusUpdater.cc.

References mf::SetIteration(), and mf::SetModuleName().

   {
     mf::SetModuleName(arg1.moduleName() + ":"s + arg1.moduleLabel() +
                       "@EndJob"s);
     mf::SetIteration("ModuleEndJob"s);
   }

art::MFSU_1_ARG_UPDATER_DEFN ( PostModuleEndJob )

Definition at line 303 of file MFStatusUpdater.cc.

References mf::SetModuleName().

   {
     mf::SetModuleName(arg1.moduleName() + ":"s + arg1.moduleLabel() +
                       "@EndJob"s);
   }

art::MFSU_1_ARG_UPDATER_DEFN ( PreModule )

Definition at line 309 of file MFStatusUpdater.cc.

References mf::SetModuleName().

   {
     mf::SetModuleName(arg1.moduleName() + ":"s + arg1.moduleLabel() +
                       "@BeginModule"s);
   }

art::MFSU_1_ARG_UPDATER_DEFN ( PostModule )

Definition at line 315 of file MFStatusUpdater.cc.

References mf::SetModuleName().

   {
     mf::SetModuleName(arg1.moduleName() + ":"s + arg1.moduleLabel() +
                       "@EndModule"s);
   }

art::MFSU_1_ARG_UPDATER_DEFN ( PreModuleBeginRun )

Definition at line 321 of file MFStatusUpdater.cc.

References mf::SetModuleName().

   {
     mf::SetModuleName(arg1.moduleName() + ":"s + arg1.moduleLabel() +
                       "@BeginRun"s);
   }

art::MFSU_1_ARG_UPDATER_DEFN ( PostModuleBeginRun )

Definition at line 327 of file MFStatusUpdater.cc.

References mf::SetModuleName().

   {
     mf::SetModuleName(arg1.moduleName() + ":"s + arg1.moduleLabel() +
                       "@BeginRun"s);
   }

art::MFSU_1_ARG_UPDATER_DEFN ( PreModuleEndRun )

Definition at line 333 of file MFStatusUpdater.cc.

References mf::SetModuleName().

   {
     mf::SetModuleName(arg1.moduleName() + ":"s + arg1.moduleLabel() +
                       "@EndRun"s);
   }

art::MFSU_1_ARG_UPDATER_DEFN ( PostModuleEndRun )

Definition at line 339 of file MFStatusUpdater.cc.

References mf::SetModuleName().

   {
     mf::SetModuleName(arg1.moduleName() + ":"s + arg1.moduleLabel() +
                       "@EndRun"s);
   }

art::MFSU_1_ARG_UPDATER_DEFN ( PreModuleBeginSubRun )

Definition at line 345 of file MFStatusUpdater.cc.

References mf::SetModuleName().

   {
     mf::SetModuleName(arg1.moduleName() + ":"s + arg1.moduleLabel() +
                       "@BeginSubRun"s);
   }

art::MFSU_1_ARG_UPDATER_DEFN ( PostModuleBeginSubRun )

Definition at line 351 of file MFStatusUpdater.cc.

References mf::SetModuleName().

   {
     mf::SetModuleName(arg1.moduleName() + ":"s + arg1.moduleLabel() +
                       "@BeginSubRun"s);
   }

art::MFSU_1_ARG_UPDATER_DEFN ( PreModuleEndSubRun )

Definition at line 357 of file MFStatusUpdater.cc.

References mf::SetModuleName().

   {
     mf::SetModuleName(arg1.moduleName() + ":"s + arg1.moduleLabel() +
                       "@EndSubRun"s);
   }

art::MFSU_1_ARG_UPDATER_DEFN ( PostModuleEndSubRun )

Definition at line 363 of file MFStatusUpdater.cc.

References mf::SetModuleName().

   {
     mf::SetModuleName(arg1.moduleName() + ":"s + arg1.moduleLabel() +
                       "@EndSubRun"s);
   }

art::MFSU_2_ARG_UPDATER_DEFN ( PostSourceEvent )

Definition at line 105 of file MFStatusUpdater.cc.

References mf::SetModuleName().

   {
     mf::SetModuleName("PostSourceEvent"s);
   }

art::MFSU_2_ARG_UPDATER_DEFN ( PreProcessEvent )

Definition at line 150 of file MFStatusUpdater.cc.

References mf::SetIteration(), and mf::SetModuleName().

   {
     mf::SetModuleName("ProcessEvent"s);
     std::ostringstream os;
     os << arg1.id();
     mf::SetIteration(os.str());
   }

art::MFSU_2_ARG_UPDATER_DEFN ( PostProcessEvent )

Definition at line 158 of file MFStatusUpdater.cc.

References mf::SetModuleName().

   {
     mf::SetModuleName("PostProcessEvent"s);
   }

art::MFSU_2_ARG_UPDATER_DEFN ( PreEndRun )

Definition at line 176 of file MFStatusUpdater.cc.

References mf::SetIteration(), and mf::SetModuleName().

   {
     mf::SetModuleName("EndRun"s);
     std::stringstream os;
     os << arg1;
     mf::SetIteration(os.str());
   }

art::MFSU_2_ARG_UPDATER_DEFN ( PreEndSubRun )

Definition at line 202 of file MFStatusUpdater.cc.

References mf::SetIteration(), and mf::SetModuleName().

   {
     mf::SetModuleName("EndSubRun"s);
     std::ostringstream os;
     os << arg1;
     mf::SetIteration(os.str());
   }

art::MFSU_2_ARG_UPDATER_DEFN ( PostProcessPath )

Definition at line 220 of file MFStatusUpdater.cc.

References mf::SetModuleName().

   {
     mf::SetModuleName("PostProcessPath "s + arg1.pathName());
   }

art::MFSU_2_ARG_UPDATER_DEFN ( PostPathBeginRun )

Definition at line 230 of file MFStatusUpdater.cc.

References mf::SetModuleName().

   {
     mf::SetModuleName("PostPathBeginRun "s + arg1);
   }

art::MFSU_2_ARG_UPDATER_DEFN ( PostPathEndRun )

Definition at line 240 of file MFStatusUpdater.cc.

References mf::SetModuleName().

   {
     mf::SetModuleName("PostPathEndRun "s + arg1);
   }

art::MFSU_2_ARG_UPDATER_DEFN ( PostPathBeginSubRun )

Definition at line 250 of file MFStatusUpdater.cc.

References mf::SetModuleName().

   {
     mf::SetModuleName("PostPathBeginSubRun "s + arg1);
   }

art::MFSU_2_ARG_UPDATER_DEFN ( PostPathEndSubRun )

Definition at line 260 of file MFStatusUpdater.cc.

References mf::SetModuleName().

   {
     mf::SetModuleName("PostPathEndSubRun "s + arg1);
   }

art::MFSU_2_ARG_UPDATER_DEFN ( PostBeginJobWorkers )

Definition at line 278 of file MFStatusUpdater.cc.

   {
     throw cet::exception("InternalError"s) << "NOP: do not call";
   }

constexpr auto art::most_deeply_nested_level ( )

noexcept

Definition at line 44 of file Level.h.

References level_up(), and NumNestingLevels.

Referenced by is_above_most_deeply_nested_level(), is_most_deeply_nested_level(), and art::EventProcessor::readAndProcessAsync().

   {
     return level_up(Level::NumNestingLevels);
   }

std::string art::name_of_assns_base ( string assns_type_name )

Definition at line 188 of file TypeID.cc.

References is_assns(), and name_of_template_arg().

Referenced by art::detail::createProductLookups(), and is_assns().

   {
     string result;
     if (!is_assns(assns_type_name)) {
       return result;
     }
     using namespace std::string_literals;
     static string const assns_start = "art::Assns<"s;
     if (name_of_template_arg(assns_type_name, 2) == "void"s) {
       // Doesn't have the base we're looking for.
       return result;
     }
     result = assns_start + name_of_template_arg(assns_type_name, 0) + ',' +
              name_of_template_arg(assns_type_name, 1) + ",void>";
     return result;
   }

std::string art::name_of_assns_partner ( string assns_type_name )

Definition at line 173 of file TypeID.cc.

References is_assns(), and name_of_template_arg().

Referenced by is_assns().

   {
     string result;
     if (!is_assns(assns_type_name)) {
       return result;
     }
     static string const assns_start = "art::Assns<"s;
     auto const arg0 = name_of_template_arg(assns_type_name, 0);
     auto const arg1 = name_of_template_arg(assns_type_name, 1);
     auto const arg2 = name_of_template_arg(assns_type_name, 2);
     result = assns_start + arg1 + ',' + arg0 + ',' + arg2 + '>';
     return result;
   }

std::string art::name_of_template_arg	(	string const &	template_instance,
		size_t	desired_arg
	)

Definition at line 121 of file TypeID.cc.

Referenced by is_assns(), name_of_assns_base(), name_of_assns_partner(), and name_of_unwrapped_product().

   {
     string result;
     auto comma_count = 0ul;
     auto template_level = 0ul;
     auto arg_start = string::npos;
     auto pos = 0ul;
     pos = template_instance.find_first_of("<>,", pos);
     while (pos != string::npos) {
       switch (template_instance[pos]) {
       case '<':
         ++template_level;
         if ((desired_arg == 0ul) && (template_level == 1ul)) {
           // Found the begin of the desired template arg.
           arg_start = pos + 1;
         }
         break;
       case '>':
         --template_level;
         if ((desired_arg == comma_count) && (template_level == 0ul)) {
           // Found the end of the desired template arg -- trim trailing
           // whitespace
           auto const arg_end =
             template_instance.find_last_not_of(" \t", pos - 1) + 1;
           result = template_instance.substr(arg_start, arg_end - arg_start);
           return result;
         }
         break;
       case ',':
         if (template_level != 1ul) {
           // Ignore arguments not at the first level.
           break;
         }
         if (comma_count == desired_arg) {
           // Found the end of the desired template arg.
           result = template_instance.substr(arg_start, pos - arg_start);
           return result;
         }
         ++comma_count;
         if (comma_count == desired_arg) {
           // Found the begin of the desired template arg.
           arg_start = pos + 1;
         }
         break;
       }
       ++pos;
       pos = template_instance.find_first_of("<>,", pos);
     }
     return result;
   }

std::string art::name_of_unwrapped_product ( string const & wrapped_name )

Definition at line 206 of file TypeID.cc.

References is_instantiation_of(), art::errors::LogicError, and name_of_template_arg().

Referenced by is_assns().

   {
     using namespace std::string_literals;
     if (!is_instantiation_of(wrapped_name, "art::Wrapper"s)) {
       throw Exception(errors::LogicError, "Can't unwrap"s)
         << "-- attempted to get unwrapped product from non-instance of art::Wrapper."s;
     }
     return name_of_template_arg(wrapped_name, 0);
   }

template<typename A >

std::enable_if_t<is_selector<A>, NotHelper<A> > art::operator! ( A const & a )

Definition at line 338 of file Selector.h.

   {
     return NotHelper<A>{a};
   }

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

inline

Definition at line 83 of file BranchKey.h.

 {
   return !(a == b);
 }

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

inline

Definition at line 34 of file FileFormatVersion.h.

References ff, and operator<<().

   {
     return !(a == b);
   }

bool art::operator!=	(	ScheduleID const	left,
		ScheduleID const	right
	)

noexcept

Definition at line 41 of file ScheduleID.cc.

References left(), and right().

Referenced by is_assns().

   {
     return !(left == right);
   }

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

Definition at line 56 of file Parentage.cc.

   {
     return !(a == b);
   }

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

Definition at line 65 of file ProcessConfiguration.cc.

   {
     return !(a == b);
   }

constexpr bool art::operator!=	(	RefCore const &	lhs,
		RefCore const &	rhs
	)

noexcept

Definition at line 81 of file RefCore.h.

   {
     return !(lhs == rhs);
   }

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

Definition at line 102 of file TypeID.cc.

   {
     return !(a == b);
   }

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

noexcept

Definition at line 105 of file ProductProvenance.cc.

   {
     return !(a == b);
   }

bool art::operator!=	(	InputTag const &	left,
		InputTag const &	right
	)

Definition at line 111 of file InputTag.cc.

References right().

   {
     return !(left == right);
   }

template<typename T , typename U >

std::enable_if_t<std::is_same_v<T, U> \|\| std::is_base_of_v<T, U> \|\| std::is_base_of_v<U, T>, bool> art::operator!=	(	ProductPtr< T > const &	lhs,
		ProductPtr< U > const &	rhs
	)

Definition at line 210 of file ProductPtr.h.

   {
     return !(lhs == rhs);
   }

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

Definition at line 249 of file ProcessHistory.cc.

   {
     return !(a == b);
   }

template<typename T , typename U >

std::enable_if_t<std::is_same_v<T, U> \|\| std::is_base_of_v<T, U> \|\| std::is_base_of_v<U, T>, bool> art::operator!=	(	Ptr< T > const &	lhs,
		Ptr< U > const &	rhs
	)

Definition at line 284 of file Ptr.h.

   {
     return !(lhs == rhs);
   }

bool art::operator!=	(	FileIndex::Element const &	lh,
		FileIndex::Element const &	rh
	)

Definition at line 445 of file FileIndex.cc.

   {
     return !(lh == rh);
   }

bool art::operator!=	(	FileIndex const &	lh,
		FileIndex const &	rh
	)

Definition at line 457 of file FileIndex.cc.

   {
     return !(lh == rh);
   }

template<typename A , typename B >

std::enable_if_t<is_selector<A> && is_selector<B>, AndHelper<A, B> > art::operator&&	(	A const &	a,
		B const &	b
	)

Definition at line 264 of file Selector.h.

   {
     return AndHelper<A, B>{a, b};
   }

bool art::operator<	(	EventProcessHistoryID const &	lh,
		EventProcessHistoryID const &	rh
	)

inline

Definition at line 17 of file EventProcessHistoryID.h.

References art::EventProcessHistoryID::eventID_.

   {
     return lh.eventID_ < rh.eventID_;
   }

bool art::operator<	(	BranchKey const &	a,
		BranchKey const &	b
	)

inline

Definition at line 63 of file BranchKey.h.

References art::BranchKey::branchType_, art::BranchKey::friendlyClassName_, art::BranchKey::moduleLabel_, art::BranchKey::processName_, and art::BranchKey::productInstanceName_.

 {
   return std::tie(a.friendlyClassName_,
                   a.moduleLabel_,
                   a.productInstanceName_,
                   a.processName_,
                   a.branchType_) < std::tie(b.friendlyClassName_,
                                             b.moduleLabel_,
                                             b.productInstanceName_,
                                             b.processName_,
                                             b.branchType_);
 }

bool art::operator<	(	TypeLabel const &	a,
		TypeLabel const &	b
	)

Definition at line 46 of file TypeLabel.cc.

References art::TypeLabel::className(), art::TypeLabel::emulatedModule_, art::TypeLabel::hasEmulatedModule(), and art::TypeLabel::productInstanceName_.

   {
     auto const& a_class_name = a.className();
     auto const& b_class_name = b.className();
     auto const& a_emulated_module =
       a.hasEmulatedModule() ? *a.emulatedModule_ : "<none>";
     auto const& b_emulated_module =
       b.hasEmulatedModule() ? *b.emulatedModule_ : "<none>";
     return std::tie(a_emulated_module, a.productInstanceName_, a_class_name) <
            std::tie(b_emulated_module, b.productInstanceName_, b_class_name);
   }

bool art::operator<	(	ProductInfo const &	a,
		ProductInfo const &	b
	)

Definition at line 51 of file ProductInfo.cc.

   {
     auto const& boundA = tie(a.consumableType,
                              a.friendlyClassName,
                              a.label,
                              a.instance,
                              a.process.name());
     auto const& boundB = tie(b.consumableType,
                              b.friendlyClassName,
                              b.label,
                              b.instance,
                              b.process.name());
     return boundA < boundB;
   }

bool art::operator<	(	PathSpec const &	a,
		PathSpec const &	b
	)

inline

Definition at line 65 of file PathSpec.h.

References operator<<(), path_spec(), path_specs(), art::PathID::to_string, and to_tuple().

   {
     return to_tuple(a) < to_tuple(b);
   }

bool art::operator<	(	ProcessConfiguration const &	a,
		ProcessConfiguration const &	b
	)

Definition at line 71 of file ProcessConfiguration.cc.

References art::ProcessConfiguration::parameterSetID(), art::ProcessConfiguration::processName(), and art::ProcessConfiguration::releaseVersion().

   {
     return std::tie(a.processName(), a.parameterSetID(), a.releaseVersion()) <
            std::tie(b.processName(), b.parameterSetID(), b.releaseVersion());
   }

constexpr bool art::operator<	(	RefCore const &	lhs,
		RefCore const &	rhs
	)

noexcept

Definition at line 87 of file RefCore.h.

References art::RefCore::swap().

   {
     return lhs.id() < rhs.id();
   }

bool art::operator<	(	ProductProvenance const &	a,
		ProductProvenance const &	b
	)

noexcept

Definition at line 113 of file ProductProvenance.cc.

   {
     return a.productID() < b.productID();
   }

template<typename T , typename U >

std::enable_if_t<std::is_same_v<T, U> \|\| std::is_base_of_v<T, U> \|\| std::is_base_of_v<U, T>, bool> art::operator<	(	ProductPtr< T > const &	lhs,
		ProductPtr< U > const &	rhs
	)

Definition at line 219 of file ProductPtr.h.

References art::ProductPtr< T >::refCore().

   {
     return lhs.refCore() < rhs.refCore();
   }

bool art::operator<	(	BranchDescription const &	a,
		BranchDescription const &	b
	)

Definition at line 255 of file BranchDescription.cc.

References art::BranchDescription::branchType(), art::BranchDescription::friendlyClassName(), art::BranchDescription::moduleLabel(), art::BranchDescription::processConfigurationIDs(), art::BranchDescription::processName(), art::BranchDescription::producedClassName(), art::BranchDescription::productID(), art::BranchDescription::productInstanceName(), and art::BranchDescription::psetIDs().

   {
     if (a.processName() < b.processName()) {
       return true;
     }
     if (b.processName() < a.processName()) {
       return false;
     }
     if (a.producedClassName() < b.producedClassName()) {
       return true;
     }
     if (b.producedClassName() < a.producedClassName()) {
       return false;
     }
     if (a.friendlyClassName() < b.friendlyClassName()) {
       return true;
     }
     if (b.friendlyClassName() < a.friendlyClassName()) {
       return false;
     }
     if (a.productInstanceName() < b.productInstanceName()) {
       return true;
     }
     if (b.productInstanceName() < a.productInstanceName()) {
       return false;
     }
     if (a.moduleLabel() < b.moduleLabel()) {
       return true;
     }
     if (b.moduleLabel() < a.moduleLabel()) {
       return false;
     }
     if (a.branchType() < b.branchType()) {
       return true;
     }
     if (b.branchType() < a.branchType()) {
       return false;
     }
     if (a.productID() < b.productID()) {
       return true;
     }
     if (b.productID() < a.productID()) {
       return false;
     }
     if (a.psetIDs() < b.psetIDs()) {
       return true;
     }
     if (b.psetIDs() < a.psetIDs()) {
       return false;
     }
     if (a.processConfigurationIDs() < b.processConfigurationIDs()) {
       return true;
     }
     if (b.processConfigurationIDs() < a.processConfigurationIDs()) {
       return false;
     }
     return false;
   }

template<typename T , typename U >

std::enable_if_t<std::is_same_v<T, U> \|\| std::is_base_of_v<T, U> \|\| std::is_base_of_v<U, T>, bool> art::operator<	(	Ptr< T > const &	lhs,
		Ptr< U > const &	rhs
	)

Definition at line 293 of file Ptr.h.

References art::Ptr< T >::refCore().

   {
     // The ordering of integer keys guarantees that the ordering of Ptrs within
     // a collection will be identical to the ordering of the referenced objects
     // in the collection.
     return lhs.refCore() == rhs.refCore() ? lhs.key() < rhs.key() :
                                             lhs.refCore() < rhs.refCore();
   }

bool art::operator<	(	FileIndex::Element const &	lh,
		FileIndex::Element const &	rh
	)

Definition at line 415 of file FileIndex.cc.

References art::FileIndex::Element::eventID.

   {
     return lh.eventID < rh.eventID;
   }

std::ostream & art::operator<<	(	std::ostream &	os,
		ParameterSetBlob const &	blob
	)

Definition at line 8 of file ParameterSetBlob.cc.

References art::ParameterSetBlob::pset_.

   {
     os << blob.pset_;
     return os;
   }

std::ostream& art::operator<<	(	std::ostream &	os,
		OutputFileStatus const	ofs
	)

inline

Definition at line 11 of file OutputFileStatus.h.

References Closed, art::errors::LogicError, Open, and Switching.

   {
     switch (ofs) {
     case OutputFileStatus::Open:
       return os << "Open";
     case OutputFileStatus::Switching:
       return os << "Switching";
     case OutputFileStatus::Closed:
       return os << "Closed";
     default:
       throw art::Exception{art::errors::LogicError,
                            "Unknown output file status."};
     }
   }

std::ostream & art::operator<<	(	std::ostream &	os,
		SubRunID const &	iID
	)

Definition at line 6 of file SubRunID.cc.

References art::SubRunID::isFlush(), art::SubRunID::isValid(), art::SubRunID::run_, and art::SubRunID::subRun_.

 {
   os << iID.run_ << " subRun: ";
   if (iID.isFlush()) {
     os << "FLUSH";
   } else if (iID.isValid()) {
     os << iID.subRun_;
   } else {
     os << "INVALID";
   }
   return os;
 }

std::ostream & art::operator<<	(	std::ostream &	os,
		EventID const &	iID
	)

Definition at line 6 of file EventID.cc.

References art::EventID::event_, art::EventID::isFlush(), art::EventID::isValid(), and art::EventID::subRun_.

 {
   os << iID.subRun_ << " event: ";
   if (iID.isFlush()) {
     os << "FLUSH";
   } else if (iID.isValid()) {
     os << iID.event_;
   } else {
     os << "INVALID";
   }
   return os;
 }

std::ostream & art::operator<<	(	std::ostream &	os,
		art::RunID const &	iID
	)

Definition at line 6 of file RunID.cc.

References art::RunID::isFlush(), art::RunID::isValid(), and art::RunID::run_.

 {
   os << "run: ";
   if (iID.isFlush()) {
     os << "FLUSH";
   } else if (iID.isValid()) {
     os << iID.run_;
   } else {
     os << "INVALID";
   }
   return os;
 }

ostream & art::operator<<	(	std::ostream &	os,
		const GroupSelector &	gs
	)

Definition at line 63 of file GroupSelector.cc.

References art::GroupSelector::print().

Referenced by is_assns(), operator!=(), art::MallocOpts::operator!=(), and operator<().

 {
   gs.print(os);
   return os;
 }

std::ostream & art::operator<<	(	std::ostream &	os,
		BranchID const &	id
	)

Definition at line 20 of file BranchID.cc.

   {
     os << id.id();
     return os;
   }

std::ostream & art::operator<<	(	std::ostream &	ost,
		const MallocOpts &	opts
	)

Definition at line 24 of file MallocOpts.cc.

References art::MallocOpts::mmap_max_, art::MallocOpts::mmap_thr_, art::MallocOpts::top_pad_, and art::MallocOpts::trim_thr_.

   {
     ost << "mmap_max=" << opts.mmap_max_ << " trim_threshold=" << opts.trim_thr_
         << " top_padding=" << opts.top_pad_
         << " mmap_threshold=" << opts.mmap_thr_;
     return ost;
   }

std::ostream & art::operator<<	(	std::ostream &	os,
		ProductID const	id
	)

Definition at line 25 of file ProductID.cc.

   {
     os << id.value();
     return os;
   }

std::ostream & art::operator<<	(	std::ostream &	os,
		BranchKey const &	bk
	)

Definition at line 30 of file BranchKey.cc.

References art::BranchKey::branchType_, art::BranchKey::friendlyClassName_, art::BranchKey::moduleLabel_, art::BranchKey::processName_, and art::BranchKey::productInstanceName_.

   {
     os << "BranchKey(" << bk.friendlyClassName_ << ", " << bk.moduleLabel_
        << ", " << bk.productInstanceName_ << ", " << bk.processName_ << ", "
        << static_cast<BranchType>(bk.branchType_) << ')';
     return os;
   }

std::ostream& art::operator<<	(	std::ostream &	os,
		BranchType const	branchType
	)

inline

Definition at line 31 of file BranchType.h.

References BranchTypeToString().

   {
     return os << BranchTypeToString(branchType);
   }

std::ostream & art::operator<<	(	std::ostream &	os,
		FileFormatVersion const &	ff
	)

Definition at line 5 of file FileFormatVersion.cc.

References art::FileFormatVersion::era_, and art::FileFormatVersion::value_.

 {
   os << (ff.era_.empty() ? "" : (ff.era_ + ": ")) << ff.value_;
   return os;
 }

std::ostream& art::operator<<	(	std::ostream &	os,
		SampledEventInfo const &	eventInfo
	)

inline

Definition at line 42 of file SampledInfo.h.

References art::SampledEventInfo::dataset, art::SampledEventInfo::id, art::SampledEventInfo::probability, and art::SampledEventInfo::weight.

   {
     os << "Sampled EventID: '" << eventInfo.id << "'  Dataset: '"
        << eventInfo.dataset << "'  Weight: " << eventInfo.weight
        << "  Probability: " << eventInfo.probability;
     return os;
   }

std::ostream& art::operator<<	(	std::ostream &	ost,
		HLTGlobalStatus const &	hlt
	)

std::ostream& art::operator<<	(	std::ostream &	os,
		ResultsAuxiliary const &	p
	)

inline

Definition at line 42 of file ResultsAuxiliary.h.

References art::ResultsAuxiliary::write().

   {
     p.write(os);
     return os;
   }

std::ostream & art::operator<<	(	ostream &	os,
		Parentage const &
	)

Definition at line 43 of file Parentage.cc.

   {
     // Unimplemented
     return os;
   }

std::ostream & art::operator<<	(	std::ostream &	os,
		TypeLabel const &	tl
	)

Definition at line 59 of file TypeLabel.cc.

References art::TypeLabel::className(), art::TypeLabel::emulatedModule(), art::TypeLabel::hasEmulatedModule(), art::TypeLabel::productInstanceName(), art::TypeLabel::supportsView(), and art::TypeLabel::transient().

   {
     os << "Emulated module:       '"
        << (tl.hasEmulatedModule() ? tl.emulatedModule() : "<none>") << "'\n"
        << "Product instance name: '" << tl.productInstanceName() << "'\n"
        << "Class name:            '" << tl.className() << "'\n"
        << "Supports views:        '" << std::boolalpha << tl.supportsView()
        << '\n'
        << "Transient:             '" << tl.transient();
     return os;
   }

std::ostream & art::operator<<	(	std::ostream &	os,
		PathSpec const &	spec
	)

Definition at line 61 of file PathSpec.cc.

References to_string().

   {
     return os << to_string(spec);
   }

std::ostream& art::operator<<	(	std::ostream &	,
		const EventAuxiliary &
	)

std::ostream & art::operator<<	(	ostream &	os,
		ScheduleID const	sid
	)

Definition at line 65 of file ScheduleID.cc.

References art::ScheduleID::id().

   {
     return os << sid.id();
   }

std::ostream & art::operator<<	(	ostream &	os,
		ProductInfo::ConsumableType const	ct
	)

Definition at line 67 of file ProductInfo.cc.

References art::ProductInfo::Many, art::ProductInfo::Product, and art::ProductInfo::ViewElement.

   {
     switch (ct) {
     case ProductInfo::ConsumableType::Product:
       os << "Product";
       break;
     case ProductInfo::ConsumableType::ViewElement:
       os << "ViewElement";
       break;
     case ProductInfo::ConsumableType::Many:
       os << "Many";
       break;
     }
     return os;
   }

std::ostream& art::operator<<	(	std::ostream &	os,
		suffix_type const	st
	)

inline

Definition at line 70 of file PluginSuffixes.h.

   {
     return os << static_cast<std::underlying_type_t<suffix_type>>(st);
   }

template<typename T >

std::ostream& art::operator<<	(	std::ostream &	os,
		ServiceTable< T > const &	t
	)

inline

Definition at line 71 of file ServiceTable.h.

References fhicl::detail::TableBase::print_allowed_configuration().

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

template<typename UserConfig , typename ImplicitConfig >

std::ostream& art::operator<<	(	std::ostream &	os,
		ProducerTable< UserConfig, ImplicitConfig > const &	t
	)

inline

Definition at line 73 of file ProducerTable.h.

References art::ProducerTable< UserConfig, ImplicitConfig, UserKeysToIgnore >::print_allowed_configuration().

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

std::ostream& art::operator<<	(	std::ostream &	os,
		Level const	l
	)

inline

Definition at line 80 of file Level.h.

References Event, InputFile, Job, NumNestingLevels, ReadyToAdvance, Run, SubRun, and underlying_value().

   {
     switch (l) {
     case Level::Job:
       os << "Job";
       break;
     case Level::InputFile:
       os << "InputFile";
       break;
     case Level::Run:
       os << "Run";
       break;
     case Level::SubRun:
       os << "SubRun";
       break;
     case Level::Event:
       os << "Event";
       break;
     case Level::NumNestingLevels:
       os << underlying_value(Level::NumNestingLevels);
       break;
     case Level::ReadyToAdvance:
       os << "ReadyToAdvance";
       break;
     }
     return os;
   }

std::ostream & art::operator<<	(	ostream &	os,
		ProductProvenance const &	p
	)

Definition at line 83 of file ProductProvenance.cc.

References art::ProductProvenance::write().

   {
     p.write(os);
     return os;
   }

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

Definition at line 84 of file ProductInfo.cc.

   {
     os << "Consumable type: " << info.consumableType << '\n'
        << "Friendly class name: " << info.friendlyClassName << '\n'
        << "Module label: " << info.label << '\n'
        << "Instance name: " << info.instance << '\n'
        << "Process name: " << info.process.name() << '\n';
     return os;
   }

std::ostream& art::operator<<	(	std::ostream &	os,
		Granularity const &	b
	)

inline

Definition at line 85 of file OutputFileGranularity.h.

References art::Granularity::Event, art::Granularity::InputFile, art::Granularity::Job, art::Granularity::Run, art::Granularity::SubRun, and art::Granularity::Unset.

   {
     std::string token{"Unset"};
     switch (b()) {
     case Granularity::Event:
       token = "Event";
       break;
     case Granularity::SubRun:
       token = "SubRun";
       break;
     case Granularity::Run:
       token = "Run";
       break;
     case Granularity::InputFile:
       token = "InputFile";
       break;
     case Granularity::Job:
       token = "Job";
       break;
     case Granularity::Unset:;
     }
     os << token;
     return os;
   }

std::ostream & art::operator<<	(	std::ostream &	os,
		ProcessConfiguration const &	pc
	)

Definition at line 85 of file ProcessConfiguration.cc.

References art::ProcessConfiguration::parameterSetID(), art::ProcessConfiguration::processName(), and art::ProcessConfiguration::releaseVersion().

   {
     os << pc.processName() << ' ' << pc.parameterSetID() << ' '
        << pc.releaseVersion()
        << ' '; // Retain the last space for backwards compatibility
     return os;
   }

std::ostream& art::operator<<	(	std::ostream &	os,
		EventAuxiliary const &	p
	)

Definition at line 109 of file EventAuxiliary.cc.

References art::EventAuxiliary::write().

   {
     p.write(os);
     return os;
   }

std::ostream & art::operator<<	(	ostream &	os,
		TypeID const &	tid
	)

Definition at line 114 of file TypeID.cc.

References art::TypeID::print().

   {
     tid.print(os);
     return os;
   }

ostream& art::operator<<	(	ostream &	ost,
		const HLTGlobalStatus &	hlt
	)

Definition at line 134 of file HLTGlobalStatus.cc.

References n, art::HLTGlobalStatus::size(), and art::HLTGlobalStatus::state().

   {
     vector<string> text{"n"s, "1"s, "0"s, "e"s};
     unsigned const n(hlt.size());
     for (auto i = 0U; i < n; ++i) {
       ost << text.at(hlt.state(i));
     }
     return ost;
   }

std::ostream & art::operator<<	(	std::ostream &	os,
		ModuleDescription const &	p
	)

Definition at line 148 of file ModuleDescription.cc.

References art::ModuleDescription::write().

   {
     p.write(os);
     return os;
   }

std::ostream & art::operator<<	(	ostream &	os,
		SubRunAuxiliary const &	p
	)

Definition at line 149 of file SubRunAuxiliary.cc.

References art::SubRunAuxiliary::write().

   {
     p.write(os);
     return os;
   }

std::ostream & art::operator<<	(	ostream &	os,
		const RunAuxiliary &	p
	)

Definition at line 150 of file RunAuxiliary.cc.

References art::RunAuxiliary::write().

   {
     p.write(os);
     return os;
   }

std::ostream & art::operator<<	(	ostream &	os,
		InputTag const &	tag
	)

Definition at line 150 of file InputTag.cc.

References art::InputTag::instance(), art::InputTag::label(), and art::InputTag::process().

   {
     static string const process("', process = '");
     os << "InputTag: label = '" << tag.label() << "', instance = '"
        << tag.instance()
        << (tag.process().empty() ? string() : (process + tag.process())) << "'";
     return os;
   }

std::ostream & art::operator<<	(	ostream &	os,
		Provenance const &	p
	)

Definition at line 157 of file Provenance.cc.

References art::Provenance::write().

   {
     return p.write(os);
   }

template<int I>

std::ostream& art::operator<<	(	std::ostream &	os,
		Hash< I > const &	h
	)

Definition at line 214 of file Hash.h.

   {
     return h.print(os);
   }

std::ostream & art::operator<<	(	ostream &	os,
		FileProperties const &	fp
	)

Definition at line 222 of file ClosingCriteria.cc.

References art::FileProperties::age(), art::FileProperties::nEvents(), art::FileProperties::nInputFiles(), art::FileProperties::nRuns(), art::FileProperties::nSubRuns(), art::FileProperties::size(), and art::ClosingCriteria::~ClosingCriteria().

   {
     os << "[nEvents: " << fp.nEvents() << ", nSubRuns: " << fp.nSubRuns()
        << ", nRuns: " << fp.nRuns() << ", nInputFiles: " << fp.nInputFiles()
        << ", size: " << fp.size() << ", age: " << fp.age().count() << "]";
     return os;
   }

template<typename T >

std::ostream& art::operator<<	(	std::ostream &	os,
		ProductPtr< T > const &	p
	)

Definition at line 226 of file ProductPtr.h.

References art::RefCore::id().

   {
     os << "(" << p.id() << ")";
     return os;
   }

std::ostream & art::operator<<	(	ostream &	os,
		EventRange const &	r
	)

Definition at line 231 of file EventRange.cc.

References art::EventRange::begin(), art::EventRange::end(), art::EventRange::is_full_subRun(), and art::EventRange::subRun().

   {
     os << "SubRun: " << r.subRun();
     if (r.is_full_subRun()) {
       os << " (full sub-run)";
     } else {
       os << " Event range: [" << r.begin() << ',' << r.end() << ')';
     }
     return os;
   }

std::ostream & art::operator<<	(	ostream &	ost,
		ProcessHistory const &	ph
	)

Definition at line 279 of file ProcessHistory.cc.

   {
     ost << "Process History = ";
     copy_all(ph, ostream_iterator<ProcessHistory::value_type>(ost, ";"));
     return ost;
   }

template<typename T >

std::ostream& art::operator<<	(	std::ostream &	os,
		Ptr< T > const &	p
	)

Definition at line 325 of file Ptr.h.

   {
     os << "(" << p.id() << ", " << p.key() << ")";
     return os;
   }

std::ostream & art::operator<<	(	std::ostream &	os,
		BranchDescription const &	p
	)

Definition at line 334 of file BranchDescription.cc.

References art::BranchDescription::write().

   {
     p.write(os);
     return os;
   }

std::ostream & art::operator<<	(	std::ostream &	os,
		MixHelper::Mode	mode
	)

Definition at line 129 of file MixHelper.cc.

References art::MixHelper::RANDOM_LIM_REPLACE, art::MixHelper::RANDOM_NO_REPLACE, art::MixHelper::RANDOM_REPLACE, art::MixHelper::SEQUENTIAL, and art::MixHelper::UNKNOWN.

 {
   switch (mode) {
   case MixHelper::Mode::SEQUENTIAL:
     return os << "SEQUENTIAL";
   case MixHelper::Mode::RANDOM_REPLACE:
     return os << "RANDOM_REPLACE";
   case MixHelper::Mode::RANDOM_LIM_REPLACE:
     return os << "RANDOM_LIM_REPLACE";
   case MixHelper::Mode::RANDOM_NO_REPLACE:
     return os << "RANDOM_NO_REPLACE";
   case MixHelper::Mode::UNKNOWN:
     return os << "UNKNOWN";
     // No default so compiler can warn.
   }
   return os;
 }

template<typename PROD >

std::ostream& art::operator<<	(	std::ostream &	os,
		Handle< PROD > const &	h
	)

Definition at line 462 of file ProductRetriever.h.

References art::Handle< T >::product().

   {
     os << h.product() << " " << h.provenance() << " " << h.id();
     return os;
   }

std::ostream & art::operator<<	(	ostream &	os,
		RangeSet const &	rs
	)

Definition at line 477 of file RangeSet.cc.

References art::RangeSet::is_full_run(), art::RangeSet::ranges(), and art::RangeSet::run().

   {
     os << " Run: " << rs.run();
     if (rs.is_full_run()) {
       os << " (full run)";
       return os;
     }
     for (auto const& er : rs.ranges()) {
       os << "\n  " << er;
     }
     return os;
   }

std::ostream & art::operator<<	(	ostream &	os,
		FileIndex::Element const &	el
	)

Definition at line 480 of file FileIndex.cc.

References art::FileIndex::Element::entry, and art::FileIndex::Element::eventID.

   {
     os << el.eventID << ": entry# " << el.entry;
     return os;
   }

std::ostream & art::operator<<	(	ostream &	os,
		FileIndex const &	fileIndex
	)

Definition at line 487 of file FileIndex.cc.

References e, art::FileIndex::kEvent, art::FileIndex::kRun, and art::FileIndex::kSubRun.

   {
     os << "\nPrinting FileIndex contents.  This includes a list of all Runs, "
           "SubRuns\n"
        << "and Events stored in the root file.\n\n";
     os << setw(15) << "Run" << setw(15) << "SubRun" << setw(15) << "Event"
        << setw(15) << "TTree Entry"
        << "\n";
     for (auto const& e : fileIndex) {
       if (e.getEntryType() == FileIndex::kEvent) {
         os << setw(15) << e.eventID.run() << setw(15) << e.eventID.subRun()
            << setw(15) << e.eventID.event() << setw(15) << e.entry << "\n";
       } else if (e.getEntryType() == FileIndex::kSubRun) {
         os << setw(15) << e.eventID.run() << setw(15) << e.eventID.subRun()
            << setw(15) << " " << setw(15) << e.entry << "  (SubRun)"
            << "\n";
       } else if (e.getEntryType() == FileIndex::kRun) {
         os << setw(15) << e.eventID.run() << setw(15) << " " << setw(15) << " "
            << setw(15) << e.entry << "  (Run)"
            << "\n";
       }
     }
     return os;
   }

bool art::operator<=	(	ScheduleID const	left,
		ScheduleID const	right
	)

noexcept

Definition at line 47 of file ScheduleID.cc.

References left(), and right().

   {
     return ((left < right) || (left == right));
   }

bool art::operator<=	(	FileIndex::Element const &	lh,
		FileIndex::Element const &	rh
	)

Definition at line 433 of file FileIndex.cc.

   {
     return !(rh < lh);
   }

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

inline

Definition at line 77 of file BranchKey.h.

 {
   return !(a < b || b < a);
 }

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

inline

Definition at line 28 of file FileFormatVersion.h.

References art::FileFormatVersion::value_.

   {
     return a.value_ == b.value_;
   }

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

Definition at line 50 of file Parentage.cc.

References art::Parentage::parents().

   {
     return a.parents() == b.parents();
   }

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

inline

Definition at line 59 of file PathSpec.h.

References to_tuple().

   {
     return to_tuple(a) == to_tuple(b);
   }

constexpr bool art::operator==	(	RefCore const &	lhs,
		RefCore const &	rhs
	)

noexcept

Definition at line 75 of file RefCore.h.

   {
     return lhs.id() == rhs.id();
   }

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

Definition at line 78 of file ProcessConfiguration.cc.

References art::ProcessConfiguration::parameterSetID(), art::ProcessConfiguration::processName(), and art::ProcessConfiguration::releaseVersion().

   {
     return std::tie(a.processName(), a.parameterSetID(), a.releaseVersion()) ==
            std::tie(b.processName(), b.parameterSetID(), b.releaseVersion());
   }

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

noexcept

Definition at line 90 of file ProductProvenance.cc.

   {
     if (a.noParentage() != b.noParentage()) {
       return false;
     }
     if (a.noParentage()) {
       return (a.productID() == b.productID()) &&
              (a.productStatus() == b.productStatus());
     }
     return (a.productID() == b.productID()) &&
            (a.productStatus() == b.productStatus()) &&
            (a.parentageID() == b.parentageID());
   }

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

noexcept

Definition at line 141 of file Provenance.cc.

   {
     return a.equals(b);
   }

template<typename T , typename U >

std::enable_if_t<std::is_same_v<T, U> \|\| std::is_base_of_v<T, U> \|\| std::is_base_of_v<U, T>, bool> art::operator==	(	ProductPtr< T > const &	lhs,
		ProductPtr< U > const &	rhs
	)

Definition at line 201 of file ProductPtr.h.

   {
     return lhs.refCore() == rhs.refCore();
   }

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

Definition at line 243 of file ProcessHistory.cc.

References art::ProcessHistory::data().

   {
     return a.data() == b.data();
   }

template<typename T , typename U >

std::enable_if_t<std::is_same_v<T, U> \|\| std::is_base_of_v<T, U> \|\| std::is_base_of_v<U, T>, bool> art::operator==	(	Ptr< T > const &	lhs,
		Ptr< U > const &	rhs
	)

Definition at line 275 of file Ptr.h.

References art::Ptr< T >::key(), and art::Ptr< T >::refCore().

   {
     return lhs.refCore() == rhs.refCore() and lhs.key() == rhs.key();
   }

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

Definition at line 327 of file BranchDescription.cc.

References art::BranchDescription::combinable, art::BranchDescription::processConfigurationIDs(), and art::BranchDescription::psetIDs().

   {
     return combinable(a, b) && (a.psetIDs() == b.psetIDs()) &&
            (a.processConfigurationIDs() == b.processConfigurationIDs());
   }

bool art::operator==	(	RangeSet const &	l,
		RangeSet const &	r
	)

Definition at line 399 of file RangeSet.cc.

References art::RangeSet::is_valid(), art::RangeSet::ranges(), and art::RangeSet::run().

   {
     if (!(l.is_valid() && r.is_valid())) {
       return false;
     }
     return (l.run() == r.run()) && (l.ranges() == r.ranges());
   }

bool art::operator==	(	FileIndex::Element const &	lh,
		FileIndex::Element const &	rh
	)

Definition at line 439 of file FileIndex.cc.

   {
     return !(lh < rh || rh < lh);
   }

bool art::operator==	(	FileIndex const &	lh,
		FileIndex const &	rh
	)

Definition at line 451 of file FileIndex.cc.

References art::FileIndex::entries_.

   {
     return lh.entries_ == rh.entries_;
   }

bool art::operator>	(	ScheduleID const	left,
		ScheduleID const	right
	)

noexcept

Definition at line 53 of file ScheduleID.cc.

References left(), and right().

Referenced by is_assns().

   {
     return !(left <= right);
   }

bool art::operator>	(	TypeID const &	a,
		TypeID const &	b
	)

Definition at line 96 of file TypeID.cc.

   {
     return b < a;
   }

bool art::operator>	(	FileIndex::Element const &	lh,
		FileIndex::Element const &	rh
	)

Definition at line 421 of file FileIndex.cc.

   {
     return rh < lh;
   }

bool art::operator>=	(	ScheduleID const	left,
		ScheduleID const	right
	)

noexcept

Definition at line 59 of file ScheduleID.cc.

References left(), and right().

   {
     return !(left < right);
   }

bool art::operator>=	(	FileIndex::Element const &	lh,
		FileIndex::Element const &	rh
	)

Definition at line 427 of file FileIndex.cc.

   {
     return !(lh < rh);
   }

template<typename A , typename B >

std::enable_if_t<is_selector<A> && is_selector<B>, OrHelper<A, B> > art::operator\|\|	(	A const &	a,
		B const &	b
	)

Definition at line 303 of file Selector.h.

   {
     return OrHelper<A, B>{a, b};
   }

template<class T , class U >

std::enable_if_t<detail::are_handles_v<T, U>, bool> art::overlapping_ranges	(	T const &	a,
		U const &	b
	)

Referenced by art::RangeSet::emplace_range(), overlapping_ranges(), art::ValidHandle< T >::productGetter(), art::detail::throw_if_invalid(), and art::SummedValue< sumdata::POTSummary >::update_impl().

template<class T , class U >

bool art::overlapping_ranges	(	SummedValue< T > const &	a,
		SummedValue< U > const &	b
	)

Definition at line 200 of file SummedValue.h.

References overlapping_ranges(), and art::SummedValue< T >::rangeOfValidity().

   {
     return overlapping_ranges(a.rangeOfValidity(), b.rangeOfValidity());
   }

bool art::overlapping_ranges	(	RangeSet const &	l,
		RangeSet const &	r
	)

Definition at line 468 of file RangeSet.cc.

References disjoint_ranges(), and art::RangeSet::is_valid().

   {
     if (!(l.is_valid() && r.is_valid())) {
       return false;
     }
     return !disjoint_ranges(l, r);
   }

std::string art::parent_path ( std::string const & path )

Definition at line 15 of file parent_path.cc.

 {
   using namespace std::string_literals;
   std::string result;
   boost::filesystem::path parent_path(
     boost::filesystem::path(in_path).parent_path());
   if (parent_path.empty()) {
     result = "."s;
   } else {
     result = parent_path.native();
   }
   return result;
 }

PathSpec art::path_spec ( std::string const & path_spec )

Definition at line 22 of file PathSpec.cc.

References art::PathID::invalid().

Referenced by art::PathManager::createModulesAndWorkers(), art::PathManager::fillSelectEventsDeps_(), art::PathManager::getModuleGraphInfoCollection_(), art::detail::make_path_ordering_edges(), art::detail::make_synchronization_edges(), art::detail::make_trigger_path_subgraphs(), operator<(), path_specs(), art::detail::path_specs(), art::PathManager::PathManager(), art::detail::print_path_names(), art::detail::prune_config_if_enabled(), and art::detail::triggerReport().

   {
     auto const colon_position = path_spec.find(":");
     if (colon_position == std::string::npos) {
       return PathSpec{path_spec, PathID::invalid()};
     }
     auto name = path_spec.substr(colon_position + 1);
     auto const id = std::stoull(path_spec.substr(0, colon_position));
     return PathSpec{std::move(name), PathID{id}};
   }

std::vector< PathSpec > art::path_specs ( std::vector< std::string > const & path_spec_strs )

Definition at line 34 of file PathSpec.cc.

References art::PathID::invalid(), and path_spec().

Referenced by art::PathManager::fillSelectEventsDeps_(), and operator<().

   {
     std::vector<PathSpec> result;
     cet::for_all_with_index(path_spec_strs,
                             [&result](size_t const i, auto const& str) {
                               auto spec = path_spec(str);
                               if (spec.path_id == PathID::invalid()) {
                                 spec.path_id = PathID{i};
                               }
                               result.push_back(std::move(spec));
                             });
     return result;
   }

template<typename T1 , typename T2 >

std::enable_if_t<std::is_same<T1, T2>::value \|\| std::is_base_of<T1, T2>::value \|\| std::is_base_of<T2, T1>::value, bool> art::pointersEqual	(	T1 *	t1,
		T2 *	t2
	)

inline

Definition at line 15 of file pointersEqual.h.

References t2, and value.

   {
     return t1 == t2;
   }

template<typename T1 , typename T2 >

std::enable_if_t<!std::is_same<T1, T2>::value && !std::is_base_of<T1, T2>::value && !std::is_base_of<T2, T1>::value, bool> art::pointersEqual	(	T1 *	,
		T2 *
	)

Definition at line 26 of file pointersEqual.h.

References art::errors::LogicError.

   {
     throw art::Exception(art::errors::LogicError)
       << "Tried to compare two incompatible pointers.\n";
   }

void art::printArtException	(	cet::exception const &	e,
		char const *	prog
	)

Definition at line 13 of file ExceptionMessages.cc.

Referenced by run_art().

       {
     std::string programName(prog ? prog : "program");
     std::string shortDesc("ArtException");
     std::ostringstream longDesc;
     longDesc << "cet::exception caught in " << programName << '\n'
              << cet::trim_right_copy(e.explain_self(), " \n");
     LogSystem(shortDesc) << longDesc.str();
   }
   catch (...) {
   }

void art::printBadAllocException ( char const * prog )

Definition at line 26 of file ExceptionMessages.cc.

Referenced by run_art().

       {
     std::string programName(prog ? prog : "program");
     std::string shortDesc("std::bad_allocException");
     std::ostringstream longDesc;
     longDesc
       << "std::bad_alloc exception caught in " << programName << '\n'
       << "The job has probably exhausted the virtual memory available to "
          "the process.";
     LogSystem(shortDesc) << longDesc.str();
   }
   catch (...) {
   }

void art::printStdException	(	std::exception const &	e,
		char const *	prog
	)

Definition at line 41 of file ExceptionMessages.cc.

Referenced by run_art().

       {
     std::string programName(prog ? prog : "program");
     std::string shortDesc("StdLibException");
     std::ostringstream longDesc;
     longDesc << "Standard library exception caught in " << programName << '\n'
              << cet::trim_right_copy(e.what(), " \n");
     LogSystem(shortDesc) << longDesc.str();
   }
   catch (...) {
   }

void art::printUnknownException ( char const * prog )

Definition at line 54 of file ExceptionMessages.cc.

Referenced by run_art().

       {
     std::string programName(prog ? prog : "program");
     std::string shortDesc("UnknownException");
     std::ostringstream longDesc;
     longDesc << "Unknown exception caught in " << programName;
     LogSystem(shortDesc) << longDesc.str();
   }
   catch (...) {
   }

std::string const & art::productProvenanceBranchName ( BranchType const bt )

Definition at line 91 of file BranchType.cc.

   {
     return select(bt,
                   {&eventProductProvenance,
                    &subRunProductProvenance,
                    &runProductProvenance,
                    &resultsProductProvenance});
   }

template<typename H >

art::ProductPtr ( H ) -> ProductPtr< typename H::element_type >

template<typename H , typename T >

art::Ptr	(	H	,
		T
	)		-> Ptr< detail::not_map_vector_t< typename H::element_type >>

template<typename T , typename P >

std::enable_if_t<!detail::range_sets_supported(P::branch_type)> art::put_product_in_principal	(	std::unique_ptr< T > &&	product,
		P &	principal,
		std::string const &	module_label,
		std::string const &	instance_name = `{}`
	)

Definition at line 44 of file put_product_in_principal.h.

References canonicalProductName(), art::RangeSet::invalid(), art::errors::NullPointerError, art::productstatus::present(), and art::errors::ProductPutFailure.

Referenced by fluxr::PPFXFluxReader::readNext(), lris::LArRawInputDriverJP250L::readNext(), lris::LArRawInputDriverShortBo::readNext(), lris::LArRawInputDriverLongBo::readNext(), and lris::LArRawInputDriver::readNext().

                                                             {})
   {
     TypeID const typeID{typeid(T)};
     if (product.get() == nullptr) {
       throw Exception(errors::NullPointerError)
         << "put_product_in_principal: A null unique_ptr was passed to 'put'.\n"
         << "The pointer is of type " << typeID << ".\n"
         << "The specified product instance name was '" << instance_name
         << "'.\n";
     }
 
     auto const& process_name = principal.processConfiguration().processName();
     auto const& product_name = canonicalProductName(
       typeID.friendlyClassName(), module_label, instance_name, process_name);
     ProductID const pid{product_name};
     auto desc = principal.getProductDescription(pid);
     if (!desc) {
       throw Exception(errors::ProductPutFailure,
                       "put_product_in_principal: error while trying to "
                       "retrieve product description:\n")
         << "No product is registered for\n"
         << "  process name:                '" << process_name << "'\n"
         << "  module label:                '" << module_label << "'\n"
         << "  product friendly class name: '" << typeID.friendlyClassName()
         << "'\n"
         << "  product instance name:       '" << instance_name << "'\n"
         << "  branch type:                 '" << principal.branchType()
         << "'\n";
     }
 
     principal.put(
       *desc,
       std::make_unique<ProductProvenance const>(pid, productstatus::present()),
       std::make_unique<Wrapper<T>>(std::move(product)),
       std::make_unique<RangeSet>(RangeSet::invalid()));
   }

template<typename T , typename P >

std::enable_if_t<detail::range_sets_supported(P::branch_type)> art::put_product_in_principal	(	std::unique_ptr< T > &&	product,
		P &	principal,
		std::string const &	module_label,
		std::string const &	instance_name = `{}`,
		RangeSet &&	rs = `RangeSet::invalid()`
	)

Definition at line 86 of file put_product_in_principal.h.

References canonicalProductName(), art::RangeSet::invalid(), art::RangeSet::is_valid(), art::errors::NullPointerError, art::productstatus::present(), art::errors::ProductPutFailure, and rangeSetFor().

                                                             {},
                            RangeSet&& rs = RangeSet::invalid())
   {
     TypeID const typeID{typeid(T)};
     if (product.get() == nullptr) {
       throw Exception(errors::NullPointerError)
         << "put_product_in_principal: A null unique_ptr was passed to 'put'.\n"
         << "The pointer is of type " << typeID << ".\n"
         << "The specified product instance name was '" << instance_name
         << "'.\n";
     }
 
     auto const& process_name = principal.processConfiguration().processName();
     auto const& product_name = canonicalProductName(
       typeID.friendlyClassName(), module_label, instance_name, process_name);
     ProductID const pid{product_name};
     auto desc = principal.getProductDescription(pid);
     if (!desc) {
       throw Exception(errors::ProductPutFailure,
                       "put_product_in_principal: error while trying to "
                       "retrieve product description:\n")
         << "No product is registered for\n"
         << "  process name:                '" << process_name << "'\n"
         << "  module label:                '" << module_label << "'\n"
         << "  product friendly class name: '" << typeID.friendlyClassName()
         << "'\n"
         << "  product instance name:       '" << instance_name << "'\n"
         << "  branch type:                 '" << principal.branchType()
         << "'\n";
     }
 
     // If the provided RangeSet is invalid, assign it a RangeSet
     // corresponding to the full (Sub)Run.
     if (!rs.is_valid()) {
       rs = rangeSetFor(principal);
     }
 
     principal.put(
       *desc,
       std::make_unique<ProductProvenance const>(pid, productstatus::present()),
       std::make_unique<Wrapper<T>>(std::move(product)),
       std::make_unique<RangeSet>(rs));
   }

template<class T >

std::enable_if_t<detail::is_handle_v<T>, RangeSet const&> art::range_of_validity ( T const & h )

Referenced by art::ValidHandle< T >::productGetter(), and art::detail::throw_if_invalid().

RangeSet art::rangeSetFor ( RunPrincipal const & rp )

inline

Definition at line 31 of file put_product_in_principal.h.

References art::RangeSet::forRun(), and art::RunPrincipal::runID().

Referenced by put_product_in_principal().

   {
     return RangeSet::forRun(rp.runID());
   }

RangeSet art::rangeSetFor ( SubRunPrincipal const & srp )

inline

Definition at line 37 of file put_product_in_principal.h.

References art::RangeSet::forSubRun(), and art::SubRunPrincipal::subRunID().

   {
     return RangeSet::forSubRun(srp.subRunID());
   }

std::vector< std::vector< std::string >::const_iterator > art::regexMatch	(	std::vector< std::string > const &	strings,
		std::string const &	pattern
	)

Definition at line 25 of file RegexMatch.cc.

References e, and glob2reg().

Referenced by art::EventSelector::data_for().

   {
     auto const reg_str = glob2reg(pattern);
     // We allow for a trigger-bit to lead the trigger path name.
     std::regex const regexp{"(\\d+:)?" + glob2reg(pattern)};
     std::vector<std::vector<std::string>::const_iterator> result;
     for (auto it = strings.begin(), e = strings.end(); it != e; ++it) {
       if (std::regex_match(*it, regexp)) {
         result.push_back(it);
       }
     }
     return result;
   }

std::vector< GroupQueryResult > art::resolve_products	(	std::vector< cet::exempt_ptr< art::Group >> const &	groups,
		art::TypeID const &	wrapped_type
	)

Definition at line 428 of file Group.cc.

Referenced by art::ProductRetriever::getContainerForView_(), and art::Principal::getMany().

   {
     std::vector<GroupQueryResult> results;
     for (auto group : groups) {
       if (group->tryToResolveProduct(wrapped_type)) {
         results.emplace_back(group.get());
       }
     }
     return results;
   }

std::optional< GroupQueryResult > art::resolve_unique_product	(	std::vector< cet::exempt_ptr< art::Group >> const &	product_groups,
		art::WrappedTypeID const &	wrapped
	)

Definition at line 387 of file Group.cc.

References e, art::WrappedTypeID::product_type, art::errors::ProductNotFound, and art::WrappedTypeID::wrapped_product_type.

Referenced by art::Principal::getBySelector().

   {
     auto by_process_name = [](auto const ga, auto const gb) {
       return ga->productDescription().processName() ==
              gb->productDescription().processName();
     };
 
     // We group product groups according to their process names.  The
     // product groups have already been assembled in reverse-process
     // history.  The first process with a match wins.  Note that it is
     // an error for there to be multiple matches per process.
     for (auto const groups_per_process :
          ::ranges::views::chunk_by(product_groups, by_process_name)) {
       // Keep track of all matched groups so that a helpful error
       // message can be reported.
       std::vector<cet::exempt_ptr<art::Group>> matched_groups;
       for (auto const group : groups_per_process) {
         if (group->tryToResolveProduct(wrapped.wrapped_product_type)) {
           matched_groups.emplace_back(group.get());
         }
       }
 
       if (auto const num_matches = matched_groups.size(); num_matches == 1) {
         return std::make_optional(GroupQueryResult{matched_groups[0]});
       } else if (num_matches > 1) {
         Exception e{errors::ProductNotFound};
         e << "Found " << num_matches
           << " products rather than one that match all criteria\n"
           << "  C++ type: " << wrapped.product_type << '\n';
         for (auto group : matched_groups) {
           e << "  " << group->productDescription().inputTag() << '\n';
         }
         throw e;
       }
     }
     return std::nullopt;
   }

template<typename L , typename R , typename D , Direction Dir>

constexpr auto const& art::right	(	const_AssnsIter< L, R, D, Dir > const &	a,
		const_AssnsIter< L, R, D, Dir > const &	b
	)

Definition at line 102 of file AssnsIter.h.

References Forward.

   {
     return (Dir == Direction::Forward) ? b : a;
   }

int art::run_art	(	int	argc,
		char **	argv,
		bpo::options_description &	all_desc,
		OptionsHandlers &&	handlers
	)

Definition at line 142 of file run_art.cc.

References e, art::detail::exists_outside_prolog(), art::detail::fhicl_key(), fhicl::intermediate_table::get(), fhicl::ParameterSet::get(), fhicl::ParameterSet::has_key(), art::detail::info_success(), fhicl::ParameterSet::make(), art::detail::print_config_summary(), printArtException(), printBadAllocException(), printStdException(), printUnknownException(), art::detail::prune_config_if_enabled(), fhicl::ParameterSetRegistry::put(), mf::SetIteration(), shutdown_flag, mf::StartMessageFacility(), value, and art::detail::collected_exception::what().

Referenced by artapp().

   {
     // This must be added separately: how to deal with any non-option arguments.
     bpo::positional_options_description pd;
     // A single non-option argument will be taken to be the source data file.
     pd.add("source", -1);
     // Parse the command line.
     bpo::variables_map vm;
     try {
       bpo::store(bpo::command_line_parser(argc, argv)
                    .options(all_desc)
                    .style(bpo::command_line_style::default_style &
                           ~bpo::command_line_style::allow_guessing)
                    .positional(pd)
                    .run(),
                  vm);
       bpo::notify(vm);
     }
     catch (bpo::error const& e) {
       cerr << "Exception from command line processing in " << argv[0] << ": "
            << e.what() << '\n';
       return 88;
     }
     // Preliminary argument checking.
     for (auto& handler : handlers) {
       auto const result = handler->checkOptions(vm);
       if (result != 0) {
         return result;
       }
     }
     // Processing of arguments and post-processing of config.
     fhicl::intermediate_table raw_config;
     for (auto& handler : handlers) {
       auto const result = handler->processOptions(vm, raw_config);
       if (result != 0) {
         return result;
       }
     }
 
     // If configuration pruning has been enabled, remove unused module
     // configurations.
     using detail::exists_outside_prolog;
     auto const scheduler_key = fhicl_key("services", "scheduler");
     auto enabled_modules = detail::EnabledModules::none();
     assert(exists_outside_prolog(raw_config, scheduler_key));
     try {
       auto const pruneConfigKey = fhicl_key(scheduler_key, "pruneConfig");
       auto const reportUnusedKey = fhicl_key(scheduler_key, "reportUnused");
       assert(exists_outside_prolog(raw_config, pruneConfigKey));
       assert(exists_outside_prolog(raw_config, reportUnusedKey));
       bool const prune_config = raw_config.get<bool>(pruneConfigKey);
       bool const report_unused = raw_config.get<bool>(reportUnusedKey);
       enabled_modules = detail::prune_config_if_enabled(
         prune_config, report_unused, raw_config);
     }
     catch (Exception const& e) {
       printArtException(e, "art");
       return e.returnCode();
     }
     catch (cet::exception const& e) {
       printArtException(e, "art");
       return 65;
     }
     catch (std::bad_alloc const& bda) {
       printBadAllocException("art");
       return 68;
     }
     catch (std::exception const& e) {
       printStdException(e, "art");
       return 66;
     }
     catch (...) {
       printUnknownException("art");
       return 67;
     }
 
     //
     // Make the parameter set from the intermediate table.
     //
     fhicl::ParameterSet main_pset;
     try {
       main_pset = fhicl::ParameterSet::make(raw_config);
     }
     catch (cet::exception const& e) {
       constexpr cet::HorizontalRule rule{36};
       cerr << "ERROR: Failed to create a parameter set from parsed "
               "configuration with exception "
            << e.what() << ".\n";
       cerr << "       Intermediate configuration state follows:\n"
            << rule('-') << '\n'
            << rule('-') << '\n';
       for (auto const& [key, value] : raw_config) {
         cerr << key << ": " << value.to_string() << '\n';
       }
       cerr << rule('-') << '\n' << rule('-') << '\n';
       return 91;
     }
     // Main parameter set must be placed in registry manually.
     try {
       fhicl::ParameterSetRegistry::put(main_pset);
     }
     catch (...) {
       cerr << "Uncaught exception while inserting main parameter set into "
               "registry.\n";
       throw;
     }
 
 #ifdef __linux__
     // Tell the system memory allocator to only use one arena: they
     // are 64 MiB in size, and the default is 8 * num_of_cores.  Using
     // the default means that when using 40 threads we get 40 arenas,
     // which means we have 40 * 64 MiB = 2560 MiB of virtual address
     // space devoted to per-thread heaps!!!
     mallopt(M_ARENA_MAX, 1);
 #endif // __linux__
 
     auto const services_pset =
       main_pset.get<fhicl::ParameterSet>("services", {});
     auto const scheduler_pset =
       services_pset.get<fhicl::ParameterSet>("scheduler", {});
 
     // Handle early configuration-debugging
     auto const debug_mode = debug_processing_mode(scheduler_pset);
     if (debug_mode != debug_processing::none) {
       auto const debug_pset = scheduler_pset.get<fhicl::ParameterSet>("debug");
       auto const filename = debug_pset.get<std::string>("fileName");
       auto const mode = debug_pset.get<std::string>("printMode");
 
       switch (debug_mode) {
       case debug_processing::validate_config: {
         [[fallthrough]];
       }
       case debug_processing::config_out: {
         print_config(main_pset, filename, mode);
         break;
       }
       case debug_processing::debug_config: {
         print_config(main_pset, filename, mode);
         return detail::info_success();
       }
       case debug_processing::config_summary: {
         detail::print_config_summary(main_pset, mode, enabled_modules);
         return detail::info_success();
       }
       case debug_processing::none:
         break;
       }
     }
     //
     // Start the messagefacility
     //
     mf::SetIteration("JobSetup");
     try {
       mf::StartMessageFacility(
         services_pset.get<fhicl::ParameterSet>("message", {}));
     }
     catch (cet::exception const& e) {
       cerr << e.what() << '\n';
       return 69;
     }
     catch (exception const& e) {
       cerr << e.what() << '\n';
       return 70;
     }
     catch (...) {
       cerr << "Caught unknown exception while initializing the message "
               "facility.\n";
       return 71;
     }
     mf::LogInfo("MF_INIT_OK") << "Messagelogger initialization complete.";
     //
     // Start the EventProcessor
     //
     int rc{0};
     try {
       EventProcessor ep{std::move(main_pset), std::move(enabled_modules)};
       // Behavior of validate_config is to validate FHiCL syntax *and*
       // user-specified configurations of paths, modules, services,
       // etc.  It is thus possible that an exception thrown during
       // construction of the EventProcessor object can have nothing to
       // do with a configuration error.
       if (debug_mode == debug_processing::validate_config) {
         return detail::info_success();
       }
       if (scheduler_pset.has_key("dataDependencyGraph")) {
         return detail::info_success();
       }
       auto ep_rc = ep.runToCompletion();
       if (ep_rc == EventProcessor::epSignal) {
         cerr << "Art has handled signal " << art::shutdown_flag << ".\n";
         if (scheduler_pset.get<bool>("errorOnSIGINT")) {
           rc = 128 + art::shutdown_flag;
         }
       }
     }
     catch (Exception const& e) {
       rc = e.returnCode();
       printArtException(e, "art");
     }
     catch (cet::exception const& e) {
       rc = 65;
       printArtException(e, "art");
     }
     catch (detail::collected_exception const& e) {
       rc = 1;
       // LogSystem already adds a newline, so trim the one that's
       // already in the exception message.
       std::string const msg{e.what()};
       mf::LogSystem("ArtException") << msg.substr(0, msg.find_last_of("\n"));
     }
     catch (bad_alloc const& bda) {
       rc = 68;
       printBadAllocException("art");
     }
     catch (exception const& e) {
       rc = 66;
       printStdException(e, "art");
     }
     catch (...) {
       rc = 67;
       printUnknownException("art");
     }
     return rc;
   }

constexpr auto art::runFragment ( )

Definition at line 33 of file ProductSemantics.h.

   {
     return FragmentSemantic<Level::Run>{};
   }

auto art::runFragment ( RangeSet const & rs )

inline

Definition at line 44 of file ProductSemantics.h.

   {
     return RangedFragmentSemantic<Level::Run>{rs};
   }

template<class T , class U >

std::enable_if_t<detail::are_handles_v<T, U>, bool> art::same_ranges	(	T const &	a,
		U const &	b
	)

Referenced by art::RangeSet::emplace_range(), art::ValidHandle< T >::productGetter(), same_ranges(), art::detail::throw_if_invalid(), and art::SummedValue< sumdata::POTSummary >::update_impl().

template<class T , class U >

bool art::same_ranges	(	SummedValue< T > const &	a,
		SummedValue< U > const &	b
	)

Definition at line 186 of file SummedValue.h.

References art::SummedValue< T >::rangeOfValidity(), and same_ranges().

   {
     return same_ranges(a.rangeOfValidity(), b.rangeOfValidity());
   }

bool art::same_ranges	(	RangeSet const &	l,
		RangeSet const &	r
	)

Definition at line 408 of file RangeSet.cc.

References r.

   {
     return l == r;
   }

auto art::sampled_from ( std::string process_name )

inline

Definition at line 110 of file Sampled.h.

   {
     return process_name.insert(0, "SampledFrom");
   }

template<class COLLECTION >

void art::setPtr	(	COLLECTION const &	coll,
		std::type_info const &	iToType,
		unsigned long	iIndex,
		void const *&	oPtr
	)

Referenced by art::Wrapper< T >::do_getElementAddress().

template<typename T >

void art::setPtr	(	cet::map_vector< T > const &	obj,
		std::type_info const &	iToType,
		unsigned long	iIndex,
		void const *&	oPtr
	)

Definition at line 52 of file setPtr.h.

References art::detail::value_type_helper::look_past_pair(), art::detail::maybeCastObj(), art::detail::value_type_helper::starts_with_pair(), and uniform_type_name().

 {
   detail::value_type_helper vh;
   std::string const wanted_type =
     uniform_type_name(cet::demangle_symbol(iToType.name()));
   static size_t pos = vh.look_past_pair<T>();
   auto const it = obj.findOrThrow(cet::map_vector_key{iIndex});
   assert(it != obj.end());
   if (pos < wanted_type.size() and vh.starts_with_pair(wanted_type, pos)) {
     // Want value_type, not mapped_type;
     oPtr = detail::maybeCastObj(&*it, iToType);
   } else {
     oPtr = detail::maybeCastObj(&it->second, iToType);
   }
 }

void art::setupSignals ( bool want_sigint_enabled )

Definition at line 120 of file UnixSignalHandlers.cc.

References handle_sigusr2().

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

   {
     installCustomHandler(SIGUSR2, handle_sigusr2);
     installCustomHandler(SIGTERM, handle_sigusr2);
     installCustomHandler(SIGQUIT, handle_sigusr2);
     if (want_sigint_enabled) {
       installCustomHandler(SIGINT, handle_sigusr2);
     }
   }

template<Direction Dir>

constexpr int art::signed_one ( )

Definition at line 17 of file AssnsIter.h.

References Forward.

   {
     return static_cast<std::underlying_type_t<Direction>>(Dir);
   }

std::pair< std::string, std::string > art::split_process_and_path_names ( std::string path_spec )

Definition at line 11 of file PathSpec.cc.

References art::detail::remove_whitespace().

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

constexpr auto art::subRunFragment ( )

Definition at line 38 of file ProductSemantics.h.

Referenced by evgen::GENIEGen::endSubRun().

   {
     return FragmentSemantic<Level::SubRun>{};
   }

auto art::subRunFragment ( RangeSet const & rs )

inline

Definition at line 49 of file ProductSemantics.h.

   {
     return RangedFragmentSemantic<Level::SubRun>{rs};
   }

template<typename T >

void art::swap	(	PtrVector< T > &	lhs,
		PtrVector< T > &	rhs
	)

inline

Definition at line 595 of file PtrVector.h.

References art::PtrVector< T >::swap().

Referenced by art::PtrVector< T >::swap().

 {
   lhs.swap(rhs);
 }

void art::swap	(	TriggerResults &	lhs,
		TriggerResults &	rhs
	)

template<class T >

void art::swap	(	Handle< T > &	a,
		Handle< T > &	b
	)

Referenced by art::Assns< L, R, void >::swap_(), and art::BranchDescription::wrappedName().

template<class T >

void art::swap	(	ValidHandle< T > &	a,
		ValidHandle< T > &	b
	)

Referenced by art::Handle< T >::swap(), and art::ValidHandle< T >::swap().

void art::swap	(	RefCore &	lhs,
		RefCore &	rhs
	)

Definition at line 70 of file RefCore.cc.

References art::RefCore::swap().

Referenced by art::RefCore::swap().

   {
     lhs.swap(rhs);
   }

void art::swap	(	OutputHandle &	a,
		OutputHandle &	b
	)

Definition at line 71 of file OutputHandle.cc.

References art::OutputHandle::swap().

Referenced by art::OutputHandle::swap().

   {
     a.swap(b);
   }

void art::swap	(	TypeID &	left,
		TypeID &	right
	)

Definition at line 108 of file TypeID.cc.

References art::TypeID::swap().

Referenced by art::TypeID::swap().

   {
     left.swap(right);
   }

template<int I>

void art::swap	(	Hash< I > &	a,
		Hash< I > &	b
	)

Definition at line 207 of file Hash.h.

References art::Hash< I >::swap().

   {
     a.swap(b);
   }

void art::swap	(	ProcessHistory &	a,
		ProcessHistory &	b
	)

Definition at line 237 of file ProcessHistory.cc.

References art::ProcessHistory::swap().

   {
     a.swap(b);
   }

void art::throw_if_not_disjoint	(	RunNumber_t const	rn,
		EventRange const &	left,
		EventRange const &	right
	)

noexcept

Definition at line 453 of file RangeSet.cc.

References art::errors::EventRangeOverlap, left(), and right().

Referenced by art::RangeSet::collapse(), and art::RangeSet::emplace_range().

   {
     if (left.is_disjoint(right))
       return;
     throw art::Exception(art::errors::EventRangeOverlap)
       << "Attempt to merge event ranges that both contain one or more of the "
          "same events\n"
       << " Run: " << rn << '\n'
       << "  " << left << "  vs.\n"
       << "  " << right << '\n';
   }

std::string art::to_iso_string_assuming_unix_epoch ( Timestamp const & ts )

Definition at line 8 of file Timestamp.cc.

References art::Timestamp::value().

Referenced by art::Timestamp::lowMask().

   {
     auto const t = static_cast<time_t>(ts.value());
     auto const p = boost::posix_time::from_time_t(t);
     return boost::posix_time::to_iso_string(p);
   }

std::string art::to_string ( ModuleType const mt )

inline

Definition at line 34 of file ModuleType.h.

References analyzer, filter, art::errors::LogicError, non_art, output_module, and producer.

Referenced by art::BasicOptionsHandler::BasicOptionsHandler(), art::PathManager::fillWorkers_(), art::PathManager::moduleInformation_(), operator<<(), art::PathManager::prependedTriggerPathNames_(), art::Wrapper< T >::productSize(), art::PostCloseFileRenamer::subTimestamp_(), art::RangeSet::to_compact_string(), and to_string().

   {
     switch (mt) {
     case ModuleType::non_art:
       return "non-art";
     case ModuleType::producer:
       return "producer";
     case ModuleType::filter:
       return "filter";
     case ModuleType::analyzer:
       return "analyzer";
     case ModuleType::output_module:
       return "output module";
     default:
       throw Exception(errors::LogicError)
         << "Unable to find string for unrecognized ModuleType value "
         << static_cast<int>(mt) << ".\n";
     }
   }

std::string art::to_string ( PathID const id )

Definition at line 49 of file PathSpec.cc.

References to_string().

   {
     return std::to_string(id.id_);
   }

std::string art::to_string ( PathSpec const & spec )

Definition at line 55 of file PathSpec.cc.

References art::PathSpec::name, art::PathSpec::path_id, and to_string().

Referenced by to_string().

   {
     return to_string(spec.path_id) + ':' + spec.name;
   }

auto art::to_tuple ( PathSpec const & spec )

inlinenoexcept

Definition at line 53 of file PathSpec.h.

Referenced by operator<(), and operator==().

   {
     return std::tie(spec.name, spec.path_id);
   }

std::string art::translateFileDeliveryStatus ( FileDeliveryStatus stat )

Definition at line 8 of file FileDeliveryStatus.cc.

References art::detail::FDS::BAD_GATEWAY, art::detail::FDS::BAD_REQUEST, art::detail::FDS::CONFLICT, art::detail::FDS::FORBIDDEN, art::detail::FDS::NO_MORE_FILES, art::detail::FDS::NOT_FOUND, art::detail::FDS::PENDING, art::detail::FDS::SERVER_EXCEPTION, art::detail::FDS::SPECIFIC_ERRORS, SUCCESS, art::detail::FDS::TRY_AGAIN_LATER, and art::detail::FDS::UNAVAILABLE.

Referenced by art::detail::FileServiceProxy::obtainURI_().

 {
   switch (stat) {
   default: {
     std::ostringstream os;
     os << "UNKNOWN" << std::setfill('0') << std::setw(3)
        << static_cast<int>(stat);
     return os.str();
   }
   case FileDeliveryStatus::PENDING:
     return "PENDING";
   case FileDeliveryStatus::SUCCESS:
     return "SUCCESS";
   case FileDeliveryStatus::TRY_AGAIN_LATER:
     return "TRY_AGAIN_LATER";
   case FileDeliveryStatus::NO_MORE_FILES:
     return "NO_MORE_FILES";
   case FileDeliveryStatus::BAD_REQUEST:
     return "BAD_REQUEST";
   case FileDeliveryStatus::FORBIDDEN:
     return "FORBIDDEN";
   case FileDeliveryStatus::NOT_FOUND:
     return "NOT_FOUND";
   case FileDeliveryStatus::CONFLICT:
     return "CONFLICT";
   case FileDeliveryStatus::SERVER_EXCEPTION:
     return "SERVER_EXCEPTION";
   case FileDeliveryStatus::BAD_GATEWAY:
     return "BAD_GATEWAY";
   case FileDeliveryStatus::UNAVAILABLE:
     return "UNAVAILABLE";
   case FileDeliveryStatus::SPECIFIC_ERRORS:
     return "SPECIFIC_ERRORS";
   }
 }

std::string art::translateFileDisposition ( FileDisposition fd )

Definition at line 8 of file FileDisposition.cc.

References art::detail::FDS::PENDING.

 {
   switch (fd) {
   default: {
     std::ostringstream os;
     os << "UNKNOWN" << std::setfill('0') << std::setw(3)
        << static_cast<int>(fd);
     return os.str();
   }
   case FileDisposition::PENDING:
     return "PENDING";
   case FileDisposition::TRANSFERRED:
     return "TRANSFERED";
   case FileDisposition::CONSUMED:
     return "CONSUMED";
   case FileDisposition::SKIPPED:
     return "SKIPPED";
   case FileDisposition::INCOMPLETE:
     return "INCOMPLETE";
   }
 }

std::string art::translateFileTransferStatus ( FileTransferStatus stat )

Definition at line 8 of file FileTransferStatus.cc.

References art::detail::FDS::BAD_REQUEST, art::detail::FDS::FORBIDDEN, art::detail::FTS::GONE, art::detail::FDS::NOT_FOUND, art::detail::FTS::PAYMENT_REQUIRED, art::detail::FDS::PENDING, art::detail::FTS::SERVER_ERROR, SUCCESS, art::detail::FTS::TOO_LARGE, art::detail::FTS::UNAUTHORIZED, art::detail::FDS::UNAVAILABLE, and art::detail::FTS::URI_TOO_LONG.

Referenced by art::detail::FileServiceProxy::obtainFileFromURI_().

 {
   switch (stat) {
   default: {
     std::ostringstream os;
     os << "UNKNOWN" << std::setfill('0') << std::setw(3)
        << static_cast<int>(stat);
     return os.str();
   }
   case FileTransferStatus::PENDING:
     return "PENDING";
   case FileTransferStatus::SUCCESS:
     return "SUCCESS";
   case FileTransferStatus::BAD_REQUEST:
     return "BAD_REQUEST";
   case FileTransferStatus::UNAUTHORIZED:
     return "UNAUTHORIZED";
   case FileTransferStatus::PAYMENT_REQUIRED:
     return "PAYMENT_REQUIRED";
   case FileTransferStatus::FORBIDDEN:
     return "FORBIDDEN";
   case FileTransferStatus::NOT_FOUND:
     return "NOT_FOUND";
   case FileTransferStatus::GONE:
     return "GONE";
   case FileTransferStatus::TOO_LARGE:
     return "TOO_LARGE";
   case FileTransferStatus::URI_TOO_LONG:
     return "URI_TOO_LONG";
   case FileTransferStatus::SERVER_ERROR:
     return "SERVER_ERROR";
   case FileTransferStatus::UNAVAILABLE:
     return "UNAVAILABLE";
   }
 }

constexpr auto art::underlying_value ( Level const l )

noexcept

Definition at line 26 of file Level.h.

Referenced by is_above_most_deeply_nested_level(), is_level_contained_by(), level_down(), level_up(), and operator<<().

   {
     return static_cast<std::underlying_type_t<Level>>(l);
   }

std::string art::uniform_type_name ( std::type_info const & tid )

inline

Definition at line 36 of file uniform_type_name.h.

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

 {
   return uniform_type_name(cet::demangle_symbol(tid.name()));
 }

std::string art::uniform_type_name ( std::string name )

Parameters

[in] name The already-demangled name for a type.

Definition at line 158 of file uniform_type_name.cc.

 {
   using namespace std::string_literals;
   // We must use the same conventions previously used by Reflex.
   // The order is important.
 
   // Translate any inlined namespace
   translateInlineNamespace(name);
 
   // We must change std::__cxx11:: -> std:: for all type names. This
   // should not have implications for I/O because ROOT stores the data
   // that STL objects represent rather than doing a "dumb serialization"
   // of the class.
   cet::replace_all(name, "std::__cxx11::"s, "std::"s);
   // According to a report from Chris Jones, Apple Clang has a similar
   // issue with std::__1.
   cet::replace_all(name, "std::__1::"s, "std::"s);
 
   // No space after comma.
   cet::replace_all(name, ", "s, ","s);
   // No space before opening square bracket.
   cet::replace_all(name, " ["s, "["s);
   // Strip default allocator.
   removeParameter(name, ",std::allocator<"s);
   // Strip default comparator.
   removeParameter(name, ",std::less<"s);
   // Strip char traits.
   removeParameter(name, ",std::char_traits<"s);
   // std::basic_string<char> -> std::string
   {
     static std::regex const bs_regex("std::basic_string<char>\\s*"s);
     reformat(name, bs_regex, "std::string"s);
   }
   // Put const qualifier before identifier.
   constBeforeIdentifier(name);
 
   // No spaces between template brakets and arguments
   // FIXME?: need a regex because just stripping the spaces
   // can cause subsequent ">>" removal fail...
   {
     static std::regex const bk_regex("([_a-zA-Z0-9])( +)>");
     static std::string const bk_format("$1>");
     reformat(name, bk_regex, bk_format);
   }
 
   // No consecutive '>'.
   //
   // FIXME: The first time we see a type with e.g. operator>> as a
   // template argument, we could have a problem.
   cet::replace_all(name, ">>"s, "> >"s);
   // No u or l qualifiers for integers.
   {
     static std::regex const ul_regex("(.*[<,][0-9]+)[ul]l*([,>].*)"s);
     reformat(name, ul_regex, "$1$2"s);
   }
   // For ROOT 6 and beyond.
   cet::replace_all(name, "unsigned long long"s, "ULong64_t"s);
   cet::replace_all(name, "long long"s, "Long64_t"s);
   // Done.
   return name;
 }

std::string art::unique_filename	(	std::string	stem,
		std::string	extension = `".root"`
	)

Definition at line 18 of file unique_filename.cc.

References close(), e, and art::errors::FileOpenError.

 {
   boost::filesystem::path const p(stem + "-%%%%-%%%%-%%%%-%%%%" + extension);
   boost::filesystem::path outpath;
   boost::system::error_code ec;
   int tmp_fd = -1, error = 0;
   do {
     outpath = boost::filesystem::unique_path(p, ec);
   } while (!ec && (tmp_fd = creat(outpath.c_str(), S_IRUSR | S_IWUSR)) == -1 &&
            (error = errno) == EEXIST);
   if (tmp_fd != -1) {
     close(tmp_fd);
   } else {
     art::Exception e(art::errors::FileOpenError);
     e << "RootOutput cannot ascertain a unique temporary filename for output "
          "based on stem\n\""
       << stem << "\": ";
     if (ec) {
       e << ec;
     } else {
       e << strerror(error);
     }
     e << ".\n";
     throw e;
   }
   return outpath.native();
 }

std::string art::wrappedClassName ( std::string const & className )

Definition at line 5 of file WrappedClassName.cc.

Referenced by art::BranchDescription::fluffTransients_().

   {
     static std::string const wrapperBegin("art::Wrapper<");
     static std::string const wrapperEnd1(">");
     static std::string const wrapperEnd2(" >");
     std::string const& wrapperEnd =
       (className[className.size() - 1] == '>' ? wrapperEnd2 : wrapperEnd1);
     std::string wrapped;
     wrapped.reserve(wrapperBegin.size() + className.size() + wrapperEnd.size());
     wrapped += wrapperBegin;
     wrapped += className;
     wrapped += wrapperEnd;
     return wrapped;
   }

Variable Documentation

DebugValue art::debugit

Definition at line 14 of file DebugMacros.cc.

Referenced by art::ActionTable::addDefaults_().

DebugTasksValue art::debugTasks

Definition at line 75 of file TaskDebugMacros.cc.

template<typename T >

constexpr bool art::is_selector

Initial value:

=

std::is_base_of_v<SelectorBase, std::remove_reference_t<T>>

Definition at line 44 of file Selector.h.

template<typename T >

detail::SharedResource_t art::SharedResource {typeid(T).name(), true}

Definition at line 25 of file SharedResource.h.

atomic< int > art::shutdown_flag {0}

Definition at line 19 of file UnixSignalHandlers.cc.

Referenced by handle_sigusr2(), art::EventProcessor::process(), art::EventProcessor::readAndProcessAsync(), run_art(), and art::EventProcessor::runToCompletion().

Namespaces

Classes

Typedefs

Enumerations

Functions

Variables

Detailed Description

Typedef Documentation

Enumeration Type Documentation

Function Documentation

Variable Documentation