HLT enums. More...

Namespaces
	actions

	detail

	errors

	evtSel

	ExceptionDetail

	fp_detail

	friendlyname

	gfactory

	hlt

	input

	productstatus

	PtrRemapperDetail

	root

	rootNames

	stats

	test

Classes
class	ActionTable

class	ActivityRegistry

class	AndHelper

class	Assns

class	Assns< L, R, void >

class	AssnsGroup

class	AssnsGroupWithData

struct	AssnsNode

class	BasicOptionsHandler

class	BasicOutputOptionsHandler

class	BasicPostProcessor

class	BasicSourceOptionsHandler

class	BeginEndPackage

class	BeginEndPackage< Level::Run >

class	BeginEndPackage< Level::SubRun >

class	BlockingPrescaler

class	BoolCache

class	BranchChildren

class	BranchDescription

class	BranchID

struct	BranchKey

class	BranchMapper

class	BranchMapperWithReader

struct	CannotFillView

class	CatalogInterface

class	ClosedRangeSetHandler

class	ClosingCriteria

class	Compare_Run_SubRun_EventEntry

class	ComparePtrs

class	ComposedSelectorWrapper

class	const_AssnsIter

class	ConstPtrCache

class	Consumer

class	CurrentModule

class	CurrentProcessingContext

class	DatabaseConnection

class	DataFlow

class	DataViewImpl

class	debugging_allocator

class	DebugOptionsHandler

struct	debugvalue

class	DecrepitRelicInputSourceImplementation

struct	Defaults

class	DeferredProductGetter

class	DelayedReader

struct	DoMakePartner

struct	DoNotMakePartner

struct	DoNotSetPtr

struct	DoSetPtr

class	DropMetaData

class	DuplicateChecker

class	EDAnalyzer

class	EDFilter

class	EDProducer

class	EDProduct

class	EDProductGetter

class	EDProductGetterFinder

class	EmptyEvent

class	EmptyEventTimestampPlugin

class	EndPathExecutor

class	EngineCreator

class	Event

class	EventAuxiliary

class	EventID

class	EventIDFilter

class	EventIDMatcher

class	EventObserverBase

class	EventPrincipal

struct	EventProcessHistoryID

class	EventProcessor

class	EventRange

class	EventSelector

struct	EventSummary

class	ExecutionCounts

class	FastCloningInfoProvider

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	GlobalSignal

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

class	Granularity

class	Group

class	GroupQueryResult

class	GroupSelector

class	GroupSelectorRules

class	Handle

struct	has_fillView

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

struct	has_mapped_type

struct	has_mapped_type< T, cet::enable_if_type_exists_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, cet::enable_if_type_exists_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	InputSourceFactory

class	InputTag

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	MasterProductRegistry

class	MatchAllSelector

struct	MaybeFillView

struct	MaybeFillView< cet::map_vector< T > >

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

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

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

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

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

struct	MaybeFillView< T, std::enable_if_t< has_fillView< T >::value > >

class	MaybeIncrementCounts

class	MaybeIncrementCounts< Level::Event, T >

class	MemoryAdjuster

class	MemoryTracker

class	MFStatusUpdater

struct	MinimalToolConfig

class	MixFilter

class	MixHelper

class	MixOp

class	MixOpBase

class	ModuleDescription

struct	ModuleInPathSummary

class	ModuleLabelSelector

struct	NewToOld

class	NoDelayedReader

class	NotHelper

struct	OldToNew

class	OpenRangeSetHandler

class	OptionsHandler

class	OrHelper

class	OutputFileInfo

class	OutputHandle

class	OutputModule

struct	OutputModuleDescription

class	OutputWorker

struct	ParameterSetBlob

class	Parentage

class	Path

class	PathManager

class	PathsInfo

struct	PathSummary

class	PostCloseFileRenamer

class	Prescaler

class	Principal

struct	ProcessConfiguration

class	ProcessHistory

class	ProcessingOptionsHandler

class	ProcessNameSelector

class	ProcessPackage

class	ProdToProdMapBuilder

class	ProducerBase

class	ProducerTable

class	ProducingService

class	ProducingServiceSignals

class	ProductID

class	ProductInfo

class	ProductInstanceNameSelector

class	ProductMetaData

class	ProductProvenance

struct	ProductRegistry

class	ProductRegistryHelper

struct	productSize

struct	productSize< cet::map_vector< E >, false >

struct	productSize< PtrVector< E >, false >

struct	productSize< std::deque< E >, false >

struct	productSize< std::list< E >, false >

struct	productSize< std::set< E >, false >

struct	productSize< std::vector< E >, false >

struct	productSize< T, false >

struct	productSize< T, true >

struct	ProductTable

class	ProductTables

class	ProductToken

class	Provenance

class	ProvenanceCheckerOutput

class	ProvenanceDumper

class	ProvenanceDumper< DETAIL, cet::enable_if_type_exists_t< typename DETAIL::Config > >

struct	ProvenanceDumperConfig

struct	ProvenanceDumperConfig< DETAIL, cet::enable_if_type_exists_t< typename DETAIL::Config > >

class	Ptr

class	PtrMaker

class	PtrRemapper

class	PtrVector

class	PtrVectorBase

class	RandomNumberGenerator

class	RandomNumberSaver

struct	RangedFragmentSemantic

class	RangeSet

class	RangeSetHandler

class	RefCore

class	Results

class	ResultsAuxiliary

class	ResultsPrincipal

class	ResultsProducer

class	RNGsnapshot

class	RootBranchInfo

class	RootBranchInfoList

class	RootDelayedReader

class	RootFileBlock

class	RootHandlers

class	RootInput

class	RootInputFile

class	RootInputFileSequence

class	RootInputTree

class	RootOutput

class	RootOutputFile

class	RootOutputTree

class	RootSizeOnDisk

class	RPManager

struct	RPParams

class	RPWorker

class	RPWorkerT

class	Run

class	RunAuxiliary

class	RunID

class	RunPrincipal

class	Schedule

class	ScheduleContext

class	ScheduleID

class	Selector

class	SelectorBase

class	ServiceDirector

class	ServiceHandle

class	ServiceHandle< T, art::ServiceScope::PER_SCHEDULE >

class	ServiceRegistry

class	ServicesManager

class	ServiceTable

class	ServiceToken

class	SortInvalidFirst

class	Source

struct	Source_generator

struct	Source_wantFileServices

class	SourceHelper

class	SQLErrMsg

class	SQLite3Wrapper

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	TFileDirectory

class	TFileService

class	thread_safe_registry_via_id

class	Timestamp

class	TimeTracker

class	TKeyVFSOpenPolicy

class	ToolConfigTable

class	Tracer

class	Transient

class	TriggerNamesService

struct	TriggerReport

class	TriggerResultInserter

class	TriggerResults

class	TrivialFileDelivery

class	TrivialFileTransfer

class	TypeID

class	TypeLabel

class	ValidHandle

class	View

class	ViewToken

class	Worker

class	WorkerInPath

struct	WorkerParams

struct	WorkerSummary

class	WorkerT

struct	WrappedTypeID

class	Wrapper

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

using	DRISI = DecrepitRelicInputSourceImplementation

using	PathPtrs = std::vector< std::unique_ptr< Path >>

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

template<typename PROD , typename OPROD = PROD>
using	MixFunc = std::function< bool(std::vector< PROD const * > const &, OPROD &, PtrRemapper 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 >

template<Level L>
using	Do = ProcessPackage< L >

template<Level L>
using	Begin = typename BeginEndPackage< L >::Begin

template<Level L>
using	End = typename BeginEndPackage< L >::End

using	ConsumableProductVectorPerBranch = std::vector< ProductInfo >

using	ConsumableProductSetPerBranch = std::set< ProductInfo >

using	ConsumableProducts = std::array< ConsumableProductVectorPerBranch, NumBranchTypes >

using	ConsumableProductSets = std::array< ConsumableProductSetPerBranch, NumBranchTypes >

using	ProductListUpdatedCallback = std::function< void(ProductList 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 = std::vector< BranchDescription const * >

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

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

using	new_t = std::string

using	old_t = std::string

using	CFUNC = void()(int, siginfo_t , void *)

using	ProductDescriptions = std::vector< BranchDescription >

typedef unsigned short	BranchListIndex

typedef std::vector< BranchListIndex >	BranchListIndexes

typedef fhicl::ParameterSetID	EventSelectionID

typedef std::vector< EventSelectionID >	EventSelectionIDVector

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 >

typedef unsigned int	ModuleDescriptionID

typedef std::map< fhicl::ParameterSetID, ParameterSetBlob >	ParameterSetMap

typedef Hash< ParentageType >	ParentageID

typedef thread_safe_registry_via_id< ParentageID, Parentage >	ParentageRegistry

typedef Hash< ProcessConfigurationType >	ProcessConfigurationID

typedef std::map< ProcessHistoryID const, ProcessHistory >	ProcessHistoryMap

typedef Hash< ProcessHistoryType >	ProcessHistoryID

typedef std::map< BranchKey, BranchDescription >	ProductList

typedef std::vector< ProductProvenance >	ProductProvenances

typedef unsigned char	ProductStatus

typedef std::string	ReleaseVersion

using	TimeValue_t = std::uint64_t

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

using	ViewLookup_t = ProcessLookup

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	ModuleType { ModuleType::NON_ART, ModuleType::ANALYZER, ModuleType::FILTER, ModuleType::PRODUCER, ModuleType::OUTPUT }

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

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

enum	BranchActionType { BranchActionBegin = 0, BranchActionEnd, BranchActionProcess }

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

enum	ServiceScope { ServiceScope::LEGACY, ServiceScope::GLOBAL, ServiceScope::PER_SCHEDULE }

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

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 }

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

template<typename T , typename... Args>
void	add_opt (T &t, Args &&...args)

int	run_art (int argc, char **argv, bpo::options_description &in_desc, cet::filepath_maker &lookupPolicy, OptionsHandlers &&handlers)

int	run_art_string_config (std::string const &config_string)

int	run_art_common_ (fhicl::ParameterSet const &main_pset)

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

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

	MFSU_1_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_1_ARG_UPDATER_DEFN (PreProcessEvent)

	MFSU_1_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::string	to_string (ModuleType mt)

bool	is_observer (ModuleType mt)

bool	is_modifier (ModuleType mt)

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

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

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

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

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

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

void	checkDictionaries (BranchDescription const &productDesc)

std::string const &	getFileFormatEra ()

int	getFileFormatVersion ()

void	unloadRootSigHandler ()

void	setRootErrorHandler (bool const want_custom)

void	completeRootHandlers ()

std::string	couldNotFindTree (std::string const &treename)

static void	fillTreeBranches (TTree , vector< TBranch > const &branches, bool saveMemory, int64_t threshold)

bool	greaterBySize (RootSizeOnDisk::Record const &lhs, RootSizeOnDisk::Record const &rhs)

template<typename T , typename P >
std::enable_if_t< P::branch_type==InEvent\|\|P::branch_type==InResults >	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< P::branch_type==InSubRun\|\|P::branch_type==InRun >	put_product_in_principal (std::unique_ptr< T > &&product, P &principal, std::string const &module_label, std::string const &instance_name={}, RangeSet &&=RangeSet::invalid())

RangeSet	rangeSetFor (RunPrincipal const &rp)

RangeSet	rangeSetFor (SubRunPrincipal const &srp)

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

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

template<typename T >
BranchDescription const &	get_ProductDescription (BranchType branch_type, std::string const &module_label, std::string const &instance_name)

template<typename T >
BranchDescription const &	get_ProductDescription (Principal const &principal, std::string const &module_label, std::string const &instance_name)

BranchDescription const &	get_ProductDescription (TypeID type_id, BranchType branch_type, std::string const &module_label, std::string const &instance_name)

BranchDescription const &	get_ProductDescription (TypeID type_id, Principal const &principal, std::string const &module_label, std::string const &instance_name)

BranchDescription const &	get_ProductDescription (TypeID tid, std::string const &process_name, ProductList const &product_list, BranchType branch_type, std::string const &module_label, std::string const &instance_name)

std::ostream &	operator<< (std::ostream &os, Group const &g)

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< T >::value, RangeSet const & >	range_of_validity (T const &h)

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

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

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

void	swap (OutputHandle &a, OutputHandle &b)

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

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

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

void	swap (Provenance &x, Provenance &y)

template<class A , class B >
std::enable_if_t< std::is_base_of< art::SelectorBase, A >::value &&std::is_base_of< art::SelectorBase, B >::value, art::AndHelper< A, B > >	operator&& (A const &a, B const &b)

template<class A , class B >
std::enable_if_t< std::is_base_of< art::SelectorBase, A >::value &&std::is_base_of< art::SelectorBase, B >::value, art::OrHelper< A, B > >	operator\|\| (A const &a, B const &b)

template<class A >
std::enable_if_t< std::is_base_of< art::SelectorBase, A >::value, art::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)

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

template<typename CONTAINER >
std::enable_if_t< detail::has_two_arg_insert< CONTAINER >::value >	concatContainers (CONTAINER &out, CONTAINER const &in)

template<typename CONTAINER >
std::enable_if_t< detail::has_three_arg_insert< CONTAINER >::value >	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)

template<class X , class Y >
bool	operator== (debugging_allocator< X > const &, debugging_allocator< Y > const &) throw ()

template<class X , class Y >
bool	operator!= (debugging_allocator< X > const &, debugging_allocator< Y > const &) throw ()

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

std::ostream &	operator<< (std::ostream &os, MasterProductRegistry const &mpr)

std::ostream &	operator<< (std::ostream &os, ProductMetaData const &pmd)

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 >
std::enable_if_t< std::is_class< T >::value, tool_return_type< T > >	make_tool (TableConfig const &tc)

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

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

MallocOptionSetter &	getGlobalOptionSetter ()

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	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::regex const &regexp)

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

std::map< new_t, old_t >	newToOldName ()

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

bool	operator!= (ScheduleID left, ScheduleID right)

bool	operator<= (ScheduleID left, ScheduleID right)

bool	operator> (ScheduleID left, ScheduleID right)

bool	operator>= (ScheduleID left, ScheduleID right)

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

void	ep_sigusr2 (int which, siginfo_t , void )

int	getSigNum ()

void	disableAllSigs (sigset_t *oldset)

void	disableRTSigs ()

void	reenableSigs (sigset_t *oldset)

void	enableSignal (sigset_t *newset, const int signum)

void	disableSignal (sigset_t *newset, const int signum)

void	installCustomHandler (const int signum, CFUNC func)

void	installSig (const int signum, CFUNC func)

void	sigInventory ()

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<class L , class R , class D , Direction Dir>
constexpr auto const &	left (const_AssnsIter< L, R, D, Dir > const &a, const_AssnsIter< L, R, D, Dir > const &b)

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

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

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

void	swap (HLTGlobalStatus &lhs, HLTGlobalStatus &rhs)

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

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

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

template<typename T , typename U >
std::enable_if_t< std::is_same< T, U >::value\|\|std::is_base_of< T, U >::value\|\|std::is_base_of< U, T >::value, 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 &, Ptr< T > const &)

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

bool	operator== (RefCore const &, RefCore const &)

bool	operator!= (RefCore const &, RefCore const &)

bool	operator< (RefCore const &, RefCore const &)

void	swap (art::RefCore &, art::RefCore &)

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)

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, BranchID const &id)

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::ostream &	operator<< (std::ostream &, BranchMapper const &)

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)

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, EventID const &iID)

std::ostream &	operator<< (std::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)

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

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

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)

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)

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

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

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

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

bool	operator!= (Parentage const &a, Parentage 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)

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

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

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

void	swap (art::ProcessHistory &a, art::ProcessHistory &b)

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

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

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

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

auto	make_product_descriptions (ProductList const &productList)

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

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

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

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

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)

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

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

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

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)

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

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

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

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 &, TypeID const &)

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

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

void	swap (TypeID &, TypeID &)

bool	is_assns (TypeID const &tid)

bool	is_assns (std::string const &type_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)

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

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

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

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

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
MallocOptionSetter	global_malloc_options

std::mutex	usr2_lock

std::atomic< int >	shutdown_flag {0}

std::mutex	signum_lock

volatile int	signum_value

debugvalue	debugit

Detailed Description

HLT enums.

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?

Definition of common HLT enums

Typedef Documentation

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

Definition at line 21 of file type_aliases.h.

template<Level L>

using art::Begin = typedef typename BeginEndPackage<L>::Begin

Definition at line 256 of file PrincipalPackages.h.

typedef unsigned short art::BranchListIndex

Definition at line 13 of file BranchListIndex.h.

typedef std::vector<BranchListIndex> art::BranchListIndexes

Definition at line 14 of file BranchListIndex.h.

using art::CFUNC = typedef void (*)(int, siginfo_t*, void*)

Definition at line 24 of file UnixSignalHandlers.h.

using art::ConsumableProducts = typedef std::array<ConsumableProductVectorPerBranch, NumBranchTypes>

Definition at line 55 of file ProductInfo.h.

using art::ConsumableProductSetPerBranch = typedef std::set<ProductInfo>

Definition at line 53 of file ProductInfo.h.

using art::ConsumableProductSets = typedef std::array<ConsumableProductSetPerBranch, NumBranchTypes>

Definition at line 57 of file ProductInfo.h.

using art::ConsumableProductVectorPerBranch = typedef std::vector<ProductInfo>

Definition at line 52 of file ProductInfo.h.

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

Definition at line 56 of file ExecutionCounts.h.

using art::DataFlowDumper = typedef ProvenanceDumper<DataFlow>

Definition at line 28 of file DataFlowDumper_module.cc.

template<Level L>

using art::Do = typedef ProcessPackage<L>

Definition at line 73 of file PrincipalPackages.h.

using art::DRISI = typedef DecrepitRelicInputSourceImplementation

Definition at line 55 of file DecrepitRelicInputSourceImplementation.cc.

template<Level L>

using art::End = typedef typename BeginEndPackage<L>::End

Definition at line 259 of file PrincipalPackages.h.

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

Definition at line 23 of file MixTypes.h.

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

Definition at line 24 of file MixTypes.h.

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

Definition at line 19 of file MixTypes.h.

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

Definition at line 22 of file MixTypes.h.

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

Definition at line 117 of file IDNumber.h.

typedef fhicl::ParameterSetID art::EventSelectionID

Definition at line 17 of file EventSelectionID.h.

typedef std::vector<EventSelectionID> art::EventSelectionIDVector

Definition at line 18 of file EventSelectionID.h.

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

Definition at line 66 of file Exception.h.

template<Level L>

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

Definition at line 108 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 17 of file MixTypes.h.

typedef unsigned int art::ModuleDescriptionID

Definition at line 8 of file ModuleDescriptionID.h.

using art::new_t = typedef std::string

Definition at line 11 of file SAMMetadataTranslators.h.

using art::old_t = typedef std::string

Definition at line 12 of file SAMMetadataTranslators.h.

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

Definition at line 10 of file OptionsHandlers.h.

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

Definition at line 8 of file ParameterSetMap.h.

typedef Hash<ParentageType> art::ParentageID

Definition at line 8 of file ParentageID.h.

typedef thread_safe_registry_via_id<ParentageID, Parentage> art::ParentageRegistry

Definition at line 9 of file ParentageRegistry.h.

using art::PathPtrs = typedef std::vector<std::unique_ptr<Path>>

Definition at line 29 of file Path.h.

typedef Hash<ProcessConfigurationType> art::ProcessConfigurationID

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.

typedef Hash<ProcessHistoryType> art::ProcessHistoryID

Definition at line 8 of file ProcessHistoryID.h.

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

Definition at line 14 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 15 of file type_aliases.h.

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

Definition at line 293 of file BranchDescription.h.

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

Definition at line 15 of file ProductList.h.

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

Definition at line 42 of file MasterProductRegistry.h.

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

Definition at line 20 of file type_aliases.h.

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

Definition at line 22 of file ProductProvenance.h.

typedef unsigned char art::ProductStatus

Definition at line 12 of file ProductStatus.h.

typedef std::string art::ReleaseVersion

Definition at line 6 of file ReleaseVersion.h.

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

Definition at line 21 of file MixTypes.h.

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

Definition at line 119 of file IDNumber.h.

using art::Selections = typedef std::vector<BranchDescription const*>

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::SubRunIDIndex = typedef std::map<SubRunID, FileIndex::EntryNumber_t>

Definition at line 20 of file MixTypes.h.

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

Definition at line 118 of file IDNumber.h.

using art::TimeValue_t = typedef std::uint64_t

Definition at line 7 of file Timestamp.h.

template<typename T >

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

Definition at line 15 of file make_tool.h.

using art::ViewLookup_t = typedef ProcessLookup

Definition at line 17 of file type_aliases.h.

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

Definition at line 10 of file WorkerMap.h.

Enumeration Type Documentation

enum art::BranchActionType

Enumerator
BranchActionBegin
BranchActionEnd
BranchActionProcess

Definition at line 11 of file BranchActionType.h.

                         {
     BranchActionBegin = 0,
     BranchActionEnd,
     BranchActionProcess
   };

enum art::BranchType

Enumerator
InEvent
InSubRun
InRun
InResults
NumBranchTypes

Definition at line 18 of file BranchType.h.

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

art::NumBranchTypes

Definition: BranchType.h:18

art::InResults

Definition: BranchType.h:18

art::InEvent

Definition: BranchType.h:18

art::InSubRun

Definition: BranchType.h:18

art::InRun

Definition: BranchType.h:18

enum art::Direction : int

strong

Enumerator
Forward
Reverse

Definition at line 24 of file AssnsIter.h.

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

art::Direction::Forward

art::Direction::Reverse

enum art::FileCatalogStatus

strong

Enumerator
SUCCESS
NO_MORE_FILES
DELIVERY_ERROR
TRANSFER_ERROR

Definition at line 26 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 13 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 12 of file Level.h.

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

enum art::ModuleType

strong

Enumerator
NON_ART
ANALYZER
FILTER
PRODUCER
OUTPUT

Definition at line 22 of file ModuleType.h.

22 { NON_ART, ANALYZER, FILTER, PRODUCER, OUTPUT };

art::ModuleType::PRODUCER

art::ModuleType::FILTER

art::ModuleType::ANALYZER

art::ModuleType::NON_ART

art::ModuleType::OUTPUT

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::ServiceScope

strong

Enumerator
LEGACY
GLOBAL
PER_SCHEDULE

Definition at line 5 of file ServiceScope.h.

5 { LEGACY, GLOBAL, PER_SCHEDULE };

art::ServiceScope::PER_SCHEDULE

art::ServiceScope::GLOBAL

art::ServiceScope::LEGACY

enum art::suffix_type

strong

Enumerator
module
plugin
service
source
tool
mfPlugin
mfStatsPlugin

Definition at line 61 of file PluginSuffixes.h.

                          {
     module,
     plugin,
     service,
     source,
     tool,
     mfPlugin,
     mfStatsPlugin
   };

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 , typename... Args>

void art::add_opt	(	T &	t,
		Args &&...	args
	)

Definition at line 34 of file OptionsHandler.h.

Referenced by art::BasicOptionsHandler::BasicOptionsHandler(), art::BasicOutputOptionsHandler::BasicOutputOptionsHandler(), art::BasicSourceOptionsHandler::BasicSourceOptionsHandler(), art::DebugOptionsHandler::DebugOptionsHandler(), art::FileCatalogOptionsHandler::FileCatalogOptionsHandler(), and art::ProcessingOptionsHandler::ProcessingOptionsHandler().

   {
     t(std::forward<Args>(args)...);
   }

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

Definition at line 83 of file BranchType.cc.

Referenced by art::MixHelper::generateEventAuxiliarySequence(), art::detail::InfoDumperInputFile::getAuxiliary(), art::RootInputTree::RootInputTree(), and art::RootOutputTree::RootOutputTree().

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

Referenced by art::RootInputTree::RootInputTree(), and art::RootOutputTree::RootOutputTree().

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

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

   {
     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 operator<<(), art::FileDumperOutput::printPrincipal(), art::detail::resolveRangeSetInfo(), and art::RootInputTree::RootInputTree().

   {
     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_(), and art::ProductID::invalid().

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

void art::checkDictionaries ( BranchDescription const & productDesc )

Definition at line 13 of file checkDictionaries.cc.

References is_assns(), name_of_assns_partner(), art::BranchDescription::producedClassName(), art::BranchDescription::transient(), wrappedClassName(), and art::BranchDescription::wrappedName().

Referenced by art::RootInputFile::dropOnInput(), and art::RootOutputFile::selectProducts().

 {
   CET_ASSERT_ONLY_ONE_THREAD();
 
   // Make sure we populate the ROOT-related transient information.  If
   // this is not done, then TBranch-related quantities will not be set
   // correctly.
   detail::BranchDescriptionStreamer::fluffRootTransients(productDesc);
   auto const isTransient = productDesc.transient();
 
   // Check product dictionaries.
   static root::DictionaryChecker dictChecker{};
   dictChecker.checkDictionaries(productDesc.wrappedName(), false);
   dictChecker.checkDictionaries(productDesc.producedClassName(), !isTransient);
 
   // Check dictionaries for assnsPartner, if appropriate. This is only
   // necessary for top-level checks so appropriate here rather than
   // checkDictionaries itself.
   if (!isTransient) {
     auto const assnsPartner =
       name_of_assns_partner(productDesc.producedClassName());
     if (!assnsPartner.empty()) {
       dictChecker.checkDictionaries(wrappedClassName(assnsPartner), true);
     }
   }
   dictChecker.reportMissingDictionaries();
 
   // Make sure that the AssnsStreamer is appropropriately setup--must
   // be done after we are sure that there is matching dictionary for
   // the partner.
   if (!is_assns(productDesc.producedClassName()))
     return;
 
   detail::AssnsStreamer::init_streamer(productDesc.producedClassName());
 }

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

Definition at line 246 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::MasterProductRegistry::updateProductLists_(), and art::BranchDescription::wrappedName().

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

void art::completeRootHandlers ( )

Definition at line 197 of file InitRootHandlers.cc.

References tkeyvfs_init().

Referenced by art::BasicOutputOptionsHandler::doProcessOptions().

   {
     // Set ROOT parameters.
     ROOT::EnableThreadSafety();
     TTree::SetMaxTreeSize(kMaxLong64);
     TH1::AddDirectory(kFALSE);
 
     // Initialize tkeyvfs sqlite3 extension for ROOT.
     tkeyvfs_init();
 
     // Set custom streamers.
     setCacheStreamers();
     setProvenanceTransientStreamers();
     detail::setBranchDescriptionStreamer();
     detail::setPtrVectorBaseStreamer();
     configureProductIDStreamer();
     configureRefCoreStreamer();
   }

template<typename CONTAINER >

std::enable_if_t<detail::has_two_arg_insert<CONTAINER>::value> art::concatContainers	(	CONTAINER &	out,
		CONTAINER const &	in
	)

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

template<typename CONTAINER >

std::enable_if_t<detail::has_three_arg_insert<CONTAINER>::value> art::concatContainers	(	CONTAINER &	out,
		CONTAINER const &	in
	)

template<class T >

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

Definition at line 249 of file Handle.h.

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

Referenced by art::DataViewImpl::get(), art::DataViewImpl::getByLabel(), and art::DataViewImpl::getMany().

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

std::string art::couldNotFindTree ( std::string const & treename )

inline

Definition at line 9 of file rootErrMsgs.h.

Referenced by art::detail::readFileIndex(), and art::RootInputFile::readParentageTree().

   {
     std::string message = "Could not find tree ";
     message.append(treename);
     message.append(" in the input file.\n");
     return message;
   }

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

Definition at line 64 of file InputTag.cc.

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

Referenced by fhicl::ParameterSet::get_one_(), and operator!=().

   {
 
     if (fhicl::detail::is_sequence(a)) {
       std::vector<std::string> tmp;
       fhicl::detail::decode(a, tmp);
       if (tmp.size() == 2)
         tag = {tmp.at(0), tmp.at(1)};
       else if (tmp.size() == 3)
         tag = {tmp.at(0), tmp.at(1), tmp.at(2)};
       else {
         std::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 std::length_error(errmsg.str());
       }
     } else {
       std::string tmp;
       fhicl::detail::decode(a, tmp);
       tag = tmp;
     }
   }

void art::disableAllSigs ( sigset_t * oldset )

Definition at line 72 of file UnixSignalHandlers.cc.

References MUST_BE_ZERO.

Referenced by installCustomHandler().

   {
     sigset_t myset;
     // all blocked for now
     MUST_BE_ZERO(sigfillset(&myset));
     MUST_BE_ZERO(pthread_sigmask(SIG_SETMASK, &myset, oldset));
   }

void art::disableRTSigs ( )

Definition at line 83 of file UnixSignalHandlers.cc.

References MUST_BE_ZERO.

Referenced by installCustomHandler().

   {
 #if defined(__linux__)
     // ignore all the RT signals
     sigset_t myset;
     MUST_BE_ZERO(sigemptyset(&myset));
 
     struct sigaction tmpact;
     memset(&tmpact, 0, sizeof(tmpact));
     tmpact.sa_handler = SIG_IGN;
 
     for (int num = SIGRTMIN; num < SIGRTMAX; ++num) {
       MUST_BE_ZERO(sigaddset(&myset, num));
       MUST_BE_ZERO(sigaction(num, &tmpact, nullptr));
     }
 
     MUST_BE_ZERO(pthread_sigmask(SIG_BLOCK, &myset, 0));
 #endif
   }

void art::disableSignal	(	sigset_t *	newset,
		const int	signum
	)

Definition at line 124 of file UnixSignalHandlers.cc.

References MUST_BE_ZERO.

   {
     // disable the specified signal
     MUST_BE_ZERO(sigdelset(newset, signum));
   }

template<class T , class U >

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

Referenced by disjoint_ranges(), art::RootDelayedReader::getProduct_(), overlapping_ranges(), art::ValidHandle< T >::swap(), art::detail::throw_if_invalid(), and art::SummedValue< T >::update_impl().

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

Definition at line 297 of file RangeSet.cc.

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

 {
   if (!both_valid(l, r))
     return false;
 
   if (!l.has_disjoint_ranges() || !r.has_disjoint_ranges())
     return false;
 
   if (l.run() != r.run())
     return true;
 
   // 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(),
              std::back_inserter(merged));
 
   return disjoint(merged);
 }

template<class T , class U >

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

Definition at line 182 of file SummedValue.h.

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

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

void art::enableSignal	(	sigset_t *	newset,
		const int	signum
	)

Definition at line 115 of file UnixSignalHandlers.cc.

References MUST_BE_ZERO.

   {
     // enable the specified signal
     MUST_BE_ZERO(sigaddset(newset, signum));
   }

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, and fhicl::detail::atom::value().

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

                                        {
   static_assert(std::is_pointer<WANTED_POINTER>::value,
                 "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);
   }
 }

void art::ep_sigusr2	(	int	which,
		siginfo_t *	,
		void *
	)

Definition at line 31 of file UnixSignalHandlers.cc.

References FDEBUG, and shutdown_flag.

Referenced by setupSignals().

   {
     FDEBUG(1) << "in sigusr2 handler\n";
     if (which == SIGINT && shutdown_flag > 0) {
       std::cerr << "User signal SIGINT terminating the process\n";
       std::terminate();
     }
     shutdown_flag = which;
   }

template<>

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

inline

Definition at line 274 of file EventProcessor.cc.

References art::EventProcessor::openInputFile().

   {
     openInputFile();
   }

template<>

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

inline

Definition at line 266 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 281 of file EventProcessor.cc.

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

   {
     finalizeRunEnabled_ = true;
     readRun();
     if (handleEmptyRuns_) {
       beginRun();
     }
   }

template<>

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

Definition at line 292 of file EventProcessor.cc.

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

   {
     finalizeSubRunEnabled_ = true;
     assert(runPrincipal_);
     assert(runPrincipal_->id().isValid());
     readSubRun();
     if (handleEmptySubRuns_) {
       beginRunIfNotDoneAlready();
       beginSubRun();
     }
   }

template<>

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

Definition at line 306 of file EventProcessor.cc.

References art::EventProcessor::eventPrincipal_, art::EventProcessor::openSomeOutputFiles(), and art::EventProcessor::writeEvent().

   {
     assert(eventPrincipal_);
     if (eventPrincipal_->id().isFlush())
       return;
 
     openSomeOutputFiles();
     writeEvent();
   }

template<>

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

Definition at line 358 of file EventProcessor.cc.

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

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

template<>

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

inline

Definition at line 369 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 338 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().

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

template<>

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

Definition at line 318 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().

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

template<>

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

inline

Definition at line 384 of file EventProcessor.cc.

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

template<>

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

inline

Definition at line 377 of file EventProcessor.cc.

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

template<>

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

inline

Definition at line 406 of file EventProcessor.cc.

References art::EventProcessor::endPathExecutor_, and art::Granularity::Event.

   {
     endPathExecutor_->recordOutputClosureRequests(Granularity::Event);
   }

template<>

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

inline

Definition at line 392 of file EventProcessor.cc.

References art::EventProcessor::endPathExecutor_, and art::Granularity::Run.

   {
     endPathExecutor_->recordOutputClosureRequests(Granularity::Run);
   }

template<>

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

inline

Definition at line 399 of file EventProcessor.cc.

References art::EventProcessor::endPathExecutor_, and art::Granularity::SubRun.

   {
     endPathExecutor_->recordOutputClosureRequests(Granularity::SubRun);
   }

template<typename T , typename H >

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

Definition at line 473 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 464 of file Ptr.h.

Referenced by cheat::CheckBackTracking::analyze(), cheat::RecoCheckAna::analyze(), opdet::FlashPurityCheckAna::analyze(), cluster::ClusterAna::analyze(), pfpf::PFPAna::analyze(), hit::MagDriftAna::analyze(), cluster::DBclusterAna::analyze(), hit::GausHitFinderAna::analyze(), ClusteringValidation::ClusteringValidation::analyze(), evd::AnalysisBaseDrawer::CalorShower(), evd::AnalysisBaseDrawer::DrawDeDx(), evd::AnalysisBaseDrawer::DrawKineticEnergy(), simfilter::FilterNoDirtNeutrinos::filter(), trkf::BezierTrackerModule::GetHitsFromClusters(), trkf::SeedFinderModule::GetSortedHitsFromClusters(), evd::RecoBaseDrawer::GetSpacePoints(), evwgh::GenieWeightCalc::GetWeight(), ems::MergeEMShower3D::mcinfo(), wc::CellTree::processCalib(), DUNE::NeutrinoShowerEff::processEff(), DUNE::NeutrinoTrackingEff::processEff(), DUNE::MuonTrackingEff::processEff(), wc::CellTree::processMC(), wc::CellTree::processOpFlash(), wc::CellTree::processOpHit(), wc::CellTree::processRaw(), wc::CellTree::processSpacePoint(), wc::CellTree::processTrigger(), event::EventMaker::produce(), hit::DisambigCheater::produce(), vertex::VertexCheater::produce(), event::EventCheater::produce(), shwf::ShowerCheater::produce(), apa::APAHitFinder::produce(), sppt::TTSpacePointFinder::produce(), trkf::BezierTrackerModule::produce(), trkf::TrackCheater::produce(), pid::Chi2ParticleID::produce(), cluster::ClusterCheater::produce(), calo::BezierCalorimetry::produce(), evwgh::EventWeight::produce(), calo::GeneralCalorimetry::produce(), CRHitRemoval::produce(), cluster::BlurredClustering::produce(), shower::EMShower::produce(), cosmic::CosmicTrackTagger::produce(), cosmic::CosmicClusterTagger::produce(), reco3d::SpacePointSolver::produce(), trkf::CCTrackMaker::produce(), calo::Calorimetry::produce(), lbne::PhotonCounterT0Matching::produce(), trkf::PMAlgTrajFitter::produce(), t0::MCTruthT0Matching::produce(), vertex::FeatureVertexFinder::produce(), trkf::PMAlgTrackMaker::produce(), trkf::CosmicTracker::produce(), cheat::PhotonBackTracker::Rebuild(), apa::DisambigAlg::RunDisambig(), nnet::TrainingDataAlg::setDataEventData(), and tss::TrackShowerHits::sortHits().

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

static void art::fillTreeBranches	(	TTree *	,
		vector< TBranch * > const &	branches,
		bool	saveMemory,
		int64_t	threshold
	)

static

Definition at line 133 of file RootOutputTree.cc.

Referenced by art::RootOutputTree::fillTree().

   {
     for (auto const b : branches) {
       auto bytesWritten = b->Fill();
       if (saveMemory && (bytesWritten > threshold)) {
         b->FlushBaskets();
         b->DropBaskets("all");
       }
     }
   }

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

References concatContainers().

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

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

template<typename T , typename OFFSETS >

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

Definition at line 340 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 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, and a2.

Referenced by util::for_each_associated_group().

   {
     ranges::for_each(assns | ranges::view::all |
                        ranges::view::group_by([](auto a1, auto a2) {
                          return a1.first == a2.first;
                        }) |
                        ranges::view::transform([](auto pairs) {
                          return pairs | ranges::view::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 evd::details::begin(), for_each_pair(), and left().

   {
     for_each_pair(assns, [&func](auto rng) {
       auto rights = rng | ranges::view::values;
       auto lefts = rng | ranges::view::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::view::all |
                        ranges::view::group_by(
                          [](auto a1, auto a2) { return a1.first == a2.first; }),
                      func);
   }

constexpr auto art::fullRun ( )

Definition at line 24 of file ProductSemantics.h.

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

constexpr auto art::fullSubRun ( )

Definition at line 29 of file ProductSemantics.h.

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

template<typename T >

BranchDescription const& art::get_ProductDescription	(	BranchType	branch_type,
		std::string const &	module_label,
		std::string const &	instance_name
	)

Referenced by get_ProductDescription(), and art::DataViewImpl::getProductDescription().

template<typename T >

BranchDescription const& art::get_ProductDescription	(	Principal const &	principal,
		std::string const &	module_label,
		std::string const &	instance_name
	)

art::BranchDescription const & art::get_ProductDescription	(	TypeID	type_id,
		BranchType	branch_type,
		std::string const &	module_label,
		std::string const &	instance_name
	)

Definition at line 14 of file get_ProductDescription.cc.

References get_ProductDescription().

 {
   return get_ProductDescription(
     tid,
     ServiceHandle<TriggerNamesService const> {}->getProcessName(),
     ProductMetaData::instance().productList(),
     branch_type,
     module_label,
     instance_name); // 5.
 }

art::BranchDescription const & art::get_ProductDescription	(	TypeID	type_id,
		Principal const &	principal,
		std::string const &	module_label,
		std::string const &	instance_name
	)

Definition at line 30 of file get_ProductDescription.cc.

References art::Principal::branchType(), get_ProductDescription(), art::Principal::processConfiguration(), and art::ProcessConfiguration::processName().

 {
   return get_ProductDescription(type_id,
                                 principal.processConfiguration().processName(),
                                 ProductMetaData::instance().productList(),
                                 principal.branchType(),
                                 module_label,
                                 instance_name); // 5.
 }

art::BranchDescription const & art::get_ProductDescription	(	TypeID	tid,
		std::string const &	process_name,
		ProductList const &	product_list,
		BranchType	branch_type,
		std::string const &	module_label,
		std::string const &	instance_name
	)

Definition at line 45 of file get_ProductDescription.cc.

References art::TypeID::friendlyClassName(), and art::errors::ProductRegistrationFailure.

 {
   BranchKey const bk{type_id.friendlyClassName(),
                      module_label,
                      instance_name,
                      process_name,
                      branch_type};
   auto const it = product_list.find(bk);
   if (it == product_list.end()) {
     throw art::Exception{art::errors::ProductRegistrationFailure,
                          "art::get_ProductDescription"}
       << "No product is registered for\n"
       << "  process name:                '" << bk.processName_ << "'\n"
       << "  module label:                '" << bk.moduleLabel_ << "'\n"
       << "  product friendly class name: '" << bk.friendlyClassName_ << "'\n"
       << "  product instance name:       '" << bk.productInstanceName_ << "'\n"
       << "  branch type:                 '" << branch_type << "'\n";
   }
   return it->second;
 }

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

Definition at line 6 of file GetReleaseVersion.cc.

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

template<class COLLECTION >

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

Definition at line 67 of file getElementAddresses.h.

References art::detail::maybeCastObj().

 {
   typedef COLLECTION product_type;
   oPtr.reserve(iIndices.size());
   for (std::vector<unsigned long>::const_iterator itIndex = iIndices.begin(),
                                                   itEnd = iIndices.end();
        itIndex != itEnd;
        ++itIndex) {
     auto it = coll.begin();
     advance(it, *itIndex);
     oPtr.push_back(detail::maybeCastObj(
       detail::GetProduct<product_type>::address(it), iToType));
   }
 }

template<typename T >

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

Definition at line 87 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().

 {
   typedef cet::map_vector<T> product_type;
   typedef typename product_type::const_iterator iter;
   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>();
   oPtr.reserve(iIndices.size());
   if ((pos < wanted_type.size()) && vh.starts_with_pair(wanted_type, pos)) {
     // Want value_type.
     for (std::vector<unsigned long>::const_iterator itIndex = iIndices.begin(),
                                                     itEnd = iIndices.end();
          itIndex != itEnd;
          ++itIndex) {
       iter it = obj.find(cet::map_vector_key(*itIndex));
       oPtr.push_back(
         detail::maybeCastObj((it == obj.end()) ? 0 : &(*it), iToType));
     }
   } else {
     // Want mapped_type.
     for (std::vector<unsigned long>::const_iterator itIndex = iIndices.begin(),
                                                     itEnd = iIndices.end();
          itIndex != itEnd;
          ++itIndex) {
       oPtr.push_back(detail::maybeCastObj(
         obj.getOrNull(cet::map_vector_key(*itIndex)), iToType));
     }
   }
 }

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

Definition at line 25 of file GetFileFormatEra.cc.

Referenced by art::MixHelper::openAndReadMetaData_(), read_all_parameter_sets(), art::RootOutputFile::writeFileCatalogMetadata(), and art::RootOutputFile::writeFileFormatVersion().

   {
     static std::string const era = "ART_2011a";
     return era;
   }

int art::getFileFormatVersion ( )

Definition at line 47 of file GetFileFormatVersion.cc.

Referenced by art::RootOutputFile::writeFileCatalogMetadata(), and art::RootOutputFile::writeFileFormatVersion().

   {
     return 12;
   }

MallocOptionSetter & art::getGlobalOptionSetter ( )

Definition at line 207 of file MallocOpts.cc.

References global_malloc_options.

Referenced by art::MemoryAdjuster::MemoryAdjuster().

   {
     return global_malloc_options;
   }

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

Definition at line 6 of file GetReleaseVersion.cc.

Referenced by art::BasicOptionsHandler::BasicOptionsHandler(), art::BasicOptionsHandler::doCheckOptions(), art::EventProcessor::EventProcessor(), art::InputSourceFactory::make(), art::Schedule::makeTriggerResultsInserter_(), art::detail::ModuleFactory::makeWorker(), art::PathsInfo::makeWorker_(), and art::detail::ModuleFactory::moduleType().

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

int art::getSigNum ( )

Definition at line 55 of file UnixSignalHandlers.cc.

References signum_value.

   {
     std::lock_guard<decltype(signum_lock)> lock{signum_lock};
     int const rc{signum_value};
     ++signum_value;
     return rc;
   }

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

Definition at line 19 of file RegexMatch.cc.

Referenced by regexMatch().

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

bool art::greaterBySize	(	RootSizeOnDisk::Record const &	lhs,
		RootSizeOnDisk::Record const &	rhs
	)

Definition at line 55 of file RootSizeOnDisk.cc.

References art::RootSizeOnDisk::Record::size().

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

 {
   return lhs.size() > rhs.size();
 }

constexpr auto art::highest_level ( )

noexcept

Definition at line 39 of file Level.h.

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

   {
     return static_cast<Level>(0);
   }

template<Direction Dir>

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

Definition at line 95 of file AssnsIter.h.

References Forward.

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

void art::installCustomHandler	(	const int	signum,
		CFUNC	func
	)

Definition at line 133 of file UnixSignalHandlers.cc.

References disableAllSigs(), disableRTSigs(), installSig(), and reenableSigs().

Referenced by setupSignals().

   {
     sigset_t oldset;
     art::disableAllSigs(&oldset);
 #if defined(__linux__)
     art::disableRTSigs();
 #endif
     art::installSig(signum, func);
     art::reenableSigs(&oldset);
   }

void art::installSig	(	const int	signum,
		CFUNC	func
	)

Definition at line 147 of file UnixSignalHandlers.cc.

References MUST_BE_ZERO.

Referenced by installCustomHandler().

   {
     // set up my RT signal now
     struct sigaction act;
     memset(&act, 0, sizeof(act));
     act.sa_sigaction = func;
     act.sa_flags = SA_RESTART;
 
     // get my signal number
     int mysig = signum;
     if (mysig == SIGKILL) {
       perror("Cannot install handler for KILL signal");
       return;
     } else if (mysig == SIGSTOP) {
       perror("Cannot install handler for STOP signal");
       return;
     }
 
     if (sigaction(mysig, &act, nullptr) != 0) {
       perror("sigaction failed");
       abort();
     }
 
     sigset_t newset;
     MUST_BE_ZERO(sigemptyset(&newset));
     MUST_BE_ZERO(sigaddset(&newset, mysig));
     MUST_BE_ZERO(pthread_sigmask(SIG_UNBLOCK, &newset, 0));
   }

constexpr bool art::is_above_most_deeply_nested_level ( Level const l )

noexcept

Definition at line 63 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 ( TypeID const & tid )

inline

Definition at line 145 of file TypeID.h.

References art::TypeID::className().

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

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

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

inline

Definition at line 151 of file TypeID.h.

References is_instantiation_of(), and s.

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

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

Definition at line 13 of file RegexMatch.cc.

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

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

constexpr bool art::is_highest_level ( Level const l )

noexcept

Definition at line 75 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 158 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 165 of file TypeID.h.

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

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

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

noexcept

Definition at line 81 of file Level.h.

References underlying_value().

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

bool art::is_modifier ( ModuleType mt )

inline

Definition at line 59 of file ModuleType.h.

References FILTER, and PRODUCER.

 {
   return mt == ModuleType::FILTER || mt == ModuleType::PRODUCER;
 }

constexpr bool art::is_most_deeply_nested_level ( Level const l )

noexcept

Definition at line 69 of file Level.h.

References most_deeply_nested_level().

   {
     return l == most_deeply_nested_level();
   }

bool art::is_observer ( ModuleType mt )

inline

Definition at line 53 of file ModuleType.h.

References ANALYZER, and OUTPUT.

Referenced by art::PathsInfo::makeAndAppendPath(), and art::PathManager::processOnePathConfig_().

 {
   return mt == ModuleType::ANALYZER || mt == ModuleType::OUTPUT;
 }

template<Level L = Level::Event>

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

Definition at line 112 of file IDNumber.h.

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

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

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

Definition at line 49 of file ProcessHistory.cc.

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

Referenced by isDescendant(), and art::detail::orderedProcessNamesCollection().

   {
     if (a.size() >= b.size())
       return false;
     typedef ProcessHistory::collection_type::const_iterator const_iterator;
     for (const_iterator itA = a.data().begin(),
                         itB = b.data().begin(),
                         itAEnd = a.data().end();
          itA != itAEnd;
          ++itA, ++itB) {
       if (*itA != *itB)
         return false;
     }
     return true;
   }

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

inline

Definition at line 173 of file ProcessHistory.h.

References isAncestor().

 {
   return isAncestor(b, a);
 }

template<class L , class R , class 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 104 of file AssnsIter.h.

References Forward.

Referenced by recob::TrackTrajectory::AtLeastValidTrajectoryPoints(), lar_cluster3d::VoronoiPathFinder::breakIntoTinyBits(), lar_cluster3d::ClusterPathFinder::breakIntoTinyBits(), lar_cluster3d::VoronoiPathFinder::buildConvexHull(), lar_cluster3d::ClusterPathFinder::buildConvexHull(), lar_cluster3d::StandardHit3DBuilder::BuildHit3D(), lar_cluster3d::kdTree::BuildKdTree(), lar_cluster3d::VoronoiPathFinder::buildVoronoiDiagram(), lar_cluster3d::ClusterPathFinder::buildVoronoiDiagram(), voronoi2d::VoronoiDiagram::ComputeFaceArea(), fhicl::detail::ValidateThenSet::delegated_parameter(), cluster::TrajCluster::endJob(), lar_cluster3d::ClusterParamsBuilder::FillClusterParams(), evgen::NUANCEGen::FillHistograms(), evgen::NDKGen::FillHistograms(), evgen::GENIEGen::FillHistograms(), lar_cluster3d::MinSpanTreeAlg::FindBestPathInCluster(), voronoi2d::VoronoiDiagram::findBoundingBox(), lar_cluster3d::StandardHit3DBuilder::findGoodTriplets(), reco_tool::CandHitDerivative::findHitCandidates(), reco_tool::CandHitMorphological::findHitCandidates(), reco_tool::WaveformTools::findPeaks(), for_each_group_with_left(), mf::service::ELdestination::formSummary(), voronoi2d::VoronoiDiagram::getConvexHull(), reco_tool::WaveformTools::getTruncatedMeanRMS(), art::TimeTracker::logToDestination_(), lar_cluster3d::Cluster3D::MakeAndSavePCAPoints(), lar_cluster3d::ClusterMergeAlg::ModifyClusters(), operator!=(), art::const_AssnsIter< L, R, D, Dir >::operator<(), util::flags::operator<(), util::flags::operator<<(), art::const_AssnsIter< L, R, D, Dir >::operator<=(), art::const_AssnsIter< L, R, D, Dir >::operator>(), art::const_AssnsIter< L, R, D, Dir >::operator>=(), lar_cluster3d::PrincipalComponentsAlg::PCAAnalysis_2D(), lar_cluster3d::PrincipalComponentsAlg::PCAAnalysis_3D(), nutools::dbi::Table::PrintColumns(), lar_pandora::LArPandoraEventDump::PrintParticle(), hit::GausHitFinder::produce(), boost::python::detail::proxy_group< Proxy >::replace(), lar_content::LArPcaHelper::RunPca(), lar_cluster3d::MinSpanTreeAlg::RunPrimsAlgorithm(), sort_pred(), sort_pred2(), lar_cluster3d::Cluster3D::splitClustersWithMST(), art::MemoryTracker::summary_(), throw_if_not_disjoint(), cluster::HoughTransformCounters< KEY, COUNTER, SIZE, ALLOC, SUBCOUNTERS >::unchecked_add_range_max(), cluster::HoughTransformCounters< KEY, COUNTER, SIZE, ALLOC, SUBCOUNTERS >::unchecked_set_range(), and util::flags::Bits_t< Storage_t >::unsetBits().

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

constexpr auto art::level_down ( Level const l )

noexcept

Definition at line 57 of file Level.h.

References underlying_value().

   {
     return static_cast<Level>(underlying_value(l) + 1);
   }

constexpr auto art::level_up ( Level const l )

noexcept

Definition at line 45 of file Level.h.

References underlying_value().

Referenced by most_deeply_nested_level().

   {
     return static_cast<Level>(underlying_value(l) - 1);
   }

auto art::make_product_descriptions ( ProductList const & productList )

inline

Definition at line 19 of file ProductList.h.

   {
     ProductDescriptions result;
     cet::transform_all(productList, back_inserter(result), [](auto const& pr) {
       return pr.second;
     });
     return result;
   }

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 19 of file make_tool.h.

References art::errors::Configuration, e, fhicl::ParameterSet::get(), art::Suffixes::tool(), and fhicl::detail::atom::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 36 of file make_tool.h.

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

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

std::enable_if_t<std::is_class<T>::value, tool_return_type<T> > art::make_tool ( TableConfig const & tc )

inline

Definition at line 56 of file make_tool.h.

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

   {
     return make_tool<T>(tc.get_PSet());
   }

template<typename T , typename TableConfig >

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

inline

Definition at line 63 of file make_tool.h.

   {
     return make_tool<T>(tc.get_PSet(), function_tool_type);
   }

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

static

Definition at line 54 of file ProvenanceCheckerOutput_module.cc.

References art::BranchMapper::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 =
           iMapper.branchToProductProvenance(parent);
         if (pInfo.get()) {
           markAncestors(*pInfo, iMapper, oMap, oMapperMissing);
         } else {
           oMapperMissing.insert(parent);
         }
       }
     }
   }

art::MFSU_0_ARG_UPDATER_DEFN ( PostBeginJob )

Definition at line 83 of file MFStatusUpdater.cc.

References s, 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 s, and mf::SetModuleName().

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

s

Float_t s

Definition: plot.C:23

mf::SetModuleName

void SetModuleName(string const &val)

Definition: MessageLogger.cc:729

art::MFSU_0_ARG_UPDATER_DEFN ( PreSourceEvent )

Definition at line 97 of file MFStatusUpdater.cc.

References s, and mf::SetModuleName().

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

s

Float_t s

Definition: plot.C:23

mf::SetModuleName

void SetModuleName(string const &val)

Definition: MessageLogger.cc:729

art::MFSU_0_ARG_UPDATER_DEFN ( PreSourceSubRun )

Definition at line 104 of file MFStatusUpdater.cc.

References s, and mf::SetModuleName().

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

art::MFSU_0_ARG_UPDATER_DEFN ( PreSourceRun )

Definition at line 114 of file MFStatusUpdater.cc.

References s, and mf::SetModuleName().

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

s

Float_t s

Definition: plot.C:23

mf::SetModuleName

void SetModuleName(string const &val)

Definition: MessageLogger.cc:729

art::MFSU_0_ARG_UPDATER_DEFN ( PreOpenFile )

Definition at line 121 of file MFStatusUpdater.cc.

References s, and mf::SetModuleName().

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

s

Float_t s

Definition: plot.C:23

mf::SetModuleName

void SetModuleName(string const &val)

Definition: MessageLogger.cc:729

art::MFSU_0_ARG_UPDATER_DEFN ( PreCloseFile )

Definition at line 125 of file MFStatusUpdater.cc.

References s, and mf::SetModuleName().

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

s

Float_t s

Definition: plot.C:23

mf::SetModuleName

void SetModuleName(string const &val)

Definition: MessageLogger.cc:729

art::MFSU_0_ARG_UPDATER_DEFN ( PostCloseFile )

Definition at line 127 of file MFStatusUpdater.cc.

References s, and mf::SetModuleName().

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

art::MFSU_1_ARG_UPDATER_DEFN ( PostSourceConstruction )

Definition at line 91 of file MFStatusUpdater.cc.

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

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

art::MFSU_1_ARG_UPDATER_DEFN ( PostSourceEvent )

Definition at line 99 of file MFStatusUpdater.cc.

References s, and mf::SetModuleName().

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

art::MFSU_1_ARG_UPDATER_DEFN ( PostSourceSubRun )

Definition at line 109 of file MFStatusUpdater.cc.

References s, and mf::SetModuleName().

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

art::MFSU_1_ARG_UPDATER_DEFN ( PostSourceRun )

Definition at line 116 of file MFStatusUpdater.cc.

References s, and mf::SetModuleName().

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

art::MFSU_1_ARG_UPDATER_DEFN ( PostOpenFile )

Definition at line 123 of file MFStatusUpdater.cc.

References s, and mf::SetModuleName().

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

s

Float_t s

Definition: plot.C:23

mf::SetModuleName

void SetModuleName(string const &val)

Definition: MessageLogger.cc:729

art::MFSU_1_ARG_UPDATER_DEFN ( PreProcessEvent )

Definition at line 132 of file MFStatusUpdater.cc.

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

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

art::MFSU_1_ARG_UPDATER_DEFN ( PostProcessEvent )

Definition at line 140 of file MFStatusUpdater.cc.

References s, and mf::SetModuleName().

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

art::MFSU_1_ARG_UPDATER_DEFN ( PreBeginRun )

Definition at line 145 of file MFStatusUpdater.cc.

References s, 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 153 of file MFStatusUpdater.cc.

References s, and mf::SetModuleName().

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

s

Float_t s

Definition: plot.C:23

mf::SetModuleName

void SetModuleName(string const &val)

Definition: MessageLogger.cc:729

art::MFSU_1_ARG_UPDATER_DEFN ( PostEndRun )

Definition at line 163 of file MFStatusUpdater.cc.

References s, and mf::SetModuleName().

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

s

Float_t s

Definition: plot.C:23

mf::SetModuleName

void SetModuleName(string const &val)

Definition: MessageLogger.cc:729

art::MFSU_1_ARG_UPDATER_DEFN ( PreBeginSubRun )

Definition at line 165 of file MFStatusUpdater.cc.

References s, 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 173 of file MFStatusUpdater.cc.

References s, and mf::SetModuleName().

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

art::MFSU_1_ARG_UPDATER_DEFN ( PostEndSubRun )

Definition at line 186 of file MFStatusUpdater.cc.

References s, and mf::SetModuleName().

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

art::MFSU_1_ARG_UPDATER_DEFN ( PreProcessPath )

Definition at line 191 of file MFStatusUpdater.cc.

References s, and mf::SetModuleName().

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

art::MFSU_1_ARG_UPDATER_DEFN ( PrePathBeginRun )

Definition at line 201 of file MFStatusUpdater.cc.

References s, and mf::SetModuleName().

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

art::MFSU_1_ARG_UPDATER_DEFN ( PrePathEndRun )

Definition at line 211 of file MFStatusUpdater.cc.

References s, and mf::SetModuleName().

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

art::MFSU_1_ARG_UPDATER_DEFN ( PrePathBeginSubRun )

Definition at line 221 of file MFStatusUpdater.cc.

References s, and mf::SetModuleName().

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

art::MFSU_1_ARG_UPDATER_DEFN ( PrePathEndSubRun )

Definition at line 231 of file MFStatusUpdater.cc.

References s, and mf::SetModuleName().

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

art::MFSU_1_ARG_UPDATER_DEFN ( PreModuleConstruction )

Definition at line 241 of file MFStatusUpdater.cc.

References s, 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 248 of file MFStatusUpdater.cc.

References s, and mf::SetModuleName().

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

art::MFSU_1_ARG_UPDATER_DEFN ( PreModuleBeginJob )

Definition at line 259 of file MFStatusUpdater.cc.

References s, 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 266 of file MFStatusUpdater.cc.

References s, and mf::SetModuleName().

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

art::MFSU_1_ARG_UPDATER_DEFN ( PreModuleEndJob )

Definition at line 272 of file MFStatusUpdater.cc.

References s, 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 279 of file MFStatusUpdater.cc.

References s, and mf::SetModuleName().

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

art::MFSU_1_ARG_UPDATER_DEFN ( PreModule )

Definition at line 285 of file MFStatusUpdater.cc.

References s, and mf::SetModuleName().

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

art::MFSU_1_ARG_UPDATER_DEFN ( PostModule )

Definition at line 291 of file MFStatusUpdater.cc.

References s, and mf::SetModuleName().

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

art::MFSU_1_ARG_UPDATER_DEFN ( PreModuleBeginRun )

Definition at line 297 of file MFStatusUpdater.cc.

References s, and mf::SetModuleName().

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

art::MFSU_1_ARG_UPDATER_DEFN ( PostModuleBeginRun )

Definition at line 303 of file MFStatusUpdater.cc.

References s, and mf::SetModuleName().

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

art::MFSU_1_ARG_UPDATER_DEFN ( PreModuleEndRun )

Definition at line 309 of file MFStatusUpdater.cc.

References s, and mf::SetModuleName().

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

art::MFSU_1_ARG_UPDATER_DEFN ( PostModuleEndRun )

Definition at line 315 of file MFStatusUpdater.cc.

References s, and mf::SetModuleName().

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

art::MFSU_1_ARG_UPDATER_DEFN ( PreModuleBeginSubRun )

Definition at line 321 of file MFStatusUpdater.cc.

References s, and mf::SetModuleName().

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

art::MFSU_1_ARG_UPDATER_DEFN ( PostModuleBeginSubRun )

Definition at line 327 of file MFStatusUpdater.cc.

References s, and mf::SetModuleName().

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

art::MFSU_1_ARG_UPDATER_DEFN ( PreModuleEndSubRun )

Definition at line 333 of file MFStatusUpdater.cc.

References s, and mf::SetModuleName().

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

art::MFSU_1_ARG_UPDATER_DEFN ( PostModuleEndSubRun )

Definition at line 339 of file MFStatusUpdater.cc.

References s, and mf::SetModuleName().

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

art::MFSU_2_ARG_UPDATER_DEFN ( PreEndRun )

Definition at line 155 of file MFStatusUpdater.cc.

References s, 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 178 of file MFStatusUpdater.cc.

References s, 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 196 of file MFStatusUpdater.cc.

References s, and mf::SetModuleName().

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

art::MFSU_2_ARG_UPDATER_DEFN ( PostPathBeginRun )

Definition at line 206 of file MFStatusUpdater.cc.

References s, and mf::SetModuleName().

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

art::MFSU_2_ARG_UPDATER_DEFN ( PostPathEndRun )

Definition at line 216 of file MFStatusUpdater.cc.

References s, and mf::SetModuleName().

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

art::MFSU_2_ARG_UPDATER_DEFN ( PostPathBeginSubRun )

Definition at line 226 of file MFStatusUpdater.cc.

References s, and mf::SetModuleName().

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

art::MFSU_2_ARG_UPDATER_DEFN ( PostPathEndSubRun )

Definition at line 236 of file MFStatusUpdater.cc.

References s, and mf::SetModuleName().

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

art::MFSU_2_ARG_UPDATER_DEFN ( PostBeginJobWorkers )

Definition at line 254 of file MFStatusUpdater.cc.

References s.

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

constexpr auto art::most_deeply_nested_level ( )

noexcept

Definition at line 51 of file Level.h.

References level_up(), and NumNestingLevels.

Referenced by is_above_most_deeply_nested_level(), and is_most_deeply_nested_level().

   {
     return level_up(Level::NumNestingLevels);
   }

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

Definition at line 114 of file TypeID.cc.

References is_assns(), name_of_template_arg(), and s.

Referenced by art::detail::createProductLookups().

 {
   std::string result;
   if (!is_assns(assns_type_name)) {
     return result;
   }
   using namespace std::string_literals;
   static std::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 ( std::string assns_type_name )

Definition at line 99 of file TypeID.cc.

References is_assns(), name_of_template_arg(), and s.

Referenced by checkDictionaries().

 {
   std::string result;
   if (!is_assns(assns_type_name)) {
     return result;
   }
   static std::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	(	std::string const &	template_instance,
		size_t	desired_arg
	)

Definition at line 46 of file TypeID.cc.

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

 {
   std::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 ( std::string const & wrapped_name )

Definition at line 132 of file TypeID.cc.

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

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

std::map<new_t, old_t> art::newToOldName ( )

inline

Definition at line 15 of file SAMMetadataTranslators.h.

Referenced by oldToNewName(), and art::NewToOld::operator()().

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

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

inline

Definition at line 37 of file SAMMetadataTranslators.h.

References newToOldName().

Referenced by art::OldToNew::operator()().

   {
     auto const newToOld = newToOldName();
     std::map<old_t, new_t> oldToNew;
     cet::transform_all(
       newToOld, std::inserter(oldToNew, oldToNew.begin()), [](auto const& pr) {
         return std::make_pair(pr.second, pr.first);
       });
     return oldToNew;
   }

template<class A >

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

Definition at line 284 of file Selector.h.

 {
   return art::NotHelper<A>(a);
 }

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

inline

Definition at line 124 of file ScheduleID.h.

References right().

 {
   return !(left == right);
 }

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

inlinenoexcept

Definition at line 114 of file InputTag.h.

References decode(), left(), and right().

 {
   return !(left == right);
 }

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

inline

Definition at line 133 of file TypeID.h.

 {
   return !(a == b);
 }

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

inline

Definition at line 167 of file ProcessHistory.h.

 {
   return !(a == b);
 }

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

inline

Definition at line 143 of file RefCore.h.

 {
   return !(lhs == rhs);
 }

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

inline

Definition at line 82 of file BranchKey.h.

 {
   return !(a == b);
 }

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

inline

Definition at line 115 of file ProductProvenance.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!=	(	Parentage const &	a,
		Parentage const &	b
	)

inline

Definition at line 54 of file Parentage.h.

   {
     return !(a == b);
   }

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

inline

Definition at line 56 of file ProcessConfiguration.h.

References operator<<().

   {
     return !(a == b);
   }

template<typename T , typename U >

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

template<class X , class Y >

bool art::operator!=	(	debugging_allocator< X > const &	,
		debugging_allocator< Y > const &
	)
throw	(
	)

Definition at line 108 of file debugging_allocator.h.

Referenced by art::const_AssnsIter< L, R, D, Dir >::const_AssnsIter(), and art::Ptr< T >::getData_().

   {
     return false;
   }

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

inline

Definition at line 211 of file FileIndex.h.

   {
     return lh < rh || rh < lh;
   }

template<class A , class B >

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

Definition at line 212 of file Selector.h.

 {
   return art::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<	(	ProcessConfiguration const &	a,
		ProcessConfiguration const &	b
	)

Definition at line 22 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<	(	RefCore const &	lhs,
		RefCore const &	rhs
	)

inline

Definition at line 149 of file RefCore.h.

References art::RefCore::id().

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

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

inline

Definition at line 62 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<	(	ProductProvenance const &	a,
		ProductProvenance const &	b
	)

inline

Definition at line 102 of file ProductProvenance.h.

References art::ProductProvenance::productID().

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

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

inline

Definition at line 44 of file ProductInfo.h.

References art::ProductInfo::consumableType_, art::ProductInfo::instance_, art::ProductInfo::label_, art::ProductInfo::process_, and art::ProductInfo::typeID_.

Referenced by art::BranchDescription::wrappedName().

   {
     return std::tie(
              a.consumableType_, a.typeID_, a.label_, a.instance_, a.process_) <
            std::tie(
              b.consumableType_, b.typeID_, b.label_, b.instance_, b.process_);
   }

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

Definition at line 45 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);
   }

template<typename T , typename U >

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

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

Definition at line 186 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;
   }

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

Definition at line 223 of file FileIndex.cc.

References art::FileIndex::Element::eventID_.

   {
     bool const result = lh.eventID_ < rh.eventID_;
     return result;
   }

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 7 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 65 of file GroupSelector.cc.

References art::GroupSelector::print().

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

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

Definition at line 39 of file TypeID.cc.

References art::TypeID::print().

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

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

inline

Definition at line 67 of file BranchMapper.h.

References art::BranchMapper::write().

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

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

Definition at line 26 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,
		ProductProvenance const &	p
	)

inline

Definition at line 108 of file ProductProvenance.h.

References art::ProductProvenance::write().

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

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

inline

Definition at line 29 of file BranchType.h.

References BranchTypeToString().

   {
     return os << BranchTypeToString(branchType);
   }

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,
		ProductID const	id
	)

Definition at line 32 of file ProductID.cc.

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

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

inline

Definition at line 162 of file Provenance.h.

References art::Provenance::write().

 {
   return p.write(os);
 }

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

Definition at line 36 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,
		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,
		MasterProductRegistry const &	mpr
	)

Definition at line 123 of file MasterProductRegistry.cc.

References art::MasterProductRegistry::print().

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

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

inline

Definition at line 45 of file Parentage.h.

References operator==().

   {
     // Unimplemented
     return os;
   }

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

Definition at line 54 of file InputTag.cc.

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

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

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

Definition at line 58 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;
   }

template<typename T >

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

inline

Definition at line 61 of file ServiceTable.h.

References fhicl::Table< T, KeysToIgnore >::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,
		Granularity const &	b
	)

inline

Definition at line 62 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<<	(	ostream &	ost,
		ProcessHistory const &	ph
	)

Definition at line 66 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,
		ProducerBase::Table< T > const &	t
	)

inline

Definition at line 66 of file ProducerBase.h.

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

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

inline

Definition at line 72 of file PluginSuffixes.h.

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

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

template<typename PROD >

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

inline

Definition at line 296 of file DataViewImpl.h.

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

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

inline

Definition at line 87 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<<	(	std::ostream &	os,
		EventRange const &	r
	)

Definition at line 162 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;
 }

template<typename T >

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

Definition at line 498 of file Ptr.h.

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

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

inline

Definition at line 114 of file ProductMetaData.h.

References art::ProductMetaData::printBranchDescriptions().

   {
     pmd.printBranchDescriptions(os);
     return os;
   }

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

inline

Definition at line 115 of file ModuleDescription.h.

References art::ModuleDescription::write().

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

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

Definition at line 26 of file ClosingCriteria.cc.

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

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

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

Definition at line 356 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<<	(	std::ostream &	ost,
		HLTGlobalStatus const &	hlt
	)

inline

Definition at line 176 of file HLTGlobalStatus.h.

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

   {
     std::vector<std::string> text(4);
     text[0] = "n";
     text[1] = "1";
     text[2] = "0";
     text[3] = "e";
     for (std::size_t i{}, n{hlt.size()}; i != n; ++i)
       ost << text.at(hlt.state(i));
     return ost;
   }

template<typename T >

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

inline

Definition at line 184 of file EDAnalyzer.h.

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

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

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

inline

Definition at line 198 of file Group.h.

References art::Group::write().

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

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

Definition at line 249 of file FileIndex.cc.

References art::FileIndex::Element::entry_, and art::FileIndex::Element::eventID_.

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

template<int I>

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

inline

Definition at line 250 of file Hash.h.

   {
     return h.print(os);
   }

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

Definition at line 265 of file BranchDescription.cc.

References art::BranchDescription::write().

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

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

Definition at line 278 of file FileIndex.cc.

References e.

   {
 
     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	left,
		ScheduleID	right
	)

inline

Definition at line 130 of file ScheduleID.h.

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

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

inline

Definition at line 199 of file FileIndex.h.

   {
     return !(rh < lh);
   }

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

inline

Definition at line 161 of file ProcessHistory.h.

References art::ProcessHistory::data().

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

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

inline

Definition at line 137 of file RefCore.h.

References art::RefCore::id().

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

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

inline

Definition at line 76 of file BranchKey.h.

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

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

Definition at line 26 of file Parentage.cc.

References art::Parentage::parents().

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

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==	(	ProcessConfiguration const &	a,
		ProcessConfiguration const &	b
	)

Definition at line 29 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==	(	art::Provenance const &	a,
		art::Provenance const &	b
	)

inline

Definition at line 168 of file Provenance.h.

References art::Provenance::equals().

Referenced by art::const_AssnsIter< L, R, D, Dir >::const_AssnsIter(), art::Ptr< T >::getData_(), operator<<(), and art::BranchDescription::wrappedName().

 {
   return a.equals(b);
 }

template<typename T , typename U >

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

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

Definition at line 86 of file ProductProvenance.cc.

References art::ProductProvenance::noParentage(), art::ProductProvenance::parentageID(), art::ProductProvenance::productID(), and art::ProductProvenance::productStatus().

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

template<class X , class Y >

bool art::operator==	(	debugging_allocator< X > const &	,
		debugging_allocator< Y > const &
	)
throw	(
	)

Definition at line 100 of file debugging_allocator.h.

   {
     return true;
   }

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

Definition at line 283 of file RangeSet.cc.

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

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

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

inline

Definition at line 205 of file FileIndex.h.

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

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

Definition at line 258 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>	(	ScheduleID	left,
		ScheduleID	right
	)

inline

Definition at line 136 of file ScheduleID.h.

References right().

Referenced by art::const_AssnsIter< L, R, D, Dir >::const_AssnsIter().

 {
   return !(left <= right);
 }

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

inline

Definition at line 127 of file TypeID.h.

 {
   return b < a;
 }

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

inline

Definition at line 187 of file FileIndex.h.

   {
     return rh < lh;
   }

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

inline

Definition at line 142 of file ScheduleID.h.

References right().

Referenced by art::const_AssnsIter< L, R, D, Dir >::const_AssnsIter().

 {
   return !(left < right);
 }

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

inline

Definition at line 193 of file FileIndex.h.

   {
     return !(lh < rh);
   }

template<class A , class B >

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

Definition at line 249 of file Selector.h.

 {
   return art::OrHelper<A, B>(a, b);
 }

template<class T , class U >

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

Referenced by art::RootDelayedReader::getProduct_(), overlapping_ranges(), art::ValidHandle< T >::swap(), art::detail::throw_if_invalid(), and art::SummedValue< T >::update_impl().

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

Definition at line 348 of file RangeSet.cc.

References disjoint_ranges().

 {
   if (!both_valid(l, r))
     return false;
   return !disjoint_ranges(l, r);
 }

template<class T , class U >

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

Definition at line 189 of file SummedValue.h.

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

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

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

Definition at line 15 of file parent_path.cc.

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

 {
   std::string result;
   boost::filesystem::path parent_path(
     boost::filesystem::path(in_path).parent_path());
   if (parent_path.empty()) {
     result = ".";
   } else {
     result = parent_path.native();
   }
   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 fhicl::detail::atom::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_common_().

                                                                  {
     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 25 of file ExceptionMessages.cc.

Referenced by run_art_common_().

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

Referenced by run_art_common_().

                                                                  {
     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 50 of file ExceptionMessages.cc.

Referenced by run_art_common_().

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

Referenced by art::RootInputTree::RootInputTree(), and art::RootOutputTree::RootOutputTree().

   {
     return select(bt,
                   {&eventProductProvenance,
                    &subRunProductProvenance,
                    &runProductProvenance,
                    &resultsProductProvenance});
   }

template<typename T , typename P >

std::enable_if_t<P::branch_type == InEvent \|\| P::branch_type == InResults> art::put_product_in_principal	(	std::unique_ptr< T > &&	product,
		P &	principal,
		std::string const &	module_label,
		std::string const &	instance_name = `{}`
	)

Referenced by rangeSetFor(), lris::LArRawInputDriverShortBo::readNext(), lris::LArRawInputDriverLongBo::readNext(), lris::LArRawInputDriver::readNext(), and lris::LArRawInputDriverJP250L::readNext().

template<typename T , typename P >

std::enable_if_t<P::branch_type == InSubRun \|\| P::branch_type == InRun> art::put_product_in_principal	(	std::unique_ptr< T > &&	product,
		P &	principal,
		std::string const &	module_label,
		std::string const &	instance_name = `{}`,
		RangeSet &&	= `RangeSet::invalid()`
	)

template<class T >

std::enable_if_t<detail::is_handle<T>::value, RangeSet const&> art::range_of_validity ( T const & h )

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

RangeSet art::rangeSetFor ( RunPrincipal const & rp )

inline

Definition at line 45 of file put_product_in_principal.h.

References art::RangeSet::forRun(), and art::RunPrincipal::id().

Referenced by rangeSetFor().

   {
     return RangeSet::forRun(rp.id());
   }

RangeSet art::rangeSetFor ( SubRunPrincipal const & srp )

inline

Definition at line 51 of file put_product_in_principal.h.

References art::RangeSet::forSubRun(), art::SubRunPrincipal::id(), InEvent, InResults, InRun, InSubRun, art::errors::NullPointerError, art::productstatus::present(), art::BranchDescription::productID(), put_product_in_principal(), and rangeSetFor().

   {
     return RangeSet::forSubRun(srp.id());
   }

void art::reenableSigs ( sigset_t * oldset )

Definition at line 106 of file UnixSignalHandlers.cc.

References MUST_BE_ZERO.

Referenced by installCustomHandler().

   {
     // reenable the signals
     MUST_BE_ZERO(pthread_sigmask(SIG_SETMASK, oldset, 0));
   }

std::vector< std::vector< std::string >::const_iterator > art::regexMatch	(	std::vector< std::string > const &	strings,
		std::regex const &	regexp
	)

Definition at line 27 of file RegexMatch.cc.

Referenced by art::EventSelector::init(), and regexMatch().

   {
     std::vector<std::vector<std::string>::const_iterator> matches;
     for (auto i = strings.begin(), iEnd = strings.end(); i != iEnd; ++i) {
       if (std::regex_match((*i), regexp)) {
         matches.push_back(i);
       }
     }
     return matches;
   }

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

Definition at line 39 of file RegexMatch.cc.

References glob2reg(), and regexMatch().

   {
     std::regex const regexp{glob2reg(pattern)};
     return regexMatch(strings, regexp);
   }

template<class L , class R , class 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 112 of file AssnsIter.h.

References Forward.

Referenced by cluster::ClusterAna::analyze(), pfpf::PFPAna::analyze(), lar_cluster3d::ClusterPathFinder::breakIntoTinyBits(), lar_cluster3d::VoronoiPathFinder::breakIntoTinyBits(), lar_cluster3d::ClusterPathFinder::buildConvexHull(), lar_cluster3d::VoronoiPathFinder::buildConvexHull(), lar_cluster3d::StandardHit3DBuilder::BuildHit3D(), lar_cluster3d::kdTree::BuildKdTree(), lar_cluster3d::ClusterPathFinder::buildVoronoiDiagram(), lar_cluster3d::VoronoiPathFinder::buildVoronoiDiagram(), util::details::RangeForWrapperIterator< BeginIter, EndIter >::Comparer::ComparerImpl< A, B, std::enable_if_t< std::is_convertible< decltype(std::declval< A >()!=std::declval< B >()), bool >::value > >::compare(), voronoi2d::compareSiteEventPtrs(), voronoi2d::VoronoiDiagram::ComputeFaceArea(), recob::dumper::DumpPCAxis(), cluster::TrajCluster::endJob(), lar_cluster3d::ClusterParamsBuilder::FillClusterParams(), lar_cluster3d::MinSpanTreeAlg::FindBestPathInCluster(), voronoi2d::VoronoiDiagram::findBoundingBox(), lar_cluster3d::StandardHit3DBuilder::findGoodTriplets(), reco_tool::CandHitDerivative::findHitCandidates(), reco_tool::CandHitMorphological::findHitCandidates(), reco_tool::WaveformTools::findPeaks(), mf::service::ELdestination::formSummary(), voronoi2d::VoronoiDiagram::getConvexHull(), G4THitsCollection< T >::GetSize(), reco_tool::WaveformTools::getTruncatedMeanRMS(), lar_cluster3d::Hit3DCompare(), lar_cluster3d::Cluster3D::MakeAndSavePCAPoints(), evd::SimulationDrawer::MCTruthLongText(), lar_cluster3d::ClusterMergeAlg::ModifyClusters(), operator!=(), util::flags::operator!=(), art::SortInvalidFirst< T >::operator()(), art::const_AssnsIter< L, R, D, Dir >::operator<(), util::flags::operator<(), recob::operator<<(), reco::operator<<(), util::flags::operator<<(), art::const_AssnsIter< L, R, D, Dir >::operator<=(), util::flags::operator<=(), util::flags::operator==(), operator>(), art::const_AssnsIter< L, R, D, Dir >::operator>(), util::flags::operator>(), operator>=(), art::const_AssnsIter< L, R, D, Dir >::operator>=(), util::flags::operator>=(), lar_cluster3d::PrincipalComponentsAlg::PCAAnalysis_2D(), lar_cluster3d::PrincipalComponentsAlg::PCAAnalysis_3D(), art::detail::InfoDumperInputFile::print_process_history(), tca::PrintAllTraj(), trkf::CCTrackMaker::PrintClusters(), cluster::ClusterCrawlerAlg::PrintClusters(), tca::PrintPFP(), trkf::CCTrackMaker::PrintTracks(), cluster::ClusterCrawlerAlg::PrintVertices(), hit::GausHitFinder::produce(), boost::python::detail::proxy_group< Proxy >::replace(), lar_content::LArPcaHelper::RunPca(), lar_cluster3d::MinSpanTreeAlg::RunPrimsAlgorithm(), sort_pred(), sort_pred2(), trkf::CCTrackMaker::SortMatches(), art::RangeSet::split_range(), lar_cluster3d::Cluster3D::splitClustersWithMST(), hit::CCHitFinderAlg::StudyHits(), throw_if_not_disjoint(), art::detail::triggerReport(), and util::flags::Bits_t< Storage_t >::unsetBits().

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

int art::run_art	(	int	argc,
		char **	argv,
		bpo::options_description &	in_desc,
		cet::filepath_maker &	lookupPolicy,
		OptionsHandlers &&	handlers
	)

Definition at line 123 of file run_art.cc.

References e, fhicl::make_ParameterSet(), fhicl::ParameterSetRegistry::put(), and run_art_common_().

Referenced by artapp(), and mu2eapp().

   {
     std::ostringstream descstr;
     descstr << "\nUsage: "
             << boost::filesystem::path(argv[0]).filename().native()
             << " <-c <config-file>> <other-options> [<source-file>]+\n\n"
             << "Basic options";
     bpo::options_description all_desc{descstr.str()};
     all_desc.add(in_desc);
     // BasicOptionsHandler should always be first in the list!
     handlers.emplace(handlers.begin(),
                      new BasicOptionsHandler{all_desc, lookupPolicy});
     // BasicPostProcessor should be last.
     handlers.emplace_back(new BasicPostProcessor);
     // 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)
                    .positional(pd)
                    .run(),
                  vm);
       bpo::notify(vm);
     }
     catch (bpo::error const& e) {
       std::cerr << "Exception from command line processing in " << argv[0]
                 << ": " << e.what() << "\n";
       return 88;
     }
     // Preliminary argument checking.
     for (auto& handler : handlers) {
       auto 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 result = handler->processOptions(vm, raw_config);
       if (result != 0) {
         return result;
       }
     }
     //
     // Make the parameter set from the intermediate table:
     //
     fhicl::ParameterSet main_pset;
     try {
       make_ParameterSet(raw_config, main_pset);
     }
     catch (cet::exception const& e) {
       constexpr cet::HorizontalRule rule{36};
       std::cerr << "ERROR: Failed to create a parameter set from parsed "
                    "configuration with exception "
                 << e.what() << ".\n";
       std::cerr << "       Intermediate configuration state follows:\n"
                 << rule('-') << '\n'
                 << rule('-') << '\n';
       for (auto const& item : raw_config) {
         std::cerr << item.first << ": " << item.second.to_string() << '\n';
       }
       std::cerr << rule('-') << '\n' << rule('-') << '\n';
       return 91;
     }
 
     // Main parameter set must be placed in registry manually.
     try {
       fhicl::ParameterSetRegistry::put(main_pset);
     }
     catch (...) {
       std::cerr << "Uncaught exception while inserting main parameter set into "
                    "registry.\n";
       throw;
     }
     return run_art_common_(main_pset);
   }

int art::run_art_common_ ( fhicl::ParameterSet const & main_pset )

Definition at line 251 of file run_art.cc.

References e, fhicl::ParameterSet::get(), fhicl::ParameterSet::has_key(), art::detail::info_success(), printArtException(), printBadAllocException(), printStdException(), printUnknownException(), mf::SetIteration(), setupSignals(), shutdown_flag, and mf::StartMessageFacility().

Referenced by run_art(), and run_art_string_config().

   {
     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_processing_mode =
       maybe_output_config(main_pset, scheduler_pset);
     if (debug_processing_mode == debug_processing::debug_config) {
       return detail::info_success(); // Bail out early
     }
 
     //
     // Start the messagefacility
     //
     mf::SetIteration("JobSetup");
     try {
       mf::StartMessageFacility(
         services_pset.get<fhicl::ParameterSet>("message", {}));
     }
     catch (cet::exception const& e) {
       std::cerr << e.what() << '\n';
       return 69;
     }
     catch (std::exception const& e) {
       std::cerr << e.what() << '\n';
       return 70;
     }
     catch (...) {
       std::cerr << "Caught unknown exception while initializing the message "
                    "facility.\n";
       return 71;
     }
 
     mf::LogInfo("MF_INIT_OK") << "Messagelogger initialization complete.";
     //
     // Initialize:
     //   unix signal facility
     art::setupSignals(scheduler_pset.get<bool>("enableSigInt", true));
 
     int rc{0};
     try {
       EventProcessor ep{main_pset};
       // 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_processing_mode == debug_processing::validate_config) {
         return detail::info_success(); // Bail out early
       }
       if (scheduler_pset.has_key("dataDependencyGraph")) {
         return detail::info_success(); // Bail out early
       }
       if (ep.runToCompletion() == EventProcessor::epSignal) {
         std::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 (std::bad_alloc const& bda) {
       rc = 68;
       printBadAllocException("art");
     }
     catch (std::exception const& e) {
       rc = 66;
       printStdException(e, "art");
     }
     catch (...) {
       rc = 67;
       printUnknownException("art");
     }
     return rc;
   }

int art::run_art_string_config ( std::string const & config_string )

Definition at line 210 of file run_art.cc.

References e, fhicl::make_ParameterSet(), fhicl::parse_document(), art::OptionsHandler::processOptions(), fhicl::ParameterSetRegistry::put(), and run_art_common_().

Referenced by artapp_string_config(), and mu2eapp_string_config().

   {
     //
     // Make the parameter set from the configuration string:
     //
     fhicl::ParameterSet main_pset;
     try {
       // create an intermediate table from the input string
       fhicl::intermediate_table raw_config;
       parse_document(config_string, raw_config);
       // run post-processing
       bpo::variables_map vm;
       BasicPostProcessor bpp;
       bpp.processOptions(vm, raw_config);
       // create the parameter set
       make_ParameterSet(raw_config, main_pset);
     }
     catch (cet::exception& e) {
       constexpr cet::HorizontalRule rule{36};
       std::cerr << "ERROR: Failed to create a parameter set from an input "
                    "configuration string with exception "
                 << e.what() << ".\n";
       std::cerr << "       Input configuration string follows:\n"
                 << rule('-') << rule('-') << "\n";
       std::cerr << config_string << "\n";
       std::cerr << rule('-') << rule('-') << '\n';
       return 91;
     }
     // Main parameter set must be placed in registry manually.
     try {
       fhicl::ParameterSetRegistry::put(main_pset);
     }
     catch (...) {
       std::cerr << "Uncaught exception while inserting main parameter set into "
                    "registry.\n";
       throw;
     }
     return run_art_common_(main_pset);
   }

constexpr auto art::runFragment ( )

Definition at line 35 of file ProductSemantics.h.

   {
     return FragmentSemantic<Level::Run>{};
   }

auto art::runFragment ( RangeSet const & rs )

inline

Definition at line 46 of file ProductSemantics.h.

   {
     return RangedFragmentSemantic<Level::Run>{rs};
   }

template<class T , class U >

std::enable_if_t<detail::are_handles<T, U>::value, bool> art::same_ranges	(	T const &	a,
		U const &	b
	)

Referenced by art::RootDelayedReader::getProduct_(), same_ranges(), art::ValidHandle< T >::swap(), art::detail::throw_if_invalid(), and art::SummedValue< T >::update_impl().

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

Definition at line 291 of file RangeSet.cc.

 {
   return l == r;
 }

template<class T , class U >

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

Definition at line 175 of file SummedValue.h.

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

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

template<class COLLECTION >

void art::setPtr	(	COLLECTION const &	coll,
		std::type_info const &	iToType,
		unsigned long	iIndex,
		void const *&	oPtr
	)

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()) && 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::setRootErrorHandler ( bool const want_custom )

Definition at line 187 of file InitRootHandlers.cc.

References RootErrorHandler().

Referenced by art::BasicOutputOptionsHandler::doCheckOptions().

   {
     if (want_custom) {
       SetErrorHandler(RootErrorHandler);
     } else {
       SetErrorHandler(DefaultErrorHandler);
     }
   }

void art::setupSignals ( bool want_sigint_enabled )

Definition at line 203 of file UnixSignalHandlers.cc.

References ep_sigusr2(), and installCustomHandler().

Referenced by run_art_common_().

   {
     art::installCustomHandler(SIGUSR2, art::ep_sigusr2);
     art::installCustomHandler(SIGTERM, art::ep_sigusr2);
     art::installCustomHandler(SIGQUIT, art::ep_sigusr2);
     if (want_sigint_enabled)
       art::installCustomHandler(SIGINT, art::ep_sigusr2);
   }

void art::sigInventory ( )

Definition at line 179 of file UnixSignalHandlers.cc.

References MUST_BE_ZERO.

   {
     sigset_t tmpset, oldset;
     //    Make a full house set of signals, except for SIGKILL = 9
     //    and SIGSTOP = 19 which cannot be blocked
     MUST_BE_ZERO(sigfillset(&tmpset));
     MUST_BE_ZERO(sigdelset(&tmpset, SIGKILL));
     MUST_BE_ZERO(sigdelset(&tmpset, SIGSTOP));
     //    Swap it with the current sigset_t
     MUST_BE_ZERO(pthread_sigmask(SIG_SETMASK, &tmpset, &oldset));
     //    Now see what's included in the set
     for (int k = 1; k < NSIG; ++k) {
       std::cerr << "sigismember is " << sigismember(&tmpset, k)
                 << " for signal " << std::setw(2) << k
 #if defined(__linux__)
                 << " (" << strsignal(k) << ")"
 #endif
                 << std::endl;
     }
     //    Finally put the original sigset_t back
     MUST_BE_ZERO(pthread_sigmask(SIG_SETMASK, &oldset, &tmpset));
   }

template<Direction Dir>

constexpr int art::signed_one ( )

Definition at line 28 of file AssnsIter.h.

   {
     return static_cast<std::underlying_type_t<Direction>>(Dir);
   }

constexpr auto art::subRunFragment ( )

Definition at line 40 of file ProductSemantics.h.

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

auto art::subRunFragment ( RangeSet const & rs )

inline

Definition at line 51 of file ProductSemantics.h.

   {
     return RangedFragmentSemantic<Level::SubRun>{rs};
   }

void art::swap	(	art::ProcessHistory &	a,
		art::ProcessHistory &	b
	)

inline

Definition at line 155 of file ProcessHistory.h.

References art::ProcessHistory::swap().

 {
   a.swap(b);
 }

void art::swap	(	TypeID &	left,
		TypeID &	right
	)

inline

Definition at line 139 of file TypeID.h.

References art::TypeID::swap().

Referenced by art::TypeID::swap().

 {
   left.swap(right);
 }

void art::swap	(	art::RefCore &	lhs,
		art::RefCore &	rhs
	)

inline

Definition at line 155 of file RefCore.h.

References art::RefCore::swap().

Referenced by art::RefCore::swap().

 {
   lhs.swap(rhs);
 }

template<typename T >

void art::swap	(	PtrVector< T > &	lhs,
		PtrVector< T > &	rhs
	)

inline

Definition at line 599 of file PtrVector.h.

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

Referenced by art::PtrVector< T >::swap().

 {
   lhs.swap(rhs);
 }

void art::swap	(	Provenance &	x,
		Provenance &	y
	)

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	(	TriggerResults &	lhs,
		TriggerResults &	rhs
	)

inline

Definition at line 70 of file TriggerResults.h.

References art::TriggerResults::swap().

   {
     lhs.swap(rhs);
   }

void art::swap	(	OutputHandle &	a,
		OutputHandle &	b
	)

inline

Definition at line 110 of file OutputHandle.h.

References art::OutputHandle::swap().

Referenced by art::OutputHandle::swap().

   {
     a.swap(b);
   }

void art::swap	(	HLTGlobalStatus &	lhs,
		HLTGlobalStatus &	rhs
	)

inline

Definition at line 169 of file HLTGlobalStatus.h.

References art::HLTGlobalStatus::swap().

   {
     lhs.swap(rhs);
   }

template<int I>

void art::swap	(	Hash< I > &	a,
		Hash< I > &	b
	)

inline

Definition at line 243 of file Hash.h.

References art::Hash< I >::swap().

   {
     a.swap(b);
   }

void art::throw_if_not_disjoint	(	RunNumber_t const	rn,
		EventRange const &	left,
		EventRange const &	right
	)

noexcept

Definition at line 333 of file RangeSet.cc.

References art::errors::EventRangeOverlap, left(), and right().

Referenced by art::RangeSet::collapse(), and art::detail::RangeSetInfo::update().

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

std::string art::to_string ( ModuleType mt )

inline

Definition at line 32 of file ModuleType.h.

References ANALYZER, FILTER, art::errors::LogicError, NON_ART, OUTPUT, and PRODUCER.

Referenced by art::PathManager::fillAllModules_(), art::detail::getType< suffix_type::module >(), art::PathManager::processOnePathConfig_(), art::RangeSet::to_compact_string(), and art::RootOutputFile::writeFileCatalogMetadata().

 {
   switch (mt) {
     case ModuleType::NON_ART:
       return "non-art";
     case ModuleType::ANALYZER:
       return "analyzer";
     case ModuleType::FILTER:
       return "filter";
     case ModuleType::PRODUCER:
       return "producer";
     case ModuleType::OUTPUT:
       return "output module";
     default:
       throw Exception(errors::LogicError)
         << "Unable to find string for unrecognized ModuleType value "
         << static_cast<int>(mt) << ".\n";
   }
 }

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, art::detail::FDS::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, art::detail::FDS::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 25 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.

References s.

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

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

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

void art::unloadRootSigHandler ( )

Definition at line 171 of file InitRootHandlers.cc.

Referenced by art::BasicOutputOptionsHandler::doProcessOptions().

   {
     // Deactivate all the Root signal handlers and restore the system defaults
     gSystem->ResetSignal(kSigChild);
     gSystem->ResetSignal(kSigBus);
     gSystem->ResetSignal(kSigSegmentationViolation);
     gSystem->ResetSignal(kSigIllegalInstruction);
     gSystem->ResetSignal(kSigSystem);
     gSystem->ResetSignal(kSigPipe);
     gSystem->ResetSignal(kSigAlarm);
     gSystem->ResetSignal(kSigUrgent);
     gSystem->ResetSignal(kSigFloatingException);
     gSystem->ResetSignal(kSigWindowChanged);
   }

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

Definition at line 5 of file WrappedClassName.cc.

Referenced by checkDictionaries(), and 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 12 of file DebugMacros.cc.

Referenced by art::ActionTable::addDefaults_().

MallocOptionSetter art::global_malloc_options

Definition at line 204 of file MallocOpts.cc.

Referenced by getGlobalOptionSetter().

std::atomic< int > art::shutdown_flag {0}

Definition at line 27 of file UnixSignalHandlers.cc.

Referenced by ep_sigusr2(), art::EventProcessor::process(), run_art_common_(), and art::EventProcessor::runToCompletion().

std::mutex art::signum_lock

Definition at line 44 of file UnixSignalHandlers.cc.

volatile int art::signum_value

Initial value:

=
    0

Definition at line 45 of file UnixSignalHandlers.cc.

Referenced by getSigNum().

std::mutex art::usr2_lock

Definition at line 23 of file UnixSignalHandlers.cc.

Namespaces

Classes

Typedefs

Enumerations

Functions

Variables

Detailed Description

Typedef Documentation

Enumeration Type Documentation

Function Documentation

Variable Documentation