edm Namespace Reference

HLT enums. More...

Namespaces
	clonehelper
	cmspybind11
	convertException
	core
	detail
	details
	detailsTrie
	dqh
	dsrvdetail
	edmmltest
	errors
	es
	esvhhelper
	eventsetup
	evetnsetup
	evtSel
	exception_actions
	fillDetails
	friendlyname
	gen
	global
	handleimpl
	hash_detail
	helper
	helpers
	hlt
	impl
	level
	limited
	maker
	messagedrop
	messagelogger
	MixingCache
	module
	mpl
	multicore
	one
	path_configuration
	pathStatusExpression
	pdtentry
	poolNames
	principal_get_adapter_detail
	producerbasehelper
	productholderindexhelper
	pset
	python
	refcore
	refcoreimpl
	refhelper
	refitem
	reftobase
	releaseversion
	root
	roottree
	service
	serviceregistry
	shared_memory
	signalslot
	soa
	soahelper
	storage
	stream
	streamer
	test
	threadLocalException
	typelookup
	vhhelper
	waiting_task
	workerhelper
	workerimpl
	writeParameterValue

Classes
struct	Accumulator
class	ActivityRegistry
class	Adjuster
class	AdjusterBase
class	AliasProductResolver
class	AllowedLabelsDescription
class	AllowedLabelsDescription< ParameterSetDescription >
class	AllowedLabelsDescription< std::vector< ParameterSet > >
class	AllowedLabelsDescriptionBase
class	AnalyzerWrapper
class	ANDGroupDescription
class	AsciiOutputModule
class	AssertHandler
class	Association
class	AssociationMap
class	AssociationMapAnalyzer
class	AssociationMapProducer
class	AssociationVector
class	AssociativeIterator
class	atomic_value_ptr
struct	atomic_value_ptr_traits
class	AtomicPtrCache
class	BaseFlatGunProducer
class	BaseRandomtXiGunProducer
class	BaseWithDict
class	BasicAnalyzer
class	BasicHandle
class	BeamHaloProducer
class	BeamMomentumGunProducer
struct	BeginLuminosityBlockProducer
struct	BeginProcessBlockProducer
struct	BeginRunProducer
class	BMixingModule
class	BoolCache
class	BooleanFilter
class	BooleanProducer
class	BranchChildren
class	BranchDescription
class	BranchID
class	BranchIDListHelper
class	BranchKey
struct	BranchToCount
struct	BranchTypeForContainerType
struct	BranchTypeForContainerType< LuminosityBlock >
struct	BranchTypeForContainerType< LuminosityBlockForOutput >
struct	BranchTypeForContainerType< ProcessBlock >
struct	BranchTypeForContainerType< ProcessBlockForOutput >
struct	BranchTypeForContainerType< Run >
struct	BranchTypeForContainerType< RunForOutput >
class	BunchCrossingFilter
class	CacheHandle
class	CallNTimesNoWait
class	CallOnceNoWait
struct	CatalogAttributes
class	CFWriter
struct	CheckAbility
struct	CheckAbility< ABILITY >
struct	CheckAbility< ABILITY, T, VArgs... >
class	ChildrenCPUTimer
struct	ClonePolicy
class	CloningPtr
class	CloseByParticleGunProducer
class	CmsRunParser
class	Comment
struct	CommonParams
class	CompactEventAuxiliaryVector
class	Compare_Index
class	Compare_Index_Run
class	Compare_Run_Lumi_EventEntry
struct	CompareRefDetSet
class	ConcurrentGeneratorFilter
class	ConcurrentHadronizerFilter
class	ConditionalTaskHelper
class	ConditionsInEventBlock
class	ConditionsInLumiBlock
class	ConditionsInRunBlock
class	ConfigurationDescriptions
struct	ConfigurationHandshake
class	ConstProductRegistry
class	ConstPtrCache
class	ConstRespectingPtr
class	ConsumesCollector
class	ConsumesCollectorAdaptor
class	ConsumesCollectorESAdaptor
class	ConsumesCollectorWithTagESAdaptor
class	ConsumesInfo
class	ContainerMask
class	ContainerMaskTraits
class	ContainerMaskTraits< edmNew::DetSetVector< T > >
struct	CopyPolicy
class	CosMuoGenProducer
class	CountAndLimit
class	CPUServiceBase
class	CPUTimer
class	CurrentModuleOnThread
struct	DaqProvenanceHelper
class	DataFrame
class	DataFrameContainer
class	DataManagingOrAliasProductResolver
class	DataManagingProductResolver
class	DataMixingEMDigiWorker
class	DataMixingEMWorker
class	DataMixingGeneralTrackWorker
class	DataMixingHcalDigiWorker
class	DataMixingHcalDigiWorkerProd
class	DataMixingHcalWorker
class	DataMixingModule
class	DataMixingMuonWorker
class	DataMixingPileupCopy
class	DataMixingSiPixelWorker
class	DataMixingSiStripRawWorker
class	DataMixingSiStripWorker
struct	debugvalue
struct	DefaultRecord
class	DefaultRunHelper
class	DelayedReader
class	DelayedReaderInputProductResolver
class	DelayedReaderThrowingSource
class	DescriptionFillerForEDLoopers
class	DescriptionFillerForESProducers
class	DescriptionFillerForESSources
class	DescriptionFillerForServices
struct	DetSet
class	DetSetRefVector
class	DetSetVector
class	DeviceProduct
class	DeviceProductBase
class	DigiAccumulatorMixModFactory
struct	do_nothing_deleter
class	DocFormatHelper
struct	DoNotPostInsert
struct	DoNotRecordParents
struct	DoNotSortUponInsertion
struct	DoPostInsert
class	DummyProvenanceReader
class	DummyVT
class	DuplicateChecker
class	DuplicateTreeSentry
class	EarlyDeleteHelper
class	EcalNoiseStorage
class	EDCollection
class	EDConsumerBase
class	EDConsumerBaseAdaptor
class	EDConsumerBaseESAdaptor
class	EDConsumerBaseWithTagESAdaptor
class	EDGetToken
class	EDGetTokenT
class	EDLooper
class	EDLooperBase
class	EDProductGetter
class	EDPutToken
class	EDPutTokenT
class	ElementID
class	ELextendedID
class	ELseverityLevel
class	EmbeddedRootSource
class	EmptyESSource
class	EmptyGroupDescription
class	EmptySource
struct	EndLuminosityBlockProducer
class	EndPathStatus
class	EndPathStatusInserter
struct	EndProcessBlockProducer
struct	EndRunProducer
class	Entry
class	ErrorObj
struct	ErrorSummaryEntry
class	ESConsumesCollector
class	ESConsumesCollectorAdaptor
class	ESConsumesCollectorT
class	ESConsumesCollectorWithTagAdaptor
struct	ESConsumesInfoEntry
struct	ESFillDirectly
class	ESGetToken
class	ESGetToken< fwliteeswriter::DummyType, fwliteeswriter::FWLWEventSetupRecord >
class	ESGetTokenGeneric
class	ESHandle
class	ESHandle< fwliteeswriter::DummyType >
struct	ESHandleAdapter
class	ESHandleBase
class	ESHandleExceptionFactory
class	ESInputTag
class	ESModuleCallingContext
class	ESParentContext
class	ESProducer
class	ESProducerExternalWork
class	ESProducerLooper
class	ESProductHost
class	ESProductResolverFactoryProducer
struct	ESProducts
class	ESProductTag
class	ESRecordAuxiliary
class	ESRecordIndex
class	ESResolverIndex
class	ESSharedResourceNames
class	ESTagGetter
class	ESTokenIndex
class	ESTransientHandle
class	ESValidHandle
class	ESWatcher
class	Event
class	EventAcquireSignalsSentry
class	EventAux
class	EventAuxiliary
class	EventAuxiliaryHistoryProducer
class	EventBase
class	EventContentAnalyzer
class	EventEntryDescription
class	EventEntryInfo
class	EventForOutput
class	EventForTransformer
class	EventID
class	EventItemGetter
	Helper class that fetches some type of Ref given ProductID and index, using the edm::Event. More...
class	EventPrincipal
class	EventProcessHistoryID
class	EventProcessor
class	EventRange
class	EventSelector
class	EventSetup
class	EventSetupCacheIdentifierChecker
class	EventSetupImpl
class	EventSetupRecordDataGetter
class	EventSetupRecordDetails
class	EventSetupRecordIntervalFinder
class	EventSignalsSentry
class	EventSkipperByID
struct	EventSummary
class	EventTime
struct	EventTimingSummary
class	EventToProcessBlockIndexes
class	EventTransitionInfo
class	Exception
class	ExceptionCollector
class	ExceptionToActionTable
class	ExpoRandomPGunProducer
class	ExpoRandomPtGunProducer
class	ExternalRandomNumberGenerator
class	ExternalRandomNumberGeneratorService
struct	ExternalWork
class	Factory
class	FileBlock
class	FileCatalogItem
class	FileFormatVersion
class	FileID
class	FileIndex
class	FileInPath
class	FileLocator
class	FileRandomKEThetaGunProducer
class	FileRandomMultiParticlePGunProducer
struct	FilledProductPtr
class	FilterObjectWrapper
class	FilterValueMapWrapper
class	FilterWrapper
class	FinalWaitingTask
class	FirstLuminosityBlockForEachRunHelper
class	FlatBaseThetaGunProducer
class	FlatRandomEGunProducer
class	FlatRandomEThetaGunProducer
class	FlatRandomMultiParticlePGunProducer
class	FlatRandomOneOverPtGunProducer
class	FlatRandomPtAndDxyGunProducer
class	FlatRandomPtGunProducer
class	FlatRandomPtThetaGunProducer
class	FromFiles
class	FullProvenanceReader
class	FunctionWithDict
class	FunctorESHandleExceptionFactory
class	FunctorHandleExceptionFactory
class	FunctorTask
class	FunctorWaitingTask
class	FwdPtr
class	FwdPtrCollectionFilter
	Selects a list of FwdPtr's to a product T (templated) that satisfy a method S(T) (templated). Can also handle input as View<T>. Can also have a factory class to create new instances of clones if desired. More...
struct	FwdPtrFromProductFactory
class	FwdPtrProducer
	Produces a list of FwdPtr's to an input collection. More...
class	FwdRef
struct	FWGenericObject
	This class is just a 'tag' used to allow a specialization of edm::Handle. More...
class	GaussRandomPThetaGunProducer
class	GeneratorFilter
class	GenericConsumer
struct	GenericObject
	This class is just a 'tag' used to allow a specialization of edm::Handle. More...
class	GenericSelectorByValueMap
class	GenHIEvent
class	GetProductCheckerOutputModule
class	GetterOfProducts
struct	GlobalCache
class	GlobalContext
class	GlobalSchedule
class	Guid
class	HadronizerFilter
class	Handle
class	Handle< FWGenericObject >
class	Handle< GenericObject >
class	HandleBase
class	HandleExceptionFactory
struct	has_fillView
struct	has_fillView< AssociationVector< KeyRefProd, CVal, KeyRef, SizeType, KeyReferenceHelper > >
struct	has_fillView< edm::DetSetVector< T > >
struct	has_fillView< edm::OwnVector< T, P > >
struct	has_fillView< edm::SortedCollection< T, SORT > >
struct	has_fillView< PtrVector< T > >
struct	has_fillView< RefToBaseVector< T > >
struct	has_fillView< RefVector< C, T, F > >
struct	has_fillView< std::deque< T, A > >
struct	has_fillView< std::list< T, A > >
struct	has_fillView< std::set< T, A > >
struct	has_fillView< std::vector< bool, A > >
struct	has_fillView< std::vector< T, A > >
struct	has_key_compare
struct	has_key_compare< T, std::void_t< typename T::key_compare > >
struct	has_setPtr
struct	has_setPtr< edm::OwnVector< T, P > >
struct	has_setPtr< edm::SortedCollection< T, SORT > >
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	HasAbilityToProduceInBeginLumis
struct	HasAbilityToProduceInBeginProcessBlocks
struct	HasAbilityToProduceInBeginRuns
struct	HasAbilityToProduceInEndLumis
struct	HasAbilityToProduceInEndProcessBlocks
struct	HasAbilityToProduceInEndRuns
class	Hash
class	HcalNoiseStorage
class	HepMC3Product
class	HepMCProduct
class	HiMixingModule
class	HiMixingWorker
class	HiMixingWorkerBase
class	History
class	HistoryAppender
class	HLTGlobalStatus
class	HLTPathStatus
class	IDGeneratorSourceBase
class	IfExistsDescription
class	IllegalParameters
class	IndexIntoFile
class	IndexIntoFileItrHolder
class	IndexSet
class	InputAnalyzer
class	InputFile
class	InputFileCatalog
struct	InputProcessBlockCache
class	InputSource
struct	InputSourceDescription
class	InputSourceFactory
class	InputTag
class	InputTagMatch
class	InternalContext
class	IntSource
class	IOVSyncValue
class	IterateNTimesLooper
class	IterWithDict
class	IterWithDictBase
class	JobReport
struct	key_traits
struct	key_traits< std::pair< U, V > >
struct	key_traits< std::string >
struct	LHEProvenanceHelper
class	LimitAndTimespan
class	LimitedTaskQueue
class	Log
class	LogDebug_
class	LogErrorHarvester
class	LogTrace_
class	Lumi3DReWeighting
class	LuminosityBlock
class	LuminosityBlockAux
class	LuminosityBlockAuxiliary
class	LuminosityBlockBase
struct	LuminosityBlockCache
class	LuminosityBlockForOutput
class	LuminosityBlockID
class	LuminosityBlockIndex
class	LuminosityBlockPrincipal
class	LuminosityBlockProcessingStatus
class	LuminosityBlockRange
struct	LuminosityBlockSummaryCache
class	LumiReWeighting
class	LumiTransitionInfo
struct	MainParameterSet
class	MakeDummyProvenanceReader
class	MakeFullProvenanceReader
class	MakeModuleHelper
class	MakeModuleHelper< edm::stream::EDAnalyzerAdaptorBase >
class	MakeModuleHelper< edm::stream::EDFilterAdaptorBase >
class	MakeModuleHelper< edm::stream::EDProducerAdaptorBase >
struct	MakeModuleParams
class	MakeOldProvenanceReader
class	MakeProvenanceReader
class	Maker
class	MakeReducedProvenanceReader
class	MapOfVectors
class	MCFileSource
class	MemberWithDict
struct	MergeableCounter
class	MergeableInputProductResolver
class	MergeableRunProductMetadata
class	MergeableRunProductMetadataBase
class	MergeableRunProductProcesses
struct	MessageDrop
class	MessageLogger
class	MessageLoggerQ
class	MessageSender
class	MixingModule
class	MixingWorker
class	MixingWorkerBase
class	ModelFilter
class	ModuleCallingContext
class	ModuleChanger
class	ModuleContextSentry
class	ModuleDescription
struct	ModuleInPathSummary
struct	ModuleInPathTimingSummary
class	ModuleLabelMatch
class	ModuleProcessName
class	ModuleRegistry
class	ModuleTime
class	ModuleTypeResolverBase
class	ModuleTypeResolverMaker
class	ModuloEventIDFilter
class	ModuloStreamIDFilter
class	MultiAssociation
class	MultiParticleInConeGunProducer
class	MultipleException
class	NavigateEventsLooper
class	NoProcessProductResolver
class	ObjectWithDict
class	OccurrenceForOutput
class	OccurrenceTraits
class	OccurrenceTraits< EventPrincipal, BranchActionStreamBegin >
class	OccurrenceTraits< LuminosityBlockPrincipal, BranchActionGlobalBegin >
class	OccurrenceTraits< LuminosityBlockPrincipal, BranchActionGlobalEnd >
class	OccurrenceTraits< LuminosityBlockPrincipal, BranchActionStreamBegin >
class	OccurrenceTraits< LuminosityBlockPrincipal, BranchActionStreamEnd >
class	OccurrenceTraits< ProcessBlockPrincipal, BranchActionGlobalBegin >
class	OccurrenceTraits< ProcessBlockPrincipal, BranchActionGlobalEnd >
class	OccurrenceTraits< ProcessBlockPrincipal, BranchActionProcessBlockInput >
class	OccurrenceTraits< RunPrincipal, BranchActionGlobalBegin >
class	OccurrenceTraits< RunPrincipal, BranchActionGlobalEnd >
class	OccurrenceTraits< RunPrincipal, BranchActionStreamBegin >
class	OccurrenceTraits< RunPrincipal, BranchActionStreamEnd >
class	OffsetToBase
class	OldProvenanceReader
class	OneLumiPoolSource
class	OneToMany
class	OneToManyWithQuality
class	OneToManyWithQualityGeneric
class	OneToOne
class	OneToOneGeneric
class	OneToValue
class	ORGroupDescription
class	OrphanHandle
class	OrphanHandleBase
class	OStreamColumn
struct	OStreamColumnEntry
struct	Other
class	OutputModuleCommunicator
class	OutputModuleCommunicatorT
struct	OutputModuleDescription
class	OutputProcessBlockHelper
class	OwnVector
class	ParameterDescription
class	ParameterDescription< ParameterSetDescription >
class	ParameterDescription< std::vector< ParameterSet > >
class	ParameterDescriptionBase
class	ParameterDescriptionCases
class	ParameterDescriptionNode
class	ParameterSet
class	ParameterSetBlob
class	ParameterSetConverter
class	ParameterSetDescription
class	ParameterSetDescriptionFiller
class	ParameterSetDescriptionFillerBase
class	ParameterSetEntry
class	ParameterSwitch
class	ParameterSwitchBase
struct	ParameterTypeToEnum
struct	ParameterTypeTraits
struct	ParameterTypeTraits< std::array< T, N > >
struct	ParameterTypeTraits< std::vector< std::pair< std::string, T > > >
class	ParameterWildcard
class	ParameterWildcard< ParameterSetDescription >
class	ParameterWildcard< std::vector< ParameterSet > >
class	ParameterWildcardBase
class	ParameterWildcardWithSpecifics
class	Parentage
class	ParentageRegistry
class	ParentContext
class	ParentProcessProductResolver
class	Path
class	PathContext
class	PathsAndConsumesOfModules
class	PathsAndConsumesOfModulesBase
class	PathStatusFilter
class	PathStatusInserter
struct	PathSummary
struct	PathTimingSummary
class	PileUp
struct	PileUpConfig
class	PlaceInPathContext
class	PluginDescription
class	PluginDescriptionAdaptor
class	PluginDescriptionAdaptorBase
class	PoolOutputModule
class	PoolSource
class	PreallocationConfiguration
class	PreMixingCrossingFrameWorker
class	PreMixingModule
class	PreMixingPileupCopy
class	Prescaler
class	Presence
class	PresenceFactory
class	Principal
class	PrincipalCache
class	PrincipalGetAdapter
class	PrintEventSetupContent
class	PrintEventSetupDataRetrieval
class	ProblemTracker
class	ProcessBlock
class	ProcessBlockForOutput
class	ProcessBlockHelper
class	ProcessBlockHelperBase
class	ProcessBlockIndex
class	ProcessBlockPrincipal
class	ProcessBlockTransitionInfo
class	ProcessConfiguration
class	ProcessContext
class	ProcessDesc
class	ProcessHistory
class	ProcessHistoryRegistry
class	ProcessingController
class	ProcessMatch
class	ProducedProductResolver
class	ProducerBase
class	ProducerSourceBase
class	ProducerSourceFromFiles
class	ProducesCollector
class	ProducesCollectorAdaptor
class	ProductData
class	ProductDeletedException
struct	ProductFromFwdPtrFactory
class	ProductFromFwdPtrProducer
	Produces a list of objects "by value" that correspond to the FwdPtr's from an input collection. More...
class	ProductID
struct	ProductLabels
class	ProductProvenance
class	ProductProvenanceLookup
class	ProductProvenanceRetriever
class	ProductPutOrMergerBase
class	ProductPutterBase
class	ProductRegistry
class	ProductRegistryHelper
class	ProductRegistryHelperAdaptor
class	ProductResolverBase
class	ProductResolverIndexAndSkipBit
class	ProductResolverIndexHelper
class	ProductSelector
class	ProductSelectorRules
class	propagate_const
class	propagate_const_array
class	Provenance
class	ProvenanceAdaptor
class	ProvenanceCheckerOutputModule
class	ProvenanceReaderBase
class	Ptr
class	PtrHolder
class	PtrVector
class	PtrVectorBase
class	PtrVectorItr
class	PutOnReadInputProductResolver
class	PuttableProductResolver
class	PuttableSourceBase
class	RandomEngineSentry
class	RandomEngineStates
class	RandomFilter
class	RandomMultiParticlePGunProducer
class	RandomNumberGenerator
struct	RandomNumberGeneratorState
class	RandomtXiGunProducer
class	RandomXiThetaGunProducer
class	Range
class	RangeMap
class	RawInputSource
class	RawInputSourceFromFiles
class	RecordEventID
class	ReducedProvenanceReader
class	Ref
class	Ref< std::vector< E >, typename refhelper::ValueTrait< std::vector< E > >::value, typename refhelper::FindTrait< std::vector< E >, typename refhelper::ValueTrait< std::vector< E > >::value >::value >
class	RefBase
class	RefCore
class	RefCoreStreamer
class	RefCoreWithIndex
class	RefCoreWithIndexStreamer
class	RefProd
class	RefToBase
class	RefToBaseProd
class	RefToBaseVector
class	RefVector
class	RefVectorBase
class	RefVectorIterator
class	RefVectorMemberPointersHolder
class	RepeatingCachedRootSource
class	ResourceInformation
class	ReusableObjectHolder
class	RootDebug
class	RootDelayedReader
class	RootEmbeddedFileSequence
class	RootFile
class	RootFileEventFinder
class	RootHandlers
class	RootInputFileSequence
class	RootOutputFile
class	RootOutputTree
class	RootPrimaryFileSequence
class	RootSecondaryFileSequence
class	RootServiceChecker
class	RootTree
class	Run
class	RunAux
class	RunAuxiliary
class	RunBase
struct	RunCache
class	RunForOutput
class	RunHelperBase
class	RunID
class	RunIndex
class	RunLumiEntryInfo
class	RunningAverage
class	RunPrincipal
class	RunProcessingStatus
struct	RunSummaryCache
class	RunTransitionInfo
class	Schedule
class	ScheduleInfo
struct	ScheduleItems
class	SecondaryEventIDAndFileInfo
class	SecondaryEventProvider
class	SecSourceAnalyzer
class	SendEvent
class	SendJobHeader
class	SendSourceTerminationSignalIfException
class	SerialTaskQueue
class	SerialTaskQueueChain
class	Service
class	ServiceRegistry
class	ServiceToken
class	ServiceWeakToken
class	SetClassParsing
class	SetRunForEachLumiHelper
class	SetRunHelper
class	SharedResourceNames
class	SharedResourcesAcquirer
class	SharedResourcesRegistry
class	SignallingProductRegistry
class	SingleChoiceNoProcessProductResolver
class	SingleConsumerQ
class	SiteLocalConfig
class	SoATuple
class	SortedCollection
class	Span
class	StableProvenance
class	StatsCount
class	StdArray
struct	StdPairHasher
class	StoredMergeableRunProductMetadata
class	StoredProcessBlockHelper
struct	StoredProductProvenance
struct	StreamCache
class	StreamContext
class	StreamedProduct
class	StreamerFileReader
class	StreamerFileWriter
class	StreamerInputFile
class	StreamerInputModule
class	StreamerInputSource
class	StreamerOutputModule
class	StreamerOutputModuleBase
class	StreamerOutputModuleCommon
class	StreamID
class	StreamSchedule
class	StreamSerializer
struct	StrictWeakOrdering
class	SubProcess
class	SubProcessBlockHelper
class	SubProcessParentageHelper
class	Suppress_LogDebug_
class	SwitchAliasProductResolver
class	SwitchBaseProductResolver
class	SwitchProducer
class	SwitchProducerProductResolver
class	SystemTimeKeeper
class	TaskBase
class	TaskSentry
class	TerminationOrigin
class	TestGlobalOutput
class	TestHandle
class	TestLimitedOutput
class	TestMix
class	TestMixedSource
class	TestOneOutput
class	TestOutputWithGetterOfProducts
class	TestOutputWithGetterOfProductsGlobal
class	TestOutputWithGetterOfProductsLimited
class	TestSource
class	ThinnedAssociation
class	ThinnedAssociationBranches
class	ThinnedAssociationsHelper
class	ThinnedRefSet
class	ThinningProducer
class	ThinningThingSelector
class	ThreadSafeAddOnlyContainer
class	ThreadSafeOutputFileStream
class	ThreadsController
struct	ThreadsInfo
class	ThrowingSource
struct	TimeOfDay
class	TimeoutPoolOutputModule
class	Timestamp
class	TimingServiceBase
class	TRandomAdaptor
struct	Transformer
class	TransformerBase
class	TransformingProductResolver
class	Trie
class	TrieFactory
class	TrieNode
	this class represent the node of a trie, it contains a link to a sub node and a link to a brother (node which have the same father) More...
class	TrieNodeIter
class	TriggerNames
struct	TriggerPath
struct	TriggerReport
class	TriggerResultInserter
class	TriggerResults
class	TriggerResultsByName
struct	TriggerTimingReport
class	TypeBases
class	TypeDataMembers
class	TypeFunctionMembers
class	TypeID
class	TypeIDBase
struct	TypeIDHasher
class	TypeMatch
class	TypeToGet
class	TypeWithDict
class	UnscheduledAuxiliary
class	UnscheduledCallProducer
class	UnscheduledConfigurator
class	UnscheduledProductResolver
class	ValidHandle
class	ValidityInterval
class	value_ptr
struct	value_ptr_traits
struct	value_ptr_traits< IndexIntoFile::IndexIntoFileItrImpl >
struct	value_ptr_traits< ParameterDescriptionNode >
struct	value_ptr_traits< ParameterSetDescription >
class	ValueMap
class	VecArray
class	VectorInputSource
struct	VectorInputSourceDescription
class	VectorInputSourceFactory
class	View
class	View< T >
class	ViewBase
class	ViewTypeChecker
class	VInputTagMatch
class	VParameterSetEntry
class	WaitingTask
class	WaitingTaskHolder
class	WaitingTaskList
class	WaitingTaskWithArenaHolder
class	WallclockTimer
struct	WantsGlobalLuminosityBlockTransitions
struct	WantsGlobalRunTransitions
struct	WantsInputProcessBlockTransitions
struct	WantsProcessBlockTransitions
struct	WantsStreamLuminosityBlockTransitions
struct	WantsStreamRunTransitions
struct	WatchInputFiles
struct	WatchProcessBlock
class	WillGetIfMatch
class	Worker
class	WorkerInPath
class	WorkerMaker
class	WorkerManager
struct	WorkerParams
class	WorkerRegistry
	The Registry of all workers that where requested Holds all instances of workers. In this implementation, Workers are owned. More...
struct	WorkerSummary
class	WorkerT
struct	WorkerTimingSummary
class	Wrapper
class	WrapperBase
class	XORGroupDescription
class	zero_allocator
class	ZombieKillerService

Typedefs
template<typename T >
using	AlignedVec = Aligned< T, 16 >
typedef std::vector< BranchID::value_type >	BranchIDList
typedef std::vector< BranchIDList >	BranchIDLists
typedef unsigned short	BranchListIndex
typedef std::vector< BranchListIndex >	BranchListIndexes
typedef void(*	CFUNC) (int, siginfo_t *, void *)
using	CPUInfoType = std::vector< std::pair< std::string, std::string > >
typedef std::vector< CTPPSFastRecHit >	CTPPSFastRecHitContainer
typedef std::vector< CTPPSFastTrack >	CTPPSFastTrackContainer
typedef DigiAccumulatorMixMod *()	DAFunc(ParameterSet const &, ProducesCollector, ConsumesCollector &)
typedef uint32_t	det_id_type
typedef edmplugin::PluginFactory< DAFunc >	DigiAccumulatorMixModPluginFactory
typedef std::list< ELdestination * >	ELlist_dest
typedef std::list< std::string >	ELlist_string
typedef std::map< ELextendedID, CountAndLimit >	ELmap_counts
typedef std::map< std::string, LimitAndTimespan >	ELmap_limits
typedef std::map< ELextendedID, StatsCount >	ELmap_stats
typedef Hash< EntryDescriptionType >	EntryDescriptionID
using	EntryDescriptionMap = std::map< EntryDescriptionID, EventEntryDescription >
using	ESConsumesInfo = std::vector< ESConsumesInfoEntry >
typedef std::vector< EventEntryInfo >	EventEntryInfoVector
typedef unsigned long long	EventNumber_t
typedef ParameterSetID	EventSelectionID
typedef std::vector< EventSelectionID >	EventSelectionIDVector
typedef std::vector< std::pair< edm::ProductID, unsigned long > >	FillViewHelperVector
typedef Handle< FWGenericObject >	FWGenericHandle
typedef Handle< GenericObject >	GenericHandle
typedef long long int	HRTimeDiffType
typedef unsigned long long int	HRTimeType
typedef edmplugin::PluginFactory< ISFunc >	InputSourcePluginFactory
typedef InputSource *()	ISFunc(ParameterSet const &, InputSourceDescription const &)
typedef VectorInputSource *()	ISVecFunc(ParameterSet const &, VectorInputSourceDescription const &)
typedef std::vector< LHCTransportLink >	LHCTransportLinkContainer
using	LogAbsolute = Log< level::System, true >
using	LogError = Log< level::Error, false >
using	LogFwkInfo = Log< level::FwkInfo, false >
using	LogFwkVerbatim = Log< level::FwkInfo, true >
using	LogImportant = Log< level::Error, true >
using	LogInfo = Log< level::Info, false >
using	LogPrint = Log< level::Warning, true >
using	LogProblem = Log< level::Error, true >
using	LogSystem = Log< level::System, false >
using	LogVerbatim = Log< level::Info, true >
using	LogWarning = Log< level::Warning, false >
typedef RunLumiEntryInfo	LumiEntryInfo
typedef unsigned int	LuminosityBlockNumber_t
using	MakerPluginFactory = edmplugin::PluginFactory< Maker *()>
typedef std::vector< MaterialInformation >	MaterialInformationContainer
typedef Hash< ModuleDescriptionType >	ModuleDescriptionID
using	ModuleTypeResolverMakerFactory = edmplugin::PluginFactory< ModuleTypeResolverMaker const *()>
using	OptionalThinnedKey = std::variant< unsigned int, detail::GetThinnedKeyFromExceptionFactory, std::monostate >
typedef edmplugin::PluginFactory< ParameterSetDescriptionFillerBase *(void)>	ParameterSetDescriptionFillerPluginFactory
typedef Hash< ParameterSetType >	ParameterSetID
typedef std::map< ParameterSetID, ParameterSetBlob >	ParameterSetMap
typedef Hash< ParentageType >	ParentageID
typedef std::string	PassID
typedef std::vector< PassiveHit >	PassiveHitContainer
using	PathStatus = HLTPathStatus
typedef std::vector< PCaloHit >	PCaloHitContainer
typedef std::shared_ptr< Pointer_to_new_exception_on_heap >	Place_for_passing_exception_ptr
typedef std::shared_ptr< edm::Exception >	Pointer_to_new_exception_on_heap
typedef Presence *()	PresenceFunc()
typedef edmplugin::PluginFactory< Presence *()>	PresencePluginFactory
typedef Hash< ProcessConfigurationType >	ProcessConfigurationID
typedef std::vector< ProcessConfiguration >	ProcessConfigurationVector
typedef Hash< ProcessHistoryType >	ProcessHistoryID
typedef std::map< ProcessHistoryID, ProcessHistory >	ProcessHistoryMap
typedef std::vector< ProcessHistory >	ProcessHistoryVector
typedef unsigned short	ProcessIndex
typedef std::string	ProcessingTask
typedef unsigned short	ProductIndex
typedef std::vector< ProductProvenance >	ProductProvenanceVector
typedef unsigned int	ProductResolverIndex
typedef std::vector< PSimHit >	PSimHitContainer
using	Record2Factories = std::multimap< EventSetupRecordKey, FactoryInfo >
typedef std::string	ReleaseVersion
typedef RunLumiEntryInfo	RunEntryInfo
typedef unsigned int	RunNumber_t
typedef std::vector< std::pair< BranchDescription const *, EDGetToken > >	SelectedProducts
typedef std::array< SelectedProducts, NumBranchTypes >	SelectedProductsForBranchType
typedef std::vector< BranchDescription >	SendDescs
typedef std::vector< StreamedProduct >	SendProds
typedef std::vector< SimTrack >	SimTrackContainer
typedef std::vector< SimVertex >	SimVertexContainer
typedef edm::Ref< std::vector< SimVertex > >	SimVertexRef
typedef edm::RefProd< std::vector< SimVertex > >	SimVertexRefProd
typedef edm::RefVector< std::vector< SimVertex > >	SimVertexRefVector
typedef std::vector< StoredProductProvenance >	StoredProductProvenanceVector
using	Strings = EventSelector::Strings
typedef std::vector< std::string >	StringVector
typedef unsigned long long	TimeValue_t
typedef detail::TriggerResultsBasedEventSelector::handle_t	Trig
typedef std::vector< edm::BranchDescription const * >	VCBDP
typedef edmplugin::PluginFactory< ISVecFunc >	VectorInputSourcePluginFactory
typedef std::vector< ParameterSet >	VParameterSet
typedef std::vector< std::string >	vstring

Enumerations
enum	BranchActionType {   BranchActionGlobalBegin = 0, BranchActionStreamBegin = 1, BranchActionStreamEnd = 2, BranchActionGlobalEnd = 3,   BranchActionProcessBlockInput = 4 }
enum	BranchType {   InEvent = 0, InLumi = 1, InRun = 2, InProcess = 3,   NumBranchTypes }
enum	CatalogType { CatalogType::TrivialCatalog, CatalogType::RucioCatalog }
enum	EDMModuleType {   EDMModuleType::kUnknown, EDMModuleType::kSource, EDMModuleType::kESSource, EDMModuleType::kESProducer,   EDMModuleType::kEDAnalyzer, EDMModuleType::kEDProducer, EDMModuleType::kEDFilter, EDMModuleType::kOutputModule }
enum	HashedTypes {   ModuleDescriptionType, ParameterSetType, ProcessHistoryType, ProcessConfigurationType,   EntryDescriptionType, ParentageType }
enum	InputType { InputType::Primary, InputType::SecondaryFile, InputType::SecondarySource }
enum	JobMode { GridJobMode, ReleaseValidationJobMode, AnalysisJobMode, NilJobMode }
enum	KindOfType { PRODUCT_TYPE, ELEMENT_TYPE }
enum	ParameterTypes {   k_int32 = 'I', k_vint32 = 'i', k_uint32 = 'U', k_vuint32 = 'u',   k_int64 = 'L', k_vint64 = 'l', k_uint64 = 'X', k_vuint64 = 'x',   k_double = 'D', k_vdouble = 'd', k_bool = 'B', k_stringRaw = 'Z',   k_vstringRaw = 'z', k_stringHex = 'S', k_vstringHex = 's', k_EventID = 'E',   k_VEventID = 'e', k_LuminosityBlockID = 'M', k_VLuminosityBlockID = 'm', k_InputTag = 't',   k_VInputTag = 'v', k_ESInputTag = 'g', k_VESInputTag = 'G', k_FileInPath = 'F',   k_LuminosityBlockRange = 'A', k_VLuminosityBlockRange = 'a', k_EventRange = 'R', k_VEventRange = 'r',   k_PSet = 'Q', k_VPSet = 'q' }
enum	ProductResolverIndexValues { ProductResolverIndexValuesBit = 1U << 30, ProductResolverIndexInvalid = std::numeric_limits<unsigned int>::max(), ProductResolverIndexInitializing = std::numeric_limits<unsigned int>::max() - 1, ProductResolverIndexAmbiguous = std::numeric_limits<unsigned int>::max() - 2 }
enum	StreamerCompressionAlgo { UNCOMPRESSED = 0, ZLIB = 1, LZMA = 2, ZSTD = 4 }
enum	TerminationOrigin { TerminationOrigin::ExceptionFromThisContext, TerminationOrigin::ExceptionFromAnotherContext, TerminationOrigin::ExternalSignal }
enum	ThinnedRefSetMode { ThinnedRefSetMode::throwOnInvalidParentRef, ThinnedRefSetMode::ignoreInvalidParentRef }
enum	Transition {   Transition::Event, Transition::BeginLuminosityBlock, Transition::EndLuminosityBlock, Transition::BeginRun,   Transition::EndRun, Transition::BeginProcessBlock, Transition::EndProcessBlock, Transition::AccessInputProcessBlock,   Transition::NumberOfTransitions, Transition::NumberOfEventSetupTransitions = BeginProcessBlock }
enum	WildcardValidationCriteria { RequireZeroOrMore, RequireAtLeastOne, RequireExactlyOne }

Functions
void	addContextAndPrintException (char const *context, cms::Exception &ex, bool disablePrint)
void	addToMissingDictionariesException (edm::Exception &exception, std::vector< std::string > &missingDictionaries, std::string const &context)
template<typename T , typename... ARGS>
std::unique_ptr< edm::ParameterDescriptionCases< T > >	allowedValues (ARGS &&... args)
static std::string	appendCurrentProcessIfAlias (std::string const &processFromInputTag, std::string const &currentProcess)
template<typename Traits >
void	beginGlobalTransitionAsync (WaitingTaskHolder iWait, Schedule &iSchedule, typename Traits::TransitionInfoType &transitionInfo, ServiceToken const &token, std::vector< SubProcess > &iSubProcesses, bool cleaningUpAfterException=false)
template<typename Traits >
void	beginStreamsTransitionAsync (WaitingTaskHolder iWait, Schedule &iSchedule, unsigned int iNStreams, typename Traits::TransitionInfoType &transitionInfo, ServiceToken const &token, std::vector< SubProcess > &iSubProcesses)
template<typename Traits >
void	beginStreamTransitionAsync (WaitingTaskHolder iWait, Schedule &iSchedule, unsigned int iStreamIndex, typename Traits::TransitionInfoType &transitionInfo, ServiceToken const &token, std::vector< SubProcess > &iSubProcesses)
template<typename ForwardSequence , typename Datum >
bool	binary_search_all (ForwardSequence const &s, Datum const &d)
	wrappers for std::binary_search More...
template<typename ForwardSequence , typename Datum , typename Predicate >
bool	binary_search_all (ForwardSequence const &s, Datum const &d, Predicate p)
template<class To , class From >
To	bit_cast (const From &src) noexcept
ProductID	branchIDToProductID (BranchID const &bid, BranchIDListHelper const &branchIDListHelper, std::vector< ProcessIndex > const &branchListIndexToProcessIndex)
std::string const &	BranchTypeToAuxBranchName (BranchType const &branchType)
std::string const &	BranchTypeToAuxiliaryBranchName (BranchType const &branchType)
std::string const &	BranchTypeToBranchEntryInfoBranchName (BranchType const &branchType)
std::string const &	BranchTypeToInfoTreeName (BranchType const &branchType)
std::string const &	BranchTypeToMetaDataTreeName (BranchType const &branchType)
std::string const &	BranchTypeToProductProvenanceBranchName (BranchType const &BranchType)
std::string const &	BranchTypeToProductStatusBranchName (BranchType const &branchType)
std::string const &	BranchTypeToProductTreeName (BranchType const &branchType)
std::string	BranchTypeToProductTreeName (BranchType const &branchType, std::string const &processName)
std::string const &	BranchTypeToString (BranchType const &branchType)
template<typename TReturn >
TReturn	callWithTryCatchAndPrint (std::function< TReturn(void)> iFunc, char const *context=nullptr, bool disablePrint=false)
template<typename T >
static void	check (T const &p, std::string const &id, SelectedProducts const &iProducts, bool iVerbose)
bool	checkClassDictionaries (std::vector< std::string > &missingDictionaries, TypeID const &typeID)
bool	checkClassDictionaries (std::vector< std::string > &missingDictionaries, std::string const &name, TypeWithDict const &typeWithDict)
bool	checkDictionary (std::vector< std::string > &missingDictionaries, TypeID const &typeID)
bool	checkDictionary (std::vector< std::string > &missingDictionaries, std::string const &name, TypeWithDict const &typeWithDict)
bool	checkDictionaryOfWrappedType (std::vector< std::string > &missingDictionaries, TypeID const &unwrappedTypeID)
bool	checkDictionaryOfWrappedType (std::vector< std::string > &missingDictionaries, std::string const &unwrappedName)
void	checkForModuleDependencyCorrectness (edm::PathsAndConsumesOfModulesBase const &iPnC, bool iPrintDependencies)
void	checkForWrongProduct (ProductID const &keyID, ProductID const &refID)
void	clearLoggedErrorsSummary (unsigned int iStreamID)
void	clearMessageLog ()
std::unique_ptr< CLHEP::HepRandomEngine >	cloneEngine (CLHEP::HepRandomEngine const &)
bool	combinable (BranchDescription const &a, BranchDescription const &b)
template<typename C , typename K >
bool	compare_key (K const &lhs, K const &rhs)
bool	contains (EventRange const &lh, EventID const &rh)
bool	contains (LuminosityBlockRange const &lh, LuminosityBlockID const &rh)
bool	contains (LuminosityBlockRange const &lh, LuminosityBlockRange const &rh)
bool	contains (EventRange const &lh, EventRange const &rh)
bool	contains_ (EventRange const &lh, EventID const &rh)
template<class FwdIter >
FwdIter	contextual_find (FwdIter b, FwdIter e, char first, char sep, char last)
template<class FwdIter >
FwdIter	contextual_find_not (FwdIter b, FwdIter e, char first, char sep, char last)
void	conversion (LuminosityBlockAux const &from, LuminosityBlockAuxiliary &to)
void	conversion (RunAux const &from, RunAuxiliary &to)
void	conversion (EventAux const &from, EventAuxiliary &to)
void	convert_handle (BasicHandle const &orig, Handle< FWGenericObject > &result)
	specialize this function forFWGenericHandle More...
template<typename T >
Handle< T >	convert_handle (BasicHandle &&bh) noexcept(true)
void	convert_handle (BasicHandle &&orig, Handle< GenericObject > &result)
	specialize this function for GenericHandle More...
template<typename T >
Handle< T >	convert_handle_check_type (BasicHandle &&bh)
constexpr BranchType	convertToBranchType (Transition iValue)
constexpr Transition	convertToTransition (BranchType iValue)
template<typename ForwardSequence , typename Func >
Func	copy_all (ForwardSequence &s, Func f)
	wrappers for copy More...
std::string	createGlobalIdentifier (bool binary=false)
bool	decode (bool &, std::string_view)
bool	decode (std::vector< bool > &, std::string_view)
bool	decode (int &, std::string_view)
bool	decode (std::vector< int > &, std::string_view)
bool	decode (unsigned int &, std::string_view)
bool	decode (std::vector< unsigned int > &, std::string_view)
bool	decode (long long &, std::string_view)
bool	decode (std::vector< long long > &, std::string_view)
bool	decode (unsigned long long &, std::string_view)
bool	decode (std::vector< unsigned long long > &, std::string_view)
bool	decode (double &, std::string_view)
bool	decode (std::vector< double > &, std::string_view)
bool	decode (std::string &, std::string_view)
bool	decode (std::vector< std::string > &, std::string_view)
bool	decode (edm::FileInPath &, std::string_view)
bool	decode (edm::InputTag &, std::string_view)
bool	decode (std::vector< edm::InputTag > &, std::string_view)
bool	decode (edm::ESInputTag &, std::string_view)
bool	decode (std::vector< edm::ESInputTag > &, std::string_view)
bool	decode (edm::EventID &, std::string_view)
bool	decode (std::vector< edm::EventID > &, std::string_view)
bool	decode (edm::LuminosityBlockID &, std::string_view)
bool	decode (std::vector< edm::LuminosityBlockID > &, std::string_view)
bool	decode (edm::LuminosityBlockRange &, std::string_view)
bool	decode (std::vector< edm::LuminosityBlockRange > &, std::string_view)
bool	decode (edm::EventRange &, std::string_view)
bool	decode (std::vector< edm::EventRange > &, std::string_view)
bool	decode (ParameterSet &, std::string_view)
bool	decode (std::vector< ParameterSet > &, std::string_view)
bool	decode_deprecated (std::string &, std::string_view)
bool	decode_deprecated (std::vector< std::string > &, std::string_view)
bool	decode_element (std::string &, std::string_view)
std::optional< std::string_view >	decode_pset_extent (std::string_view from)
std::optional< std::string_view >	decode_string_extent (std::string_view from)
std::optional< std::string_view >	decode_vpset_extent (std::string_view from)
std::optional< std::string_view >	decode_vstring_extent (std::string_view from)
std::vector< std::string >	defaultCmsRunServices ()
std::string	defaultModuleLabel (std::string label)
void	disableAllSigs (sigset_t *oldset)
bool	DisableLoggedErrorsSummary ()
void	disableRTSigs ()
void	disableSignal (sigset_t *newset, int signum)
bool	distinct (LuminosityBlockRange const &lh, LuminosityBlockRange const &rh)
bool	distinct (EventRange const &lh, EventRange const &rh)
void	doBuildRealData (const std::string &name)
void	dumpOptionsToLogFile (unsigned int nThreads, unsigned int nStreams, unsigned int nConcurrentLumis, unsigned int nConcurrentRuns)
const char *	edmModuleType (edm::ModuleDescription const &module)
EDMModuleType	edmModuleTypeEnum (edm::ModuleDescription const &module)
void	edmodule_mightGet_config (ConfigurationDescriptions &iDesc)
bool	EnableLoggedErrorsSummary ()
void	enableSignal (sigset_t *newset, int signum)
bool	encode (std::string &, bool)
bool	encode (std::string &, std::vector< bool > const &)
bool	encode (std::string &, int)
bool	encode (std::string &, std::vector< int > const &)
bool	encode (std::string &, unsigned int)
bool	encode (std::string &, std::vector< unsigned int > const &)
bool	encode (std::string &, long long)
bool	encode (std::string &, std::vector< long long > const &)
bool	encode (std::string &, unsigned long long)
bool	encode (std::string &, std::vector< unsigned long long > const &)
bool	encode (std::string &, double)
bool	encode (std::string &, std::vector< double > const &)
bool	encode (std::string &, std::string const &)
bool	encode (std::string &, std::vector< std::string > const &)
bool	encode (std::string &, edm::FileInPath const &)
bool	encode (std::string &, edm::InputTag const &)
bool	encode (std::string &, std::vector< edm::InputTag > const &)
bool	encode (std::string &, edm::ESInputTag const &)
bool	encode (std::string &, std::vector< edm::ESInputTag > const &)
bool	encode (std::string &, edm::EventID const &)
bool	encode (std::string &, std::vector< edm::EventID > const &)
bool	encode (std::string &, edm::LuminosityBlockID const &)
bool	encode (std::string &, std::vector< edm::LuminosityBlockID > const &)
bool	encode (std::string &, edm::LuminosityBlockRange const &)
bool	encode (std::string &, std::vector< edm::LuminosityBlockRange > const &)
bool	encode (std::string &, edm::EventRange const &)
bool	encode (std::string &, std::vector< edm::EventRange > const &)
bool	encode (std::string &, ParameterSet const &)
bool	encode (std::string &, std::vector< ParameterSet > const &)
bool	encode_deprecated (std::string &, std::string const &)
bool	encode_deprecated (std::string &, std::vector< std::string > const &)
bool	encode_element (std::string &, std::string const &)
template<typename Traits >
void	endGlobalTransitionAsync (WaitingTaskHolder iWait, Schedule &iSchedule, typename Traits::TransitionInfoType &transitionInfo, ServiceToken const &token, std::vector< SubProcess > &iSubProcesses, bool cleaningUpAfterException)
template<typename Traits >
void	endStreamsTransitionAsync (WaitingTaskHolder iWait, Schedule &iSchedule, unsigned int iNStreams, typename Traits::TransitionInfoType &transitionInfo, ServiceToken const &iToken, std::vector< SubProcess > &iSubProcesses, bool cleaningUpAfterException)
template<typename Traits >
void	endStreamTransitionAsync (WaitingTaskHolder iWait, Schedule &iSchedule, unsigned int iStreamIndex, typename Traits::TransitionInfoType &transitionInfo, ServiceToken const &token, std::vector< SubProcess > &iSubProcesses, bool cleaningUpAfterException)
void	ensureAvailableAccelerators (edm::ParameterSet const &parameterSet)
void	ep_sigusr2 (int, siginfo_t *, void *)
unsigned int	eventProcessBlockIndex (Event const &event, std::string const &processName)
void	exceptionContext (cms::Exception &, ESModuleCallingContext const &)
void	exceptionContext (std::ostream &, GlobalContext const &)
void	exceptionContext (std::ostream &, StreamContext const &)
void	exceptionContext (cms::Exception &, ModuleCallingContext const &)
void	fillDescriptionFromPSet (ParameterSet const &pset, ParameterSetDescription &desc)
std::shared_ptr< EDLooperBase >	fillLooper (eventsetup::EventSetupsController &esController, eventsetup::EventSetupProvider &cp, ParameterSet &params, std::vector< std::string > const &loopers)
void	fillMaxEventsDescription (ParameterSetDescription &description)
void	fillMaxLuminosityBlocksDescription (ParameterSetDescription &description)
void	fillMaxSecondsUntilRampdownDescription (ParameterSetDescription &description)
static void	fillModuleInPathSummary (Path const &path, size_t which, ModuleInPathSummary &sum)
void	fillOptionsDescription (ParameterSetDescription &description)
void	fillParameterSetBranch (TTree *parameterSetsTree, int basketSize)
static void	fillPathSummary (Path const &path, PathSummary &sum)
void	fillProcessHistoryBranch (TTree *metaDataTree, int basketSize, ProcessHistoryRegistry const &processHistoryRegistry)
template<typename T , typename A >
void	fillPtrVector (std::vector< T, A > const &obj, std::type_info const &iToType, std::vector< unsigned long > const &iIndicies, std::vector< void const *> &oPtr)
template<typename T , typename A >
void	fillPtrVector (std::list< T, A > const &obj, std::type_info const &iToType, std::vector< unsigned long > const &iIndicies, std::vector< void const *> &oPtr)
template<typename T , typename A >
void	fillPtrVector (std::deque< T, A > const &obj, std::type_info const &iToType, std::vector< unsigned long > const &iIndicies, std::vector< void const *> &oPtr)
template<typename T , typename A , typename Comp >
void	fillPtrVector (std::set< T, A, Comp > const &obj, std::type_info const &iToType, std::vector< unsigned long > const &iIndicies, std::vector< void const *> &oPtr)
template<typename T , typename SORT >
void	fillPtrVector (SortedCollection< T, SORT > const &obj, std::type_info const &toType, std::vector< unsigned long > const &indices, std::vector< void const *> &ptrs)
template<typename T , typename P >
void	fillPtrVector (OwnVector< T, P > const &obj, std::type_info const &toType, std::vector< unsigned long > const &indices, std::vector< void const *> &ptrs)
template<class T , class A >
void	fillView (std::vector< T, A > const &obj, ProductID const &id, std::vector< void const *> &ptrs, FillViewHelperVector &helpers)
template<class T , class A >
void	fillView (std::list< T, A > const &obj, ProductID const &id, std::vector< void const *> &ptrs, FillViewHelperVector &helpers)
template<class T , class A >
void	fillView (std::deque< T, A > const &obj, ProductID const &id, std::vector< void const *> &ptrs, FillViewHelperVector &helpers)
template<class T , class A , class Comp >
void	fillView (std::set< T, A, Comp > const &obj, ProductID const &id, std::vector< void const *> &ptrs, FillViewHelperVector &helpers)
template<typename C , typename T , typename F >
void	fillView (RefVector< C, T, F > const &obj, ProductID const &id, std::vector< void const *> &pointers, FillViewHelperVector &helpers)
template<typename T >
void	fillView (PtrVector< T > const &obj, ProductID const &, std::vector< void const *> &pointers, FillViewHelperVector &helpers)
template<typename T >
void	fillView (RefToBaseVector< T > const &obj, ProductID const &, std::vector< void const *> &pointers, FillViewHelperVector &helpers)
template<typename T >
void	fillView (std::vector< edm::Ptr< T > > const &obj, ProductID const &id, std::vector< void const *> &pointers, FillViewHelperVector &helpers)
template<typename KeyRefProd , typename CVal , typename KeyRef , typename SizeType , typename KeyReferenceHelper >
void	fillView (AssociationVector< KeyRefProd, CVal, KeyRef, SizeType, KeyReferenceHelper > const &obj, ProductID const &id, std::vector< void const *> &pointers, FillViewHelperVector &helpers)
template<class T >
void	fillView (DetSetVector< T > const &obj, ProductID const &id, std::vector< void const *> &pointers, FillViewHelperVector &helpers)
template<typename T , typename SORT >
void	fillView (SortedCollection< T, SORT > const &obj, ProductID const &id, std::vector< void const *> &pointers, FillViewHelperVector &helpers)
template<typename T , typename P >
void	fillView (OwnVector< T, P > const &obj, ProductID const &id, std::vector< void const *> &pointers, FillViewHelperVector &helpers)
static void	fillWorkerSummary (Worker const *pw, WorkerSummary &sum)
static void	fillWorkerSummaryAux (Worker const &w, WorkerSummary &sum)
template<typename ForwardSequence , typename Predicate >
ForwardSequence::const_iterator	find_if_in_all (ForwardSequence const &s, Predicate const &p)
	wrappers for std::find More...
template<typename ForwardSequence , typename Predicate >
ForwardSequence::iterator	find_if_in_all (ForwardSequence &s, Predicate const &p)
template<typename ForwardSequence , typename Datum >
ForwardSequence::const_iterator	find_in_all (ForwardSequence const &s, Datum const &d)
	wrappers for std::find More...
template<typename ForwardSequence , typename Datum >
ForwardSequence::iterator	find_in_all (ForwardSequence &s, Datum const &d)
template<typename Key , typename Value >
Value const &	findOrAssert (std::map< Key, Value > const &m, Key const &k)
template<typename Key , typename Value >
Value &	findOrAssert (std::map< Key, Value > &m, Key const &k)
template<typename Key , typename Value >
Value const &	findOrDefault (std::map< Key, Value > const &m, Key const &k, Value const &defaultValue)
template<typename Key , typename Value >
Value &	findOrDefault (std::map< Key, Value > &m, Key const &k, Value &defaultValue)
template<typename Key , typename Value >
Value	findOrDefault (std::map< Key, Value > const &m, Key const &k)
template<typename Key , typename Value >
Value &	findOrInsert (std::map< Key, Value > &m, Key const &k)
template<typename T , typename U >
T	first (std::pair< T, U > const &p)
void	FlushMessageLog ()
template<typename ForwardSequence , typename Func >
Func	for_all (ForwardSequence &s, Func f)
	wrapper for std::for_each More...
template<typename S , typename T >
S &	formatFile (T const &f, S &os)
bool	FreshErrorsExist (unsigned int iStreamID)
template<typename T >
T const &	get (ProcessBlock const &processBlock, EDGetToken const &token)
template<typename T >
T const &	get (ProcessBlock const &processBlock, EDGetTokenT< T > const &token)
template<typename T >
T const &	get (Run const &event, InputTag const &tag)
template<typename T >
T const &	get (LuminosityBlock const &event, InputTag const &tag)
template<typename T >
T const &	get (Run const &event, EDGetToken const &token)
template<typename T >
T const &	get (LuminosityBlock const &event, EDGetToken const &token)
template<typename T >
T const &	get (Run const &event, EDGetTokenT< T > const &token)
template<typename T >
T const &	get (LuminosityBlock const &event, EDGetTokenT< T > const &token)
template<typename T >
T const &	get (Event const &event, InputTag const &tag) noexcept(false)
template<typename T >
T const &	get (Event const &event, EDGetToken const &token) noexcept(false)
template<typename T >
T const &	get (Event const &event, EDGetTokenT< T > const &token) noexcept(false)
template<typename T >
constexpr T &	get_underlying (propagate_const< T > &)
template<typename T >
constexpr T const &	get_underlying (propagate_const< T > const &)
template<typename T >
constexpr std::decay_t< T > &	get_underlying (propagate_const_array< T > &)
template<typename T >
constexpr std::decay_t< T > const &	get_underlying (propagate_const_array< T > const &)
template<typename T >
constexpr std::shared_ptr< T > &	get_underlying_safe (propagate_const< std::shared_ptr< T >> &iP)
template<typename T >
constexpr std::shared_ptr< T const >	get_underlying_safe (propagate_const< std::shared_ptr< T >> const &iP)
template<typename T >
constexpr std::shared_ptr< T[]> &	get_underlying_safe (propagate_const_array< std::shared_ptr< T[]>> &iP)
template<typename T >
constexpr std::shared_ptr< T const []>	get_underlying_safe (propagate_const_array< std::shared_ptr< T[]>> const &iP)
template<typename T >
constexpr T *&	get_underlying_safe (propagate_const< T *> &iP)
template<typename T >
constexpr T const *	get_underlying_safe (propagate_const< T *> const &iP)
template<typename T >
constexpr T *	get_underlying_safe (propagate_const_array< T[]> &iP)
template<typename T >
constexpr T const *	get_underlying_safe (propagate_const_array< T[]> const &iP)
template<typename T >
constexpr std::unique_ptr< T > &	get_underlying_safe (propagate_const< std::unique_ptr< T >> &iP)
template<typename T >
constexpr std::unique_ptr< T const >	get_underlying_safe (propagate_const< std::unique_ptr< T >> const &iP)
template<typename T >
constexpr std::unique_ptr< T[]> &	get_underlying_safe (propagate_const_array< std::unique_ptr< T[]>> &iP)
template<typename T >
constexpr std::unique_ptr< T const []>	get_underlying_safe (propagate_const_array< std::unique_ptr< T[]>> const &iP)
std::vector< std::string > const &	getAllTriggerNames ()
template<typename T >
std::unique_ptr< T >	getAnyPtr (void *p, int offset)
std::string	getEnvironmentVariable (std::string const &name, std::string const &defaultValue=std::string())
int	getFileFormatVersion ()
ParameterSet const &	getParameterSet (ParameterSetID const &id)
std::string	getPassID ()
ParameterSet const &	getProcessParameterSetContainingModule (ModuleDescription const &moduleDescription)
ParameterSet const *	getProducerParameterSet (Provenance const &provenance, ProcessHistory const &)
template<typename T >
T const *	getProduct (RefCore const &ref)
template<typename PROD >
std::shared_ptr< Wrapper< PROD > const >	getProductByTag (Principal const &ep, InputTag const &tag, ModuleCallingContext const *mcc)
template<typename T >
T const *	getProductWithCoreFromRef (RefCore const &ref, EDProductGetter const *prodGetter)
std::unique_ptr< edm::ParameterSet >	getPSetFromConfig (const std::string &config)
template<typename C >
helper::MatcherGetRef< C >::ref_type	getRef (const Handle< C > &c, size_t k)
template<typename C , typename T , typename F , typename KEY >
T const *	getRefPtr (RefCore const &product, KEY const &iKey)
std::string	getReleaseVersion ()
TClass *	getTClass (const std::type_info &ti)
template<typename T >
std::tuple< T const *, unsigned int >	getThinnedProduct (RefCore const &ref, unsigned int key, EDProductGetter const *prodGetter)
std::string	getUuid (TTree *uuidTree)
std::unique_ptr< WrapperBase >	getWrapperBasePtr (void *p, int offset)
std::string	glob2reg (std::string const &pattern)
void	GroupLogStatistics (std::string_view category)
void	HaltMessageLogging ()
bool	hasDictionary (std::type_info const &)
template<typename T >
void	hash_combine (std::size_t &seed, const T &val)
template<typename T , typename... Types>
void	hash_combine (std::size_t &seed, const T &val, const Types &... args)
template<typename... Types>
std::size_t	hash_value (const Types &... args)
HRTimeType	hrRealTime ()
void	insertSelectedProcesses (BranchDescription const &desc, std::set< std::string > &processes, std::set< std::string > &processesWithKeptProcessBlockProducts)
void	installCustomHandler (int signum, CFUNC func)
void	installSig (int signum, CFUNC func)
bool	is_glob (std::string const &pattern)
bool	isAncestor (ProcessHistory const &a, ProcessHistory const &b)
bool	isDebugEnabled ()
bool	isDescendant (ProcessHistory const &a, ProcessHistory const &b)
constexpr bool	isEndTransition (Transition iValue)
bool	isErrorEnabled ()
template<typename T >
constexpr bool	isFinite (T x)
template<>
constexpr bool	isFinite (float x)
template<>
constexpr bool	isFinite (double x)
template<>
constexpr bool	isFinite (long double x)
bool	isFwkInfoEnabled ()
bool	isInfoEnabled ()
bool	isMessageProcessingSetUp ()
template<typename T >
constexpr bool	isNotFinite (T x)
bool	isSameEvent (EventAuxiliary const &a, EventAuxiliary const &b)
bool	isSameEvent (EventPrincipal const &a, EventPrincipal const &b)
template<typename C , typename KEY >
bool	isThinnedAvailable (RefCore const &product, KEY const &iKey)
bool	isTransientEqual (ParameterSet const &a, ParameterSet const &b)
bool	isValidGlobalIdentifier (std::string const &guid)
bool	isWarningEnabled ()
template<typename V , typename T >
bool	iterateTrieLeaves (V &v, TrieNode< T > const &n, std::string const &label="")
	visits only leaf nodes More...
static std::string const	kBaseType ("Source")
bool	lessThan (LuminosityBlockRange const &lh, LuminosityBlockRange const &rh)
bool	lessThan (EventRange const &lh, EventRange const &rh)
bool	lessThanSpecial (EventRange const &lh, EventRange const &rh)
bool	loadCap (const std::string &name, std::vector< std::string > &missingDictionaries)
void	loadExtraClasses ()
std::vector< messagelogger::ErrorSummaryEntry >	LoggedErrorsOnlySummary (unsigned int iStreamID)
std::vector< messagelogger::ErrorSummaryEntry >	LoggedErrorsSummary (unsigned int iStreamID)
void	LogStatistics ()
void	longBranchPrint (TTree *tr)
template<typename ForwardSequence , typename Datum >
ForwardSequence::const_iterator	lower_bound_all (ForwardSequence const &s, Datum const &d)
	wrappers for std::lower_bound More...
template<typename ForwardSequence , typename Datum >
ForwardSequence::iterator	lower_bound_all (ForwardSequence &s, Datum const &d)
template<typename ForwardSequence , typename Datum , typename Predicate >
ForwardSequence::const_iterator	lower_bound_all (ForwardSequence const &s, Datum const &d, Predicate p)
template<typename ForwardSequence , typename Datum , typename Predicate >
ForwardSequence::iterator	lower_bound_all (ForwardSequence &s, Datum const &d, Predicate p)
template<typename F >
FunctorTask< F > *	make_functor_task (F f)
template<typename F >
auto	make_lambda_with_holder (WaitingTaskWithArenaHolder h, F &&f)
template<typename T , typename F >
std::unique_ptr< T, F >	make_sentry (T *iObject, F iFunc)
	NOTE: if iObject is null, then iFunc will not be called. More...
template<typename T , typename... Args>
std::shared_ptr< T >	make_shared_noexcept_false (Args &&... args)
template<typename F >
FunctorWaitingTask< F > *	make_waiting_task (F f)
template<typename F >
auto	make_waiting_task_with_holder (WaitingTaskWithArenaHolder h, F &&f)
template<typename KeyRefType , typename AC , typename EventType >
AssociativeIterator< KeyRefType, AC, edm::EventItemGetter< KeyRefType, EventType > >	makeAssociativeIterator (const AC &map, const EventType &event)
std::vector< ProcessIndex >	makeBranchListIndexToProcessIndex (BranchListIndexes const &branchListIndexes)
template<typename T >
std::shared_ptr< ESHandleExceptionFactory >	makeESHandleExceptionFactory (T &&iFunctor)
template<typename U >
auto	makeESValid (const U &iOtherHandleType) noexcept(false)
template<typename T >
std::shared_ptr< HandleExceptionFactory >	makeHandleExceptionFactory (T &&iFunctor)
std::unique_ptr< InputSource >	makeInput (unsigned int moduleIndex, ParameterSet &params, CommonParams const &common, std::shared_ptr< ProductRegistry > preg, std::shared_ptr< BranchIDListHelper > branchIDListHelper, std::shared_ptr< ProcessBlockHelper > const &processBlockHelper, std::shared_ptr< ThinnedAssociationsHelper > thinnedAssociationsHelper, std::shared_ptr< ActivityRegistry > areg, std::shared_ptr< ProcessConfiguration const > processConfiguration, PreallocationConfiguration const &allocations)
std::unique_ptr< edm::ModuleTypeResolverMaker const >	makeModuleTypeResolverMaker (edm::ParameterSet const &pset)
static std::shared_ptr< cms::Exception >	makeNotFoundException (char const *where, KindOfType kindOfType, TypeID const &productType, std::string const &label, std::string const &instance, std::string const &process)
void	makeParameterSets (std::string const &configtext, std::unique_ptr< ParameterSet > &main)
	essentially the same as the previous method More...
template<class HandleT >
Ref< typename HandleT::element_type, typename HandleT::element_type::value_type::value_type >	makeRefTo (const HandleT &iHandle, det_id_type iDetID, typename HandleT::element_type::value_type::const_iterator itIter)
template<typename T >
RefToBaseProd< T >	makeRefToBaseProdFrom (RefToBase< T > const &iRef, Event const &iEvent)
template<class HandleT >
Ref< typename HandleT::element_type, typename HandleT::element_type::value_type::value_type >	makeRefToDetSetRefVector (const HandleT &iHandle, det_id_type iDetID, typename HandleT::element_type::value_type::const_iterator itIter)
template<class HandleT >
Ref< typename HandleT::element_type, typename HandleT::element_type::value_type::value_type >	makeRefToDetSetRefVector (const HandleT &iHandle, det_id_type iDetID, typename HandleT::element_type::value_type::iterator itIter)
template<class HandleT >
Ref< typename HandleT::element_type, typename HandleT::element_type::value_type::value_type >	makeRefToDetSetVector (const HandleT &iHandle, det_id_type iDetID, typename HandleT::element_type::value_type::iterator itIter)
std::unique_ptr< RunHelperBase >	makeRunHelper (ParameterSet const &pset)
template<typename U >
auto	makeValid (const U &iOtherHandleType) noexcept(false)
std::string	match (BranchDescription const &a, BranchDescription const &b, std::string const &fileName)
LuminosityBlockID const &	max (LuminosityBlockID const &lh, LuminosityBlockID const &rh)
EventID const &	max (EventID const &lh, EventID const &rh)
const unsigned int	maxIDlength (200)
bool	merge (LuminosityBlockRange &lh, LuminosityBlockRange &rh)
LuminosityBlockID const &	min (LuminosityBlockID const &lh, LuminosityBlockID const &rh)
EventID const &	min (EventID const &lh, EventID const &rh)
std::string	moduleName (StableProvenance const &provenance, ProcessHistory const &history)
template<typename... TArgs, typename ToT >
void	moveFromTo (ESProducts< TArgs... > &iFrom, ToT &iTo)
EDProductGetter const *	mustBeNonZero (EDProductGetter const *prodGetter, std::string refType, ProductID const &productID)
static Principal::CacheIdentifier_t	nextIdentifier ()
std::vector< ModuleDescription const * >	nonConsumedUnscheduledModules (edm::PathsAndConsumesOfModulesBase const &iPnC, std::vector< ModuleProcessName > &consumedByChildren)
Long64_t	numEntries (TFile *hdl, std::string const &trname)
TFile *	openFileHdl (std::string const &fname)
std::unique_ptr< ParameterDescriptionNode >	operator && (ParameterDescriptionNode const &node_left, ParameterDescriptionNode const &node_right)
std::unique_ptr< ParameterDescriptionNode >	operator && (std::unique_ptr< ParameterDescriptionNode > node_left, ParameterDescriptionNode const &node_right)
std::unique_ptr< ParameterDescriptionNode >	operator && (ParameterDescriptionNode const &node_left, std::unique_ptr< ParameterDescriptionNode > node_right)
std::unique_ptr< ParameterDescriptionNode >	operator && (std::unique_ptr< ParameterDescriptionNode > node_left, std::unique_ptr< ParameterDescriptionNode > node_right)
std::unique_ptr< ParameterDescriptionNode >	operator && (ParameterDescriptionNode const &node_left, ParameterDescriptionNode const &node_right)
std::unique_ptr< ParameterDescriptionNode >	operator && (std::unique_ptr< ParameterDescriptionNode > node_left, ParameterDescriptionNode const &node_right)
std::unique_ptr< ParameterDescriptionNode >	operator && (ParameterDescriptionNode const &node_left, std::unique_ptr< ParameterDescriptionNode > node_right)
std::unique_ptr< ParameterDescriptionNode >	operator && (std::unique_ptr< ParameterDescriptionNode > node_left, std::unique_ptr< ParameterDescriptionNode > node_right)
bool	operator!= (FileID const &lh, FileID const &rh)
bool	operator!= (RunLumiEntryInfo const &a, RunLumiEntryInfo const &b)
bool	operator!= (ElementID const &lh, ElementID const &rh)
bool	operator!= (EventEntryInfo const &a, EventEntryInfo const &b)
bool	operator!= (ProductID const &lh, ProductID const &rh)
bool	operator!= (BranchKey const &a, BranchKey const &b)
bool	operator!= (TypeID const &a, TypeID const &b)
template<typename T1 , template< typename X1 > class B1, typename T2 , template< typename X2 > class B2>
bool	operator!= (const zero_allocator< T1, B1 > &a, const zero_allocator< T2, B2 > &b)
bool	operator!= (EventEntryDescription const &a, EventEntryDescription const &b)
bool	operator!= (ProductProvenance const &a, ProductProvenance const &b)
bool	operator!= (const TypeIDBase &a, const TypeIDBase &b)
bool	operator!= (Parentage const &a, Parentage const &b)
bool	operator!= (ProcessConfiguration const &a, ProcessConfiguration const &b)
constexpr bool	operator!= (ELseverityLevel const &e1, ELseverityLevel const &e2) noexcept
bool	operator!= (ProcessHistory const &a, ProcessHistory const &b)
template<typename T >
bool	operator!= (FwdPtr< T > const &lhs, FwdPtr< T > const &rhs)
bool	operator!= (FileIndex::Element const &lh, FileIndex::Element const &rh)
bool	operator!= (TypeWithDict const &a, TypeWithDict const &b)
bool	operator!= (RefCore const &lhs, RefCore const &rhs)
template<typename KEY >
bool	operator!= (RefVectorBase< KEY > const &lhs, RefVectorBase< KEY > const &rhs)
	Inequality operator. More...
bool	operator!= (TypeWithDict const &a, std::type_info const &b)
template<typename T >
bool	operator!= (View< T > const &, View< T > const &)
bool	operator!= (std::type_info const &a, TypeWithDict const &b)
template<typename T >
bool	operator!= (RefToBaseProd< T > const &lhs, RefToBaseProd< T > const &rhs)
template<typename T , typename U >
bool	operator!= (atomic_value_ptr< T > const &lhs, U const &rhs)
template<typename T , typename U >
bool	operator!= (U const &lhs, atomic_value_ptr< T > const &rhs)
template<typename C >
bool	operator!= (RefProd< C > const &lhs, RefProd< C > const &rhs)
template<typename T , typename U >
bool	operator!= (value_ptr< T > const &lhs, U const &rhs)
bool	operator!= (ProductRegistry const &a, ProductRegistry const &b)
bool	operator!= (Entry const &a, Entry const &b)
template<typename T , typename U >
bool	operator!= (U const &lhs, value_ptr< T > const &rhs)
template<typename C , typename T , typename F >
bool	operator!= (RefVector< C, T, F > const &lhs, RefVector< C, T, F > const &rhs)
template<typename T >
bool	operator!= (Ptr< T > const &lhs, Ptr< T > const &rhs)
template<typename C , typename T , typename F >
bool	operator!= (FwdRef< C, T, F > const &lhs, FwdRef< C, T, F > const &rhs)
template<typename C , typename T , typename F >
bool	operator!= (Ref< C, T, F > const &lhs, FwdRef< C, T, F > const &rhs)
template<typename C , typename T , typename F >
bool	operator!= (FwdRef< C, T, F > const &lhs, Ref< C, T, F > const &rhs)
bool	operator!= (ParameterSet const &a, ParameterSet const &b)
template<typename C , typename T , typename F >
bool	operator!= (Ref< C, T, F > const &lhs, Ref< C, T, F > const &rhs)
template<typename C >
Association< C >	operator+ (const Association< C > &a1, const Association< C > &a2)
template<typename C , typename T , typename F >
RefVectorIterator< C, T, F >	operator+ (typename RefVectorIterator< C, T, F >::difference n, RefVectorIterator< C, T, F > const &iter)
template<typename T >
ValueMap< T >	operator+ (const ValueMap< T > &a1, const ValueMap< T > &a2)
bool	operator< (EventProcessHistoryID const &lh, EventProcessHistoryID const &rh)
bool	operator< (ModuleProcessName const &a, ModuleProcessName const &b)
bool	operator< (RunLumiEntryInfo const &a, RunLumiEntryInfo const &b)
bool	operator< (StoredProductProvenance const &a, StoredProductProvenance const &b)
bool	operator< (BranchKey const &a, BranchKey const &b)
bool	operator< (EventEntryInfo const &a, EventEntryInfo const &b)
bool	operator< (ElementID const &lh, ElementID const &rh)
bool	operator< (WorkerTimingSummary const &a, WorkerTimingSummary const &b)
bool	operator< (ProductProvenance const &a, ProductProvenance const &b)
bool	operator< (ProductID const &lh, ProductID const &rh)
bool	operator< (WorkerSummary const &a, WorkerSummary const &b)
bool	operator< (ProcessConfiguration const &a, ProcessConfiguration const &b)
template<class T >
bool	operator< (DetSet< T > const &x, DetSet< T > const &y)
template<class T >
bool	operator< (DetSet< T > const &x, det_id_type y)
template<class T >
bool	operator< (det_id_type x, DetSet< T > const &y)
constexpr bool	operator< (ELseverityLevel const &e1, ELseverityLevel const &e2) noexcept
bool	operator< (FileIndex::Element const &lh, FileIndex::Element const &rh)
bool	operator< (TypeWithDict const &a, TypeWithDict const &b)
template<typename T >
bool	operator< (FwdPtr< T > const &lhs, FwdPtr< T > const &rhs)
bool	operator< (RefCore const &lhs, RefCore const &rhs)
template<typename T >
bool	operator< (View< T > const &, View< T > const &)
template<typename T >
bool	operator< (RefToBaseProd< T > const &lhs, RefToBaseProd< T > const &rhs)
template<typename C >
bool	operator< (RefProd< C > const &lhs, RefProd< C > const &rhs)
template<typename T >
bool	operator< (Ptr< T > const &lhs, Ptr< T > const &rhs)
bool	operator< (BranchDescription const &a, BranchDescription const &b)
template<typename C , typename T , typename F >
bool	operator< (FwdRef< C, T, F > const &lhs, FwdRef< C, T, F > const &rhs)
template<typename C , typename T , typename F >
bool	operator< (Ref< C, T, F > const &lhs, FwdRef< C, T, F > const &rhs)
template<typename C , typename T , typename F >
bool	operator< (FwdRef< C, T, F > const &lhs, Ref< C, T, F > const &rhs)
template<typename C , typename T , typename F >
bool	operator< (Ref< C, T, F > const &lhs, Ref< C, T, F > const &rhs)
std::ostream &	operator<< (std::ostream &os, TimeOfDay const &tod)
std::ostream &	operator<< (std::ostream &os, ParameterSetBlob const &blob)
std::ostream &	operator<< (std::ostream &os, FileID const &id)
std::ostream &	operator<< (std::ostream &, PlaceInPathContext const &)
std::ostream &	operator<< (std::ostream &os, BranchType const &branchType)
std::ostream &	operator<< (std::ostream &os, BranchID const &id)
std::ostream &	operator<< (std::ostream &os, RunLumiEntryInfo const &p)
std::ostream &	operator<< (std::ostream &, InternalContext const &)
std::ostream &	operator<< (std::ostream &out, const reco::GenParticleRef &genRef)
std::ostream &	operator<< (std::ostream &os, FileFormatVersion const &ff)
std::ostream &	operator<< (std::ostream &os, EventEntryInfo const &p)
std::ostream &	operator<< (std::ostream &, PathContext const &)
std::ostream &	operator<< (std::ostream &, ProcessContext const &)
std::ostream &	operator<< (std::ostream &os, EventEntryDescription const &p)
std::ostream &	operator<< (std::ostream &iOS, ESResolverIndex const &iIndex)
std::ostream &	operator<< (std::ostream &os, ElementID const &id)
std::ostream &	operator<< (std::ostream &os, ProductProvenance const &p)
std::ostream &	operator<< (std::ostream &os, BranchKey const &bk)
std::ostream &	operator<< (std::ostream &os, ProductID const &id)
std::ostream &	operator<< (std::ostream &oStream, RunID const &iID)
std::ostream &	operator<< (std::ostream &os, const RunAuxiliary &p)
std::ostream &	operator<< (std::ostream &os, TypeID const &id)
std::ostream &	operator<< (std::ostream &, ParentContext const &)
std::ostream &	operator<< (std::ostream &os, const ProductSelector &gs)
std::ostream &	operator<< (std::ostream &os, const LuminosityBlockAuxiliary &p)
std::ostream &	operator<< (std::ostream &os, Parentage const &p)
std::ostream &	operator<< (std::ostream &os, StableProvenance const &p)
std::ostream &	operator<< (std::ostream &oStream, LuminosityBlockRange const &iID)
std::ostream &	operator<< (std::ostream &oStream, EventRange const &iID)
std::ostream &	operator<< (std::ostream &ost, InputTag const &tag)
std::ostream &	operator<< (std::ostream &os, ProcessConfiguration const &pc)
std::ostream &	operator<< (std::ostream &t, OStreamColumn const &c)
std::ostream &	operator<< (std::ostream &iOS, ESTokenIndex const &iIndex)
std::ostream &	operator<< (std::ostream &, GlobalContext const &)
template<typename E >
std::ostream &	operator<< (std::ostream &t, OStreamColumnEntry< E > const &ce)
std::ostream &	operator<< (std::ostream &, StreamContext const &)
std::ostream &	operator<< (std::ostream &os, ModuleDescription const &p)
std::ostream &	operator<< (std::ostream &os, ParameterSetEntry const &psetEntry)
std::ostream &	operator<< (std::ostream &oStream, LuminosityBlockID const &iID)
std::ostream &	operator<< (std::ostream &, ModuleCallingContext const &)
std::ostream &	operator<< (std::ostream &os, Provenance const &p)
std::ostream &	operator<< (std::ostream &iOS, ESRecordIndex const &iIndex)
std::ostream &	operator<< (std::ostream &ost, const HLTGlobalStatus &hlt)
	Formatted printout of trigger table. More...
std::ostream &	operator<< (std::ostream &os, JobReport::RunReport const &f)
std::ostream &	operator<< (std::ostream &os, const EventAuxiliary &p)
std::ostream &	operator<< (std::ostream &oStream, EventID const &iID)
template<class T >
ErrorObj &	operator<< (ErrorObj &e, const T &t)
std::ostream &	operator<< (std::ostream &, ESInputTag const &)
std::ostream &	operator<< (std::ostream &ost, ProcessHistory const &ph)
ErrorObj &	operator<< (ErrorObj &e, const char s[])
std::ostream &	operator<< (std::ostream &os, const edm::FileInPath &fip)
std::ostream &	operator<< (std::ostream &os, VParameterSetEntry const &vpsetEntry)
std::ostream &	operator<< (std::ostream &os, FileIndex const &fileIndex)
std::ostream &	operator<< (std::ostream &os, TypeWithDict const &id)
std::ostream &	operator<< (std::ostream &os, const CompactEventAuxiliaryVector::CompactEventAuxiliary &p)
std::ostream &	operator<< (std::ostream &os, const CompactEventAuxiliaryVector::CompactEventAuxiliaryExtra &p)
std::ostream &	operator<< (std::ostream &os, ProductResolverBase const &phb)
std::ostream &	operator<< (std::ostream &os, ProductRegistry const &pr)
template<int I>
std::ostream &	operator<< (std::ostream &os, Hash< I > const &h)
std::ostream &	operator<< (std::ostream &os, BranchDescription const &p)
template<typename PROD >
std::ostream &	operator<< (std::ostream &os, Handle< PROD > const &h)
template<typename T , std::size_t N>
std::ostream &	operator<< (std::ostream &out, edm::StdArray< T, N > const &array)
template<typename C , typename T , typename F >
std::ostream &	operator<< (std::ostream &os, RefVector< C, T, F > const &r)
std::ostream &	operator<< (std::ostream &os, JobReport::InputFile const &f)
std::ostream &	operator<< (std::ostream &os, JobReport::OutputFile const &f)
std::ostream &	operator<< (std::ostream &os, ParameterSet const &pset)
std::ostream &	operator<< (std::ostream &os, Entry const &entry)
constexpr bool	operator<= (ELseverityLevel const &e1, ELseverityLevel const &e2) noexcept
bool	operator<= (FileIndex::Element const &lh, FileIndex::Element const &rh)
template<typename T >
bool	operator<= (View< T > const &, View< T > const &)
bool	operator== (FileID const &lh, FileID const &rh)
bool	operator== (RunLumiEntryInfo const &a, RunLumiEntryInfo const &b)
bool	operator== (ElementID const &lh, ElementID const &rh)
bool	operator== (ProductID const &lh, ProductID const &rh)
bool	operator== (EventEntryInfo const &a, EventEntryInfo const &b)
bool	operator== (BranchKey const &a, BranchKey const &b)
template<typename T1 , template< typename X1 > class B1, typename T2 , template< typename X2 > class B2>
bool	operator== (const zero_allocator< T1, B1 > &a, const zero_allocator< T2, B2 > &b)
bool	operator== (EventEntryDescription const &a, EventEntryDescription const &b)
bool	operator== (ProductProvenance const &a, ProductProvenance const &b)
bool	operator== (ProcessConfiguration const &a, ProcessConfiguration const &b)
bool	operator== (Parentage const &a, Parentage const &b)
bool	operator== (StableProvenance const &a, StableProvenance const &b)
template<class T >
bool	operator== (RefToBaseVector< T > const &a, RefToBaseVector< T > const &b)
constexpr bool	operator== (ELseverityLevel const &e1, ELseverityLevel const &e2) noexcept
bool	operator== (Provenance const &a, Provenance const &b)
bool	operator== (ProcessHistory const &a, ProcessHistory const &b)
template<typename T >
bool	operator== (FwdPtr< T > const &lhs, FwdPtr< T > const &rhs)
bool	operator== (FileIndex::Element const &lh, FileIndex::Element const &rh)
bool	operator== (RefCore const &lhs, RefCore const &rhs)
template<typename KEY >
bool	operator== (RefVectorBase< KEY > const &lhs, RefVectorBase< KEY > const &rhs)
	Equality operator. More...
bool	operator== (TypeWithDict const &a, TypeWithDict const &b)
bool	operator== (edm::FileInPath const &a, edm::FileInPath const &b)
bool	operator== (TypeWithDict const &a, std::type_info const &b)
template<typename T >
bool	operator== (View< T > const &, View< T > const &)
bool	operator== (std::type_info const &a, TypeWithDict const &b)
template<typename T >
bool	operator== (RefToBaseProd< T > const &lhs, RefToBaseProd< T > const &rhs)
template<typename T , typename U >
bool	operator== (atomic_value_ptr< T > const &lhs, U const &rhs)
template<typename T , typename U >
bool	operator== (U const &lhs, atomic_value_ptr< T > const &rhs)
template<typename C >
bool	operator== (RefProd< C > const &lhs, RefProd< C > const &rhs)
template<typename T , typename U >
bool	operator== (value_ptr< T > const &lhs, U const &rhs)
bool	operator== (ProductRegistry const &a, ProductRegistry const &b)
bool	operator== (Entry const &a, Entry const &b)
template<typename T , typename U >
bool	operator== (U const &lhs, value_ptr< T > const &rhs)
template<typename C , typename T , typename F >
bool	operator== (RefVector< C, T, F > const &lhs, RefVector< C, T, F > const &rhs)
template<typename C , typename T , typename F >
bool	operator== (FwdRef< C, T, F > const &lhs, FwdRef< C, T, F > const &rhs)
template<typename C , typename T , typename F >
bool	operator== (Ref< C, T, F > const &lhs, FwdRef< C, T, F > const &rhs)
template<class T , class U , std::size_t N>
constexpr bool	operator== (StdArray< T, N > const &lhs, StdArray< U, N > const &rhs)
template<typename T >
bool	operator== (Ptr< T > const &lhs, Ptr< T > const &rhs)
template<typename C , typename T , typename F >
bool	operator== (FwdRef< C, T, F > const &lhs, Ref< C, T, F > const &rhs)
bool	operator== (BranchDescription const &a, BranchDescription const &b)
bool	operator== (ParameterSet const &a, ParameterSet const &b)
template<typename T , typename SORT , typename ALLOC >
bool	operator== (SortedCollection< T, SORT > const &c, std::vector< T, ALLOC > const &v)
template<typename T , typename SORT >
bool	operator== (SortedCollection< T, SORT > const &a, SortedCollection< T, SORT > const &b)
template<typename C , typename T , typename F >
bool	operator== (Ref< C, T, F > const &lhs, Ref< C, T, F > const &rhs)
bool	operator> (TypeID const &a, TypeID const &b)
bool	operator> (const TypeIDBase &a, const TypeIDBase &b)
constexpr bool	operator> (ELseverityLevel const &e1, ELseverityLevel const &e2) noexcept
bool	operator> (FileIndex::Element const &lh, FileIndex::Element const &rh)
template<typename T >
bool	operator> (View< T > const &, View< T > const &)
constexpr bool	operator>= (ELseverityLevel const &e1, ELseverityLevel const &e2) noexcept
bool	operator>= (FileIndex::Element const &lh, FileIndex::Element const &rh)
template<typename T >
bool	operator>= (View< T > const &, View< T > const &)
std::istream &	operator>> (std::istream &is, FileInPath &fip)
std::unique_ptr< ParameterDescriptionCases< bool > >	operator>> (bool caseValue, ParameterDescriptionNode const &node)
std::unique_ptr< ParameterDescriptionCases< int > >	operator>> (int caseValue, ParameterDescriptionNode const &node)
std::unique_ptr< ParameterDescriptionCases< std::string > >	operator>> (std::string const &caseValue, ParameterDescriptionNode const &node)
std::unique_ptr< ParameterDescriptionCases< std::string > >	operator>> (char const *caseValue, ParameterDescriptionNode const &node)
std::unique_ptr< ParameterDescriptionCases< bool > >	operator>> (bool caseValue, std::unique_ptr< ParameterDescriptionNode > node)
std::unique_ptr< ParameterDescriptionCases< int > >	operator>> (int caseValue, std::unique_ptr< ParameterDescriptionNode > node)
std::unique_ptr< ParameterDescriptionCases< std::string > >	operator>> (std::string const &caseValue, std::unique_ptr< ParameterDescriptionNode > node)
std::unique_ptr< ParameterDescriptionCases< std::string > >	operator>> (char const *caseValue, std::unique_ptr< ParameterDescriptionNode > node)
std::unique_ptr< ParameterDescriptionNode >	operator^ (ParameterDescriptionNode const &node_left, ParameterDescriptionNode const &node_right)
std::unique_ptr< ParameterDescriptionNode >	operator^ (std::unique_ptr< ParameterDescriptionNode > node_left, ParameterDescriptionNode const &node_right)
std::unique_ptr< ParameterDescriptionNode >	operator^ (ParameterDescriptionNode const &node_left, std::unique_ptr< ParameterDescriptionNode > node_right)
std::unique_ptr< ParameterDescriptionNode >	operator^ (std::unique_ptr< ParameterDescriptionNode > node_left, std::unique_ptr< ParameterDescriptionNode > node_right)
std::unique_ptr< ParameterDescriptionCases< bool > >	operator|| (std::unique_ptr< ParameterDescriptionCases< bool > >, std::unique_ptr< ParameterDescriptionCases< bool > >)
std::unique_ptr< ParameterDescriptionCases< int > >	operator|| (std::unique_ptr< ParameterDescriptionCases< int > >, std::unique_ptr< ParameterDescriptionCases< int > >)
std::unique_ptr< ParameterDescriptionCases< std::string > >	operator|| (std::unique_ptr< ParameterDescriptionCases< std::string > >, std::unique_ptr< ParameterDescriptionCases< std::string > >)
std::unique_ptr< ParameterDescriptionNode >	operator|| (ParameterDescriptionNode const &node_left, ParameterDescriptionNode const &node_right)
std::unique_ptr< ParameterDescriptionNode >	operator|| (std::unique_ptr< ParameterDescriptionNode > node_left, ParameterDescriptionNode const &node_right)
std::unique_ptr< ParameterDescriptionNode >	operator|| (ParameterDescriptionNode const &node_left, std::unique_ptr< ParameterDescriptionNode > node_right)
std::unique_ptr< ParameterDescriptionNode >	operator|| (std::unique_ptr< ParameterDescriptionNode > node_left, std::unique_ptr< ParameterDescriptionNode > node_right)
static std::atomic< int >	ourSerial (0)
bool	overlaps (LuminosityBlockRange const &lh, LuminosityBlockRange const &rh)
bool	overlaps (EventRange const &lh, EventRange const &rh)
ParameterSet const &	parameterSet (StableProvenance const &provenance, ProcessHistory const &history)
template<>
std::string	ParameterSet::getParameter< std::string > (std::string const &name) const
template<>
std::string	ParameterSet::getParameter< std::string > (char const *name) const
template<>
std::vector< double >	ParameterSet::getParameter< std::vector< double > > (std::string const &name) const
template<>
std::vector< double >	ParameterSet::getParameter< std::vector< double > > (char const *name) const
template<>
std::vector< ESInputTag >	ParameterSet::getParameter< std::vector< ESInputTag > > (std::string const &name) const
template<>
std::vector< ESInputTag >	ParameterSet::getParameter< std::vector< ESInputTag > > (char const *name) const
template<>
std::vector< EventID >	ParameterSet::getParameter< std::vector< EventID > > (std::string const &name) const
template<>
std::vector< EventID >	ParameterSet::getParameter< std::vector< EventID > > (char const *name) const
template<>
std::vector< EventRange >	ParameterSet::getParameter< std::vector< EventRange > > (std::string const &name) const
template<>
std::vector< EventRange >	ParameterSet::getParameter< std::vector< EventRange > > (char const *name) const
template<>
std::vector< InputTag >	ParameterSet::getParameter< std::vector< InputTag > > (std::string const &name) const
template<>
std::vector< InputTag >	ParameterSet::getParameter< std::vector< InputTag > > (char const *name) const
template<>
std::vector< int >	ParameterSet::getParameter< std::vector< int > > (std::string const &name) const
template<>
std::vector< int >	ParameterSet::getParameter< std::vector< int > > (char const *name) const
template<>
std::vector< long long >	ParameterSet::getParameter< std::vector< long long > > (std::string const &name) const
template<>
std::vector< long long >	ParameterSet::getParameter< std::vector< long long > > (char const *name) const
template<>
std::vector< LuminosityBlockID >	ParameterSet::getParameter< std::vector< LuminosityBlockID > > (std::string const &name) const
template<>
std::vector< LuminosityBlockID >	ParameterSet::getParameter< std::vector< LuminosityBlockID > > (char const *name) const
template<>
std::vector< LuminosityBlockRange >	ParameterSet::getParameter< std::vector< LuminosityBlockRange > > (std::string const &name) const
template<>
std::vector< LuminosityBlockRange >	ParameterSet::getParameter< std::vector< LuminosityBlockRange > > (char const *name) const
template<>
std::vector< PdtEntry >	ParameterSet::getParameter< std::vector< PdtEntry > > (char const *name) const
template<>
std::vector< PdtEntry >	ParameterSet::getParameter< std::vector< PdtEntry > > (std::string const &name) const
template<>
std::vector< std::string >	ParameterSet::getParameter< std::vector< std::string > > (std::string const &name) const
template<>
std::vector< std::string >	ParameterSet::getParameter< std::vector< std::string > > (char const *name) const
template<>
std::vector< unsigned int >	ParameterSet::getParameter< std::vector< unsigned int > > (std::string const &name) const
template<>
std::vector< unsigned int >	ParameterSet::getParameter< std::vector< unsigned int > > (char const *name) const
template<>
std::vector< unsigned long long >	ParameterSet::getParameter< std::vector< unsigned long long > > (std::string const &name) const
template<>
std::vector< unsigned long long >	ParameterSet::getParameter< std::vector< unsigned long long > > (char const *name) const
template<>
std::vector< std::string >	ParameterSet::getParameterNamesForType< std::vector< PdtEntry > > (bool trackiness) const
template<>
std::string	ParameterSet::getUntrackedParameter< std::string > (std::string const &name, std::string const &defaultValue) const
template<>
std::string	ParameterSet::getUntrackedParameter< std::string > (std::string const &name) const
template<>
std::string	ParameterSet::getUntrackedParameter< std::string > (char const *name, std::string const &defaultValue) const
template<>
std::string	ParameterSet::getUntrackedParameter< std::string > (char const *name) const
template<>
std::vector< double >	ParameterSet::getUntrackedParameter< std::vector< double > > (std::string const &name, std::vector< double > const &defaultValue) const
template<>
std::vector< double >	ParameterSet::getUntrackedParameter< std::vector< double > > (std::string const &name) const
template<>
std::vector< double >	ParameterSet::getUntrackedParameter< std::vector< double > > (char const *name) const
template<>
std::vector< double >	ParameterSet::getUntrackedParameter< std::vector< double > > (char const *name, std::vector< double > const &defaultValue) const
template<>
std::vector< ESInputTag >	ParameterSet::getUntrackedParameter< std::vector< ESInputTag > > (std::string const &name, std::vector< ESInputTag > const &defaultValue) const
template<>
std::vector< ESInputTag >	ParameterSet::getUntrackedParameter< std::vector< ESInputTag > > (std::string const &name) const
template<>
std::vector< ESInputTag >	ParameterSet::getUntrackedParameter< std::vector< ESInputTag > > (char const *name, std::vector< ESInputTag > const &defaultValue) const
template<>
std::vector< ESInputTag >	ParameterSet::getUntrackedParameter< std::vector< ESInputTag > > (char const *name) const
template<>
std::vector< EventID >	ParameterSet::getUntrackedParameter< std::vector< EventID > > (std::string const &name) const
template<>
std::vector< EventID >	ParameterSet::getUntrackedParameter< std::vector< EventID > > (std::string const &name, std::vector< EventID > const &defaultValue) const
template<>
std::vector< EventID >	ParameterSet::getUntrackedParameter< std::vector< EventID > > (char const *name, std::vector< EventID > const &defaultValue) const
template<>
std::vector< EventID >	ParameterSet::getUntrackedParameter< std::vector< EventID > > (char const *name) const
template<>
std::vector< EventRange >	ParameterSet::getUntrackedParameter< std::vector< EventRange > > (std::string const &name, std::vector< EventRange > const &defaultValue) const
template<>
std::vector< EventRange >	ParameterSet::getUntrackedParameter< std::vector< EventRange > > (std::string const &name) const
template<>
std::vector< EventRange >	ParameterSet::getUntrackedParameter< std::vector< EventRange > > (char const *name, std::vector< EventRange > const &defaultValue) const
template<>
std::vector< EventRange >	ParameterSet::getUntrackedParameter< std::vector< EventRange > > (char const *name) const
template<>
std::vector< InputTag >	ParameterSet::getUntrackedParameter< std::vector< InputTag > > (std::string const &name) const
template<>
std::vector< InputTag >	ParameterSet::getUntrackedParameter< std::vector< InputTag > > (std::string const &name, std::vector< InputTag > const &defaultValue) const
template<>
std::vector< InputTag >	ParameterSet::getUntrackedParameter< std::vector< InputTag > > (char const *name) const
template<>
std::vector< InputTag >	ParameterSet::getUntrackedParameter< std::vector< InputTag > > (char const *name, std::vector< InputTag > const &defaultValue) const
template<>
std::vector< int >	ParameterSet::getUntrackedParameter< std::vector< int > > (std::string const &name, std::vector< int > const &defaultValue) const
template<>
std::vector< int >	ParameterSet::getUntrackedParameter< std::vector< int > > (std::string const &name) const
template<>
std::vector< int >	ParameterSet::getUntrackedParameter< std::vector< int > > (char const *name, std::vector< int > const &defaultValue) const
template<>
std::vector< int >	ParameterSet::getUntrackedParameter< std::vector< int > > (char const *name) const
template<>
std::vector< long long >	ParameterSet::getUntrackedParameter< std::vector< long long > > (std::string const &name) const
template<>
std::vector< long long >	ParameterSet::getUntrackedParameter< std::vector< long long > > (std::string const &name, std::vector< long long > const &defaultValue) const
template<>
std::vector< long long >	ParameterSet::getUntrackedParameter< std::vector< long long > > (char const *name) const
template<>
std::vector< long long >	ParameterSet::getUntrackedParameter< std::vector< long long > > (char const *name, std::vector< long long > const &defaultValue) const
template<>
std::vector< LuminosityBlockID >	ParameterSet::getUntrackedParameter< std::vector< LuminosityBlockID > > (std::string const &name) const
template<>
std::vector< LuminosityBlockID >	ParameterSet::getUntrackedParameter< std::vector< LuminosityBlockID > > (std::string const &name, std::vector< LuminosityBlockID > const &defaultValue) const
template<>
std::vector< LuminosityBlockID >	ParameterSet::getUntrackedParameter< std::vector< LuminosityBlockID > > (char const *name) const
template<>
std::vector< LuminosityBlockID >	ParameterSet::getUntrackedParameter< std::vector< LuminosityBlockID > > (char const *name, std::vector< LuminosityBlockID > const &defaultValue) const
template<>
std::vector< LuminosityBlockRange >	ParameterSet::getUntrackedParameter< std::vector< LuminosityBlockRange > > (std::string const &name, std::vector< LuminosityBlockRange > const &defaultValue) const
template<>
std::vector< LuminosityBlockRange >	ParameterSet::getUntrackedParameter< std::vector< LuminosityBlockRange > > (std::string const &name) const
template<>
std::vector< LuminosityBlockRange >	ParameterSet::getUntrackedParameter< std::vector< LuminosityBlockRange > > (char const *name, std::vector< LuminosityBlockRange > const &defaultValue) const
template<>
std::vector< LuminosityBlockRange >	ParameterSet::getUntrackedParameter< std::vector< LuminosityBlockRange > > (char const *name) const
template<>
std::vector< PdtEntry >	ParameterSet::getUntrackedParameter< std::vector< PdtEntry > > (char const *name) const
template<>
std::vector< PdtEntry >	ParameterSet::getUntrackedParameter< std::vector< PdtEntry > > (char const *name, std::vector< PdtEntry > const &defaultValue) const
template<>
std::vector< PdtEntry >	ParameterSet::getUntrackedParameter< std::vector< PdtEntry > > (std::string const &name, std::vector< PdtEntry > const &defaultValue) const
template<>
std::vector< PdtEntry >	ParameterSet::getUntrackedParameter< std::vector< PdtEntry > > (std::string const &name) const
template<>
std::vector< std::string >	ParameterSet::getUntrackedParameter< std::vector< std::string > > (std::string const &name, std::vector< std::string > const &defaultValue) const
template<>
std::vector< std::string >	ParameterSet::getUntrackedParameter< std::vector< std::string > > (std::string const &name) const
template<>
std::vector< std::string >	ParameterSet::getUntrackedParameter< std::vector< std::string > > (char const *name, std::vector< std::string > const &defaultValue) const
template<>
std::vector< std::string >	ParameterSet::getUntrackedParameter< std::vector< std::string > > (char const *name) const
template<>
std::vector< unsigned int >	ParameterSet::getUntrackedParameter< std::vector< unsigned int > > (std::string const &name) const
template<>
std::vector< unsigned int >	ParameterSet::getUntrackedParameter< std::vector< unsigned int > > (std::string const &name, std::vector< unsigned int > const &defaultValue) const
template<>
std::vector< unsigned int >	ParameterSet::getUntrackedParameter< std::vector< unsigned int > > (char const *name, std::vector< unsigned int > const &defaultValue) const
template<>
std::vector< unsigned int >	ParameterSet::getUntrackedParameter< std::vector< unsigned int > > (char const *name) const
template<>
std::vector< unsigned long long >	ParameterSet::getUntrackedParameter< std::vector< unsigned long long > > (std::string const &name) const
template<>
std::vector< unsigned long long >	ParameterSet::getUntrackedParameter< std::vector< unsigned long long > > (std::string const &name, std::vector< unsigned long long > const &defaultValue) const
template<>
std::vector< unsigned long long >	ParameterSet::getUntrackedParameter< std::vector< unsigned long long > > (char const *name) const
template<>
std::vector< unsigned long long >	ParameterSet::getUntrackedParameter< std::vector< unsigned long long > > (char const *name, std::vector< unsigned long long > const &defaultValue) const
std::string	parameterTypeEnumToString (ParameterTypes iType)
template<>
ParameterTypes	ParameterTypeToEnum::toEnum< std::string > ()
template<>
ParameterTypes	ParameterTypeToEnum::toEnum< std::vector< double > > ()
template<>
ParameterTypes	ParameterTypeToEnum::toEnum< std::vector< ESInputTag > > ()
template<>
ParameterTypes	ParameterTypeToEnum::toEnum< std::vector< EventID > > ()
template<>
ParameterTypes	ParameterTypeToEnum::toEnum< std::vector< EventRange > > ()
template<>
ParameterTypes	ParameterTypeToEnum::toEnum< std::vector< InputTag > > ()
template<>
ParameterTypes	ParameterTypeToEnum::toEnum< std::vector< int > > ()
template<>
ParameterTypes	ParameterTypeToEnum::toEnum< std::vector< long long > > ()
template<>
ParameterTypes	ParameterTypeToEnum::toEnum< std::vector< LuminosityBlockID > > ()
template<>
ParameterTypes	ParameterTypeToEnum::toEnum< std::vector< LuminosityBlockRange > > ()
template<>
ParameterTypes	ParameterTypeToEnum::toEnum< std::vector< std::string > > ()
template<>
ParameterTypes	ParameterTypeToEnum::toEnum< std::vector< unsigned > > ()
template<>
ParameterTypes	ParameterTypeToEnum::toEnum< std::vector< unsigned long long > > ()
template<typename T >
void const *	pointerToBase (std::type_info const &baseTypeInfo, T const *address)
std::vector< ParameterSet >	popSubProcessVParameterSet (ParameterSet &parameterSet)
static void	postIndexIntoFilePrintEventLists (TFile *tfl, FileFormatVersion const &fileFormatVersion, TTree *metaDataTree)
static void	postIndexIntoFilePrintEventsInLumis (TFile *tfl, FileFormatVersion const &fileFormatVersion, TTree *metaDataTree)
static void	preIndexIntoFilePrintEventLists (TFile *, FileFormatVersion const &fileFormatVersion, TTree *metaDataTree)
static void	preIndexIntoFilePrintEventsInLumis (TFile *, FileFormatVersion const &fileFormatVersion, TTree *metaDataTree)
template<typename S >
S &	print (S &os, JobReport::InputFile const &f)
template<typename S >
S &	print (S &os, JobReport::OutputFile const &f)
template<typename S >
S &	print (S &os, JobReport::RunReport const &rep)
void	printBranchNames (TTree *tree)
void	printCmsException (cms::Exception &e, edm::JobReport *jobRep=nullptr, int rc=-1)
void	printCmsExceptionWarning (char const *behavior, cms::Exception const &e)
void	printEventLists (TFile *tfl)
void	printEventsInLumis (TFile *tfl)
void	printTrees (TFile *hdl)
void	printUuids (TTree *uuidTree)
Guid const &	processGUID ()
BranchID	productIDToBranchID (ProductID const &pid, BranchIDLists const &lists, BranchListIndexes const &indexes)
bool	public_base_classes (std::vector< std::string > &missingDictionaries, TypeID const &typeID, std::vector< TypeID > &baseTypes)
void	pythonToCppException (const std::string &iType, const std::string &error)
void	read_from_cin (std::string &output)
std::string	read_whole_file (std::string const &filename)
	only does the yacc interpretation More...
std::unique_ptr< edm::ParameterSet >	readConfig (std::string const &config, const std::vector< std::string > &args)
	same, but with arguments More...
std::unique_ptr< edm::ParameterSet >	readConfig (std::string const &config)
std::unique_ptr< edm::ParameterSet >	readPSetsFrom (std::string const &fileOrString)
void	reenableSigs (sigset_t *oldset)
template<typename C >
Ptr< typename C::value_type >	refToPtr (Ref< C, typename C::value_type, refhelper::FindUsingAdvance< C, typename C::value_type > > const &ref)
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)
void	replaceString (std::string &demangledName, std::string const &from, std::string const &to)
void	resolveSymbolicLinks (std::string &fullPath)
static const edm::ParameterSetDescriptionFillerPluginFactory::PMaker< edm::ParameterSetDescriptionFiller< HiMixingModule > >	s_filler_0__LINE__ ("HiMixingModule")
static const edm::MakerPluginFactory ::PMaker< edm::WorkerMaker< HiMixingModule > >	s_maker__LINE__ ("HiMixingModule")
template<typename ForwardSequence , typename Datum >
bool	search_all (ForwardSequence const &s, Datum const &d)
template<typename ForwardSequence , typename Predicate >
bool	search_if_in_all (ForwardSequence const &s, Predicate const &p)
template<typename T , typename U >
U	second (std::pair< T, U > const &p)
static std::string const	separator (":")
void	setIsMergeable (BranchDescription &)
void	setMaxLoggedErrorsSummaryIndicies (unsigned int iMax)
unsigned int	setNThreads (unsigned int iNThreads, unsigned int iStackSize, std::unique_ptr< ThreadsController > &oPtr)
template<typename T , typename A >
void	setPtr (std::vector< T, A > const &obj, std::type_info const &iToType, unsigned long iIndex, void const *&oPtr)
template<typename T , typename A >
void	setPtr (std::list< T, A > const &obj, std::type_info const &iToType, unsigned long iIndex, void const *&oPtr)
template<typename T , typename A >
void	setPtr (std::deque< T, A > const &obj, std::type_info const &iToType, unsigned long iIndex, void const *&oPtr)
template<typename T , typename A , typename Comp >
void	setPtr (std::set< T, A, Comp > const &obj, std::type_info const &iToType, unsigned long iIndex, void const *&oPtr)
template<typename T , typename SORT >
void	setPtr (SortedCollection< T, SORT > const &obj, std::type_info const &toType, unsigned long index, void const *&ptr)
template<typename T , typename P >
void	setPtr (OwnVector< T, P > const &obj, std::type_info const &toType, unsigned long index, void const *&ptr)
void	setRefCoreStreamer (bool resetAll=false)
EDProductGetter const *	setRefCoreStreamer (EDProductGetter const *ep)
void	setRefCoreStreamerInTClass ()
void	setStandAloneMessageThreshold (edm::messagelogger::ELseverityLevel const &severity)
void	setThreadOptions (ThreadsInfo const &threadsInfo, edm::ParameterSet &pset)
ServiceRegistry::Operate	setupSiteLocalConfig ()
void	sigInventory ()
template<typename RandomAccessSequence >
void	sort_all (RandomAccessSequence &s)
	wrappers for std::sort More...
template<typename RandomAccessSequence , typename Predicate >
void	sort_all (RandomAccessSequence &s, Predicate p)
std::vector< LuminosityBlockRange > &	sortAndRemoveOverlaps (std::vector< LuminosityBlockRange > &lumiRange)
std::vector< EventRange > &	sortAndRemoveOverlaps (std::vector< EventRange > &eventRange)
static std::string const	source ("source")
template<class OutIter >
bool	split (OutIter result, std::string_view string_to_split, char first, char sep, char last)
template<typename FUNC >
bool	split (std::string_view string_to_split, char first, char sep, char last, FUNC f)
void	squelchStandAloneMessageCategory (std::string const &category)
template<typename RandomAccessSequence >
void	stable_sort_all (RandomAccessSequence &s)
	wrappers for std::stable_sort More...
template<typename RandomAccessSequence , typename Predicate >
void	stable_sort_all (RandomAccessSequence &s, Predicate p)
std::string_view	stemFromPath (std::string_view path)
std::string	stripNamespace (std::string const &theName)
bool	stripTemplate (std::string &theName)
template<typename T >
void	subProcessDoGlobalBeginTransitionAsync (WaitingTaskHolder iHolder, SubProcess &iSubProcess, LumiTransitionInfo const &iTransitionInfo, bool)
template<typename T >
void	subProcessDoGlobalBeginTransitionAsync (WaitingTaskHolder iHolder, SubProcess &iSubProcess, RunTransitionInfo const &iTransitionInfo, bool)
template<typename Traits >
void	subProcessDoGlobalBeginTransitionAsync (WaitingTaskHolder iHolder, SubProcess &iSubProcess, ProcessBlockTransitionInfo const &iTransitionInfo, bool cleaningUpAfterException)
void	subProcessDoGlobalEndTransitionAsync (WaitingTaskHolder iHolder, SubProcess &iSubProcess, LumiTransitionInfo const &iTransitionInfo, bool cleaningUpAfterException)
void	subProcessDoGlobalEndTransitionAsync (WaitingTaskHolder iHolder, SubProcess &iSubProcess, RunTransitionInfo const &iTransitionInfo, bool cleaningUpAfterException)
void	subProcessDoGlobalEndTransitionAsync (WaitingTaskHolder iHolder, SubProcess &iSubProcess, ProcessBlockTransitionInfo const &iTransitionInfo, bool cleaningUpAfterException)
void	subProcessDoStreamBeginTransitionAsync (WaitingTaskHolder iHolder, SubProcess &iSubProcess, unsigned int i, LumiTransitionInfo const &iTransitionInfo)
void	subProcessDoStreamBeginTransitionAsync (WaitingTaskHolder iHolder, SubProcess &iSubProcess, unsigned int i, RunTransitionInfo const &iTransitionInfo)
void	subProcessDoStreamEndTransitionAsync (WaitingTaskHolder iHolder, SubProcess &iSubProcess, unsigned int i, LumiTransitionInfo const &iTransitionInfo, bool cleaningUpAfterException)
void	subProcessDoStreamEndTransitionAsync (WaitingTaskHolder iHolder, SubProcess &iSubProcess, unsigned int i, RunTransitionInfo const &iTransitionInfo, bool cleaningUpAfterException)
void	swap (ElementID &a, ElementID &b)
void	swap (ProductID &a, ProductID &b)
void	swap (OrphanHandleBase &a, OrphanHandleBase &b)
void	swap (Parentage &a, Parentage &b)
template<class T , class P >
void	swap (CloningPtr< T, P > &a, CloningPtr< T, P > &b)
void	swap (ProductData &a, ProductData &b)
void	swap (TriggerResults &lhs, TriggerResults &rhs)
template<class T >
void	swap (RefToBaseVector< T > &a, RefToBaseVector< T > &b)
void	swap (HLTGlobalStatus &lhs, HLTGlobalStatus &rhs)
	Free swap function. More...
void	swap (ESHandleBase &a, ESHandleBase &b)
void	swap (BasicHandle &a, BasicHandle &b) noexcept(true)
void	swap (ProcessHistory &a, ProcessHistory &b)
template<class T >
void	swap (DetSet< T > &a, DetSet< T > &b)
template<typename C >
void	swap (Association< C > &lhs, Association< C > &rhs)
void	swap (HandleBase &a, HandleBase &b)
void	swap (ErrorObj &a, ErrorObj &b)
template<class T >
void	swap (EDCollection< T > &a, EDCollection< T > &b)
void	swap (FileInPath &a, FileInPath &b)
template<typename K , typename T >
void	swap (MapOfVectors< K, T > &lhs, MapOfVectors< K, T > &rhs)
template<typename KEY >
void	swap (RefVectorBase< KEY > &a, RefVectorBase< KEY > &b)
	swap two vectors More...
void	swap (edm::RefCore &lhs, edm::RefCore &rhs)
void	swap (edm::RefCoreWithIndex &lhs, edm::RefCoreWithIndex &rhs)
template<typename C , typename T , typename F >
void	swap (RefVector< C, T, F > &a, RefVector< C, T, F > &b) noexcept
template<typename T >
void	swap (edm::RefToBaseProd< T > const &lhs, edm::RefToBaseProd< T > const &rhs)
template<typename T >
void	swap (value_ptr< T > &vp1, value_ptr< T > &vp2)
void	swap (DataFrameContainer &lhs, DataFrameContainer &rhs)
template<typename C >
void	swap (RefProd< C > const &lhs, RefProd< C > const &rhs)
template<int I>
void	swap (Hash< I > &a, Hash< I > &b)
template<typename T >
void	swap (PtrVector< T > &lhs, PtrVector< T > &rhs)
template<typename ID , typename C , typename P >
void	swap (RangeMap< ID, C, P > &a, RangeMap< ID, C, P > &b)
template<typename T , typename C >
void	swap (DetSetRefVector< T, C > &a, DetSetRefVector< T, C > &b)
template<typename T >
void	swap (ValueMap< T > &lhs, ValueMap< T > &rhs)
template<typename KeyRefProd , typename CVal , typename KeyRef , typename SizeType , typename KeyReferenceHelper >
void	swap (AssociationVector< KeyRefProd, CVal, KeyRef, SizeType, KeyReferenceHelper > &a, AssociationVector< KeyRefProd, CVal, KeyRef, SizeType, KeyReferenceHelper > &b)
void	swap (ParameterSet &a, ParameterSet &b)
template<typename C >
void	swap (MultiAssociation< C > &lhs, MultiAssociation< C > &rhs)
template<typename T >
void	swap (View< T > &lhs, View< T > &rhs)
template<typename T , typename SORT >
void	swap (SortedCollection< T, SORT > &a, SortedCollection< T, SORT > &b)
template<class T >
void	swap (RefToBase< T > &a, RefToBase< T > &b)
template<class T >
void	swap (DetSetVector< T > &a, DetSetVector< T > &b)
template<typename T , typename P >
void	swap (OwnVector< T, P > &a, OwnVector< T, P > &b) noexcept
template<typename F >
std::exception_ptr	syncWait (F &&iFunc)
template<typename C , typename T , typename F >
Ref< C, T, F >	thinnedRefFrom (Ref< C, T, F > const &parent, RefProd< C > const &thinned, edm::EDProductGetter const &prodGetter)
	Return a Ref to thinned collection corresponding to an element of the Ref to parent collection. More...
ThreadsInfo	threadOptions (edm::ParameterSet const &pset)
static void	throwAmbiguousException (const char *where, TypeID const &productType, std::string const &label, std::string const &instance, std::string const &process)
void	throwExceptionWithText (char const *txt)
void	throwMissingDictionariesException (std::vector< std::string > &missingDictionaries, std::string const &context)
void	throwMissingDictionariesException (std::vector< std::string > &missingDictionaries, std::string const &context, std::vector< std::string > &producedTypes)
void	throwMissingDictionariesException (std::vector< std::string > &missingDictionaries, std::string const &context, std::vector< std::string > &producedTypes, std::vector< std::string > &branchNames, bool fromStreamerSource=false)
void	throwMissingDictionariesException (std::vector< std::string > &missingDictionaries, std::string const &context, std::set< std::string > &producedTypes, bool consumedWithView)
static void	throwProductDeletedException (ProductID const &pid, edm::EventPrincipal::ConstProductResolverPtr const phb)
static void	throwProductNotFoundException (char const *where, errors::ErrorCodes error, BranchID const &bid)
static void	throwTypeException (std::string const &function, std::string const &typeName)
std::vector< std::string >	tokenize (std::string const &input, std::string const &separator)
	breaks the input string into tokens, delimited by the separator More...
template<typename T >
pybind11::list	toPython11List (const std::vector< T > &v)
template<typename T >
std::vector< T >	toVector (pybind11::list &l)
std::string_view	transitionName (GlobalContext::Transition)
std::string_view	transitionName (StreamContext::Transition)
static std::string const	triggerResults ("TriggerResults")
static std::string const	triggerResultsInserter ("TriggerResultsInserter")
template<typename C , typename T , typename F >
Ref< C, T, F >	tryThinnedRefFrom (Ref< C, T, F > const &parent, RefProd< C > const &thinned, edm::EDProductGetter const &prodGetter)
	Return a Ref to thinned collection corresponding to an element of the Ref to parent collection. More...
template<typename T >
T const *	tryToGetProductWithCoreFromRef (RefCore const &ref, EDProductGetter const *prodGetter)
std::string	typeDemangle (char const *mangledName)
std::string	uniqueSharedResourceName ()
bool	untaintString (char const *pattern, char const *regexp)
void	validateTopLevelParameterSets (ParameterSet *processParameterSet)
template<typename InputType , typename Function >
auto	vector_transform (std::vector< InputType > const &input, Function predicate) -> std::vector< typename std::remove_cv< typename std::remove_reference< decltype(predicate(input.front()))>::type >::type >
template<typename V , typename T >
void	walkTrie (V &v, TrieNode< T > const &n, std::string const &label="")
	visit each node of the trie More...
std::string	withoutQuotes (std::string const &from)
std::string	wrappedClassName (std::string const &iFullName)

Variables
debugvalue	debugit
constexpr const ELseverityLevel	ELdebug {ELseverityLevel::ELsev_success}
constexpr const ELseverityLevel	ELerror {ELseverityLevel::ELsev_error}
constexpr const ELseverityLevel	ELfwkInfo {ELseverityLevel::ELsev_fwkInfo}
constexpr const ELseverityLevel	ELhighestSeverity {ELseverityLevel::ELsev_highestSeverity}
constexpr const ELseverityLevel	ELinfo {ELseverityLevel::ELsev_info}
constexpr const ELseverityLevel	ELsevere {ELseverityLevel::ELsev_severe}
constexpr const ELseverityLevel	ELunspecified {ELseverityLevel::ELsev_unspecified}
constexpr const ELseverityLevel	ELwarning {ELseverityLevel::ELsev_warning}
constexpr const ELseverityLevel	ELzeroSeverity {ELseverityLevel::ELsev_zeroSeverity}
EventNumber_t const	invalidEventNumber = 0U
LuminosityBlockNumber_t const	invalidLuminosityBlockNumber = 0U
RunNumber_t const	invalidRunNumber = 0U
static unsigned long long constexpr	kAveEventPerSec = 200ULL
static constexpr std::string_view	kJobReportEndElement = "</FrameworkJobReport>\n"
static constexpr int	kMinSizeOfComment = 8
static unsigned long long constexpr	kNanoSecPerSec = 1000000000ULL
static const unsigned char	MLSCRIBE_RUNNING_INDICATOR = 29
constexpr const char *	module_type_desc []
constexpr unsigned int	numberOfRunLumiEventProductTrees = 3
constexpr unsigned int	s_defaultNumberOfThreads = 1
constexpr unsigned int	s_defaultSizeOfStackForThreadsInKB = 10 * 1024
static const std::vector< void const * >	s_emptyCache {}
static ProcessHistory const	s_emptyProcessHistory
static std::atomic< Principal::CacheIdentifier_t >	s_nextIdentifier {1}
thread_local EDProductGetter const *	s_productGetter = nullptr
static unsigned int const	shift = 8 * sizeof(unsigned int)
volatile std::atomic< bool >	shutdown_flag {false}

Detailed Description

HLT enums.

why defined in namespace edm:: ?? (L.L.)

classes declaration

Register the record.

Find a non-event-data file, given a relative path.

This class manages the storage and retrieval of correlations between Alignables for the AlignmentParameterStore. This implementation does not stores the entries of the "big covariance matrix" itself, but the statistical correlations, i.e. R_ij=C_ij/sqrt(C_ii*C_jj) rather than C_ij.

If a correlation exceeds a certain value (especially corrupted correlations with an absolute value bigger than 1) it is downweighted.

This module is an source module reading continously file as they are copied in the input directory. The processed file is moved to directoryt inprocessDir before being processed. Once it is processed it is moved to processedDir. To prevent processing files before their transfer is finished, it is waited than file size is stable during one second before the file is processed. This protection is obviously not full proof, especially to transfer lag.

Description: Forward declare standard edm::fillPtrVector functions

Usage:

Description: Forward declare the standard setPtr functions

Usage:

Summary

The edm::FwdRef<> is a storable reference to an item in a stored "forward" container, which also contains a reference to an item in a "backward" container that the "forward" container is derived from.

For example, you could use one to hold a reference back to one particular track within a derived std::vector<> of tracks, but you want to keep the original Ref's to the original std::vector<> of tracks (for instance, if you've made a selection on the tracks in the list and want to remove the unnecessary ones from the event).

Usage

The edm::FwdRef<> works just like a pointer

edm::FwdRef<Foo> fooPtr = ... //set the value
functionTakingConstFoo(*fooPtr); //get the Foo object
fooPtr->bar();  //call a method of the held Foo object

The main purpose of an edm::FwdRef<> is it can be used as a member datum for a class that is to be stored in the edm::Event where the user can simultaneously check the "backwards" ref as well as the default "forward" ref.

Customization

The edm::FwdRef<> takes three template parameters, and both "forward" and "backward" refs must be the same types:

1) C: The type of the container which is holding the item

2) T: The type of the item. This defaults to C::value_type

3) F: A helper class (a functor) which knows how to find a particular 'T' within the container given an appropriate key. The type of the key is deduced from F::second_argument. The default for F is refhelper::FindTrait<C,T>::value. If no specialization of FindTrait<> is available for the combination (C,T) then it defaults to getting the iterator to be beginning of the container and using std::advance() to move to the appropriate key in the container.

It is possible to customize the 'lookup' algorithm used.
1) The helper class F must provide value_type, first_argument_type and second_argument_type typedefs.

2) The helper class F must define the function call operator in such a way that the following call is well-formed: f is an instance of type F coll is an instance of type C k is an instance of type F::key_type

     result_type r = f(coll,k);     

 If one wishes to make a specialized lookup the default lookup for
 the container/type pair then one needs to partially specialize
 the templated class edm::refhelper::FindTrait<C,T> such that it
 has a typedef named 'value' which refers to the specialized
 helper class (i.e., F)

 The class template FwdRef<C,T,F> supports 'null' references.

 -- a default-constructed FwdRef is 'null'; furthermore, it also
    has an invalid (or 'null') ProductID.
 -- a FwdRef constructed through the single-arguement constructor
    that takes a ProductID is also null.        

Definition of common HLT enums

Author

Martin Grunewald

Summary

The edm::Ref<> is a storable reference to an item in a stored container. For example, you could use one to hold a reference back to one particular track within an std::vector<> of tracks.

Usage

The edm::Ref<> works just like a pointer

edm::Ref<FooCollection> fooPtr = ... //set the value
functionTakingConstFoo(*fooPtr); //get the Foo object
fooPtr->bar();  //call a method of the held Foo object

The main purpose of an edm::Ref<> is it can be used as a member datum for a class that is to be stored in the edm::Event.

Customization

The edm::Ref<> takes three template parameters

1) C: The type of the container which is holding the item

2) T: The type of the item. This defaults to C::value_type

3) F: A helper class (a functor) which knows how to find a particular 'T' within the container given an appropriate key. The type of the key is deduced from F::second_argument. The default for F is refhelper::FindTrait<C, T>::value. If no specialization of FindTrait<> is available for the combination (C, T) then it defaults to getting the iterator to be beginning of the container and using std::advance() to move to the appropriate key in the container.

It is possible to customize the 'lookup' algorithm used.
1) The helper class F must provide value_type, first_argument_type and second_argument_type typedefs.

2) The helper class F must define the function call operator in such a way that the following call is well-formed: f is an instance of type F coll is an instance of type C k is an instance of type F::key_type

     result_type r = f(coll, k);     

 If one wishes to make a specialized lookup the default lookup for
 the container/type pair then one needs to partially specialize
 the templated class edm::refhelper::FindTrait<C, T> such that it
 has a typedef named 'value' which refers to the specialized
 helper class (i.e., F)

 The class template Ref<C, T, F> supports 'null' references.

 -- a default-constructed Ref is 'null'; furthermore, it also
    has an invalid (or 'null') ProductID.
 -- a Ref constructed through the single-arguement constructor
    that takes a ProductID is also null.        

Author

W. David Dagenhart, created 5 January, 2021

Declaration of the enum HashedTypes, used in defining several "id" classes.

Author

W. David Dagenhart, created 1 August, 2014

Functions to return atomic properties of the material A_eff and Z_eff are computed as the A-weighted sums of the A's and the Z's of Pb, W and O

Author

Patrick Janot

Date

: 25-Jan-2004

Functions to return atomic properties of the material A_eff and Z_eff are computed as the A-weighted sums of the A's and the Z's of Cu and Zn (brass) - For now assume it is all Copper, and it'll be good enough.

Author

Patrick Janot

Date

: 25-Jan-2004

Parameters used in the hadron fast simulation

chain_first

Description: Handles creation of a chain of WaitingTasks

Usage: Use the function to begin constructing a chain of waiting tasks. Once the chain is declared, call lastTask() with a WaitingTaskHolder to get back a new WaitingTaskHolder or runLast() to schedule the chain to run.

findDependentRecordsFor findDependentRecordsFor.h "findDependentRecordsFor.h"

Description: [one line class summary]

Usage: <usage>

getAllTriggerNames getAllTriggerNames.h "FWCore/Framework/interface/getAllTriggerNames.h"

Description: Returns a list of all the trigger names in the current process Usage: <usage>

edm::getProducerParameterSet

Description: Returns the ParameterSet of the module that produced the product corresponding to the Provenance.

This shouldn't ever fail if the Provenance and other objects it uses have been properly initialized, which should always be the case when called from a module using the Provenance from a Handle returned by a function like getByToken. If it does fail it will throw an exception.

globalTransitionAsync globalTransitionAsync.h "globalTransitionAsync.h"

Description: Helper functions for handling asynchronous global transitions

Usage: <usage>

---

This struct is used to communication parameters into the module factory.

---

---

This struct is used to communication parameters into the worker factory.

---

Author

W. David Dagenhart, created 13 January, 2021

Helper functions for making stream modules

Description: [one line class summary]

Usage: <usage>

streamTransitionAsync streamTransitionAsync.h "streamTransitionAsync.h"

Description: Helper functions for handling asynchronous stream transitions

Usage: <usage>

Description: The types here are used to pass information down to the Worker class from the EventProcessor.

-------------------------------------------------------------------—

Description: <one line="" class="" summary>="">

Implementation: <Notes on="" implementation>="">

allowedValues allowedValues.h FWCore/ParameterSet/interface/allowedValues.h

Description: Used to describe the allowed values in a ParameterSet

Usage: The function is used in conjunction with ParameterSetDescription::ifValue to just constrain the allowed values and not add additional dependent ParameterSet nodes (which is allowed by ifValue).

edm::ParameterSetDescription psetDesc;
psetDesc.ifValue(edm::ParameterDescription<std::string>("sswitch", "a", true),
                 edm::allowedValues<std::string>("a", "h", "z") );

Implementation Details: The node associated with each allowed value is the EmptyGroupDescription which is just a dummy place holder.

How ParameterSets are nested inside ParameterSets The main feature is that they're made persistent using a ParameterSetID, and only reconstituted as needed, when the value_ptr = 0;

A singleton for managing the plugin feedback function and assert hook function. It is unclear how this will react in a multithreaded application.

It is possible that in the future this object will allow arbitrary state object to be pushed in and pulled out so that when asserts occur, good state information can be printed.

connect_but_block_self connect_but_block_self.h FWCore/ServiceRegistry/interface/connect_but_block_self.h

Description: Connects a functional object to a signal, but guarantees that the functional object will never see a signal caused by its own action.

Usage: <usage>

edm::setupSiteLocalConfig

Description: Setups up the SiteLocalConfig service.

Usage:

Description: classes and functions used by edm::soa::Table

Usage: These are internal details of Table's implementation

edm::bit_cast bit_cast.h "FWCore/Utilities/interface/bit_cast.h"

Description: C++ 20 std::bit_cast stand-in

Usage: See documentation on std::bit_cast in C++ 20

This is the basic exception that is thrown by the framework code. It exists primarily to distinguish framework thrown exception types from developer thrown exception types. As such there is very little interface other than constructors specific to this derived type.

FileInPath knows how to take a string, interpreted as a relative path to a file, and to interpret using the "standard CMS non-event-data file searching mechanism".

The mechanism using the environment variables: CMSSW_SEARCH_PATH: may be set by the end-user CMSSW_RELEASE_BASE: should be set by a site administrator CMSSW_DATA_PATH: should be set by a site administrator

CMSSW_SEARCH_PATH is a 'search path' limited to 1 to 3 components. The legal values are:

  "." or "LOCAL", which means to search for files under
       the top level of the "local working area", which is
       defined as ${SCRAMRT_LOCALRT}/src

  "CMSSW_RELEASE_BASE", which means search the "official place",
        defined by the value of the CMSSW_RELEASE_BASE environment
        variable, for files.

  "CMSSW_DATA_PATH", which means search the "official place",
        defined by the value of the CMSSW_DATA_PATH environment
        variable, for files.

  ".:CMSSW_RELEASE_BASE" or "LOCAL:CMSSW_RELEASE_BASE",
         which means look first in the current working
         directory, then in the "official place", for files.

  ".:CMSSW_DATA_PATH" or "LOCAL:CMSSW_DATA_PATH",
         which means look first in the current working
         directory, then in the "official place", for files.

  ".:CMSSW_RELEASE_BASE:CMSSW_DATA_PATH" or "LOCAL:CMSSW_RELEASE_BASE:CMSSW_DATA_PATH",
         which means look first in the current working
         directory, then in both "official places", for files.

hash_combine hash_combine.h "FWCore/Utilities/interface/hash_combine.h"

Description: Convenience Functions to Combine Hash Values

Based on http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2014/n3876.pdf Combination algorithm is the same as boost::hash_combine

Usage: <usage>

make_sentry make_sentry.h "FWCore/Utilities/interface/make_sentry.h"

Description: Creates a std::unique_ptr from a lambda to be used as a sentry

Usage: <usage>

A ThreadSafeRegistry is used to keep track of the instances of some type 'value_typed'. These objects are each associated with a given 'key_type' object, which must be retrievable from the value_type object, and which must uniquely identify the value_type's value.

This class is sufficiently thread-safe to be usable in a thread-safe manner. Don't let the name mislead you into thinking it provides more guarantee than that!

If 'm' is of type 'value_type const&', the expression

key_type k = m.id();

must be legal, and must return the unique key associated with the value of 'm'.

//////////////////////////////////////// Stacked Tracker Simulations /// Written by: /// Andrew W. Rose /// 2008 /// ////////////////////////////////////////

class HLTJetPairDzMatchFilter an HLT filter which picks up a JetCollection (supposedly, of L2 tau jets) and passes only events with at least one pair of non-overlapping jets with vertices within some dz

HLT filter by muon+track mass (taken from two RecoChargedCandidate collections). Tracks are subject to quality and momentum cuts. The match with previous muon (and possibly track, if run after another mass filter) candidates is checked.

Description: Producer for EcalRecHits to be used for pi0/eta ECAL calibration.

Implementation: <Notes on="" implementation>="">

See header file for a description of this class.

Author

Jo. Weng - CERN, Ph Division & Uni Karlsruhe

F.Moortgat - CERN, Ph Division

StreamSerializer.cc

Utility class for serializing framework objects (e.g. ProductRegistry and Event) into streamer message objects.

Classes for calorimetric re-clustering

Author

Andrew W. Rose

Date

2013, Jul 12

Author

Andrew W. Rose

Date

2013, Jul 18

The ModelFilter class will select events in a "soup" MC (like the SUSY signal MC) from the comments of LHEEventProduct that match "modelTag". The user can require the value of that parameter to lie between a min and max value.

This is derived from EDFilterValueMapWrapper but rather than filtering it just stores a valuemap with the result

A HitTripletGenerator from HitPairGenerator and vector of Layers. The HitPairGenerator provides a set of hit pairs. For each pair the search for compatible hit(s) is done among provided Layers

A MultiHitGenerator from HitPairGenerator and vector of Layers. The HitPairGenerator provides a set of hit pairs. For each pair the search for compatible hit(s) is done among provided Layers

---

class: BeamFitter.h package: RecoVertex/BeamSpotProducer

author: Francisco Yumiceva, Fermilab (yumic.nosp@m.eva@.nosp@m.fnal..nosp@m.gov) Geng-Yuan Jeng, UC Riverside (Geng-.nosp@m.Yuan.nosp@m..Jeng.nosp@m.@cer.nosp@m.n.ch)

---

---

class: PVFitter.h package: RecoVertex/BeamSpotProducer

author: Francisco Yumiceva, Fermilab (yumic.nosp@m.eva@.nosp@m.fnal..nosp@m.gov) Geng-Yuan Jeng, UC Riverside (Geng-.nosp@m.Yuan.nosp@m..Jeng.nosp@m.@cer.nosp@m.n.ch)

---

Converts digis back into analog signals, to be used as noise

sensitiveDetectorMakers

Description: Makes it easy to find what SensitiveDetectorMakerBase are available

Usage: <usage>

Typedef Documentation

AlignedVec

template<typename T >

using edm::AlignedVec = typedef Aligned<T, 16>

Definition at line 105 of file SoATuple.h.

BranchIDList

typedef std::vector<BranchID::value_type> edm::BranchIDList

Definition at line 18 of file BranchIDList.h.

BranchIDLists

typedef std::vector<BranchIDList> edm::BranchIDLists

Definition at line 19 of file BranchIDList.h.

BranchListIndex

typedef unsigned short edm::BranchListIndex

Definition at line 17 of file BranchListIndex.h.

BranchListIndexes

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

Definition at line 18 of file BranchListIndex.h.

CFUNC

typedef void(* edm::CFUNC) (int, siginfo_t *, void *)

Definition at line 20 of file UnixSignalHandlers.h.

CPUInfoType

using edm::CPUInfoType = typedef std::vector<std::pair<std::string, std::string> >

Definition at line 49 of file CPU.cc.

CTPPSFastRecHitContainer

typedef std::vector<CTPPSFastRecHit> edm::CTPPSFastRecHitContainer

Definition at line 13 of file CTPPSFastRecHitContainer.h.

CTPPSFastTrackContainer

typedef std::vector<CTPPSFastTrack> edm::CTPPSFastTrackContainer

Definition at line 11 of file CTPPSFastTrackContainer.h.

DAFunc

typedef DigiAccumulatorMixMod*() edm::DAFunc(ParameterSet const &, ProducesCollector, ConsumesCollector &)

Definition at line 12 of file DigiAccumulatorMixModFactory.h.

det_id_type

typedef uint32_t edm::det_id_type

Definition at line 20 of file DetSet.h.

DigiAccumulatorMixModPluginFactory

typedef edmplugin::PluginFactory<DAFunc> edm::DigiAccumulatorMixModPluginFactory

Definition at line 13 of file DigiAccumulatorMixModFactory.h.

ELlist_dest

typedef std::list<ELdestination *> edm::ELlist_dest

Definition at line 30 of file ELlist.h.

ELlist_string

typedef std::list<std::string> edm::ELlist_string

Definition at line 33 of file ELlist.h.

ELmap_counts

typedef std::map<ELextendedID, CountAndLimit> edm::ELmap_counts

Definition at line 86 of file ELmap.h.

ELmap_limits

typedef std::map<std::string, LimitAndTimespan> edm::ELmap_limits

Definition at line 84 of file ELmap.h.

ELmap_stats

typedef std::map<ELextendedID, StatsCount> edm::ELmap_stats

Definition at line 88 of file ELmap.h.

EntryDescriptionID

typedef Hash<EntryDescriptionType> edm::EntryDescriptionID

Definition at line 8 of file EntryDescriptionID.h.

EntryDescriptionMap

using edm::EntryDescriptionMap = typedef std::map<EntryDescriptionID, EventEntryDescription>

Definition at line 62 of file RootFile.h.

ESConsumesInfo

using edm::ESConsumesInfo = typedef std::vector<ESConsumesInfoEntry>

Definition at line 62 of file ESConsumesCollector.h.

EventEntryInfoVector

typedef std::vector<EventEntryInfo> edm::EventEntryInfoVector

Definition at line 50 of file EventEntryInfo.h.

EventNumber_t

typedef unsigned long long edm::EventNumber_t

Definition at line 12 of file RunLumiEventNumber.h.

EventSelectionID

typedef ParameterSetID edm::EventSelectionID

Definition at line 15 of file EventSelectionID.h.

EventSelectionIDVector

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

Definition at line 16 of file EventSelectionID.h.

FillViewHelperVector

typedef std::vector<std::pair<edm::ProductID, unsigned long> > edm::FillViewHelperVector

Definition at line 30 of file FillViewHelperVector.h.

FWGenericHandle

typedef Handle<FWGenericObject> edm::FWGenericHandle

Definition at line 125 of file FWGenericHandle.h.

GenericHandle

typedef Handle<GenericObject> edm::GenericHandle

Definition at line 121 of file GenericHandle.h.

HRTimeDiffType

typedef long long int edm::HRTimeDiffType

Definition at line 87 of file HRRealTime.h.

HRTimeType

typedef unsigned long long int edm::HRTimeType

Definition at line 88 of file HRRealTime.h.

InputSourcePluginFactory

typedef edmplugin::PluginFactory<ISFunc> edm::InputSourcePluginFactory

Definition at line 14 of file InputSourceFactory.h.

ISFunc

typedef InputSource*() edm::ISFunc(ParameterSet const &, InputSourceDescription const &)

Definition at line 12 of file InputSourceFactory.h.

ISVecFunc

typedef VectorInputSource*() edm::ISVecFunc(ParameterSet const &, VectorInputSourceDescription const &)

Definition at line 14 of file VectorInputSourceFactory.h.

LHCTransportLinkContainer

typedef std::vector<LHCTransportLink> edm::LHCTransportLinkContainer

Definition at line 8 of file LHCTransportLinkContainer.h.

LogAbsolute

using edm::LogAbsolute = typedef Log<level::System, true>

Definition at line 140 of file MessageLogger.h.

LogError

using edm::LogError = typedef Log<level::Error, false>

Definition at line 129 of file MessageLogger.h.

LogFwkInfo

using edm::LogFwkInfo = typedef Log<level::FwkInfo, false>

Definition at line 132 of file MessageLogger.h.

LogFwkVerbatim

using edm::LogFwkVerbatim = typedef Log<level::FwkInfo, true>

Definition at line 135 of file MessageLogger.h.

LogImportant

using edm::LogImportant = typedef Log<level::Error, true>

Definition at line 139 of file MessageLogger.h.

LogInfo

using edm::LogInfo = typedef Log<level::Info, false>

Definition at line 131 of file MessageLogger.h.

LogPrint

using edm::LogPrint = typedef Log<level::Warning, true>

Definition at line 136 of file MessageLogger.h.

LogProblem

using edm::LogProblem = typedef Log<level::Error, true>

Definition at line 137 of file MessageLogger.h.

LogSystem

using edm::LogSystem = typedef Log<level::System, false>

Definition at line 130 of file MessageLogger.h.

LogVerbatim

using edm::LogVerbatim = typedef Log<level::Info, true>

Definition at line 134 of file MessageLogger.h.

LogWarning

using edm::LogWarning = typedef Log<level::Warning, false>

Definition at line 128 of file MessageLogger.h.

LumiEntryInfo

typedef RunLumiEntryInfo edm::LumiEntryInfo

Definition at line 43 of file RunLumiEntryInfo.h.

LuminosityBlockNumber_t

typedef unsigned int edm::LuminosityBlockNumber_t

Definition at line 13 of file RunLumiEventNumber.h.

MakerPluginFactory

using edm::MakerPluginFactory = typedef edmplugin::PluginFactory<Maker*()>

Definition at line 9 of file MakerPluginFactory.h.

MaterialInformationContainer

typedef std::vector<MaterialInformation> edm::MaterialInformationContainer

Definition at line 48 of file MaterialInformation.h.

ModuleDescriptionID

typedef Hash<ModuleDescriptionType> edm::ModuleDescriptionID

Definition at line 62 of file classes.h.

ModuleTypeResolverMakerFactory

using edm::ModuleTypeResolverMakerFactory = typedef edmplugin::PluginFactory<ModuleTypeResolverMaker const*()>

Definition at line 12 of file ModuleTypeResolverMakerFactory.h.

OptionalThinnedKey

using edm::OptionalThinnedKey = typedef std::variant<unsigned int, detail::GetThinnedKeyFromExceptionFactory, std::monostate>

Definition at line 39 of file EDProductGetter.h.

ParameterSetDescriptionFillerPluginFactory

typedef edmplugin::PluginFactory<ParameterSetDescriptionFillerBase*(void)> edm::ParameterSetDescriptionFillerPluginFactory

Definition at line 30 of file ParameterSetDescriptionFillerPluginFactory.h.

ParameterSetID

typedef Hash<ParameterSetType> edm::ParameterSetID

Definition at line 21 of file ParameterSetID.h.

ParameterSetMap

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

Definition at line 39 of file ParameterSetConverter.h.

ParentageID

typedef Hash<ParentageType> edm::ParentageID

Definition at line 8 of file ParentageID.h.

PassID

typedef std::string edm::PassID

Definition at line 7 of file PassID.h.

PassiveHitContainer

typedef std::vector<PassiveHit> edm::PassiveHitContainer

Definition at line 100 of file PassiveHit.h.

PathStatus

using edm::PathStatus = typedef HLTPathStatus

Definition at line 7 of file PathStatus.h.

PCaloHitContainer

typedef std::vector<PCaloHit> edm::PCaloHitContainer

Definition at line 8 of file PCaloHitContainer.h.

Place_for_passing_exception_ptr

typedef std::shared_ptr<Pointer_to_new_exception_on_heap> edm::Place_for_passing_exception_ptr

Definition at line 13 of file ConfigurationHandshake.h.

Pointer_to_new_exception_on_heap

typedef std::shared_ptr<edm::Exception> edm::Pointer_to_new_exception_on_heap

Definition at line 10 of file ConfigurationHandshake.h.

PresenceFunc

typedef Presence*() edm::PresenceFunc()

Definition at line 13 of file PresenceFactory.h.

PresencePluginFactory

typedef edmplugin::PluginFactory<Presence*()> edm::PresencePluginFactory

Definition at line 11 of file PresenceFactory.h.

ProcessConfigurationID

typedef Hash<ProcessConfigurationType> edm::ProcessConfigurationID

Definition at line 8 of file ProcessConfigurationID.h.

ProcessConfigurationVector

typedef std::vector<ProcessConfiguration> edm::ProcessConfigurationVector

Definition at line 62 of file ProcessConfiguration.h.

ProcessHistoryID

typedef Hash<ProcessHistoryType> edm::ProcessHistoryID

Definition at line 8 of file ProcessHistoryID.h.

ProcessHistoryMap

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

Definition at line 15 of file ProcessHistoryRegistry.h.

ProcessHistoryVector

typedef std::vector<ProcessHistory> edm::ProcessHistoryVector

Definition at line 16 of file ProcessHistoryRegistry.h.

ProcessIndex

typedef unsigned short edm::ProcessIndex

Definition at line 25 of file ProductID.h.

ProcessingTask

typedef std::string edm::ProcessingTask

Definition at line 7 of file ProcessingTask.h.

ProductIndex

typedef unsigned short edm::ProductIndex

Definition at line 26 of file ProductID.h.

ProductProvenanceVector

typedef std::vector<ProductProvenance> edm::ProductProvenanceVector

Definition at line 60 of file ProductProvenance.h.

ProductResolverIndex

typedef unsigned int edm::ProductResolverIndex

Definition at line 8 of file ProductResolverIndex.h.

PSimHitContainer

typedef std::vector<PSimHit> edm::PSimHitContainer

Definition at line 11 of file PSimHitContainer.h.

Record2Factories

using edm::Record2Factories = typedef std::multimap<EventSetupRecordKey, FactoryInfo>

Definition at line 28 of file ESProductResolverFactoryProducer.cc.

ReleaseVersion

typedef std::string edm::ReleaseVersion

Definition at line 6 of file ReleaseVersion.h.

RunEntryInfo

typedef RunLumiEntryInfo edm::RunEntryInfo

Definition at line 44 of file RunLumiEntryInfo.h.

RunNumber_t

typedef unsigned int edm::RunNumber_t

Definition at line 14 of file RunLumiEventNumber.h.

SelectedProducts

typedef std::vector<std::pair<BranchDescription const *, EDGetToken> > edm::SelectedProducts

Definition at line 11 of file SelectedProducts.h.

SelectedProductsForBranchType

typedef std::array<SelectedProducts, NumBranchTypes> edm::SelectedProductsForBranchType

Definition at line 13 of file SelectedProducts.h.

SendDescs

typedef std::vector<BranchDescription> edm::SendDescs

Definition at line 100 of file StreamedProducts.h.

SendProds

typedef std::vector<StreamedProduct> edm::SendProds

Definition at line 67 of file StreamedProducts.h.

SimTrackContainer

typedef std::vector<SimTrack> edm::SimTrackContainer

Definition at line 12 of file SimTrackContainer.h.

SimVertexContainer

typedef std::vector<SimVertex> edm::SimVertexContainer

Definition at line 12 of file SimVertexContainer.h.

SimVertexRef

typedef edm::Ref<std::vector<SimVertex> > edm::SimVertexRef

Definition at line 13 of file SimVertexContainer.h.

SimVertexRefProd

typedef edm::RefProd<std::vector<SimVertex> > edm::SimVertexRefProd

Definition at line 14 of file SimVertexContainer.h.

SimVertexRefVector

typedef edm::RefVector<std::vector<SimVertex> > edm::SimVertexRefVector

Definition at line 15 of file SimVertexContainer.h.

StoredProductProvenanceVector

typedef std::vector<StoredProductProvenance> edm::StoredProductProvenanceVector

Definition at line 34 of file StoredProductProvenance.h.

Strings

using edm::Strings = typedef EventSelector::Strings

Definition at line 48 of file EventSelector.cc.

StringVector

typedef std::vector<std::string> edm::StringVector

Definition at line 16 of file ParameterSetConverter.h.

TimeValue_t

typedef unsigned long long edm::TimeValue_t

Definition at line 21 of file Timestamp.h.

Trig

typedef detail::TriggerResultsBasedEventSelector::handle_t edm::Trig

Definition at line 16 of file StreamerOutputModuleBase.h.

VCBDP

typedef std::vector< edm::BranchDescription const * > edm::VCBDP

Definition at line 16 of file ProductSelector.cc.

VectorInputSourcePluginFactory

typedef edmplugin::PluginFactory<ISVecFunc> edm::VectorInputSourcePluginFactory

Definition at line 15 of file VectorInputSourceFactory.h.

VParameterSet

typedef std::vector<ParameterSet> edm::VParameterSet

Definition at line 35 of file ParameterSet.h.

vstring

typedef std::vector< std::string > edm::vstring

Definition at line 482 of file Schedule.cc.

Enumeration Type Documentation

BranchActionType

enum edm::BranchActionType

Enumerator
BranchActionGlobalBegin
BranchActionStreamBegin
BranchActionStreamEnd
BranchActionGlobalEnd
BranchActionProcessBlockInput

Definition at line 11 of file BranchActionType.h.

                        {
    BranchActionGlobalBegin = 0,
    BranchActionStreamBegin = 1,
    BranchActionStreamEnd = 2,
    BranchActionGlobalEnd = 3,
    BranchActionProcessBlockInput = 4
  };

BranchType

enum edm::BranchType

Enumerator
InEvent
InLumi
InRun
InProcess
NumBranchTypes

Definition at line 11 of file BranchType.h.

{ InEvent = 0, InLumi = 1, InRun = 2, InProcess = 3, NumBranchTypes };

CatalogType

enum edm::CatalogType

strong

Enumerator
TrivialCatalog
RucioCatalog

Definition at line 47 of file SiteLocalConfig.h.

{ TrivialCatalog, RucioCatalog };

EDMModuleType

enum edm::EDMModuleType

strong

Enumerator
kUnknown
kSource
kESSource
kESProducer
kEDAnalyzer
kEDProducer
kEDFilter
kOutputModule

Definition at line 8 of file EDMModuleType.h.

                           {
    kUnknown,
    kSource,
    kESSource,
    kESProducer,
    kEDAnalyzer,
    kEDProducer,
    kEDFilter,
    kOutputModule
  };

HashedTypes

enum edm::HashedTypes

Enumerator
ModuleDescriptionType
ParameterSetType
ProcessHistoryType
ProcessConfigurationType
EntryDescriptionType
ParentageType

Definition at line 8 of file HashedTypes.h.

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

InputType

enum edm::InputType

strong

Enumerator
Primary
SecondaryFile
SecondarySource

Definition at line 5 of file InputType.h.

{ Primary, SecondaryFile, SecondarySource };

JobMode

enum edm::JobMode

Enumerator
GridJobMode
ReleaseValidationJobMode
AnalysisJobMode
NilJobMode

Definition at line 15 of file JobMode.h.

{ GridJobMode, ReleaseValidationJobMode, AnalysisJobMode, NilJobMode };

KindOfType

enum edm::KindOfType

Enumerator
PRODUCT_TYPE
ELEMENT_TYPE

Definition at line 5 of file ProductKindOfType.h.

{ PRODUCT_TYPE, ELEMENT_TYPE };

ParameterTypes

enum edm::ParameterTypes

Enumerator
k_int32
k_vint32
k_uint32
k_vuint32
k_int64
k_vint64
k_uint64
k_vuint64
k_double
k_vdouble
k_bool
k_stringRaw
k_vstringRaw
k_stringHex
k_vstringHex
k_EventID
k_VEventID
k_LuminosityBlockID
k_VLuminosityBlockID
k_InputTag
k_VInputTag
k_ESInputTag
k_VESInputTag
k_FileInPath
k_LuminosityBlockRange
k_VLuminosityBlockRange
k_EventRange
k_VEventRange
k_PSet
k_VPSet

Definition at line 33 of file ParameterDescriptionNode.h.

                      {
    k_int32 = 'I',
    k_vint32 = 'i',
    k_uint32 = 'U',
    k_vuint32 = 'u',
    k_int64 = 'L',
    k_vint64 = 'l',
    k_uint64 = 'X',
    k_vuint64 = 'x',
    k_double = 'D',
    k_vdouble = 'd',
    k_bool = 'B',
    k_stringRaw = 'Z',
    k_vstringRaw = 'z',
    k_stringHex = 'S',
    k_vstringHex = 's',
    k_EventID = 'E',
    k_VEventID = 'e',
    k_LuminosityBlockID = 'M',
    k_VLuminosityBlockID = 'm',
    k_InputTag = 't',
    k_VInputTag = 'v',
    k_ESInputTag = 'g',
    k_VESInputTag = 'G',
    k_FileInPath = 'F',
    k_LuminosityBlockRange = 'A',
    k_VLuminosityBlockRange = 'a',
    k_EventRange = 'R',
    k_VEventRange = 'r',
    k_PSet = 'Q',
    k_VPSet = 'q'
  };

ProductResolverIndexValues

enum edm::ProductResolverIndexValues

Enumerator
ProductResolverIndexValuesBit
ProductResolverIndexInvalid
ProductResolverIndexInitializing
ProductResolverIndexAmbiguous

Definition at line 10 of file ProductResolverIndex.h.

                                  {

    // All values of the ProductResolverIndex in this enumeration should
    // have this bit set to 1,
    ProductResolverIndexValuesBit = 1U << 30,

    ProductResolverIndexInvalid = std::numeric_limits<unsigned int>::max(),
    ProductResolverIndexInitializing = std::numeric_limits<unsigned int>::max() - 1,
    ProductResolverIndexAmbiguous = std::numeric_limits<unsigned int>::max() - 2
  };

StreamerCompressionAlgo

enum edm::StreamerCompressionAlgo

Enumerator
UNCOMPRESSED
ZLIB
LZMA
ZSTD

Definition at line 66 of file StreamSerializer.h.

{ UNCOMPRESSED = 0, ZLIB = 1, LZMA = 2, ZSTD = 4 };

TerminationOrigin

enum edm::TerminationOrigin

strong

Enumerator
ExceptionFromThisContext
ExceptionFromAnotherContext
ExternalSignal

Definition at line 28 of file TerminationOrigin.h.

{ ExceptionFromThisContext, ExceptionFromAnotherContext, ExternalSignal };

ThinnedRefSetMode

enum edm::ThinnedRefSetMode

strong

Enumerator
throwOnInvalidParentRef
ignoreInvalidParentRef

Definition at line 54 of file ThinnedRefSet.h.

{ throwOnInvalidParentRef, ignoreInvalidParentRef };

Transition

enum edm::Transition

strong

Enumerator
Event
BeginLuminosityBlock
EndLuminosityBlock
BeginRun
EndRun
BeginProcessBlock
EndProcessBlock
AccessInputProcessBlock
NumberOfTransitions
NumberOfEventSetupTransitions

Definition at line 12 of file Transition.h.

                        {
    Event,
    BeginLuminosityBlock,
    EndLuminosityBlock,
    BeginRun,
    EndRun,
    BeginProcessBlock,
    EndProcessBlock,
    AccessInputProcessBlock,
    NumberOfTransitions,
    NumberOfEventSetupTransitions = BeginProcessBlock
  };

WildcardValidationCriteria

enum edm::WildcardValidationCriteria

Enumerator
RequireZeroOrMore
RequireAtLeastOne
RequireExactlyOne

Definition at line 17 of file ParameterWildcardBase.h.

{ RequireZeroOrMore, RequireAtLeastOne, RequireExactlyOne };

Function Documentation

addContextAndPrintException()

void edm::addContextAndPrintException	(	char const *	context,
		cms::Exception &	ex,
		bool	disablePrint
	)

Definition at line 11 of file ExceptionHelpers.cc.

References cms::Exception::addContext(), visDQMUpload::context, edm::Service< T >::isAvailable(), printCmsException(), cms::Exception::returnCode(), cms::Exception::setAlreadyPrinted(), and mitigatedMETSequence_cff::U.

Referenced by callWithTryCatchAndPrint(), edm::StreamSchedule::finishProcessOneEvent(), edm::GlobalSchedule::processOneGlobalAsync(), edm::StreamSchedule::processOneStreamAsync(), and edm::SecondaryEventProvider::setupPileUpEvent().

                                                                                             {
    if (context != nullptr && strlen(context) != 0U) {
      ex.addContext(context);
    }
    if (!disablePrint) {
      Service<JobReport> jobReportSvc;
      if (jobReportSvc.isAvailable()) {
        JobReport* jobRep = jobReportSvc.operator->();
        edm::printCmsException(ex, jobRep, ex.returnCode());
      } else {
        edm::printCmsException(ex);
      }
      ex.setAlreadyPrinted();
    }
  }

addToMissingDictionariesException()

void edm::addToMissingDictionariesException	(	edm::Exception &	exception,
		std::vector< std::string > &	missingDictionaries,
		std::string const &	context
	)

Definition at line 168 of file DictionaryTools.cc.

References visDQMUpload::context, cppFunctionSkipper::exception, B2GTnPMonitor_cfi::item, jetUpdater_cfi::sort, and tier0::unique().

Referenced by throwMissingDictionariesException().

                                                                   {
    std::sort(missingDictionaries.begin(), missingDictionaries.end());
    missingDictionaries.erase(std::unique(missingDictionaries.begin(), missingDictionaries.end()),
                              missingDictionaries.end());

    std::ostringstream ostr;
    for (auto const& item : missingDictionaries) {
      ostr << "  " << item << "\n";
    }
    exception << "No data dictionary found for the following classes:\n\n"
              << ostr.str() << "\n"
              << "Most likely each dictionary was never generated, but it may\n"
              << "be that it was generated in the wrong package. Please add\n"
              << "(or move) the specification \'<class name=\"whatever\"/>\' to\n"
              << "the appropriate classes_def.xml file along with any other\n"
              << "information needed there. For example, if this class has any\n"
              << "transient members, you need to specify them in classes_def.xml.\n"
              << "Also include the class header in classes.h\n";

    if (!context.empty()) {
      exception.addContext(context);
    }
  }

allowedValues()

template<typename T , typename... ARGS>

std::unique_ptr<edm::ParameterDescriptionCases<T> > edm::allowedValues

(

ARGS &&...

args

)

Definition at line 38 of file allowedValues.h.

References writedatasetfile::args.

                                                                               {
    return (... || (std::forward<ARGS>(args) >> edm::EmptyGroupDescription()));
  }

appendCurrentProcessIfAlias()

static std::string edm::appendCurrentProcessIfAlias ( std::string const &  processFromInputTag, std::string const &  currentProcess  )

static

Definition at line 36 of file Principal.cc.

References edm::InputTag::kCurrentProcess, and AlCaHLTBitMon_QueryRunRegistry::string.

Referenced by edm::Principal::findProductByLabel(), and edm::Principal::getByLabel().

                                                                                  {
    if (processFromInputTag == InputTag::kCurrentProcess) {
      std::string returnValue = processFromInputTag;
      returnValue += " (";
      returnValue += currentProcess;
      returnValue += ")";
      return returnValue;
    }
    return processFromInputTag;
  }

beginGlobalTransitionAsync()

template<typename Traits >

void edm::beginGlobalTransitionAsync	(	WaitingTaskHolder	iWait,
		Schedule &	iSchedule,
		typename Traits::TransitionInfoType &	transitionInfo,
		ServiceToken const &	token,
		std::vector< SubProcess > &	iSubProcesses,
		bool	cleaningUpAfterException = false
	)

Definition at line 81 of file globalTransitionAsync.h.

References edm::waiting_task::chain::first(), info(), eostools::move(), edm::Schedule::processOneGlobalAsync(), edm::waiting_task::chain::runLast(), edm::waiting_task::chain::then(), and unpackBuffers-CaloStage2::token.

                                                                         {
    // When we are done processing the global for this process,
    // we need to run the global for all SubProcesses
    using namespace edm::waiting_task;

    chain::first([&](auto nextTask) {
      iSchedule.processOneGlobalAsync<Traits>(std::move(nextTask), transitionInfo, token, cleaningUpAfterException);
    }) |
        chain::then([&iSubProcesses, info = transitionInfo, cleaningUpAfterException](std::exception_ptr const* iPtr,
                                                                                      auto nextTask) {
          if (iPtr) {
            //delay handling exception until after subProcesses run
            chain::first([&](auto nextTask) {
              for (auto& subProcess : iSubProcesses) {
                subProcessDoGlobalBeginTransitionAsync<Traits>(nextTask, subProcess, info, cleaningUpAfterException);
              }
            }) | chain::then([excpt = *iPtr](std::exception_ptr const*, auto nextTask) {
              nextTask.doneWaiting(excpt);
            }) | chain::runLast(nextTask);
          } else {
            for (auto& subProcess : iSubProcesses) {
              subProcessDoGlobalBeginTransitionAsync<Traits>(nextTask, subProcess, info, cleaningUpAfterException);
            }
          }
        }) |
        chain::runLast(iWait);
  }

beginStreamsTransitionAsync()

template<typename Traits >

void edm::beginStreamsTransitionAsync	(	WaitingTaskHolder	iWait,
		Schedule &	iSchedule,
		unsigned int	iNStreams,
		typename Traits::TransitionInfoType &	transitionInfo,
		ServiceToken const &	token,
		std::vector< SubProcess > &	iSubProcesses
	)

Definition at line 98 of file streamTransitionAsync.h.

References mps_fire::i, and unpackBuffers-CaloStage2::token.

                                                                         {
    for (unsigned int i = 0; i < iNStreams; ++i) {
      beginStreamTransitionAsync<Traits>(iWait, iSchedule, i, transitionInfo, token, iSubProcesses);
    }
  }

beginStreamTransitionAsync()

template<typename Traits >

void edm::beginStreamTransitionAsync	(	WaitingTaskHolder	iWait,
		Schedule &	iSchedule,
		unsigned int	iStreamIndex,
		typename Traits::TransitionInfoType &	transitionInfo,
		ServiceToken const &	token,
		std::vector< SubProcess > &	iSubProcesses
	)

Definition at line 64 of file streamTransitionAsync.h.

References edm::waiting_task::chain::first(), info(), eostools::move(), edm::Schedule::processOneStreamAsync(), edm::waiting_task::chain::runLast(), subProcessDoStreamBeginTransitionAsync(), edm::waiting_task::chain::then(), and unpackBuffers-CaloStage2::token.

                                                                        {
    //When we are done processing the stream for this process,
    // we need to run the stream for all SubProcesses
    //NOTE: The subprocesses set their own service tokens
    using namespace edm::waiting_task;
    chain::first([&](auto nextTask) {
      iSchedule.processOneStreamAsync<Traits>(std::move(nextTask), iStreamIndex, transitionInfo, token);
    }) |
        chain::then(
            [&iSubProcesses, iStreamIndex, info = transitionInfo](std::exception_ptr const* iPtr, auto nextTask) {
              if (iPtr) {
                auto excpt = *iPtr;
                //defer handling exception until after sub processes run
                chain::first([&](std::exception_ptr const*, auto nextTask) {
                  for (auto& subProcess : iSubProcesses) {
                    subProcessDoStreamBeginTransitionAsync(nextTask, subProcess, iStreamIndex, info);
                  };
                }) | chain::then([excpt](std::exception_ptr const*, auto nextTask) { nextTask.doneWaiting(excpt); }) |
                    chain::runLast(nextTask);
              } else {
                for (auto& subProcess : iSubProcesses) {
                  subProcessDoStreamBeginTransitionAsync(nextTask, subProcess, iStreamIndex, info);
                };
              }
            }) |
        chain::runLast(iWait);
  }

binary_search_all() [1/2]

template<typename ForwardSequence , typename Datum >

bool edm::binary_search_all ( ForwardSequence const &  s, Datum const &  d  )

inline

wrappers for std::binary_search

Definition at line 58 of file Algorithms.h.

References ztail::d, and alignCSCRings::s.

Referenced by edm::EventContentAnalyzer::analyze(), CaloVNoiseSignalGenerator::contains(), edm::MixingModule::MixingModule(), edm::ProductSelector::selected(), and edm::EventSkipperByID::skipIt().

                                                                          {
    return std::binary_search(s.begin(), s.end(), d);
  }

binary_search_all() [2/2]

template<typename ForwardSequence , typename Datum , typename Predicate >

bool edm::binary_search_all ( ForwardSequence const &  s, Datum const &  d, Predicate  p  )

inline

Definition at line 63 of file Algorithms.h.

References ztail::d, AlCaHLTBitMon_ParallelJobs::p, and alignCSCRings::s.

                                                                                       {
    return std::binary_search(s.begin(), s.end(), d, p);
  }

bit_cast()

template<class To , class From >

To edm::bit_cast ( const From &  src )

inlinenoexcept

Definition at line 29 of file bit_cast.h.

References math::cholesky::dst, and TrackRefitter_38T_cff::src.

Referenced by atomicMaxF(), MiniFloatConverter::denorm_min(), MiniFloatConverter::float16to32(), MiniFloatConverter::float32to16crop(), MiniFloatConverter::float32to16round(), MiniFloatConverter::max(), MiniFloatConverter::max32RoundedToMax16(), MiniFloatConverter::min(), MiniFloatConverter::min32RoundedToMin16(), MiniFloatConverter::ReduceMantissaToNbitsRounding::operator()(), and MiniFloatConverter::reduceMantissaToNbits().

                                               {
    static_assert(sizeof(To) == sizeof(From), "incompatible types");
    To dst;
    std::memcpy(&dst, &src, sizeof(To));
    return dst;
  }

branchIDToProductID()

ProductID edm::branchIDToProductID	(	BranchID const &	bid,
		BranchIDListHelper const &	branchIDListHelper,
		std::vector< ProcessIndex > const &	branchListIndexToProcessIndex
	)

Definition at line 18 of file branchIDToProductID.cc.

References edm::BranchIDListHelper::branchIDToIndexMap(), Exception, edm::BranchID::isValid(), ALPAKA_ACCELERATOR_NAMESPACE::vertexFinder::it, SiStripPI::max, edm::errors::NotFound, FastTimerService_cff::range, and findQualityFiles::v.

Referenced by edm::EventPrincipal::branchIDToProductID(), and ProvenanceDumper::work_().

                                                                                              {
    if (not bid.isValid()) {
      throw Exception(errors::NotFound, "InvalidID") << "branchIDToProductID: invalid BranchID supplied\n";
    }

    auto range = branchIDListHelper.branchIDToIndexMap().equal_range(bid);
    for (auto it = range.first; it != range.second; ++it) {
      edm::BranchListIndex blix = it->second.first;
      if (blix < branchListIndexToProcessIndex.size()) {
        auto v = branchListIndexToProcessIndex[blix];
        if (v != std::numeric_limits<edm::BranchListIndex>::max()) {
          edm::ProductIndex productIndex = it->second.second;
          edm::ProcessIndex processIndex = v;
          return edm::ProductID(processIndex + 1, productIndex + 1);
        }
      }
    }
    // cannot throw, because some products may legitimately not have product ID's (e.g. pile-up).
    return edm::ProductID();
  }

BranchTypeToAuxBranchName()

std::string const & edm::BranchTypeToAuxBranchName

(

BranchType const &

branchType

)

Definition at line 122 of file BranchType.cc.

References cms::cuda::assert().

Referenced by fwlite::Event::Event().

                                                                           {
    assert(branchType < eventLumiRunSize);
    return auxNames[branchType];
  }

BranchTypeToAuxiliaryBranchName()

std::string const & edm::BranchTypeToAuxiliaryBranchName

(

BranchType const &

branchType

)

Definition at line 116 of file BranchType.cc.

References cms::cuda::assert().

Referenced by fwlite::Event::Event(), fwlite::EntryFinder::fillIndex(), edm::PoolOutputModule::fillSelectedItemList(), fwlite::LuminosityBlock::LuminosityBlock(), TFWLiteSelectorBasic::Process(), edm::RootFile::RootFile(), edm::RootOutputFile::RootOutputFile(), fwlite::Run::Run(), edm::RootTree::startTraining(), and edm::RootOutputFile::writeEventAuxiliary().

                                                                                 {
    assert(branchType < eventLumiRunSize);
    return auxiliaryNames[branchType];
  }

BranchTypeToBranchEntryInfoBranchName()

std::string const & edm::BranchTypeToBranchEntryInfoBranchName

(

BranchType const &

branchType

)

Definition at line 134 of file BranchType.cc.

References cms::cuda::assert().

Referenced by fwlite::internal::BranchMapReaderStrategyV8::updateFile(), and ProvenanceDumper::work_().

                                                                                       {
    assert(branchType < eventLumiRunSize);
    return eventEntryInfoNames[branchType];
  }

BranchTypeToInfoTreeName()

std::string const & edm::BranchTypeToInfoTreeName

(

BranchType const &

branchType

)

Definition at line 111 of file BranchType.cc.

References cms::cuda::assert().

Referenced by edm::RootTree::RootTree().

                                                                          {
    assert(branchType < eventLumiRunSize);
    return infoNames[branchType];
  }

BranchTypeToMetaDataTreeName()

std::string const & edm::BranchTypeToMetaDataTreeName

(

BranchType const &

branchType

)

Definition at line 105 of file BranchType.cc.

References cms::cuda::assert().

Referenced by edm::RootTree::RootTree(), and ProvenanceDumper::work_().

                                                                              {
    assert(branchType < eventLumiRunSize);
    return metaTreeNames[branchType];
  }

BranchTypeToProductProvenanceBranchName()

std::string const & edm::BranchTypeToProductProvenanceBranchName

(

BranchType const &

BranchType

)

Definition at line 139 of file BranchType.cc.

References cms::cuda::assert().

Referenced by edm::ReducedProvenanceReader::ReducedProvenanceReader(), edm::RootOutputFile::RootOutputFile(), and ProvenanceDumper::work_().

                                                                                         {
    assert(branchType < eventLumiRunSize);
    return productProvenanceNames[branchType];
  }

BranchTypeToProductStatusBranchName()

std::string const & edm::BranchTypeToProductStatusBranchName

(

BranchType const &

branchType

)

Definition at line 128 of file BranchType.cc.

References cms::cuda::assert().

                                                                                     {
    assert(branchType < eventLumiRunSize);
    return productStatusNames[branchType];
  }

BranchTypeToProductTreeName() [1/2]

std::string const & edm::BranchTypeToProductTreeName

(

BranchType const &

branchType

)

Definition at line 95 of file BranchType.cc.

References cms::cuda::assert().

Referenced by edm::RootTree::RootTree(), and ProvenanceDumper::work_().

                                                                             {
    assert(branchType < eventLumiRunSize);
    return treeNames[branchType];
  }

BranchTypeToProductTreeName() [2/2]

std::string edm::BranchTypeToProductTreeName	(	BranchType const &	branchType,
		std::string const &	processName
	)

Definition at line 100 of file BranchType.cc.

References cms::cuda::assert(), InProcess, and SimL1EmulatorRepack_CalouGT_cff::processName.

                                                                                                    {
    assert(branchType == InProcess);
    return branchTypeNames[InProcess] + "s" + processName;
  }

BranchTypeToString()

std::string const & edm::BranchTypeToString

(

BranchType const &

branchType

)

Definition at line 93 of file BranchType.cc.

Referenced by operator<<(), and edm::EDConsumerBase::throwBranchMismatch().

{ return branchTypeNames[branchType]; }

callWithTryCatchAndPrint()

template<typename TReturn >

TReturn edm::callWithTryCatchAndPrint	(	std::function< TReturn(void)>	iFunc,
		char const *	context = nullptr,
		bool	disablePrint = false
	)

Definition at line 49 of file ExceptionHelpers.h.

References addContextAndPrintException(), visDQMUpload::context, and edm::convertException::wrap().

                                                              {
    try {
      return convertException::wrap([iFunc]() { return iFunc(); });
    } catch (cms::Exception& ex) {
      addContextAndPrintException(context, ex, disablePrint);
      throw;
    }
    return TReturn();
  }

check()

template<typename T >

static void edm::check ( T const &  p, std::string const &  id, SelectedProducts const &  iProducts, bool  iVerbose  )

static

Definition at line 84 of file GetProductCheckerOutputModule.cc.

References edm::Provenance::branchDescription(), edm::BranchDescription::branchID(), Exception, edm::BasicHandle::isValid(), edm::BranchDescription::moduleLabel(), AlCaHLTBitMon_ParallelJobs::p, edm::BranchDescription::processName(), edm::BranchDescription::productInstanceName(), edm::BasicHandle::provenance(), unpackBuffers-CaloStage2::token, and edm::BranchDescription::unwrappedTypeID().

Referenced by SegmentsTrackAssociator::associate(), edm::ProductSelector::checkForDuplicateKeptBranch(), DDDWorld::DDDWorld(), L1TMenuHelper::getLUSOTrigger(), edm::StreamerInputFile::openStreamerFile(), edm::DataMixingMuonWorker::putMuon(), edm::GetProductCheckerOutputModule::write(), edm::GetProductCheckerOutputModule::writeLuminosityBlock(), and edm::GetProductCheckerOutputModule::writeRun().

                                                                                                       {
    for (auto const& product : iProducts) {
      BranchDescription const* branchDescription = product.first;
      TypeID const& tid = branchDescription->unwrappedTypeID();
      EDGetToken const& token = product.second;
      BasicHandle bh = p.getByToken(token, tid);
      if (iVerbose) {
        if (bh.isValid()) {
          edm::LogInfo("FoundProduct") << "found " << branchDescription->moduleLabel() << " '"
                                       << branchDescription->productInstanceName() << "' "
                                       << branchDescription->processName();
        } else {
          edm::LogInfo("DidNotFindProduct")
              << "did not find " << branchDescription->moduleLabel() << " '" << branchDescription->productInstanceName()
              << "' " << branchDescription->processName();
        }
      }
      if (nullptr != bh.provenance() &&
          bh.provenance()->branchDescription().branchID() != branchDescription->branchID()) {
        throw cms::Exception("BranchIDMissMatch")
            << "While processing " << id << " getByToken request for " << branchDescription->moduleLabel() << " '"
            << branchDescription->productInstanceName() << "' " << branchDescription->processName()
            << "\n should have returned BranchID " << branchDescription->branchID() << " but returned BranchID "
            << bh.provenance()->branchDescription().branchID() << "\n";
      }
    }
  }

checkClassDictionaries() [1/2]

bool edm::checkClassDictionaries	(	std::vector< std::string > &	missingDictionaries,
		TypeID const &	typeID
	)

Definition at line 103 of file DictionaryTools.cc.

References edm::TypeWithDict::byName(), haddnano::cl, edm::TypeID::className(), runTheMatrix::const, hasDictionary(), B2GTnPMonitor_cfi::item, mps_fire::result, and edm::TypeID::typeInfo().

Referenced by edm::ProductRegistryHelper::addToRegistry(), edm::ProductRegistry::checkDictionariesOfConsumedTypes(), edm::ProductRegistry::initializeLookupTables(), and loadCap().

                                                                                               {
    // For a class type with a dictionary the TClass* will be
    // non-null and hasDictionary will return true.
    // For a type like "int", the TClass* pointer will be a
    // nullptr and hasDictionary will return true.
    // For a class type without a dictionary it is possible for
    // TClass* to be non-null and hasDictionary to return false.

    TClass* tClass = TClass::GetClass(typeID.typeInfo());
    if (!hasDictionary(typeID.typeInfo())) {
      // a second attempt to load
      TypeWithDict::byName(typeID.className());
      tClass = TClass::GetClass(typeID.typeInfo());
    }
    if (!hasDictionary(typeID.typeInfo())) {
      missingDictionaries.emplace_back(typeID.className());
      return false;
    }

    if (tClass == nullptr) {
      return true;
    }

    bool result = true;

    THashTable hashTable;
    bool recursive = true;
    tClass->GetMissingDictionaries(hashTable, recursive);

    for (auto const& item : hashTable) {
      TClass const* cl = static_cast<TClass const*>(item);
      missingDictionaries.emplace_back(cl->GetName());
      result = false;
    }
    return result;
  }

checkClassDictionaries() [2/2]

bool edm::checkClassDictionaries	(	std::vector< std::string > &	missingDictionaries,
		std::string const &	name,
		TypeWithDict const &	typeWithDict
	)

Definition at line 140 of file DictionaryTools.cc.

References haddnano::cl, runTheMatrix::const, edm::TypeWithDict::getClass(), edm::TypeWithDict::invalidTypeInfo(), B2GTnPMonitor_cfi::item, Skims_PA_cff::name, and mps_fire::result.

                                                                {
    if (!bool(typeWithDict) || typeWithDict.invalidTypeInfo()) {
      missingDictionaries.emplace_back(name);
      return false;
    }

    TClass* tClass = typeWithDict.getClass();
    if (tClass == nullptr) {
      missingDictionaries.emplace_back(name);
      return false;
    }

    THashTable hashTable;
    bool recursive = true;
    tClass->GetMissingDictionaries(hashTable, recursive);

    bool result = true;

    for (auto const& item : hashTable) {
      TClass const* cl = static_cast<TClass const*>(item);
      missingDictionaries.emplace_back(cl->GetName());
      result = false;
    }
    return result;
  }

checkDictionary() [1/2]

bool edm::checkDictionary	(	std::vector< std::string > &	missingDictionaries,
		TypeID const &	typeID
	)

Definition at line 68 of file DictionaryTools.cc.

References edm::TypeWithDict::byName(), edm::TypeID::className(), hasDictionary(), and edm::TypeID::typeInfo().

Referenced by edm::ProductRegistryHelper::addToRegistry(), edm::ProductRegistry::checkDictionariesOfConsumedTypes(), checkDictionaryOfWrappedType(), edm::ProductRegistry::initializeLookupTables(), edm::core::OutputModuleCore::keepThisBranch(), and public_base_classes().

                                                                                        {
    TClass::GetClass(typeID.typeInfo());
    if (!hasDictionary(typeID.typeInfo())) {
      // a second attempt to load
      TypeWithDict::byName(typeID.className());
    }
    if (!hasDictionary(typeID.typeInfo())) {
      missingDictionaries.emplace_back(typeID.className());
      return false;
    }
    return true;
  }

checkDictionary() [2/2]

bool edm::checkDictionary	(	std::vector< std::string > &	missingDictionaries,
		std::string const &	name,
		TypeWithDict const &	typeWithDict
	)

Definition at line 93 of file DictionaryTools.cc.

References edm::TypeWithDict::invalidTypeInfo(), and Skims_PA_cff::name.

                                                         {
    if (!bool(typeWithDict) || typeWithDict.invalidTypeInfo()) {
      missingDictionaries.emplace_back(name);
      return false;
    }
    return true;
  }

checkDictionaryOfWrappedType() [1/2]

bool edm::checkDictionaryOfWrappedType	(	std::vector< std::string > &	missingDictionaries,
		TypeID const &	unwrappedTypeID
	)

Definition at line 81 of file DictionaryTools.cc.

References edm::TypeWithDict::byName(), checkDictionary(), edm::TypeID::className(), AlCaHLTBitMon_QueryRunRegistry::string, and wrappedClassName().

Referenced by edm::ProductRegistryHelper::addToRegistry(), and edm::ProductRegistry::initializeLookupTables().

                                                                                                              {
    std::string wrappedName = wrappedClassName(unwrappedTypeID.className());
    TypeWithDict wrappedTypeWithDict = TypeWithDict::byName(wrappedName);
    return checkDictionary(missingDictionaries, wrappedName, wrappedTypeWithDict);
  }

checkDictionaryOfWrappedType() [2/2]

bool edm::checkDictionaryOfWrappedType	(	std::vector< std::string > &	missingDictionaries,
		std::string const &	unwrappedName
	)

Definition at line 87 of file DictionaryTools.cc.

References edm::TypeWithDict::byName(), checkDictionary(), AlCaHLTBitMon_QueryRunRegistry::string, and wrappedClassName().

                                                                                                               {
    std::string wrappedName = wrappedClassName(unwrappedName);
    TypeWithDict wrappedTypeWithDict = TypeWithDict::byName(wrappedName);
    return checkDictionary(missingDictionaries, wrappedName, wrappedTypeWithDict);
  }

checkForModuleDependencyCorrectness()

void edm::checkForModuleDependencyCorrectness	(	edm::PathsAndConsumesOfModulesBase const &	iPnC,
		bool	iPrintDependencies
	)

Definition at line 354 of file PathsAndConsumesOfModules.cc.

References edm::PathsAndConsumesOfModulesBase::allModules(), cms::cuda::assert(), ALPAKA_ACCELERATOR_NAMESPACE::brokenline::constexpr(), submitPVResolutionJobs::count, symbols::deps, makeListRunsInFiles::description, relativeConstraints::empty, edm::PathsAndConsumesOfModulesBase::endPaths(), Exception, spr::find(), newFWLiteAna::found, mps_fire::i, l1ctLayer2EG_cff::id, dqmiolumiharvest::j, kInvalidIndex, lastIndex, SiStripPI::max, mod(), edm::PathsAndConsumesOfModulesBase::modulesOnEndPath(), edm::PathsAndConsumesOfModulesBase::modulesOnPath(), edm::PathsAndConsumesOfModulesBase::modulesWhoseProductsAreConsumedBy(), eostools::move(), hltrates_dqm_sourceclient-live_cfg::offset, operator==(), AlCaHLTBitMon_ParallelJobs::p, hltMonBTagIPClient_cfi::pathName, Skims_PA_cff::paths, edm::PathsAndConsumesOfModulesBase::paths(), alignCSCRings::s, edm::errors::ScheduleExecutionFailure, second(), mps_update::status, and AlCaHLTBitMon_QueryRunRegistry::string.

Referenced by edm::EventProcessor::beginJob(), and edm::SubProcess::keepOnlyConsumedUnscheduledModules().

                                                                                                                  {
    constexpr auto kInvalidIndex = std::numeric_limits<unsigned int>::max();

    //Need to lookup ids to names quickly
    std::unordered_map<unsigned int, std::string> moduleIndexToNames;

    std::unordered_map<std::string, unsigned int> pathStatusInserterModuleLabelToModuleID;

    //for testing, state that TriggerResults is at the end of all paths
    const std::string kTriggerResults("TriggerResults");
    const std::string kPathStatusInserter("PathStatusInserter");
    const std::string kEndPathStatusInserter("EndPathStatusInserter");
    unsigned int kTriggerResultsIndex = kInvalidIndex;
    ModuleStatus triggerResultsStatus;
    unsigned int largestIndex = 0;
    for (auto const& description : iPnC.allModules()) {
      moduleIndexToNames.insert(std::make_pair(description->id(), description->moduleLabel()));
      if (kTriggerResults == description->moduleLabel()) {
        kTriggerResultsIndex = description->id();
      }
      if (description->id() > largestIndex) {
        largestIndex = description->id();
      }
      if (description->moduleName() == kPathStatusInserter) {
        triggerResultsStatus.dependsOn_.push_back(description->id());
      }
      if (description->moduleName() == kPathStatusInserter || description->moduleName() == kEndPathStatusInserter) {
        pathStatusInserterModuleLabelToModuleID[description->moduleLabel()] = description->id();
      }
    }

    std::vector<ModuleStatus> statusOfModules(largestIndex + 1);
    for (auto const& nameID : pathStatusInserterModuleLabelToModuleID) {
      statusOfModules[nameID.second].onPath_ = true;
      unsigned int pathIndex;
      auto const& paths = iPnC.paths();
      auto itFound = std::find(paths.begin(), paths.end(), nameID.first);
      if (itFound != paths.end()) {
        pathIndex = itFound - paths.begin();
      } else {
        auto const& endPaths = iPnC.endPaths();
        itFound = std::find(endPaths.begin(), endPaths.end(), nameID.first);
        assert(itFound != endPaths.end());
        pathIndex = itFound - endPaths.begin() + iPnC.paths().size();
      }
      statusOfModules[nameID.second].pathsOn_.push_back(pathIndex);
    }
    if (kTriggerResultsIndex != kInvalidIndex) {
      statusOfModules[kTriggerResultsIndex] = std::move(triggerResultsStatus);
    }

    std::vector<PathStatus> statusOfPaths(iPnC.paths().size() + iPnC.endPaths().size());

    //If there are no paths, no modules will run so nothing to check
    if (statusOfPaths.empty()) {
      return;
    }

    {
      auto nPaths = iPnC.paths().size();
      for (unsigned int p = 0; p < nPaths; ++p) {
        auto& status = statusOfPaths[p];
        status.index_ = p;
        status.modulesOnPath_.reserve(iPnC.modulesOnPath(p).size() + 1);
        std::unordered_set<unsigned int> uniqueModules;
        for (auto const& mod : iPnC.modulesOnPath(p)) {
          if (uniqueModules.insert(mod->id()).second) {
            status.modulesOnPath_.push_back(mod->id());
            statusOfModules[mod->id()].onPath_ = true;
            statusOfModules[mod->id()].pathsOn_.push_back(p);
          }
        }
        status.nModules_ = uniqueModules.size() + 1;

        //add the PathStatusInserter at the end
        auto found = pathStatusInserterModuleLabelToModuleID.find(iPnC.paths()[p]);
        assert(found != pathStatusInserterModuleLabelToModuleID.end());
        status.modulesOnPath_.push_back(found->second);
      }
    }
    {
      auto offset = iPnC.paths().size();
      auto nPaths = iPnC.endPaths().size();
      for (unsigned int p = 0; p < nPaths; ++p) {
        auto& status = statusOfPaths[p + offset];
        status.endPath_ = true;
        status.index_ = p;
        status.modulesOnPath_.reserve(iPnC.modulesOnEndPath(p).size() + 1);
        std::unordered_set<unsigned int> uniqueModules;
        for (auto const& mod : iPnC.modulesOnEndPath(p)) {
          if (uniqueModules.insert(mod->id()).second) {
            status.modulesOnPath_.push_back(mod->id());
            statusOfModules[mod->id()].onPath_ = true;
            statusOfModules[mod->id()].pathsOn_.push_back(p + offset);
          }
        }
        status.nModules_ = uniqueModules.size();

        //add the EndPathStatusInserter at the end
        auto found = pathStatusInserterModuleLabelToModuleID.find(iPnC.endPaths()[p]);
        if (found != pathStatusInserterModuleLabelToModuleID.end()) {
          status.modulesOnPath_.push_back(found->second);
          ++status.nModules_;
        }
      }
    }

    for (auto const& description : iPnC.allModules()) {
      unsigned int const moduleIndex = description->id();
      auto const& dependentModules = iPnC.modulesWhoseProductsAreConsumedBy(moduleIndex);
      auto& deps = statusOfModules[moduleIndex];
      deps.dependsOn_.reserve(dependentModules.size());
      for (auto const& depDescription : dependentModules) {
        if (iPrintDependencies) {
          edm::LogAbsolute("ModuleDependency")
              << "ModuleDependency '" << description->moduleLabel() << "' depends on data products from module '"
              << depDescription->moduleLabel() << "'";
        }
        deps.dependsOn_.push_back(depDescription->id());
      }
    }

    unsigned int nPathsFinished = 0;
    for (auto const& status : statusOfPaths) {
      if (status.nModules_ == 0) {
        ++nPathsFinished;
      }
    }

    //if a circular dependency exception happens, stackTrace has the info
    std::vector<unsigned int> stackTrace;
    bool madeForwardProgress = true;
    try {
      //'simulate' the running of the paths. On each step mark each module as 'run'
      // if all the module's dependencies were fulfilled in a previous step
      unsigned long long searchIndex = 0;
      while (madeForwardProgress and nPathsFinished != statusOfPaths.size()) {
        madeForwardProgress = false;
        for (auto& p : statusOfPaths) {
          //the path has already completed in an earlier pass
          if (p.activeModuleSlot_ == p.nModules_) {
            continue;
          }
          ++searchIndex;
          bool didRun = checkIfCanRun(searchIndex, p.modulesOnPath_[p.activeModuleSlot_], statusOfModules, stackTrace);
          if (didRun) {
            madeForwardProgress = true;
            ++p.activeModuleSlot_;
            if (p.activeModuleSlot_ == p.nModules_) {
              ++nPathsFinished;
            }
          }
        }
      }
    } catch (CircularDependencyException const&) {
      //the last element in stackTrace must appear somewhere earlier in stackTrace
      std::ostringstream oStr;

      unsigned int lastIndex = stackTrace.front();
      bool firstSkipped = false;
      for (auto id : stackTrace) {
        if (firstSkipped) {
          oStr << "  module '" << moduleIndexToNames[lastIndex] << "' depends on " << moduleIndexToNames[id] << "\n";
        } else {
          firstSkipped = true;
        }
        lastIndex = id;
      }
      throw edm::Exception(edm::errors::ScheduleExecutionFailure, "Unrunnable schedule\n")
          << "Circular module dependency found in configuration\n"
          << oStr.str();
    }

    auto pathName = [&](PathStatus const& iP) {
      if (iP.endPath_) {
        return iPnC.endPaths()[iP.index_];
      }
      return iPnC.paths()[iP.index_];
    };

    //The program would deadlock
    if (not madeForwardProgress) {
      std::ostringstream oStr;
      auto modIndex = std::numeric_limits<unsigned int>::max();
      unsigned int presentPath;
      for (auto itP = statusOfPaths.begin(); itP != statusOfPaths.end(); ++itP) {
        auto const& p = *itP;
        if (p.activeModuleSlot_ == p.nModules_) {
          continue;
        }
        //this path is stuck
        modIndex = p.modulesOnPath_[p.activeModuleSlot_];
        presentPath = itP - statusOfPaths.begin();
        break;
      }
      //NOTE the following should always be true as at least 1 path should be stuc.
      // I've added the condition just to be paranoid.
      if (modIndex != std::numeric_limits<unsigned int>::max()) {
        struct ProgressInfo {
          ProgressInfo(unsigned int iMod, unsigned int iPath, bool iPreceeds = false)
              : moduleIndex_(iMod), pathIndex_(iPath), preceeds_(iPreceeds) {}

          ProgressInfo(unsigned int iMod) : moduleIndex_(iMod), pathIndex_{}, preceeds_(false) {}

          unsigned int moduleIndex_ = std::numeric_limits<unsigned int>::max();
          std::optional<unsigned int> pathIndex_;
          bool preceeds_;

          bool operator==(ProgressInfo const& iOther) const {
            return moduleIndex_ == iOther.moduleIndex_ and pathIndex_ == iOther.pathIndex_;
          }
        };

        std::vector<ProgressInfo> progressTrace;
        progressTrace.emplace_back(modIndex, presentPath);

        //The following starts from the first found unrun module on a path. It then finds
        // the first modules it depends on that was not run. If that module is on a Task
        // it then repeats the check for that module's dependencies. If that module is on
        // a path, it checks to see if that module is the first unrun module of a path
        // and if so it repeats the check for that module's dependencies, if not it
        // checks the dependencies of the stuck module on that path.
        // Eventually, all these checks should allow us to find a cycle of modules.

        //NOTE: the only way foundUnrunModule should ever by false by the end of the
        // do{}while loop is if there is a bug in the algorithm. I've included it to
        // try to avoid that case causing an infinite loop in the program.
        bool foundUnrunModule;
        do {
          //check dependencies looking for stuff not run and on a path
          foundUnrunModule = false;
          for (auto depMod : statusOfModules[modIndex].dependsOn_) {
            auto const& depStatus = statusOfModules[depMod];
            if (not depStatus.wasRun_ and depStatus.onPath_) {
              foundUnrunModule = true;
              //last run on a path?
              bool lastOnPath = false;
              unsigned int foundPath;
              for (auto pathOn : depStatus.pathsOn_) {
                auto const& depPaths = statusOfPaths[pathOn];
                if (depPaths.modulesOnPath_[depPaths.activeModuleSlot_] == depMod) {
                  lastOnPath = true;
                  foundPath = pathOn;
                  break;
                }
              }
              if (lastOnPath) {
                modIndex = depMod;
                progressTrace.emplace_back(modIndex, foundPath);
              } else {
                //some earlier module on the same path is stuck
                progressTrace.emplace_back(depMod, depStatus.pathsOn_[0]);
                auto const& depPath = statusOfPaths[depStatus.pathsOn_[0]];
                modIndex = depPath.modulesOnPath_[depPath.activeModuleSlot_];
                progressTrace.emplace_back(modIndex, depStatus.pathsOn_[0], true);
              }
              break;
            }
          }
          if (not foundUnrunModule) {
            //check unscheduled modules
            for (auto depMod : statusOfModules[modIndex].dependsOn_) {
              auto const& depStatus = statusOfModules[depMod];
              if (not depStatus.wasRun_ and not depStatus.onPath_) {
                foundUnrunModule = true;
                progressTrace.emplace_back(depMod);
                modIndex = depMod;
                break;
              }
            }
          }
        } while (foundUnrunModule and (0 == std::count(progressTrace.begin(),
                                                       progressTrace.begin() + progressTrace.size() - 1,
                                                       progressTrace.back())));

        auto printTrace = [&](auto& oStr, auto itBegin, auto itEnd) {
          for (auto itTrace = itBegin; itTrace != itEnd; ++itTrace) {
            if (itTrace != itBegin) {
              if (itTrace->preceeds_) {
                oStr << " and follows module '" << moduleIndexToNames[itTrace->moduleIndex_] << "' on the path\n";
              } else {
                oStr << " and depends on module '" << moduleIndexToNames[itTrace->moduleIndex_] << "'\n";
              }
            }
            if (itTrace + 1 != itEnd) {
              if (itTrace->pathIndex_) {
                oStr << "  module '" << moduleIndexToNames[itTrace->moduleIndex_] << "' is on path '"
                     << pathName(statusOfPaths[*itTrace->pathIndex_]) << "'";
              } else {
                oStr << "  module '" << moduleIndexToNames[itTrace->moduleIndex_] << "' is in a task";
              }
            }
          }
        };

        if (not foundUnrunModule) {
          //If we get here, this suggests a problem with either the algorithm that finds problems or the algorithm
          // that attempts to report the problem
          oStr << "Algorithm Error, unable to find problem. Contact framework group.\n Traced problem this far\n";
          printTrace(oStr, progressTrace.begin(), progressTrace.end());
        } else {
          printTrace(
              oStr, std::find(progressTrace.begin(), progressTrace.end(), progressTrace.back()), progressTrace.end());
        }
      }
      //the schedule deadlocked
      throw edm::Exception(edm::errors::ScheduleExecutionFailure, "Unrunnable schedule\n")
          << "The Path/EndPath configuration could cause the job to deadlock\n"
          << oStr.str();
    }

    //NOTE: although the following conditions are not needed for safe running, they are
    // policy choices the collaboration has made.

    //HLT wants all paths to be equivalent. If a path has a module A that needs data from module B and module B appears on one path
    // as module A then B must appear on ALL paths that have A.
    unsigned int modIndex = 0;
    for (auto& mod : statusOfModules) {
      for (auto& depIndex : mod.dependsOn_) {
        std::size_t count = 0;
        std::size_t nonEndPaths = 0;
        for (auto modPathID : mod.pathsOn_) {
          if (statusOfPaths[modPathID].endPath_) {
            continue;
          }
          ++nonEndPaths;
          for (auto depPathID : statusOfModules[depIndex].pathsOn_) {
            if (depPathID == modPathID) {
              ++count;
              break;
            }
          }
        }
        if (count != 0 and count != nonEndPaths) {
          std::ostringstream onStr;
          std::ostringstream missingStr;

          for (auto modPathID : mod.pathsOn_) {
            if (statusOfPaths[modPathID].endPath_) {
              continue;
            }
            bool found = false;
            for (auto depPathID : statusOfModules[depIndex].pathsOn_) {
              if (depPathID == modPathID) {
                found = true;
              }
            }
            auto& s = statusOfPaths[modPathID];
            if (found) {
              onStr << pathName(s) << " ";
            } else {
              missingStr << pathName(s) << " ";
            }
          }
          throw edm::Exception(edm::errors::ScheduleExecutionFailure, "Unrunnable schedule\n")
              << "Paths are non consistent\n"
              << "  module '" << moduleIndexToNames[modIndex] << "' depends on '" << moduleIndexToNames[depIndex]
              << "' which appears on paths\n  " << onStr.str() << "\nbut is missing from\n  " << missingStr.str();
        }
      }
      ++modIndex;
    }

    //Check to see if for each path if the order of the modules is correct based on dependencies
    auto allDependencies = findAllDependenciesForModules(statusOfModules);
    for (auto& p : statusOfPaths) {
      for (unsigned long int i = 0; p.nModules_ > 0 and i < p.nModules_ - 1; ++i) {
        auto moduleID = p.modulesOnPath_[i];
        if (not allDependencies[moduleID].empty()) {
          for (unsigned long int j = i + 1; j < p.nModules_; ++j) {
            auto testModuleID = p.modulesOnPath_[j];
            if (allDependencies[moduleID].find(testModuleID) != allDependencies[moduleID].end()) {
              throw edm::Exception(edm::errors::ScheduleExecutionFailure, "Unrunnable schedule\n")
                  << "Dependent module later on Path\n"
                  << "  module '" << moduleIndexToNames[moduleID] << "' depends on '"
                  << moduleIndexToNames[testModuleID] << "' which is later on path " << pathName(p);
            }
          }
        }
      }
    }
  }

checkForWrongProduct()

void edm::checkForWrongProduct	(	ProductID const &	keyID,
		ProductID const &	refID
	)

Definition at line 5 of file CommonExceptions.cc.

References Exception, and edm::errors::InvalidReference.

Referenced by edm::AssociationVector< KeyRefProd, CVal, KeyRef, SizeType, KeyReferenceHelper >::operator[]().

                                                                            {
    if (keyID != refID) {
      throw Exception(errors::InvalidReference)
          << "AssociationVector: trying to use [] operator passing a reference\n"
          << " with the wrong product id (i.e.: pointing to the wrong collection)\n"
          << " keyRef.id = " << keyID << ", ref.id = " << refID << "\n";
    }
  }

clearLoggedErrorsSummary()

void edm::clearLoggedErrorsSummary

(

unsigned int

iStreamID

)

Definition at line 182 of file MessageSender.cc.

References cms::cuda::assert(), and errorSummaryMaps.

Referenced by edm::service::MessageLogger::postEvent().

                                                        {
    assert(iStreamID < errorSummaryMaps.size());
    errorSummaryMaps[iStreamID].clear();
  }

clearMessageLog()

void edm::clearMessageLog

(

)

Definition at line 40 of file MessageLogger.cc.

References edm::MessageDrop::clear(), and edm::MessageDrop::instance().

{ MessageDrop::instance()->clear(); }

cloneEngine()

std::unique_ptr< CLHEP::HepRandomEngine > edm::cloneEngine

(

CLHEP::HepRandomEngine const &

existingEngine

)

Definition at line 27 of file cloneEngine.cc.

References Exception, and edm::errors::Unknown.

Referenced by PileupRandomNumberGenerator::cloneEngine(), edm::service::RandomNumberGeneratorService::cloneEngine(), and PileupRandomNumberGenerator::setEngine().

                                                                                              {
    std::vector<unsigned long> stateL = existingEngine.put();
    long seedL = existingEngine.getSeed();
    std::unique_ptr<CLHEP::HepRandomEngine> newEngine;
    if (stateL[0] == CLHEP::engineIDulong<CLHEP::HepJamesRandom>()) {
      newEngine = std::make_unique<CLHEP::HepJamesRandom>(seedL);
    } else if (stateL[0] == CLHEP::engineIDulong<CLHEP::RanecuEngine>()) {
      newEngine = std::make_unique<CLHEP::RanecuEngine>();
    } else if (stateL[0] == CLHEP::engineIDulong<CLHEP::MixMaxRng>()) {
      newEngine = std::make_unique<CLHEP::MixMaxRng>(seedL);
    } else if (stateL[0] == CLHEP::engineIDulong<TRandomAdaptor>()) {
      newEngine = std::make_unique<TRandomAdaptor>(seedL);
    } else {
      // Sanity check, it should not be possible for this to happen.
      throw Exception(errors::Unknown) << "The RandomNumberGeneratorService is trying to clone unknown engine type\n";
    }
    newEngine->get(stateL);
    return newEngine;
  }

combinable()

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

Definition at line 341 of file BranchDescription.cc.

References a, and b.

Referenced by edm::ProductRegistry::addFromInput(), edm::ProductRegistry::copyProduct(), and operator==().

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

compare_key()

template<typename C , typename K >

bool edm::compare_key	(	K const &	lhs,
		K const &	rhs
	)

Definition at line 130 of file Ref.h.

References ALPAKA_ACCELERATOR_NAMESPACE::brokenline::constexpr().

                                               {
    if constexpr (has_key_compare<C>::value) {
      using comparison_functor = typename C::key_compare;
      return comparison_functor()(lhs, rhs);
    } else {
      return lhs < rhs;
    }
  }

contains() [1/4]

bool edm::contains	(	EventRange const &	lh,
		EventID const &	rh
	)

Definition at line 37 of file EventRange.cc.

References contains_(), edm::EventID::event(), mathSSE::lh, edm::EventID::run(), and mitigatedMETSequence_cff::U.

Referenced by HGCalTriggerClusterIdentificationBDT::category(), contains(), CaloTowersCreationAlgo::convert(), MultipleScatteringGeometry::detLayers(), CTPPSDiamondDQMSource::dqmBeginRun(), PrintMTDSens::dumpTouch(), pat::PATElectronProducer::fillElectron2(), pat::PATMuonProducer::fillMuon(), PrintMTDSens::getBaseNumber(), HeavyFlavorValidation::getFilterLevel(), core.JSONAnalyzer.JSONAnalyzer::process(), CaloTowersCreationAlgo::rescaleTowers(), CTPPSLHCInfoESSource::setIntervalFor(), CTPPSOpticalFunctionsESSource::setIntervalFor(), PPSAssociationCutsESSource::setIntervalFor(), and TotemDAQMappingESSourceXML::setIntervalFor().

                                                         {
    if (lh.startLumi() == 0) {
      return (contains_(lh, EventID(rh.run(), 0U, rh.event())));
    }
    return (contains_(lh, rh));
  }

contains() [2/4]

bool edm::contains	(	LuminosityBlockRange const &	lh,
		LuminosityBlockID const &	rh
	)

Definition at line 48 of file LuminosityBlockRange.cc.

References mathSSE::lh.

                                                                             {
    if (rh >= lh.startLumiID() && rh <= lh.endLumiID()) {
      return true;
    }
    return false;
  }

contains() [3/4]

bool edm::contains	(	LuminosityBlockRange const &	lh,
		LuminosityBlockRange const &	rh
	)

Definition at line 55 of file LuminosityBlockRange.cc.

References contains(), edm::LuminosityBlockRange::endLumiID(), mathSSE::lh, and edm::LuminosityBlockRange::startLumiID().

                                                                                {
    if (contains(lh, rh.startLumiID()) && contains(lh, rh.endLumiID())) {
      return true;
    }
    return false;
  }

contains() [4/4]

bool edm::contains	(	EventRange const &	lh,
		EventRange const &	rh
	)

Definition at line 46 of file EventRange.cc.

References cms::cuda::assert(), contains(), edm::EventRange::endEventID(), mathSSE::lh, edm::EventRange::startEventID(), and edm::EventRange::startLumi().

                                                            {
    assert((lh.startLumi() == 0) == (rh.startLumi() == 0));
    return (contains(lh, rh.startEventID()) && contains(lh, rh.endEventID()));
  }

contains_()

bool edm::contains_	(	EventRange const &	lh,
		EventID const &	rh
	)

Definition at line 44 of file EventRange.cc.

References mathSSE::lh.

Referenced by contains().

{ return (rh >= lh.startEventID() && rh <= lh.endEventID()); }

contextual_find()

template<class FwdIter >

FwdIter edm::contextual_find	(	FwdIter	b,
		FwdIter	e,
		char	first,
		char	sep,
		char	last
	)

Definition at line 38 of file split.h.

References b, MillePedeFileConverter_cfg::e, dqmdumpme::first, and dqmdumpme::last.

Referenced by split().

                                                                                  {
  for (int nested = 0; b != e; ++b) {
    if (*b == first)
      ++nested;
    else if (*b == last)
      --nested;
    else if (*b == sep && nested == 0)
      return b;
  }

  return e;

}  // contextual_find()

contextual_find_not()

template<class FwdIter >

FwdIter edm::contextual_find_not	(	FwdIter	b,
		FwdIter	e,
		char	first,
		char	sep,
		char	last
	)

Definition at line 56 of file split.h.

References b, and MillePedeFileConverter_cfg::e.

Referenced by split().

                                                                               {
  for (; b != e; ++b) {
    if (*b != sep)
      return b;
  }

  return e;

}  // contextual_find_not()

conversion() [1/3]

void edm::conversion	(	LuminosityBlockAux const &	from,
		LuminosityBlockAuxiliary &	to
	)

Definition at line 11 of file LuminosityBlockAux.cc.

References edm::LuminosityBlockAux::id_, edm::Timestamp::invalidTimestamp(), edm::LuminosityBlockAux::processHistoryID_, and edm::LuminosityBlockAux::runID_.

                                                                                {
    to.processHistoryID_ = from.processHistoryID_;
    to.id_ = LuminosityBlockID(from.runID_, from.id_);
    to.beginTime_ = to.endTime_ = Timestamp::invalidTimestamp();
  }

conversion() [2/3]

void edm::conversion	(	RunAux const &	from,
		RunAuxiliary &	to
	)

Definition at line 11 of file RunAux.cc.

References edm::RunAux::id_, edm::Timestamp::invalidTimestamp(), and edm::RunAux::processHistoryID_.

                                                        {
    to.processHistoryID_ = from.processHistoryID_;
    to.id_ = RunID(from.id_);
    to.beginTime_ = to.endTime_ = Timestamp::invalidTimestamp();
  }

conversion() [3/3]

void edm::conversion	(	EventAux const &	from,
		EventAuxiliary &	to
	)

Definition at line 9 of file EventAux.cc.

References edm::EventAux::id_, edm::EventAux::luminosityBlockID_, edm::EventAux::processHistoryID_, and edm::EventAux::time_.

Referenced by ConversionLikelihoodCalculator::calculateLikelihood(), edm::RootFile::fillLumiAuxiliary(), edm::RootFile::fillRunAuxiliary(), edm::RootFile::fillThisEventAuxiliary(), ReducedEGProducer::linkConversionsByTrackRef(), RPCIntegrator::phi_DT_MP_conv(), ConversionTrackRefFix::produce(), FWConversionProxyBuilder::requestCommon(), fwlite::Run::updateAux(), fwlite::LuminosityBlock::updateAux(), and fwlite::Event::updateAux().

                                                            {
    to.processHistoryID_ = from.processHistoryID_;
    to.id_ = from.id_;
    to.time_ = from.time_;
    to.luminosityBlock_ = from.luminosityBlockID_;
  }

convert_handle() [1/3]

void edm::convert_handle	(	BasicHandle const &	orig,
		Handle< FWGenericObject > &	result
	)

specialize this function forFWGenericHandle

Definition at line 20 of file FWGenericHandle.cc.

References cms::cuda::assert(), DMR_cfg::cerr, Exception, edm::BasicHandle::failedToGet(), h, edm::BasicHandle::id(), edm::errors::InvalidReference, edm::errors::LogicError, edm::BasicHandle::provenance(), mps_fire::result, edm::BasicHandle::whyFailed(), edm::convertException::wrap(), edm::WrapperBase::wrappedTypeInfo(), and edm::BasicHandle::wrapper().

                                                                                {
    if (orig.failedToGet()) {
      result.setWhyFailed(orig.whyFailed());
      return;
    }

    WrapperBase const* originalWrap = orig.wrapper();
    if (originalWrap == nullptr) {
      throw edm::Exception(edm::errors::InvalidReference, "NullPointer")
          << "edm::BasicHandle has null pointer to Wrapper";
    }

    edm::ObjectWithDict wrap(edm::TypeWithDict(originalWrap->wrappedTypeInfo()),
                             const_cast<void*>(static_cast<void const*>(originalWrap)));
    assert(bool(wrap));

    edm::ObjectWithDict product(wrap.get("obj"));

    if (!product) {
      throw edm::Exception(edm::errors::LogicError) << "FWGenericObject could not find 'obj' member";
    }
    if (product.typeOf() != result.type()) {
      std::cerr << "FWGenericObject asked for " << result.type().name() << " but was given a "
                << product.typeOf().name();
      throw edm::Exception(edm::errors::LogicError)
          << "FWGenericObject asked for " << result.type().name() << " but was given a " << product.typeOf().name();
    }

    Handle<FWGenericObject> h(product, orig.provenance(), orig.id());
    h.swap(result);
  }

convert_handle() [2/3]

template<typename T >

Handle<T> edm::convert_handle ( BasicHandle &&  bh )

noexcept

Definition at line 22 of file ConvertHandle.h.

References runTheMatrix::const, edm::handleimpl::makeInvalidReferenceException(), eostools::move(), UNLIKELY, and wrapper.

Referenced by edm::Event::getByLabel(), edm::EventBase::getByLabel(), and edm::Event::getByToken().

                                                            {
    if UNLIKELY (bh.failedToGet()) {
      return Handle<T>(std::move(bh.whyFailedFactory()));
    }
    void const* basicWrapper = bh.wrapper();
    if UNLIKELY (nullptr == basicWrapper) {
      return Handle<T>{handleimpl::makeInvalidReferenceException()};
    }
    auto wrapper = static_cast<Wrapper<T> const*>(basicWrapper);

    return Handle<T>(wrapper->product(), bh.provenance());
  }

convert_handle() [3/3]

void edm::convert_handle	(	BasicHandle &&	orig,
		Handle< GenericObject > &	result
	)

specialize this function for GenericHandle

Definition at line 19 of file GenericHandle.cc.

References cms::cuda::assert(), Exception, h, edm::errors::InvalidReference, edm::errors::LogicError, mps_fire::result, edm::convertException::wrap(), and edm::WrapperBase::wrappedTypeInfo().

                                                                         {
    if (orig.failedToGet()) {
      result.setWhyFailedFactory(orig.whyFailedFactory());
      return;
    }
    WrapperBase const* originalWrap = orig.wrapper();
    if (originalWrap == nullptr) {
      throw Exception(errors::InvalidReference, "NullPointer") << "edm::BasicHandle has null pointer to Wrapper";
    }

    ObjectWithDict wrap(originalWrap->wrappedTypeInfo(), const_cast<WrapperBase*>(originalWrap));
    assert(bool(wrap));

    ObjectWithDict product(wrap.get("obj"));
    if (!product) {
      throw Exception(errors::LogicError) << "GenericObject could not find 'obj' member";
    }
    if (product.typeOf() != result.type()) {
      throw Exception(errors::LogicError)
          << "GenericObject asked for " << result.type().name() << " but was given a " << product.typeOf().name();
    }

    Handle<GenericObject> h(product, orig.provenance(), orig.id());
    h.swap(result);
  }

convert_handle_check_type()

template<typename T >

Handle<T> edm::convert_handle_check_type

(

BasicHandle &&

bh

)

Definition at line 36 of file ConvertHandle.h.

References runTheMatrix::const, edm::handleimpl::makeInvalidReferenceException(), eostools::move(), edm::handleimpl::throwConvertTypeError(), UNLIKELY, and wrapper.

                                                        {
    if UNLIKELY (bh.failedToGet()) {
      return Handle<T>(std::move(bh.whyFailedFactory()));
    }
    void const* basicWrapper = bh.wrapper();
    if UNLIKELY (basicWrapper == nullptr) {
      return Handle<T>{handleimpl::makeInvalidReferenceException()};
    }
    if UNLIKELY (!(bh.wrapper()->dynamicTypeInfo() == typeid(T))) {
      handleimpl::throwConvertTypeError(typeid(T), bh.wrapper()->dynamicTypeInfo());
    }
    Wrapper<T> const* wrapper = static_cast<Wrapper<T> const*>(basicWrapper);

    return Handle<T>(wrapper->product(), bh.provenance());
  }

convertToBranchType()

constexpr BranchType edm::convertToBranchType

(

Transition

iValue

)

Definition at line 26 of file Transition.h.

References ALPAKA_ACCELERATOR_NAMESPACE::brokenline::constexpr(), InEvent, InLumi, InProcess, and InRun.

Referenced by edm::ProductRegistryHelper::addToRegistry(), and edm::ProducerBase< edm::global::EDProducer, Args... >::resolvePutIndicies().

                                                              {
    constexpr BranchType branches[] = {InEvent, InLumi, InLumi, InRun, InRun, InProcess, InProcess};
    return branches[static_cast<std::underlying_type<Transition>::type>(iValue)];
  }

convertToTransition()

constexpr Transition edm::convertToTransition

(

BranchType

iValue

)

Definition at line 31 of file Transition.h.

References BeginLuminosityBlock, BeginProcessBlock, BeginRun, ALPAKA_ACCELERATOR_NAMESPACE::brokenline::constexpr(), and Event.

Referenced by edm::ProducerBase< edm::global::EDProducer, Args... >::produces().

                                                              {
    constexpr Transition trans[] = {
        Transition::Event, Transition::BeginLuminosityBlock, Transition::BeginRun, Transition::BeginProcessBlock};
    return trans[iValue];
  }

copy_all()

template<typename ForwardSequence , typename Func >

Func edm::copy_all ( ForwardSequence &  s, Func  f  )

inline

wrappers for copy

Definition at line 20 of file Algorithms.h.

References filterCSVwithJSON::copy, f, and alignCSCRings::s.

Referenced by edm::service::ThreadSafeLogMessageLoggerScribe::configure_errorlog(), dumpEventHeader(), dumpInitHeader(), MsgTools::fillNames(), edm::es::Label::operator()(), operator<<(), edm::ProductSelector::print(), edm::hash_detail::print_(), edm::hash_detail::toDigest_(), tokenize(), and edm::hash_detail::toString_().

                                                   {
    return std::copy(s.begin(), s.end(), f);
  }

createGlobalIdentifier()

std::string edm::createGlobalIdentifier

(

bool

binary = false

)

Definition at line 5 of file GlobalIdentifier.cc.

References edm::Guid::toBinary(), and edm::Guid::toString().

Referenced by TritonService::FallbackOpts::FallbackOpts(), PerformancePayloadFromBinnedTFormula::initialize(), PerformancePayloadFromTFormula::initialize(), NanoAODRNTupleOutputModule::openFile(), NanoAODOutputModule::openFile(), DQMRootOutputModule::openFile(), cond::payloadInspector::PlotImage< PayloadType >::PlotImage(), TritonService::preBeginJob(), edm::RootOutputFile::RootOutputFile(), and edm::RootFile::validateFile().

                                                {
    Guid guid;
    return binary ? guid.toBinary() : guid.toString();
  }

decode() [1/29]

bool edm::decode	(	bool &	to,
		std::string_view	from
	)

Definition at line 72 of file types.cc.

Referenced by compareDQMOutput::compare(), decode(), decode_element(), cmsswSequenceInfo::formatsequenceinfo(), Types.string::formatValueForConfig(), mps_fire::forward_proxy(), condformats_serialization_generate::get_clang_version(), condformats_serialization_generate::get_statement(), edm::Entry::getBool(), edm::Entry::getDouble(), edm::Entry::getESInputTag(), edm::Entry::getEventID(), edm::Entry::getEventRange(), edm::Entry::getFileInPath(), edm::Entry::getInputTag(), edm::Entry::getInt32(), edm::Entry::getInt64(), edm::Entry::getLuminosityBlockID(), edm::Entry::getLuminosityBlockRange(), cmsswSequenceInfo::getplugininfo(), edm::Entry::getPSet(), edm::Entry::getString(), uploadConditions.HTTP::getToken(), edm::Entry::getUInt32(), edm::Entry::getUInt64(), edm::Entry::getVDouble(), edm::Entry::getVESInputTag(), edm::Entry::getVEventID(), edm::Entry::getVEventRange(), edm::Entry::getVInputTag(), edm::Entry::getVInt32(), edm::Entry::getVInt64(), edm::Entry::getVLuminosityBlockID(), edm::Entry::getVLuminosityBlockRange(), edm::Entry::getVPSet(), edm::Entry::getVString(), edm::Entry::getVUInt32(), edm::Entry::getVUInt64(), cmsswSequenceInfo::inspectsequence(), cmsswSequenceInfo::inspectworkflows(), uploadConditions::re_upload(), o2oRun_SiStripDAQ::run(), postprocessor.PostProcessor::run(), edm::Entry::validate(), and mps_fire::write_HTCondor_submit_file_pede().

                                              {
  if (from == "true") {
    to = true;
    return true;
  } else if (from == "false") {
    to = false;
    return true;
  } else {
    return false;
  }
}  // decode to bool

decode() [2/29]

bool edm::decode	(	std::vector< bool > &	to,
		std::string_view	from
	)

Definition at line 95 of file types.cc.

References submitPVResolutionJobs::count, decode(), split(), submitPVValidationJobs::t, and heppy_batch::val.

                                                         {
  to.clear();
  to.reserve(std::count(from.begin(), from.end(), ','));
  return split(from, '{', ',', '}', [&to](auto t) {
    bool val = false;
    if (!decode(val, t)) {
      return false;
    }
    to.push_back(val);
    return true;
  });
}  // decode to vector<bool>

decode() [3/29]

bool edm::decode	(	int &	to,
		std::string_view	from
	)

Definition at line 131 of file types.cc.

References b, MillePedeFileConverter_cfg::e, and Validation_hcalonly_cfi::sign.

                                             {
  std::string_view::const_iterator b = from.begin(), e = from.end();

  if (*b != '+' && *b != '-') {
    return false;
  }
  int sign = (*b == '+') ? +1 : -1;

  to = 0;
  while (++b != e) {
    if (!std::isdigit(*b)) {
      return false;
    }
    to = 10 * to + (*b - '0');
  }
  to *= sign;

  return true;
}  // decode to int

decode() [4/29]

bool edm::decode	(	std::vector< int > &	to,
		std::string_view	from
	)

Definition at line 214 of file types.cc.

References submitPVResolutionJobs::count, decode(), split(), submitPVValidationJobs::t, and heppy_batch::val.

                                                        {
  to.clear();
  to.reserve(std::count(from.begin(), from.end(), ','));
  return split(from, '{', ',', '}', [&to](auto t) {
    int val = 0;
    if (!decode(val, t)) {
      return false;
    }
    to.push_back(val);
    return true;
  });
}  // decode to vector<int>

decode() [5/29]

bool edm::decode	(	unsigned int &	to,
		std::string_view	from
	)

Definition at line 293 of file types.cc.

References b, and MillePedeFileConverter_cfg::e.

                                                      {
  std::string_view::const_iterator b = from.begin(), e = from.end();

  to = 0u;
  for (; b != e; ++b) {
    if (*b == 'u' || *b == 'U') {
      return true;
    }
    if (!std::isdigit(*b)) {
      return false;
    }
    to = 10u * to + (*b - '0');
  }
  return true;
}  // decode to unsigned

decode() [6/29]

bool edm::decode	(	std::vector< unsigned int > &	to,
		std::string_view	from
	)

Definition at line 356 of file types.cc.

References submitPVResolutionJobs::count, decode(), split(), submitPVValidationJobs::t, and heppy_batch::val.

                                                                 {
  to.clear();
  to.reserve(std::count(from.begin(), from.end(), ','));
  return split(from, '{', ',', '}', [&to](auto t) {
    unsigned int val = 0;
    if (!decode(val, t)) {
      return false;
    }
    to.push_back(val);
    return true;
  });
}  // decode to vector<unsigned int>

decode() [7/29]

bool edm::decode	(	long long &	to,
		std::string_view	from
	)

Definition at line 172 of file types.cc.

References b, MillePedeFileConverter_cfg::e, and Validation_hcalonly_cfi::sign.

                                                   {
  std::string_view::const_iterator b = from.begin(), e = from.end();

  if (*b != '+' && *b != '-') {
    return false;
  }
  int sign = (*b == '+') ? +1 : -1;

  to = 0;
  while (++b != e) {
    if (!std::isdigit(*b)) {
      return false;
    }
    to = 10 * to + (*b - '0');
  }
  to *= sign;

  return true;
}  // decode to int

decode() [8/29]

bool edm::decode	(	std::vector< long long > &	to,
		std::string_view	from
	)

Definition at line 252 of file types.cc.

References decode(), L1DTConfigBti_cff::LL, split(), submitPVValidationJobs::t, groupFilesInBlocks::temp, and heppy_batch::val.

                                                              {
  std::vector<std::string_view> temp;
  if (!split(std::back_inserter(temp), from, '{', ',', '}')) {
    return false;
  }

  to.clear();
  for (auto t : temp) {
    long long val = 0LL;
    if (!decode(val, t)) {
      return false;
    }
    to.push_back(val);
  }

  return true;
}  // decode to vector<int>

decode() [9/29]

bool edm::decode	(	unsigned long long &	to,
		std::string_view	from
	)

Definition at line 325 of file types.cc.

References b, and MillePedeFileConverter_cfg::e.

                                                            {
  std::string_view::const_iterator b = from.begin(), e = from.end();
  to = 0u;
  for (; b != e; ++b) {
    if (*b == 'u' || *b == 'U') {
      return true;
    }
    if (!std::isdigit(*b)) {
      return false;
    }
    to = 10u * to + (*b - '0');
  }
  return true;
}  // decode to unsigned

decode() [10/29]

bool edm::decode	(	std::vector< unsigned long long > &	to,
		std::string_view	from
	)

Definition at line 393 of file types.cc.

References submitPVResolutionJobs::count, decode(), split(), submitPVValidationJobs::t, and heppy_batch::val.

                                                                       {
  to.clear();
  to.reserve(std::count(from.begin(), from.end(), ','));
  return split(from, '{', ',', '}', [&to](auto t) {
    unsigned long long val = 0ULL;
    if (!decode(val, t)) {
      return false;
    }
    to.push_back(val);
    return true;
  });
}  // decode to vector<unsigned int>

decode() [11/29]

bool edm::decode	(	double &	to,
		std::string_view	from
	)

Definition at line 431 of file types.cc.

References cppFunctionSkipper::exception, infinity, SiStripPI::max, and AlCaHLTBitMon_QueryRunRegistry::string.

                                                {
  if (from == "NaN") {
    to = std::numeric_limits<double>::quiet_NaN();
  } else if (from == "+inf" || from == "inf") {
    to = std::numeric_limits<double>::has_infinity ? std::numeric_limits<double>::infinity()
                                                   : std::numeric_limits<double>::max();
  } else if (from == "-inf") {
    to = std::numeric_limits<double>::has_infinity ? -std::numeric_limits<double>::infinity()
                                                   : -std::numeric_limits<double>::max();
  }

  else {
    try {
      // std::cerr << "from:" << from << std::endl;
      to = std::stod(std::string(from));
      // std::cerr << "to:" << to << std::endl;
    } catch (const std::exception&) {
      return false;
    }
  }
  return true;
}

decode() [12/29]

bool edm::decode	(	std::vector< double > &	to,
		std::string_view	from
	)

Definition at line 470 of file types.cc.

References submitPVResolutionJobs::count, decode(), split(), submitPVValidationJobs::t, and heppy_batch::val.

                                                           {
  to.clear();
  to.reserve(std::count(from.begin(), from.end(), ','));
  return split(from, '{', ',', '}', [&to](auto t) {
    double val;
    if (!decode(val, t))
      return false;
    to.push_back(val);
    return true;
  });
}  // decode to vector<double>

decode() [13/29]

bool edm::decode	(	std::string &	to,
		std::string_view	from
	)

Definition at line 521 of file types.cc.

References or.

                                                   {
  if (from.empty() or from.back() != '\0') {
    return false;
  }
  to = from.substr(0, from.size() - 1);

  std::size_t searchIndex = 0;
  while (std::string::npos != (searchIndex = to.find_first_of('\0', searchIndex))) {
    if (searchIndex == to.size() - 1 or to[searchIndex + 1] != '\0') {
      //unpaired string
      return false;
    }
    to.erase(searchIndex, 1);
    ++searchIndex;
  }
  return true;
}

decode() [14/29]

bool edm::decode	(	std::vector< std::string > &	to,
		std::string_view	from
	)

Definition at line 1097 of file types.cc.

References decode_element(), decode_string_extent(), eostools::move(), AlCaHLTBitMon_QueryRunRegistry::string, and heppy_batch::val.

                                                              {
  if (from.size() < 2) {
    return false;
  }
  if (from.front() != '{') {
    return false;
  }
  if (from.back() != '}') {
    return false;
  }
  to.clear();
  if (from.size() == 2) {
    //an empty vector
    return true;
  }
  if (from[1] != '\0') {
    return false;
  }
  auto remaining = from.substr(2, from.size() - 2 /*leading {/0*/ - 1 /*trailing } */);
  while (not remaining.empty()) {
    auto strng = decode_string_extent(remaining);
    if (not strng) {
      return false;
    }
    std::string val;
    if (!decode_element(val, *strng)) {
      return false;
    }
    to.emplace_back(std::move(val));

    remaining = remaining.substr(strng->size());
    if (remaining.empty())
      break;
    if (remaining.front() == ',') {
      remaining = remaining.substr(1);
    } else {
      return false;
    }
  }
  return true;
}  // decode to vector<string>

decode() [15/29]

bool edm::decode	(	edm::FileInPath &	to,
		std::string_view	from
	)

Definition at line 579 of file types.cc.

References AlCaHLTBitMon_QueryRunRegistry::string, and groupFilesInBlocks::temp.

                                                    {
  std::string sfrom{from};
  std::istringstream is(sfrom);
  FileInPath temp;
  temp.readFromParameterSetBlob(is);
  if (!is)
    return false;
  to = temp;
  return true;
}  // decode to FileInPath

decode() [16/29]

bool edm::decode	(	edm::InputTag &	to,
		std::string_view	from
	)

Definition at line 603 of file types.cc.

References ProducerED_cfi::InputTag, and AlCaHLTBitMon_QueryRunRegistry::string.

                                                  {
  to = InputTag(std::string(from));
  return true;
}  // decode to InputTag

decode() [17/29]

bool edm::decode	(	std::vector< edm::InputTag > &	to,
		std::string_view	from
	)

Definition at line 617 of file types.cc.

References decode(), ProducerED_cfi::InputTag, and makeListRunsInFiles::strings.

                                                             {
  std::vector<std::string> strings;
  decode(strings, from);

  for (std::vector<std::string>::const_iterator stringItr = strings.begin(), stringItrEnd = strings.end();
       stringItr != stringItrEnd;
       ++stringItr) {
    to.push_back(InputTag(*stringItr));
  }
  return true;
}  // decode to VInputTag

decode() [18/29]

bool edm::decode	(	edm::ESInputTag &	to,
		std::string_view	from
	)

Definition at line 643 of file types.cc.

References AlCaHLTBitMon_QueryRunRegistry::string.

                                                    {
  if (not from.empty() and from.npos == from.find(':')) {
    to = ESInputTag(std::string(from), "");
  } else {
    to = ESInputTag(std::string(from));
  }
  return true;
}  // decode to InputTag

decode() [19/29]

bool edm::decode	(	std::vector< edm::ESInputTag > &	to,
		std::string_view	from
	)

Definition at line 664 of file types.cc.

References decode(), and makeListRunsInFiles::strings.

                                                               {
  std::vector<std::string> strings;
  decode(strings, from);

  for (std::vector<std::string>::const_iterator stringItr = strings.begin(), stringItrEnd = strings.end();
       stringItr != stringItrEnd;
       ++stringItr) {
    to.push_back(ESInputTag(*stringItr));
  }
  return true;
}  // decode to VInputTag

decode() [20/29]

bool edm::decode	(	edm::EventID &	to,
		std::string_view	from
	)

Definition at line 690 of file types.cc.

References cms::cuda::assert(), writedatasetfile::run, AlCaHLTBitMon_QueryRunRegistry::string, and tokenize().

                                                    {
  std::vector<std::string> tokens = edm::tokenize(std::string(from), ":");
  assert(tokens.size() == 2 || tokens.size() == 3);
  unsigned int run = strtoul(tokens[0].c_str(), nullptr, 0);
  unsigned int lumi = (tokens.size() == 2 ? 0 : strtoul(tokens[1].c_str(), nullptr, 0));
  unsigned long long event = strtoull(tokens[tokens.size() - 1].c_str(), nullptr, 0);
  to = edm::EventID(run, lumi, event);

  return true;
}  // decode to EventID

decode() [21/29]

bool edm::decode	(	std::vector< edm::EventID > &	to,
		std::string_view	from
	)

Definition at line 716 of file types.cc.

References decode(), and makeListRunsInFiles::strings.

                                                               {
  std::vector<std::string> strings;
  decode(strings, from);

  for (std::vector<std::string>::const_iterator stringItr = strings.begin(), stringItrEnd = strings.end();
       stringItr != stringItrEnd;
       ++stringItr) {
    edm::EventID eventID;
    decode(eventID, *stringItr);
    to.push_back(eventID);
  }
  return true;
}  // decode to VInputTag

decode() [22/29]

bool edm::decode	(	edm::LuminosityBlockID &	to,
		std::string_view	from
	)

Definition at line 746 of file types.cc.

References cms::cuda::assert(), writedatasetfile::run, AlCaHLTBitMon_QueryRunRegistry::string, and tokenize().

                                                              {
  std::vector<std::string> tokens = edm::tokenize(std::string(from), ":");
  assert(tokens.size() == 2);
  unsigned int run = strtoul(tokens[0].c_str(), nullptr, 0);
  unsigned int lumi = strtoul(tokens[1].c_str(), nullptr, 0);
  to = edm::LuminosityBlockID(run, lumi);
  return true;
}  // decode to LuminosityBlockID

decode() [23/29]

bool edm::decode	(	std::vector< edm::LuminosityBlockID > &	to,
		std::string_view	from
	)

Definition at line 766 of file types.cc.

References decode(), and makeListRunsInFiles::strings.

                                                                         {
  std::vector<std::string> strings;
  decode(strings, from);

  for (std::vector<std::string>::const_iterator stringItr = strings.begin(), stringItrEnd = strings.end();
       stringItr != stringItrEnd;
       ++stringItr) {
    edm::LuminosityBlockID lumiID;
    decode(lumiID, *stringItr);
    to.push_back(lumiID);
  }
  return true;
}  // decode to VInputTag

decode() [24/29]

bool edm::decode	(	edm::LuminosityBlockRange &	to,
		std::string_view	from
	)

Definition at line 797 of file types.cc.

References cms::cuda::assert(), decode(), AlCaHLTBitMon_QueryRunRegistry::string, and tokenize().

                                                                 {
  std::vector<std::string> tokens = edm::tokenize(std::string(from), "-");
  assert(tokens.size() == 2);
  edm::LuminosityBlockID begin;
  edm::LuminosityBlockID end;
  edm::decode(begin, tokens[0]);
  edm::decode(end, tokens[1]);
  to = edm::LuminosityBlockRange(begin.run(), begin.luminosityBlock(), end.run(), end.luminosityBlock());
  return true;
}  // decode to LuminosityBlockRange

decode() [25/29]

bool edm::decode	(	std::vector< edm::LuminosityBlockRange > &	to,
		std::string_view	from
	)

Definition at line 819 of file types.cc.

References decode(), beamSpotPI::lumiRange, and makeListRunsInFiles::strings.

                                                                            {
  std::vector<std::string> strings;
  decode(strings, from);

  for (std::vector<std::string>::const_iterator stringItr = strings.begin(), stringItrEnd = strings.end();
       stringItr != stringItrEnd;
       ++stringItr) {
    edm::LuminosityBlockRange lumiRange;
    decode(lumiRange, *stringItr);
    to.push_back(lumiRange);
  }
  return true;
}  // decode to VInputTag

decode() [26/29]

bool edm::decode	(	edm::EventRange &	to,
		std::string_view	from
	)

Definition at line 850 of file types.cc.

References cms::cuda::assert(), decode(), AlCaHLTBitMon_QueryRunRegistry::string, and tokenize().

                                                       {
  std::vector<std::string> tokens = edm::tokenize(std::string(from), "-");
  assert(tokens.size() == 2);
  edm::EventID begin;
  edm::EventID end;
  edm::decode(begin, tokens[0]);
  edm::decode(end, tokens[1]);
  assert((begin.luminosityBlock() == 0) == (end.luminosityBlock() == 0));
  to = edm::EventRange(
      begin.run(), begin.luminosityBlock(), begin.event(), end.run(), end.luminosityBlock(), end.event());
  return true;
}  // decode to EventRange

decode() [27/29]

bool edm::decode	(	std::vector< edm::EventRange > &	to,
		std::string_view	from
	)

Definition at line 881 of file types.cc.

References decode(), unittestinputsource_cfi::eventRange, and makeListRunsInFiles::strings.

                                                                  {
  std::vector<std::string> strings;
  decode(strings, from);

  for (std::vector<std::string>::const_iterator stringItr = strings.begin(), stringItrEnd = strings.end();
       stringItr != stringItrEnd;
       ++stringItr) {
    edm::EventRange eventRange;
    decode(eventRange, *stringItr);
    to.push_back(eventRange);
  }
  return true;
}

decode() [28/29]

bool edm::decode	(	ParameterSet &	to,
		std::string_view	from
	)

Definition at line 1193 of file types.cc.

                                                      {
  to = ParameterSet(from);
  return true;
}  // decode to ParameterSet

decode() [29/29]

bool edm::decode	(	std::vector< ParameterSet > &	to,
		std::string_view	from
	)

Definition at line 1218 of file types.cc.

References submitPVResolutionJobs::count, decode(), edm::ParameterSet::extent(), eostools::move(), and heppy_batch::val.

                                                                 {
  to.clear();
  if (from.size() < 2) {
    return false;
  }
  if (from[0] != '{') {
    return false;
  }
  if (from.back() != '}') {
    return false;
  }

  to.reserve(std::count(from.begin(), from.end(), ',') + 1);

  auto remaining = from.substr(1, from.size() - 2);
  while (not remaining.empty()) {
    auto extent = ParameterSet::extent(remaining);
    if (extent.empty()) {
      return false;
    }
    ParameterSet val;
    if (!decode(val, extent)) {
      return false;
    }
    to.push_back(std::move(val));
    remaining.remove_prefix(extent.size());
    if (not remaining.empty()) {
      if (remaining[0] != ',') {
        return false;
      }
      remaining.remove_prefix(1);
    }
  }
  return true;
}  // decode to vector<ParameterSet>

decode_deprecated() [1/2]

bool edm::decode_deprecated	(	std::string &	to,
		std::string_view	from
	)

Definition at line 539 of file types.cc.

References b, HltBtagPostValidation_cff::c, MillePedeFileConverter_cfg::e, and from_hex().

Referenced by decode_deprecated(), edm::Entry::getString(), edm::Entry::getVString(), and edm::Entry::validate().

                                                              {
  /*std::cerr << "Decoding: " << from << '\n'; //DEBUG*/
  std::string_view::const_iterator b = from.begin(), e = from.end();

  to = "";
  to.reserve((e - b) / 2);
  char c = '\0';
  for (bool even_pos = true; b != e; ++b, even_pos = !even_pos) {
    if (even_pos) {
      /*std::cerr << "Even: |"
                  << *b
                  << "|   giving "
                  << from_hex(*b)
                  << "\n"; //DEBUG*/
      c = static_cast<char>(from_hex(*b));
    } else {
      /*std::cerr << "Odd:  |"
                  << *b
                  << "|   giving "
                  << from_hex(*b)
                  << "\n"; //DEBUG*/
      c = static_cast<char>(c * 16 + from_hex(*b));
      //      if(std::isalnum(c))  {
      /*std::cerr << "Ans:  |" << c << "|\n"; //DEBUG*/
      to += c;
      //}
      //else  { // keep all special chars encoded
      //to += "\\x";
      //to += to_hex_rep(c);
      //}
    }
  }
  /*std::cerr << "Decoded: " << to << '\n'; //DEBUG*/
  return true;
}  // decode to String

decode_deprecated() [2/2]

bool edm::decode_deprecated	(	std::vector< std::string > &	to,
		std::string_view	from
	)

Definition at line 1044 of file types.cc.

References submitPVResolutionJobs::count, decode_deprecated(), split(), AlCaHLTBitMon_QueryRunRegistry::string, submitPVValidationJobs::t, and heppy_batch::val.

                                                                         {
  to.clear();
  to.reserve(std::count(from.begin(), from.end(), ','));
  return split(from, '{', ',', '}', [&to](auto t) {
    std::string val;
    // treat blank string specially
    if (t == "XXX") {
      val = "";
    } else if (!decode_deprecated(val, t)) {
      return false;
    }
    to.push_back(val);
    return true;
  });
}  // decode to vector<string>

decode_element()

bool edm::decode_element	(	std::string &	to,
		std::string_view	from
	)

Definition at line 1139 of file types.cc.

References decode().

Referenced by decode().

{ return decode(to, from); }

decode_pset_extent()

std::optional< std::string_view > edm::decode_pset_extent

(

std::string_view

from

)

Definition at line 1207 of file types.cc.

References MillePedeFileConverter_cfg::e, and edm::ParameterSet::extent().

Referenced by edm::Entry::bounds(), and decode_vpset_extent().

                                                                       {
  auto e = ParameterSet::extent(from);
  if (e.empty()) {
    return {};
  }
  return e;
}

decode_string_extent()

std::optional< std::string_view > edm::decode_string_extent

(

std::string_view

from

)

Definition at line 504 of file types.cc.

Referenced by edm::Entry::bounds(), decode(), and decode_vstring_extent().

                                                                         {
  std::size_t searchIndex = 0;
  std::size_t indexEnd = 0;
  while (std::string_view::npos != (indexEnd = from.find_first_of('\0', searchIndex))) {
    if (indexEnd + 1 == from.size()) {
      return from;
    }
    if (from[indexEnd + 1] == '\0') {
      searchIndex = indexEnd + 2;
    } else {
      return from.substr(0, indexEnd + 1);
    }
  }
  //didn't find an unpaired '\0'
  return {};
}

decode_vpset_extent()

std::optional< std::string_view > edm::decode_vpset_extent

(

std::string_view

from

)

Definition at line 1275 of file types.cc.

References decode_pset_extent().

Referenced by edm::Entry::bounds().

                                                                        {
  if (from.size() < 2) {
    return {};
  }
  if (from.front() != '{') {
    return {};
  }
  if (from[1] == '}') {
    return from.substr(0, 2);
  }
  if (from.size() < 3) {
    return {};
  }
  auto remaining = from.substr(1);
  while (not remaining.empty()) {
    auto extent = decode_pset_extent(remaining);
    if (not extent) {
      return {};
    }
    remaining.remove_prefix(extent->size());
    if (remaining.empty())
      return {};
    if (remaining.front() == '}') {
      return from.substr(0, from.size() - remaining.size() + 1);
    }
    if (remaining.front() == ',') {
      remaining = remaining.substr(1);
    } else {
      return {};
    }
  }
  return {};
}

decode_vstring_extent()

std::optional< std::string_view > edm::decode_vstring_extent

(

std::string_view

from

)

Definition at line 1060 of file types.cc.

References decode_string_extent().

Referenced by edm::Entry::bounds().

                                                                          {
  if (from.size() < 2) {
    return {};
  }
  if (from.front() != '{') {
    return {};
  }
  if (from[1] == '}') {
    return from.substr(0, 2);
  }
  if (from.size() < 3) {
    return {};
  }
  if (from[1] != '\0') {
    return {};
  }
  auto remaining = from.substr(2);
  while (not remaining.empty()) {
    auto strng = decode_string_extent(remaining);
    if (not strng) {
      return {};
    }
    remaining = remaining.substr(strng->size());
    if (remaining.empty())
      return {};
    if (remaining.front() == '}') {
      return from.substr(0, from.size() - remaining.size() + 1);
    }
    if (remaining.front() == ',') {
      remaining = remaining.substr(1);
    } else {
      return {};
    }
  }
  return {};
}

defaultCmsRunServices()

std::vector< std::string > edm::defaultCmsRunServices

(

)

Definition at line 19 of file defaultCmsRunServices.cc.

                                               {
    std::vector<std::string> returnValue = {"MessageLogger",
                                            "InitRootHandlers",
                                            "UnixSignalService",
                                            "AdaptorConfig",
                                            "SiteLocalConfigService",
                                            "StatisticsSenderService",
                                            "ResourceInformationService",
                                            "CPU",
                                            "CondorStatusService",
                                            "XrdStatisticsService"};

    return returnValue;
  }

defaultModuleLabel()

std::string edm::defaultModuleLabel

(

std::string

label

)

Definition at line 6 of file defaultModuleLabel.cc.

References HltBtagPostValidation_cff::c, spr::find(), mps_fire::i, label, and MatrixUtil::remove().

Referenced by edm::ConfigurationDescriptions::addWithDefaultLabel().

                                                {
    // remove all colons (module type may contain namespace)
    label.erase(std::remove(label.begin(), label.end(), ':'), label.end());

    // remove everything after first '@' (used for module alternatives)
    label.erase(std::find(label.begin(), label.end(), '@'), label.end());

    // the following code originates from HLTrigger/HLTcore/interface/defaultModuleLabel.h
    // if the label is all uppercase, change it to all lowercase
    // if the label starts with more than one uppercase letter, change n-1 to lowercase
    // otherwise, change the first letter to lowercase
    unsigned int ups = 0;
    for (char c : label)
      if (std::isupper(c))
        ++ups;
      else
        break;
    if (ups > 1 and ups != label.size())
      --ups;
    for (unsigned int i = 0; i < ups; ++i)
      label[i] = std::tolower(label[i]);

    return label;
  }

disableAllSigs()

void edm::disableAllSigs

(

sigset_t *

oldset

)

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

DisableLoggedErrorsSummary()

bool edm::DisableLoggedErrorsSummary

(

)

Definition at line 156 of file MessageSender.cc.

References errorSummaryIsBeingKept, and runTheMatrix::ret.

Referenced by edm::LogErrorHarvester::endJob(), and HLTLogMonitorFilter::endJob().

                                    {
    bool ret = errorSummaryIsBeingKept.exchange(false, std::memory_order_acq_rel);
    return ret;
  }

disableRTSigs()

void edm::disableRTSigs

(

)

Definition at line 47 of file UnixSignalHandlers.cc.

References MUST_BE_ZERO, and EgammaValidation_cff::num.

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) {
      // signal 38 is used by Intel Amplifier
      if (num == 38)
        continue;

      MUST_BE_ZERO(sigaddset(&myset, num));
      MUST_BE_ZERO(sigaction(num, &tmpact, nullptr));
    }

    MUST_BE_ZERO(pthread_sigmask(SIG_BLOCK, &myset, nullptr));
#endif
  }

disableSignal()

void edm::disableSignal	(	sigset_t *	newset,
		int	signum
	)

Definition at line 86 of file UnixSignalHandlers.cc.

References MUST_BE_ZERO.

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

distinct() [1/2]

bool edm::distinct	(	LuminosityBlockRange const &	lh,
		LuminosityBlockRange const &	rh
	)

Definition at line 68 of file LuminosityBlockRange.cc.

References lessThan(), and mathSSE::lh.

                                                                                {
    return lessThan(lh, rh) || lessThan(rh, lh);
  }

distinct() [2/2]

bool edm::distinct	(	EventRange const &	lh,
		EventRange const &	rh
	)

Definition at line 69 of file EventRange.cc.

References cms::cuda::assert(), lessThan(), mathSSE::lh, and edm::EventRange::startLumi().

Referenced by overlaps(), and cond::persistency::Query< Types... >::Query().

                                                            {
    assert((lh.startLumi() == 0) == (rh.startLumi() == 0));
    return lessThan(lh, rh) || lessThan(rh, lh);
  }

doBuildRealData()

void edm::doBuildRealData

(

const std::string &

name

)

Definition at line 22 of file ClassFiller.cc.

References edm::errors::Configuration, Exception, FDEBUG, and Skims_PA_cff::name.

Referenced by edm::StreamerInputSource::buildClassCache().

                                              {
    FDEBUG(3) << "doing BuildRealData for " << name << "\n";
    TClass* ttest = TClass::GetClass(name.c_str());
    if (ttest != nullptr) {
      ttest->BuildRealData();
    } else {
      throw edm::Exception(errors::Configuration) << "Could not find TClass for " << name << "\n";
    }
  }

dumpOptionsToLogFile()

void edm::dumpOptionsToLogFile	(	unsigned int	nThreads,
		unsigned int	nStreams,
		unsigned int	nConcurrentLumis,
		unsigned int	nConcurrentRuns
	)

Definition at line 184 of file validateTopLevelParameterSets.cc.

Referenced by edm::EventProcessor::init().

                                                          {
    LogAbsolute("Options") << "Number of Threads = " << nThreads << "\nNumber of Streams = " << nStreams
                           << "\nNumber of Concurrent Lumis = " << nConcurrentLumis
                           << "\nNumber of Concurrent Runs = " << nConcurrentRuns;
  }

edmModuleType()

const char * edm::edmModuleType

(

edm::ModuleDescription const &

module

)

Definition at line 31 of file EDMModuleType.cc.

References edmModuleTypeEnum(), and module_type_desc.

                                                                {
    return module_type_desc[static_cast<std::underlying_type_t<EDMModuleType>>(edmModuleTypeEnum(module))];
  }

edmModuleTypeEnum()

EDMModuleType edm::edmModuleTypeEnum

(

edm::ModuleDescription const &

module

)

Definition at line 10 of file EDMModuleType.cc.

References edm::pset::Registry::instance(), kEDAnalyzer, kEDFilter, kEDProducer, kESProducer, kESSource, kOutputModule, kSource, kUnknown, module_type_desc, muonDTDigis_cfi::pset, AlCaHLTBitMon_QueryRunRegistry::string, submitPVValidationJobs::t, and findQualityFiles::v.

Referenced by edmModuleType(), DependencyGraph::edmModuleType(), and ProcessCallGraph::preBeginJob().

                                                                      {
    auto const& registry = *edm::pset::Registry::instance();
    auto const& pset = *registry.getMapped(module.parameterSetID());

    if (not pset.existsAs<std::string>("@module_edm_type"))
      return EDMModuleType::kUnknown;

    std::string const& t = pset.getParameter<std::string>("@module_edm_type");
    for (EDMModuleType v : {EDMModuleType::kSource,
                            EDMModuleType::kESSource,
                            EDMModuleType::kESProducer,
                            EDMModuleType::kEDAnalyzer,
                            EDMModuleType::kEDProducer,
                            EDMModuleType::kEDFilter,
                            EDMModuleType::kOutputModule}) {
      if (t == module_type_desc[static_cast<std::underlying_type_t<EDMModuleType>>(v)])
        return v;
    }
    return EDMModuleType::kUnknown;
  }

edmodule_mightGet_config()

void edm::edmodule_mightGet_config

(

ConfigurationDescriptions &

iDesc

)

Definition at line 36 of file edmodule_mightGet_config.cc.

References edm::ParameterSetDescription::addOptionalUntracked(), edm::ConfigurationDescriptions::defaultDescription(), edm::ParameterSetDescription::isLabelUnused(), kComment, kMightGet(), and findQualityFiles::v.

Referenced by edm::stream::EDAnalyzerBase::prevalidate(), edm::stream::EDFilterBase::prevalidate(), edm::global::EDAnalyzerBase::prevalidate(), edm::limited::EDAnalyzerBase::prevalidate(), edm::one::EDAnalyzerBase::prevalidate(), edm::stream::EDProducerBase::prevalidate(), edm::one::EDProducerBase::prevalidate(), edm::one::EDFilterBase::prevalidate(), edm::limited::EDFilterBase::prevalidate(), edm::global::EDFilterBase::prevalidate(), edm::global::EDProducerBase::prevalidate(), and edm::limited::EDProducerBase::prevalidate().

                                                                  {
    //NOTE: by not giving a default, we are intentionally not having 'mightGet' added
    // to any cfi files. This was done intentionally to avoid problems with HLT. If requested,
    // the appropriate default would be an empty vector.
    if (iDesc.defaultDescription()) {
      if (iDesc.defaultDescription()->isLabelUnused(kMightGet)) {
        iDesc.defaultDescription()->addOptionalUntracked<std::vector<std::string> >(kMightGet)->setComment(kComment);
      }
    }
    for (auto& v : iDesc) {
      if (v.second.isLabelUnused(kMightGet)) {
        v.second.addOptionalUntracked<std::vector<std::string> >(kMightGet)->setComment(kComment);
      }
    }
  }

EnableLoggedErrorsSummary()

bool edm::EnableLoggedErrorsSummary

(

)

Definition at line 151 of file MessageSender.cc.

References errorSummaryIsBeingKept, and runTheMatrix::ret.

Referenced by edm::LogErrorHarvester::beginJob(), and HLTLogMonitorFilter::beginJob().

                                   {
    bool ret = errorSummaryIsBeingKept.exchange(true, std::memory_order_acq_rel);
    return ret;
  }

enableSignal()

void edm::enableSignal	(	sigset_t *	newset,
		int	signum
	)

Definition at line 79 of file UnixSignalHandlers.cc.

References MUST_BE_ZERO.

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

encode() [1/29]

bool edm::encode	(	std::string &	to,
		bool	from
	)

Definition at line 86 of file types.cc.

Referenced by encode(), encode_element(), and edm::Entry::Entry().

                                         {
  to = from ? "true" : "false";
  return true;
}  // encode from bool

encode() [2/29]

bool edm::encode	(	std::string &	to,
		std::vector< bool > const &	from
	)

Definition at line 110 of file types.cc.

References b, fileCollector2::converted, MillePedeFileConverter_cfg::e, encode(), and AlCaHLTBitMon_QueryRunRegistry::string.

                                                           {
  to = "{";

  std::string converted;
  for (std::vector<bool>::const_iterator b = from.begin(), e = from.end(); b != e; ++b) {
    if (!encode(converted, *b)) {
      return false;
    }
    if (b != from.begin()) {
      to += ",";
    }
    to += converted;
  }
  to += '}';
  return true;
}  // encode from vector<bool>

encode() [3/29]

bool edm::encode	(	std::string &	to,
		int	from
	)

Definition at line 153 of file types.cc.

                                        {
  bool is_negative = (from < 0);
  if (is_negative) {
    from = -from;  // TODO: work around this for most negative integer
  }
  to.clear();
  do {
    to = static_cast<char>(from % 10 + '0') + to;
    from /= 10;
  } while (from > 0);
  to = (is_negative ? '-' : '+') + to;

  return true;
}  // encode from int

encode() [4/29]

bool edm::encode	(	std::string &	to,
		std::vector< int > const &	from
	)

Definition at line 229 of file types.cc.

References b, fileCollector2::converted, MillePedeFileConverter_cfg::e, encode(), and AlCaHLTBitMon_QueryRunRegistry::string.

                                                          {
  to = "{";

  std::string converted;
  for (std::vector<int>::const_iterator b = from.begin(), e = from.end(); b != e; ++b) {
    if (!encode(converted, *b)) {
      return false;
    }

    if (b != from.begin()) {
      to += ",";
    }
    to += converted;
  }

  to += '}';
  return true;
}  // encode from vector<int>

encode() [5/29]

bool edm::encode	(	std::string &	to,
		unsigned int	from
	)

Definition at line 311 of file types.cc.

                                                 {
  to.clear();
  do {
    to = static_cast<char>(from % 10 + '0') + to;
    from /= 10u;
  } while (from > 0u);

  return true;
}  // encode from unsigned

encode() [6/29]

bool edm::encode	(	std::string &	to,
		std::vector< unsigned int > const &	from
	)

Definition at line 371 of file types.cc.

References b, fileCollector2::converted, MillePedeFileConverter_cfg::e, encode(), and AlCaHLTBitMon_QueryRunRegistry::string.

                                                                   {
  to = "{";

  std::string converted;
  for (std::vector<unsigned int>::const_iterator b = from.begin(), e = from.end(); b != e; ++b) {
    if (!encode(converted, *b)) {
      return false;
    }
    if (b != from.begin()) {
      to += ",";
    }
    to += converted;
  }

  to += '}';
  return true;
}  // encode from vector<unsigned int>

encode() [7/29]

bool edm::encode	(	std::string &	to,
		long long	from
	)

Definition at line 194 of file types.cc.

                                              {
  bool is_negative = (from < 0);
  if (is_negative) {
    from = -from;  // TODO: work around this for most negative integer
  }

  to.clear();
  do {
    to = static_cast<char>(from % 10 + '0') + to;
    from /= 10;
  } while (from > 0);
  to = (is_negative ? '-' : '+') + to;

  return true;
}  // encode from int

encode() [8/29]

bool edm::encode	(	std::string &	to,
		std::vector< long long > const &	from
	)

Definition at line 272 of file types.cc.

References b, fileCollector2::converted, MillePedeFileConverter_cfg::e, encode(), and AlCaHLTBitMon_QueryRunRegistry::string.

                                                                {
  to = "{";

  std::string converted;
  for (std::vector<long long>::const_iterator b = from.begin(), e = from.end(); b != e; ++b) {
    if (!encode(converted, *b)) {
      return false;
    }
    if (b != from.begin()) {
      to += ",";
    }
    to += converted;
  }
  to += '}';
  return true;
}  // encode from vector<int>

encode() [9/29]

bool edm::encode	(	std::string &	to,
		unsigned long long	from
	)

Definition at line 342 of file types.cc.

                                                       {
  to.clear();
  do {
    to = static_cast<char>(from % 10 + '0') + to;
    from /= 10u;
  } while (from > 0u);

  return true;
}  // encode from unsigned

encode() [10/29]

bool edm::encode	(	std::string &	to,
		std::vector< unsigned long long > const &	from
	)

Definition at line 408 of file types.cc.

References b, fileCollector2::converted, MillePedeFileConverter_cfg::e, encode(), and AlCaHLTBitMon_QueryRunRegistry::string.

                                                                         {
  to = "{";

  std::string converted;
  for (std::vector<unsigned long long>::const_iterator b = from.begin(), e = from.end(); b != e; ++b) {
    if (!encode(converted, *b)) {
      return false;
    }

    if (b != from.begin()) {
      to += ",";
    }
    to += converted;
  }

  to += '}';
  return true;
}  // encode from vector<unsigned int>

encode() [11/29]

bool edm::encode	(	std::string &	to,
		double	from
	)

Definition at line 456 of file types.cc.

                                           {
  std::ostringstream ost;
  ost.precision(std::numeric_limits<double>::max_digits10);
  ost << from;
  if (!ost)
    return false;
  to = ost.str();
  return true;
}

encode() [12/29]

bool edm::encode	(	std::string &	to,
		std::vector< double > const &	from
	)

Definition at line 484 of file types.cc.

References b, fileCollector2::converted, MillePedeFileConverter_cfg::e, encode(), and AlCaHLTBitMon_QueryRunRegistry::string.

                                                             {
  to = "{";

  std::string converted;
  for (std::vector<double>::const_iterator b = from.begin(), e = from.end(); b != e; ++b) {
    if (!encode(converted, *b))
      return false;

    if (b != from.begin())
      to += ",";
    to += converted;
  }

  to += '}';
  return true;
}  // encode from vector<double>

encode() [13/29]

bool edm::encode	(	std::string &	to,
		std::string const &	from
	)

Definition at line 908 of file types.cc.

                                                     {
  to = from;
  //need to escape any nulls by making them pairs
  std::size_t lastFound = 0;
  while (std::string::npos != (lastFound = to.find_first_of('\0', lastFound))) {
    to.insert(lastFound, 1, '\0');
    lastFound += 2;
  }
  to += '\0';
  return true;
}

encode() [14/29]

bool edm::encode	(	std::string &	to,
		std::vector< std::string > const &	from
	)

Definition at line 1143 of file types.cc.

References b, fileCollector2::converted, MillePedeFileConverter_cfg::e, encode_element(), and AlCaHLTBitMon_QueryRunRegistry::string.

                                                                {
  to = "{";

  //special cases
  // empty vector : "{}"
  // vector with one empty element: "{\0\0}"
  // vector with one '}' element: "{\0}\0}"
  // vector with two '}' elements: "{\0}\0,}\0}"
  //needed to tell an empty vector from one with the first string being "}"
  if (not from.empty()) {
    to += '\0';
  }
  std::string converted;
  for (std::vector<std::string>::const_iterator b = from.begin(), e = from.end(); b != e; ++b) {
    if (!encode_element(converted, *b)) {
      return false;
    }

    if (b != from.begin())
      to += ",";
    to += converted;
  }

  to += '}';
  return true;
}  // encode from vector<string>

encode() [15/29]

bool edm::encode	(	std::string &	to,
		edm::FileInPath const &	from
	)

Definition at line 590 of file types.cc.

                                                      {
  std::ostringstream ost;
  ost << from;
  if (!ost)
    return false;
  to = ost.str();
  return true;
}

encode() [16/29]

bool edm::encode	(	std::string &	to,
		edm::InputTag const &	from
	)

Definition at line 608 of file types.cc.

References edm::InputTag::encode().

                                                    {
  to = from.encode();
  return true;
}

encode() [17/29]

bool edm::encode	(	std::string &	to,
		std::vector< edm::InputTag > const &	from
	)

Definition at line 629 of file types.cc.

References encode(), and makeListRunsInFiles::strings.

                                                               {
  std::vector<std::string> strings;
  for (std::vector<InputTag>::const_iterator tagItr = from.begin(), tagItrEnd = from.end(); tagItr != tagItrEnd;
       ++tagItr) {
    strings.push_back(tagItr->encode());
  }
  encode(to, strings);
  return true;
}

encode() [18/29]

bool edm::encode	(	std::string &	to,
		edm::ESInputTag const &	from
	)

Definition at line 652 of file types.cc.

References edm::ESInputTag::encode().

                                                      {
  to = from.encode();
  if (not to.empty() and to.back() == ':') {
    to.pop_back();
  }
  return true;
}

encode() [19/29]

bool edm::encode	(	std::string &	to,
		std::vector< edm::ESInputTag > const &	from
	)

Definition at line 676 of file types.cc.

References encode(), and makeListRunsInFiles::strings.

                                                                 {
  std::vector<std::string> strings;
  for (std::vector<ESInputTag>::const_iterator tagItr = from.begin(), tagItrEnd = from.end(); tagItr != tagItrEnd;
       ++tagItr) {
    strings.push_back(tagItr->encode());
  }
  encode(to, strings);
  return true;
}

encode() [20/29]

bool edm::encode	(	std::string &	to,
		edm::EventID const &	from
	)

Definition at line 701 of file types.cc.

References edm::EventID::event(), edm::EventID::luminosityBlock(), edm::EventID::run(), and mitigatedMETSequence_cff::U.

                                                      {
  std::ostringstream os;
  if (from.luminosityBlock() == 0U) {
    os << from.run() << ":" << from.event();
  } else {
    os << from.run() << ":" << from.luminosityBlock() << ":" << from.event();
  }
  to = os.str();
  return true;
}

encode() [21/29]

bool edm::encode	(	std::string &	to,
		std::vector< edm::EventID > const &	from
	)

Definition at line 730 of file types.cc.

References encode(), AlCaHLTBitMon_QueryRunRegistry::string, and makeListRunsInFiles::strings.

                                                                 {
  std::vector<std::string> strings;
  for (std::vector<edm::EventID>::const_iterator idItr = from.begin(), idItrEnd = from.end(); idItr != idItrEnd;
       ++idItr) {
    std::string encodedEventID;
    encode(encodedEventID, *idItr);
    strings.push_back(encodedEventID);
  }
  encode(to, strings);
  return true;
}

encode() [22/29]

bool edm::encode	(	std::string &	to,
		edm::LuminosityBlockID const &	from
	)

Definition at line 755 of file types.cc.

References edm::LuminosityBlockID::luminosityBlock(), and edm::LuminosityBlockID::run().

                                                                {
  std::ostringstream os;
  os << from.run() << ":" << from.luminosityBlock();
  to = os.str();
  return true;
}

encode() [23/29]

bool edm::encode	(	std::string &	to,
		std::vector< edm::LuminosityBlockID > const &	from
	)

Definition at line 780 of file types.cc.

References encode(), AlCaHLTBitMon_QueryRunRegistry::string, and makeListRunsInFiles::strings.

                                                                           {
  std::vector<std::string> strings;
  for (std::vector<edm::LuminosityBlockID>::const_iterator idItr = from.begin(), idItrEnd = from.end();
       idItr != idItrEnd;
       ++idItr) {
    std::string encodedLuminosityBlockID;
    encode(encodedLuminosityBlockID, *idItr);
    strings.push_back(encodedLuminosityBlockID);
  }
  encode(to, strings);
  return true;
}

encode() [24/29]

bool edm::encode	(	std::string &	to,
		edm::LuminosityBlockRange const &	from
	)

Definition at line 808 of file types.cc.

References edm::LuminosityBlockRange::endLumi(), edm::LuminosityBlockRange::endRun(), edm::LuminosityBlockRange::startLumi(), and edm::LuminosityBlockRange::startRun().

                                                                   {
  std::ostringstream os;
  os << from.startRun() << ":" << from.startLumi() << "-" << from.endRun() << ":" << from.endLumi();
  to = os.str();
  return true;
}

encode() [25/29]

bool edm::encode	(	std::string &	to,
		std::vector< edm::LuminosityBlockRange > const &	from
	)

Definition at line 833 of file types.cc.

References encode(), AlCaHLTBitMon_QueryRunRegistry::string, and makeListRunsInFiles::strings.

                                                                              {
  std::vector<std::string> strings;
  for (std::vector<edm::LuminosityBlockRange>::const_iterator idItr = from.begin(), idItrEnd = from.end();
       idItr != idItrEnd;
       ++idItr) {
    std::string encodedLuminosityBlockRange;
    encode(encodedLuminosityBlockRange, *idItr);
    strings.push_back(encodedLuminosityBlockRange);
  }
  encode(to, strings);
  return true;
}

encode() [26/29]

bool edm::encode	(	std::string &	to,
		edm::EventRange const &	from
	)

Definition at line 863 of file types.cc.

References cms::cuda::assert(), edm::EventRange::endEvent(), edm::EventRange::endLumi(), edm::EventRange::endRun(), edm::EventRange::startEvent(), edm::EventRange::startLumi(), and edm::EventRange::startRun().

                                                         {
  std::ostringstream os;
  if (from.startLumi() == 0) {
    assert(from.endLumi() == 0);
    os << from.startRun() << ":" << from.startEvent() << "-" << from.endRun() << ":" << from.endEvent();
  } else {
    assert(from.endLumi() != 0);
    os << from.startRun() << ":" << from.startLumi() << ":" << from.startEvent() << "-" << from.endRun() << ":"
       << from.endLumi() << ":" << from.endEvent();
  }
  to = os.str();
  return true;
}

encode() [27/29]

bool edm::encode	(	std::string &	to,
		std::vector< edm::EventRange > const &	from
	)

Definition at line 895 of file types.cc.

References encode(), AlCaHLTBitMon_QueryRunRegistry::string, and makeListRunsInFiles::strings.

                                                                    {
  std::vector<std::string> strings;
  for (std::vector<edm::EventRange>::const_iterator idItr = from.begin(), idItrEnd = from.end(); idItr != idItrEnd;
       ++idItr) {
    std::string encodedEventRange;
    encode(encodedEventRange, *idItr);
    strings.push_back(encodedEventRange);
  }
  encode(to, strings);
  return true;
}

encode() [28/29]

bool edm::encode	(	std::string &	to,
		ParameterSet const &	from
	)

Definition at line 1200 of file types.cc.

References edm::ParameterSet::toString().

                                                        {
  to = from.toString();
  return true;
}  // encode from ParameterSet

encode() [29/29]

bool edm::encode	(	std::string &	to,
		std::vector< ParameterSet > const &	from
	)

Definition at line 1256 of file types.cc.

References b, fileCollector2::converted, MillePedeFileConverter_cfg::e, encode(), and AlCaHLTBitMon_QueryRunRegistry::string.

                                                                   {
  to = "{";

  std::string converted;
  for (std::vector<ParameterSet>::const_iterator b = from.begin(), e = from.end(); b != e; ++b) {
    if (!encode(converted, *b)) {
      return false;
    }
    if (b != from.begin()) {
      to += ",";
    }
    to += converted;
  }
  to += '}';
  return true;
}  // encode from vector<ParameterSet>

encode_deprecated() [1/2]

bool edm::encode_deprecated	(	std::string &	to,
		std::string const &	from
	)

Definition at line 920 of file types.cc.

References append_hex_rep(), b, MillePedeFileConverter_cfg::e, from_hex(), and NONE.

Referenced by encode_deprecated().

                                                                {
  std::string::const_iterator b = from.begin(), e = from.end();

  enum escape_state { NONE, BACKSLASH, HEX, HEX1, OCT1, OCT2 };

  escape_state state = NONE;
  int code = 0;
  to = "";
  for (; b != e; ++b) {
    /*std::cerr << "State: " << state << "; char = " << *b << '\n'; //DEBUG*/
    switch (state) {
      case NONE: {
        if (*b == '\\')
          state = BACKSLASH;
        else
          append_hex_rep(to, *b);
        /*std::cerr << "To: |" << to << "|\n"; //DEBUG*/
        break;
      }
      case BACKSLASH: {
        code = 0;
        switch (*b) {
          case 'x':
          case 'X': {
            state = HEX;
            break;
          }
          case '0':
          case '1':
          case '2':
          case '3':
          case '4':
          case '5':
          case '6':
          case '7': {
            code = 8 * code + from_hex(*b);
            state = OCT1;
            break;
          }
          case 'n': {
            append_hex_rep(to, 10);
            state = NONE;
            break;
          }
          case 't': {
            append_hex_rep(to, 9);
            state = NONE;
            break;
          }
          default: {
            append_hex_rep(to, *b);
            state = NONE;
            break;
          }
        }
        break;
      }
      case HEX: {
        to += *b;
        state = HEX1;
        break;
      }
      case HEX1: {
        to += *b;
        state = NONE;
        break;
      }
      case OCT1: {
        switch (*b) {
          case '0':
          case '1':
          case '2':
          case '3':
          case '4':
          case '5':
          case '6':
          case '7': {
            code = 8 * code + from_hex(*b);
            state = OCT2;
            break;
          }
          default: {
            append_hex_rep(to, code);
            state = NONE;
            break;
          }
        }
        break;
      }
      case OCT2: {
        switch (*b) {
          case '0':
          case '1':
          case '2':
          case '3':
          case '4':
          case '5':
          case '6':
          case '7': {
            code = 8 * code + from_hex(*b);
            break;
          }
          default: {
            append_hex_rep(to, code);
            break;
          }
        }
        state = NONE;
        break;
      }
      default: {
        throw std::logic_error("can't happen");
        break;
      }
    }
  }  // for

  return true;
}  // encode from String

encode_deprecated() [2/2]

bool edm::encode_deprecated	(	std::string &	to,
		std::vector< std::string > const &	from
	)

Definition at line 1172 of file types.cc.

References b, fileCollector2::converted, MillePedeFileConverter_cfg::e, encode_deprecated(), and AlCaHLTBitMon_QueryRunRegistry::string.

                                                                           {
  to = "{";

  std::string converted;
  for (std::vector<std::string>::const_iterator b = from.begin(), e = from.end(); b != e; ++b) {
    if (!encode_deprecated(converted, *b)) {
      return false;
    }

    if (b != from.begin())
      to += ",";
    to += converted;
  }

  to += '}';
  return true;
}  // encode from vector<string>

encode_element()

bool edm::encode_element	(	std::string &	to,
		std::string const &	from
	)

Definition at line 1170 of file types.cc.

References encode().

Referenced by encode().

{ return encode(to, from); }

endGlobalTransitionAsync()

template<typename Traits >

void edm::endGlobalTransitionAsync	(	WaitingTaskHolder	iWait,
		Schedule &	iSchedule,
		typename Traits::TransitionInfoType &	transitionInfo,
		ServiceToken const &	token,
		std::vector< SubProcess > &	iSubProcesses,
		bool	cleaningUpAfterException
	)

Definition at line 115 of file globalTransitionAsync.h.

References edm::waiting_task::chain::first(), info(), eostools::move(), edm::Schedule::processOneGlobalAsync(), edm::waiting_task::chain::runLast(), subProcessDoGlobalEndTransitionAsync(), edm::waiting_task::chain::then(), and unpackBuffers-CaloStage2::token.

                                                               {
    using namespace edm::waiting_task;
    chain::first([&](auto nextTask) {
      iSchedule.processOneGlobalAsync<Traits>(std::move(nextTask), transitionInfo, token, cleaningUpAfterException);
    })
        // When we are done processing the global for this process,
        // we need to run the global for all SubProcesses
        | chain::then([&iSubProcesses, info = transitionInfo, cleaningUpAfterException](std::exception_ptr const* iPtr,
                                                                                        auto nextTask) {
            if (iPtr) {
              //still run the sub process but pass this exception to the nextTask
              auto excpt = *iPtr;
              chain::first([&](auto nextTask) {
                for (auto& subProcess : iSubProcesses) {
                  subProcessDoGlobalEndTransitionAsync(nextTask, subProcess, info, cleaningUpAfterException);
                }
              }) | chain::then([excpt](std::exception_ptr const*, auto nextTask) { nextTask.doneWaiting(excpt); }) |
                  chain::runLast(std::move(nextTask));
            } else {
              for (auto& subProcess : iSubProcesses) {
                subProcessDoGlobalEndTransitionAsync(nextTask, subProcess, info, cleaningUpAfterException);
              }
            }
          }) |
        chain::runLast(iWait);
  }

endStreamsTransitionAsync()

template<typename Traits >

void edm::endStreamsTransitionAsync	(	WaitingTaskHolder	iWait,
		Schedule &	iSchedule,
		unsigned int	iNStreams,
		typename Traits::TransitionInfoType &	transitionInfo,
		ServiceToken const &	iToken,
		std::vector< SubProcess > &	iSubProcesses,
		bool	cleaningUpAfterException
	)

Definition at line 146 of file streamTransitionAsync.h.

References mps_fire::i.

                                                                {
    for (unsigned int i = 0; i < iNStreams; ++i) {
      endStreamTransitionAsync<Traits>(
          iWait, iSchedule, i, transitionInfo, iToken, iSubProcesses, cleaningUpAfterException);
    }
  }

endStreamTransitionAsync()

template<typename Traits >

void edm::endStreamTransitionAsync	(	WaitingTaskHolder	iWait,
		Schedule &	iSchedule,
		unsigned int	iStreamIndex,
		typename Traits::TransitionInfoType &	transitionInfo,
		ServiceToken const &	token,
		std::vector< SubProcess > &	iSubProcesses,
		bool	cleaningUpAfterException
	)

Definition at line 110 of file streamTransitionAsync.h.

References edm::waiting_task::chain::first(), info(), edm::Schedule::processOneStreamAsync(), edm::waiting_task::chain::runLast(), subProcessDoStreamEndTransitionAsync(), edm::waiting_task::chain::then(), and unpackBuffers-CaloStage2::token.

                                                               {
    //When we are done processing the stream for this process,
    // we need to run the stream for all SubProcesses
    //NOTE: The subprocesses set their own service tokens

    using namespace edm::waiting_task;
    chain::first([&](auto nextTask) {
      iSchedule.processOneStreamAsync<Traits>(nextTask, iStreamIndex, transitionInfo, token, cleaningUpAfterException);
    }) |
        chain::then([&iSubProcesses, iStreamIndex, info = transitionInfo, cleaningUpAfterException](
                        std::exception_ptr const* iPtr, auto nextTask) {
          if (iPtr) {
            auto excpt = *iPtr;
            chain::first([&](std::exception_ptr const*, auto nextTask) {
              for (auto& subProcess : iSubProcesses) {
                subProcessDoStreamEndTransitionAsync(
                    nextTask, subProcess, iStreamIndex, info, cleaningUpAfterException);
              }
            }) | chain::then([excpt](std::exception_ptr const*, auto nextTask) { nextTask.doneWaiting(excpt); }) |
                chain::runLast(nextTask);
          } else {
            for (auto& subProcess : iSubProcesses) {
              subProcessDoStreamEndTransitionAsync(nextTask, subProcess, iStreamIndex, info, cleaningUpAfterException);
            }
          }
        }) |
        chain::runLast(iWait);
  }

ensureAvailableAccelerators()

void edm::ensureAvailableAccelerators

(

edm::ParameterSet const &

parameterSet

)

Definition at line 8 of file ensureAvailableAccelerators.cc.

References edm::ParameterSet::getUntrackedParameter(), edm::ParameterSet::getUntrackedParameterSet(), parameterSet(), and edm::errors::UnavailableAccelerator.

Referenced by edm::EventProcessor::init(), and edm::test::TestProcessor::TestProcessor().

                                                                        {
    auto const& selectedAccelerators =
        parameterSet.getUntrackedParameter<std::vector<std::string>>("@selected_accelerators");
    if (selectedAccelerators.empty()) {
      Exception ex(errors::UnavailableAccelerator);
      ex << "The system has no compute accelerators that match the patterns specified in "
            "process.options.accelerators:\n";
      ParameterSet const& optionsPset(parameterSet.getUntrackedParameterSet("options"));
      auto const& patterns = optionsPset.getUntrackedParameter<std::vector<std::string>>("accelerators");
      for (auto const& pat : patterns) {
        ex << " " << pat << "\n";
      }
      ex << "\nThe following compute accelerators are available:\n";
      auto const& availableAccelerators =
          parameterSet.getUntrackedParameter<std::vector<std::string>>("@available_accelerators");
      for (auto const& acc : availableAccelerators) {
        ex << " " << acc << "\n";
      }

      throw ex;
    }
  }

ep_sigusr2()

void edm::ep_sigusr2	(	int	,
		siginfo_t *	,
		void *
	)

Definition at line 25 of file UnixSignalHandlers.cc.

References FDEBUG, and shutdown_flag.

Referenced by edm::service::UnixSignalService::UnixSignalService().

                                          {
    FDEBUG(1) << "in sigusr2 handler\n";
    shutdown_flag.store(true);
  }

eventProcessBlockIndex()

unsigned int edm::eventProcessBlockIndex	(	Event const &	event,
		std::string const &	processName
	)

Definition at line 7 of file processBlockUtilities.cc.

References SimL1EmulatorRepack_CalouGT_cff::processName.

                                                                                        {
    return event.processBlockIndex(processName);
  }

exceptionContext() [1/4]

void edm::exceptionContext	(	cms::Exception &	ex,
		ESModuleCallingContext const &	mcc
	)

Definition at line 11 of file exceptionContext.cc.

References cms::Exception::addContext(), edm::ESModuleCallingContext::componentDescription(), edm::ESModuleCallingContext::esmoduleCallingContext(), edm::ESParentContext::kESModule, edm::ESParentContext::kModule, edm::ESModuleCallingContext::kPrefetching, edm::eventsetup::ComponentDescription::label_, edm::ESModuleCallingContext::moduleCallingContext(), edm::ESModuleCallingContext::state(), edm::ESModuleCallingContext::type(), and edm::eventsetup::ComponentDescription::type_.

Referenced by edm::eventsetup::ESSourceProductResolverBase::doPrefetchAndSignals(), exceptionContext(), edm::Worker::handleExternalWorkException(), edm::eventsetup::CallbackExternalWork< T, TAcquireFunc, TAcquireReturn, TProduceFunc, TProduceReturn, TRecord, TDecorator >::makeAcquireTask(), edm::eventsetup::CallbackExternalWork< T, TAcquireFunc, TAcquireReturn, TProduceFunc, TProduceReturn, TRecord, TDecorator >::makeExceptionHandlerTask(), edm::eventsetup::CallbackBase< T, TProduceFunc, TProduceReturn, TRecord, TDecorator >::makeProduceTask(), edm::Worker::runAcquire(), and edm::Worker::runModule().

                                                                             {
    ESModuleCallingContext const* imcc = &mcc;
    while (true) {
      std::ostringstream iost;
      if (imcc->state() == ESModuleCallingContext::State::kPrefetching) {
        iost << "Prefetching for EventSetup module ";
      } else {
        iost << "Calling method for EventSetup module ";
      }
      iost << imcc->componentDescription()->type_ << "/'" << imcc->componentDescription()->label_ << "'";

      ex.addContext(iost.str());
      if (imcc->type() != ESParentContext::Type::kESModule) {
        break;
      }
      imcc = imcc->esmoduleCallingContext();
    }
    if (imcc->type() == ESParentContext::Type::kModule) {
      edm::exceptionContext(ex, *imcc->moduleCallingContext());
    }
  }

exceptionContext() [2/4]

void edm::exceptionContext	(	std::ostream &	os,
		GlobalContext const &	gc
	)

Definition at line 79 of file GlobalContext.cc.

References edm::GlobalContext::kAccessInputProcessBlock, edm::GlobalContext::kBeginJob, edm::GlobalContext::kBeginLuminosityBlock, edm::GlobalContext::kBeginProcessBlock, edm::GlobalContext::kBeginRun, edm::GlobalContext::kEndJob, edm::GlobalContext::kEndLuminosityBlock, edm::GlobalContext::kEndProcessBlock, edm::GlobalContext::kEndRun, edm::GlobalContext::kWriteLuminosityBlock, edm::GlobalContext::kWriteProcessBlock, edm::GlobalContext::kWriteRun, edm::GlobalContext::luminosityBlockID(), edm::LuminosityBlockID::run(), and edm::GlobalContext::transition().

                                                                 {
    os << "Processing ";
    switch (gc.transition()) {
      case GlobalContext::Transition::kBeginJob:
        os << "begin Job";
        break;
      case GlobalContext::Transition::kBeginProcessBlock:
        os << "begin ProcessBlock";
        break;
      case GlobalContext::Transition::kAccessInputProcessBlock:
        os << "access input ProcessBlock";
        break;
      case GlobalContext::Transition::kBeginRun:
        os << "global begin Run " << RunID(gc.luminosityBlockID().run());
        break;
      case GlobalContext::Transition::kBeginLuminosityBlock:
        os << "global begin LuminosityBlock " << gc.luminosityBlockID();
        break;
      case GlobalContext::Transition::kEndLuminosityBlock:
        os << "global end LuminosityBlock " << gc.luminosityBlockID();
        break;
      case GlobalContext::Transition::kEndRun:
        os << "global end Run " << RunID(gc.luminosityBlockID().run());
        break;
      case GlobalContext::Transition::kEndProcessBlock:
        os << "end ProcessBlock";
        break;
      case GlobalContext::Transition::kEndJob:
        os << "endJob";
        break;
      case GlobalContext::Transition::kWriteProcessBlock:
        os << "write ProcessBlock";
        break;
      case GlobalContext::Transition::kWriteRun:
        os << "write Run " << RunID(gc.luminosityBlockID().run());
        break;
      case GlobalContext::Transition::kWriteLuminosityBlock:
        os << "write LuminosityBlock " << gc.luminosityBlockID();
        break;
    }
  }

exceptionContext() [3/4]

void edm::exceptionContext	(	std::ostream &	os,
		StreamContext const &	sc
	)

Definition at line 71 of file StreamContext.cc.

References edm::StreamContext::eventID(), edm::StreamContext::kBeginLuminosityBlock, edm::StreamContext::kBeginRun, edm::StreamContext::kBeginStream, edm::StreamContext::kEndLuminosityBlock, edm::StreamContext::kEndRun, edm::StreamContext::kEndStream, edm::StreamContext::kEvent, edm::StreamContext::kInvalid, writedatasetfile::run, edm::StreamContext::streamID(), and edm::StreamContext::transition().

                                                                 {
    os << "Processing  ";
    auto id = sc.eventID();
    switch (sc.transition()) {
      case StreamContext::Transition::kBeginStream:
        os << "begin Stream";
        break;
      case StreamContext::Transition::kBeginRun:
        os << "stream begin Run " << RunID(id.run());
        break;
      case StreamContext::Transition::kBeginLuminosityBlock:
        os << "stream begin LuminosityBlock " << LuminosityBlockID(id.run(), id.luminosityBlock());
        break;
      case StreamContext::Transition::kEvent:
        os << "Event " << sc.eventID();
        break;
      case StreamContext::Transition::kEndLuminosityBlock:
        os << "stream end LuminosityBlock " << LuminosityBlockID(id.run(), id.luminosityBlock());
        break;
      case StreamContext::Transition::kEndRun:
        os << "stream end Run " << RunID(id.run());
        break;
      case StreamContext::Transition::kEndStream:
        os << "end Stream";
        break;
      case StreamContext::Transition::kInvalid:
        os << "Invalid";
        break;
    }
    os << " stream: " << sc.streamID();
  }

exceptionContext() [4/4]

void edm::exceptionContext	(	cms::Exception &	ex,
		ModuleCallingContext const &	mcc
	)

Definition at line 92 of file ModuleCallingContext.cc.

References cms::Exception::addContext(), exceptionContext(), edm::ModuleCallingContext::globalContext(), edm::ModuleCallingContext::internalContext(), edm::ParentContext::kGlobal, edm::ParentContext::kInternal, edm::ParentContext::kModule, edm::ParentContext::kPlaceInPath, edm::ModuleCallingContext::kPrefetching, edm::ParentContext::kStream, edm::InternalContext::moduleCallingContext(), edm::ModuleCallingContext::moduleCallingContext(), edm::ModuleCallingContext::moduleDescription(), edm::ModuleDescription::moduleLabel(), edm::ModuleDescription::moduleName(), or, edm::PlaceInPathContext::pathContext(), edm::PathContext::pathName(), edm::ModuleCallingContext::placeInPathContext(), edm::ModuleCallingContext::state(), edm::PathContext::streamContext(), edm::ModuleCallingContext::streamContext(), and edm::ModuleCallingContext::type().

                                                                           {
    ModuleCallingContext const* imcc = &mcc;
    while ((imcc->type() == ParentContext::Type::kModule) or (imcc->type() == ParentContext::Type::kInternal)) {
      std::ostringstream iost;
      if (imcc->state() == ModuleCallingContext::State::kPrefetching) {
        iost << "Prefetching for module ";
      } else {
        iost << "Calling method for module ";
      }
      iost << imcc->moduleDescription()->moduleName() << "/'" << imcc->moduleDescription()->moduleLabel() << "'";

      if (imcc->type() == ParentContext::Type::kInternal) {
        iost << " (probably inside some kind of mixing module)";
        imcc = imcc->internalContext()->moduleCallingContext();
      } else {
        imcc = imcc->moduleCallingContext();
      }
      ex.addContext(iost.str());
    }
    std::ostringstream ost;
    if (imcc->state() == ModuleCallingContext::State::kPrefetching) {
      ost << "Prefetching for module ";
    } else {
      ost << "Calling method for module ";
    }
    ost << imcc->moduleDescription()->moduleName() << "/'" << imcc->moduleDescription()->moduleLabel() << "'";
    ex.addContext(ost.str());

    if (imcc->type() == ParentContext::Type::kPlaceInPath) {
      ost.str("");
      ost << "Running path '";
      ost << imcc->placeInPathContext()->pathContext()->pathName() << "'";
      ex.addContext(ost.str());
      auto streamContext = imcc->placeInPathContext()->pathContext()->streamContext();
      if (streamContext) {
        ost.str("");
        edm::exceptionContext(ost, *streamContext);
        ex.addContext(ost.str());
      }
    } else {
      if (imcc->type() == ParentContext::Type::kStream) {
        ost.str("");
        edm::exceptionContext(ost, *(imcc->streamContext()));
        ex.addContext(ost.str());
      } else if (imcc->type() == ParentContext::Type::kGlobal) {
        ost.str("");
        edm::exceptionContext(ost, *(imcc->globalContext()));
        ex.addContext(ost.str());
      }
    }
  }

fillDescriptionFromPSet()

void edm::fillDescriptionFromPSet	(	ParameterSet const &	pset,
		ParameterSetDescription &	desc
	)

Definition at line 96 of file FillDescriptionFromPSet.cc.

References submitPVResolutionJobs::desc, mps_splice::entry, eostools::move(), and muonDTDigis_cfi::pset.

Referenced by edm::ParameterDescription< std::vector< ParameterSet > >::printNestedContent_(), and edm::ParameterDescription< std::vector< ParameterSet > >::writeOneElementToCfi().

                                                                                        {
    ParameterSet::table const& entries = pset.tbl();
    for (ParameterSet::table::const_iterator entry = entries.begin(), endEntries = entries.end(); entry != endEntries;
         ++entry) {
      std::map<edm::ParameterTypes, FillDescriptionFromParameter>::iterator iter =
          findTheRightFunction().find(static_cast<edm::ParameterTypes>(entry->second.typeCode()));
      if (iter != findTheRightFunction().end()) {
        iter->second(pset, entry->first, entry->second.isTracked(), desc);
      }
    }

    ParameterSet::psettable const& pset_entries = pset.psetTable();
    for (ParameterSet::psettable::const_iterator pset_entry = pset_entries.begin(), endEntries = pset_entries.end();
         pset_entry != endEntries;
         ++pset_entry) {
      edm::ParameterSet nestedPset;
      if (pset_entry->second.isTracked()) {
        nestedPset = pset.getParameterSet(pset_entry->first);
      } else {
        nestedPset = pset.getUntrackedParameterSet(pset_entry->first);
      }
      ParameterSetDescription nestedDescription;
      fillDescriptionFromPSet(nestedPset, nestedDescription);
      if (pset_entry->second.isTracked()) {
        desc.add<edm::ParameterSetDescription>(pset_entry->first, nestedDescription);
      } else {
        desc.addUntracked<edm::ParameterSetDescription>(pset_entry->first, nestedDescription);
      }
    }

    ParameterSet::vpsettable const& vpset_entries = pset.vpsetTable();
    for (ParameterSet::vpsettable::const_iterator vpset_entry = vpset_entries.begin(), endEntries = vpset_entries.end();
         vpset_entry != endEntries;
         ++vpset_entry) {
      std::vector<edm::ParameterSet> nestedVPset;
      if (vpset_entry->second.isTracked()) {
        nestedVPset = pset.getParameterSetVector(vpset_entry->first);
      } else {
        nestedVPset = pset.getUntrackedParameterSetVector(vpset_entry->first);
      }
      ParameterSetDescription emptyDescription;

      auto pd = std::make_unique<ParameterDescription<std::vector<ParameterSet>>>(
          vpset_entry->first, emptyDescription, vpset_entry->second.isTracked(), nestedVPset);

      pd->setPartOfDefaultOfVPSet(true);
      std::unique_ptr<ParameterDescriptionNode> node(std::move(pd));
      desc.addNode(std::move(node));
    }
  }

fillLooper()

std::shared_ptr<EDLooperBase> edm::fillLooper	(	eventsetup::EventSetupsController &	esController,
		eventsetup::EventSetupProvider &	cp,
		ParameterSet &	params,
		std::vector< std::string > const &	loopers
	)

Definition at line 197 of file EventProcessor.cc.

References cms::cuda::assert(), edm::eventsetup::ComponentFactory< T >::get(), and submitPVValidationJobs::params.

Referenced by edm::EventProcessor::init().

                                                                                {
    std::shared_ptr<EDLooperBase> vLooper;

    assert(1 == loopers.size());

    for (auto const& looperName : loopers) {
      ParameterSet* providerPSet = params.getPSetForUpdate(looperName);
      // Unlikely we would ever need the ModuleTypeResolver in Looper
      vLooper = eventsetup::LooperFactory::get()->addTo(esController, cp, *providerPSet, nullptr);
    }
    return vLooper;
  }

fillMaxEventsDescription()

void edm::fillMaxEventsDescription

(

ParameterSetDescription &

description

)

Definition at line 125 of file validateTopLevelParameterSets.cc.

References edm::ParameterSetDescription::addWildcardUntracked(), and makeListRunsInFiles::description.

Referenced by validateTopLevelParameterSets().

                                                                      {
    description.addUntracked<int>("input", -1)->setComment("Default of -1 implies no limit.");

    ParameterSetDescription nestedDescription;
    nestedDescription.addWildcardUntracked<int>("*");
    description.addOptionalNode(ParameterDescription<int>("output", false) xor
                                    ParameterDescription<ParameterSetDescription>("output", nestedDescription, false),
                                false);
  }

fillMaxLuminosityBlocksDescription()

void edm::fillMaxLuminosityBlocksDescription

(

ParameterSetDescription &

description

)

Definition at line 135 of file validateTopLevelParameterSets.cc.

References makeListRunsInFiles::description.

Referenced by validateTopLevelParameterSets().

                                                                                {
    description.addUntracked<int>("input", -1)->setComment("Default of -1 implies no limit.");
  }

fillMaxSecondsUntilRampdownDescription()

void edm::fillMaxSecondsUntilRampdownDescription

(

ParameterSetDescription &

description

)

Definition at line 139 of file validateTopLevelParameterSets.cc.

References makeListRunsInFiles::description.

Referenced by validateTopLevelParameterSets().

                                                                                    {
    description.addUntracked<int>("input", -1)->setComment("Default of -1 implies no limit.");
  }

fillModuleInPathSummary()

static void edm::fillModuleInPathSummary ( Path const &  path, size_t  which, ModuleInPathSummary &  sum  )

static

Definition at line 1271 of file StreamSchedule.cc.

References edm::ModuleInPathSummary::bitPosition, edm::ModuleInPathSummary::moduleLabel, castor_dqm_sourceclient_file_cfg::path, edm::ModuleInPathSummary::timesExcept, edm::ModuleInPathSummary::timesFailed, edm::ModuleInPathSummary::timesPassed, edm::ModuleInPathSummary::timesVisited, and eostools::which().

Referenced by fillPathSummary().

                                                                                                {
    sum.timesVisited += path.timesVisited(which);
    sum.timesPassed += path.timesPassed(which);
    sum.timesFailed += path.timesFailed(which);
    sum.timesExcept += path.timesExcept(which);
    sum.moduleLabel = path.getWorker(which)->description()->moduleLabel();
    sum.bitPosition = path.bitPosition(which);
  }

fillOptionsDescription()

void edm::fillOptionsDescription

(

ParameterSetDescription &

description

)

Definition at line 22 of file validateTopLevelParameterSets.cc.

References edm::ParameterSetDescription::add(), edm::ParameterSetDescription::addUntracked(), edm::ParameterSetDescription::addWildcardUntracked(), makeListRunsInFiles::description, s_defaultNumberOfThreads, and AlCaHLTBitMon_QueryRunRegistry::string.

Referenced by validateTopLevelParameterSets().

                                                                    {
    description.addUntracked<unsigned int>("numberOfThreads", s_defaultNumberOfThreads)
        ->setComment("If zero, let TBB use its default which is normally the number of CPUs on the machine");
    description.addUntracked<unsigned int>("numberOfStreams", 0)
        ->setComment(
            "If zero, then set the number of streams to be the same as the number of "
            "Threads (except always 1 if there is a looper)");
    description.addUntracked<unsigned int>("numberOfConcurrentLuminosityBlocks", 0)
        ->setComment(
            "If zero, use Framework default (currently 2 when the number of streams >= 2, otherwise 1). "
            "In all cases, the number of concurrent luminosity blocks will be reset to "
            "be the same as the number of streams if it is greater than the "
            "numbers of streams.");
    description.addUntracked<unsigned int>("numberOfConcurrentRuns", 1)
        ->setComment(
            "If zero or greater than the number of concurrent luminosity blocks, this will be reset to "
            "be the same as the number of concurrent luminosity blocks.");

    edm::ParameterSetDescription eventSetupDescription;
    eventSetupDescription.addUntracked<unsigned int>("numberOfConcurrentIOVs", 0)
        ->setComment(
            "If zero, use the Framework default which currently means the same as the "
            "number of concurrent luminosity blocks. Can be overridden by a hard coded "
            "static in a record C++ definition or by forceNumberOfConcurrentIOVs. "
            "In all cases, the number of concurrent IOVs will be reset to be the "
            "same as the number of concurrent luminosity blocks if greater than the "
            "number of concurrent luminosity blocks.");
    edm::ParameterSetDescription nestedDescription;
    nestedDescription.addWildcardUntracked<unsigned int>("*")->setComment(
        "Parameter names should be record names and the values are the number of concurrent IOVS for each record."
        " Overrides all other methods of setting number of concurrent IOVs.");
    eventSetupDescription.addUntracked<edm::ParameterSetDescription>("forceNumberOfConcurrentIOVs", nestedDescription);
    description.addUntracked<edm::ParameterSetDescription>("eventSetup", eventSetupDescription);

    description.addUntracked<std::vector<std::string>>("accelerators", {"*"})
        ->setComment(
            "Specify the set of compute accelerator(s) the job is allowed to use. The values can contain the direct "
            "names of accelerators supported by the ProcessAccelerators defined in the configuration, or patterns "
            "matching to them (patterns use '*' and '?' wildcards similar to shell). The actual set of accelerators to "
            "be used is determined on the worker node based on the available hardware. A CPU fallback with the name "
            "'cpu' is always included in the set of available accelerators. If no accelerator matching to the patterns "
            "are available on the worker node, the job is terminated with a specific error code. Same happens if an "
            "empty value is given in the configuration. Default value is pattern '*', which implies use of any "
            "supported and available hardware (including the CPU fallback).");
    description.addUntracked<bool>("wantSummary", false)
        ->setComment("Set true to print a report on the trigger decisions and timing of modules");
    description.addUntracked<std::string>("fileMode", "FULLMERGE")
        ->setComment("Legal values are 'NOMERGE' and 'FULLMERGE'");
    description.addUntracked<bool>("forceEventSetupCacheClearOnNewRun", false);
    description.addUntracked<bool>("throwIfIllegalParameter", true)
        ->setComment("Set false to disable exception throws when configuration validation detects illegal parameters");
    description.addUntracked<bool>("printDependencies", false)->setComment("Print data dependencies between modules");
    description.addUntracked<bool>("deleteNonConsumedUnscheduledModules", true)
        ->setComment(
            "Delete modules that are unscheduled, i.e. only in Tasks, whose products are not consumed by any other "
            "otherwise-running module");

    // No default for this one because the parameter value is
    // actually used in the main function in cmsRun.cpp before
    // the parameter set is validated here.
    description.addOptionalUntracked<unsigned int>("sizeOfStackForThreadsInKB");

    std::vector<std::string> emptyVector;

    description.addUntracked<std::vector<std::string>>("Rethrow", emptyVector);
    description.addUntracked<std::vector<std::string>>("TryToContinue", emptyVector);
    description.addUntracked<std::vector<std::string>>("IgnoreCompletely", emptyVector);

    description.addUntracked<std::vector<std::string>>("modulesToCallForTryToContinue", emptyVector)
        ->setComment("Labels of modules which should still be called when an exception in TryToContinue list happens.");

    description.addUntracked<std::vector<std::string>>("canDeleteEarly", emptyVector)
        ->setComment("Branch names of products that the Framework can try to delete before the end of the Event");

    {
      edm::ParameterSetDescription validator;
      validator.add<std::string>("product");
      validator.add<std::vector<std::string>>("references")
          ->setComment("All the branch names for products to which 'product' contains a reference.");
      description.addVPSetUntracked("holdsReferencesToDeleteEarly", validator, std::vector<edm::ParameterSet>{})
          ->setComment(
              "The 'product' branch name of product which internally hold references to data in another product");
    }
    description.addUntracked<std::vector<std::string>>("modulesToIgnoreForDeleteEarly", emptyVector)
        ->setComment(
            "labels of modules whose consumes information will be ingored when determing lifetime for delete early "
            "data products");
    description.addUntracked<bool>("dumpOptions", false)
        ->setComment(
            "Print values of selected Framework parameters. The Framework might modify the values "
            "in the options parameter set and this prints the values after that modification.");

    description.addOptionalUntracked<bool>("allowUnscheduled")
        ->setComment(
            "Obsolete. Has no effect. Allowed only for backward compatibility for old Python configuration files.");
    description.addOptionalUntracked<std::string>("emptyRunLumiMode")
        ->setComment(
            "Obsolete. Has no effect. Allowed only for backward compatibility for old Python configuration files.");
    description.addOptionalUntracked<bool>("makeTriggerResults")
        ->setComment(
            "Obsolete. Has no effect. Allowed only for backward compatibility for old Python configuration files.");
  }

fillParameterSetBranch()

void edm::fillParameterSetBranch	(	TTree *	parameterSetsTree,
		int	basketSize
	)

Definition at line 18 of file CommonProvenanceFiller.cc.

References b, edm::poolNames::idToParameterSetBlobsBranchName(), edm::pset::Registry::instance(), and muonDTDigis_cfi::pset.

Referenced by NanoAODOutputModule::reallyCloseFile(), and edm::RootOutputFile::writeParameterSetRegistry().

                                                                        {
    std::pair<ParameterSetID, ParameterSetBlob> idToBlob;
    std::pair<ParameterSetID, ParameterSetBlob>* pIdToBlob = &idToBlob;
    TBranch* b =
        parameterSetsTree->Branch(poolNames::idToParameterSetBlobsBranchName().c_str(), &pIdToBlob, basketSize, 0);

    for (auto const& pset : *pset::Registry::instance()) {
      idToBlob.first = pset.first;
      idToBlob.second.pset() = pset.second.toString();

      b->Fill();
    }
  }

fillPathSummary()

static void edm::fillPathSummary ( Path const &  path, PathSummary &  sum  )

static

Definition at line 1280 of file StreamSchedule.cc.

References cms::cuda::assert(), edm::PathSummary::bitPosition, fillModuleInPathSummary(), mps_fire::i, edm::PathSummary::moduleInPathSummaries, edm::PathSummary::name, castor_dqm_sourceclient_file_cfg::path, groupFilesInBlocks::temp, edm::PathSummary::timesExcept, edm::PathSummary::timesFailed, edm::PathSummary::timesPassed, and edm::PathSummary::timesRun.

Referenced by edm::SystemTimeKeeper::fillTriggerTimingReport(), and edm::StreamSchedule::getTriggerReport().

                                                                  {
    sum.name = path.name();
    sum.bitPosition = path.bitPosition();
    sum.timesRun += path.timesRun();
    sum.timesPassed += path.timesPassed();
    sum.timesFailed += path.timesFailed();
    sum.timesExcept += path.timesExcept();

    Path::size_type sz = path.size();
    if (sum.moduleInPathSummaries.empty()) {
      std::vector<ModuleInPathSummary> temp(sz);
      for (size_t i = 0; i != sz; ++i) {
        fillModuleInPathSummary(path, i, temp[i]);
      }
      sum.moduleInPathSummaries.swap(temp);
    } else {
      assert(sz == sum.moduleInPathSummaries.size());
      for (size_t i = 0; i != sz; ++i) {
        fillModuleInPathSummary(path, i, sum.moduleInPathSummaries[i]);
      }
    }
  }

fillProcessHistoryBranch()

void edm::fillProcessHistoryBranch	(	TTree *	metaDataTree,
		int	basketSize,
		ProcessHistoryRegistry const &	processHistoryRegistry
	)

Definition at line 32 of file CommonProvenanceFiller.cc.

References cms::cuda::assert(), b, AlCaHLTBitMon_ParallelJobs::p, and edm::poolNames::processHistoryBranchName().

Referenced by NanoAODOutputModule::reallyCloseFile(), and edm::RootOutputFile::writeProcessHistoryRegistry().

                                                                                      {
    ProcessHistoryVector procHistoryVector;
    for (auto const& ph : processHistoryRegistry) {
      procHistoryVector.push_back(ph.second);
    }
    ProcessHistoryVector* p = &procHistoryVector;
    TBranch* b = metaDataTree->Branch(poolNames::processHistoryBranchName().c_str(), &p, basketSize, 0);
    assert(b);
    b->Fill();
  }

fillPtrVector() [1/6]

template<typename T , typename A >

void edm::fillPtrVector	(	std::vector< T, A > const &	obj,
		std::type_info const &	iToType,
		std::vector< unsigned long > const &	iIndicies,
		std::vector< void const *> &	oPtr
	)

Definition at line 80 of file fillPtrVector.h.

References getGTfromDQMFile::obj, and edm::detail::reallyfillPtrVector().

                                                   {
    detail::reallyfillPtrVector(obj, iToType, iIndicies, oPtr);
  }

fillPtrVector() [2/6]

template<typename T , typename A >

void edm::fillPtrVector	(	std::list< T, A > const &	obj,
		std::type_info const &	iToType,
		std::vector< unsigned long > const &	iIndicies,
		std::vector< void const *> &	oPtr
	)

Definition at line 88 of file fillPtrVector.h.

References getGTfromDQMFile::obj, and edm::detail::reallyfillPtrVector().

                                                   {
    detail::reallyfillPtrVector(obj, iToType, iIndicies, oPtr);
  }

fillPtrVector() [3/6]

template<typename T , typename A >

void edm::fillPtrVector	(	std::deque< T, A > const &	obj,
		std::type_info const &	iToType,
		std::vector< unsigned long > const &	iIndicies,
		std::vector< void const *> &	oPtr
	)

Definition at line 96 of file fillPtrVector.h.

References getGTfromDQMFile::obj, and edm::detail::reallyfillPtrVector().

                                                   {
    detail::reallyfillPtrVector(obj, iToType, iIndicies, oPtr);
  }

fillPtrVector() [4/6]

template<typename T , typename A , typename Comp >

void edm::fillPtrVector	(	std::set< T, A, Comp > const &	obj,
		std::type_info const &	iToType,
		std::vector< unsigned long > const &	iIndicies,
		std::vector< void const *> &	oPtr
	)

Definition at line 104 of file fillPtrVector.h.

References getGTfromDQMFile::obj, and edm::detail::reallyfillPtrVector().

                                                   {
    detail::reallyfillPtrVector(obj, iToType, iIndicies, oPtr);
  }

fillPtrVector() [5/6]

template<typename T , typename SORT >

void edm::fillPtrVector ( SortedCollection< T, SORT > const &  obj, std::type_info const &  toType, std::vector< unsigned long > const &  indices, std::vector< void const *> &  ptrs  )

inline

Definition at line 394 of file SortedCollection.h.

References dqmdumpme::indices, and getGTfromDQMFile::obj.

                                                          {
    obj.fillPtrVector(toType, indices, ptrs);
  }

fillPtrVector() [6/6]

template<typename T , typename P >

void edm::fillPtrVector ( OwnVector< T, P > const &  obj, std::type_info const &  toType, std::vector< unsigned long > const &  indices, std::vector< void const *> &  ptrs  )

inline

Definition at line 581 of file OwnVector.h.

References dqmdumpme::indices, and getGTfromDQMFile::obj.

                                                          {
    obj.fillPtrVector(toType, indices, ptrs);
  }

fillView() [1/12]

template<class T , class A >

void edm::fillView	(	std::vector< T, A > const &	obj,
		ProductID const &	id,
		std::vector< void const *> &	ptrs,
		FillViewHelperVector &	helpers
	)

Definition at line 45 of file FillView.h.

References getGTfromDQMFile::obj, and edm::detail::reallyFillView().

                                               {
    detail::reallyFillView(obj, id, ptrs, helpers);
  }

fillView() [2/12]

template<class T , class A >

void edm::fillView	(	std::list< T, A > const &	obj,
		ProductID const &	id,
		std::vector< void const *> &	ptrs,
		FillViewHelperVector &	helpers
	)

Definition at line 53 of file FillView.h.

References getGTfromDQMFile::obj, and edm::detail::reallyFillView().

                                               {
    detail::reallyFillView(obj, id, ptrs, helpers);
  }

fillView() [3/12]

template<class T , class A >

void edm::fillView	(	std::deque< T, A > const &	obj,
		ProductID const &	id,
		std::vector< void const *> &	ptrs,
		FillViewHelperVector &	helpers
	)

Definition at line 61 of file FillView.h.

References getGTfromDQMFile::obj, and edm::detail::reallyFillView().

                                               {
    detail::reallyFillView(obj, id, ptrs, helpers);
  }

fillView() [4/12]

template<class T , class A , class Comp >

void edm::fillView	(	std::set< T, A, Comp > const &	obj,
		ProductID const &	id,
		std::vector< void const *> &	ptrs,
		FillViewHelperVector &	helpers
	)

Definition at line 69 of file FillView.h.

References getGTfromDQMFile::obj, and edm::detail::reallyFillView().

                                               {
    detail::reallyFillView(obj, id, ptrs, helpers);
  }

fillView() [5/12]

template<typename C , typename T , typename F >

void edm::fillView ( RefVector< C, T, F > const &  obj, ProductID const &  id, std::vector< void const *> &  pointers, FillViewHelperVector &  helpers  )

inline

Definition at line 192 of file RefVector.h.

References getGTfromDQMFile::obj.

                                                      {
    obj.fillView(id, pointers, helpers);
  }

fillView() [6/12]

template<typename T >

void edm::fillView ( PtrVector< T > const &  obj, ProductID const &  , std::vector< void const *> &  pointers, FillViewHelperVector &  helpers  )

inline

Definition at line 199 of file PtrVector.h.

References getGTfromDQMFile::obj.

                                                      {
    obj.fillView(pointers, helpers);
  }

fillView() [7/12]

template<typename T >

void edm::fillView ( RefToBaseVector< T > const &  obj, ProductID const &  , std::vector< void const *> &  pointers, FillViewHelperVector &  helpers  )

inline

Definition at line 204 of file RefToBaseVector.h.

References getGTfromDQMFile::obj.

                                                      {
    obj.fillView(pointers, helpers);
  }

fillView() [8/12]

template<typename T >

void edm::fillView ( std::vector< edm::Ptr< T > > const &  obj, ProductID const &  id, std::vector< void const *> &  pointers, FillViewHelperVector &  helpers  )

inline

Definition at line 262 of file Ptr.h.

References getGTfromDQMFile::obj, and AlCaHLTBitMon_ParallelJobs::p.

                                                      {
    pointers.reserve(obj.size());
    helpers.reserve(obj.size());
    for (auto const& p : obj) {
      if (p.isAvailable()) {
        pointers.push_back(p.get());
      } else {
        pointers.push_back(nullptr);
      }
      helpers.emplace_back(p.id(), p.key());
    }
  }

fillView() [9/12]

template<typename KeyRefProd , typename CVal , typename KeyRef , typename SizeType , typename KeyReferenceHelper >

void edm::fillView ( AssociationVector< KeyRefProd, CVal, KeyRef, SizeType, KeyReferenceHelper > const &  obj, ProductID const &  id, std::vector< void const *> &  pointers, FillViewHelperVector &  helpers  )

inline

Definition at line 290 of file AssociationVector.h.

References getGTfromDQMFile::obj.

Referenced by edm::RefToBaseProd< T >::RefToBaseProd().

                                                      {
    obj.fillView(id, pointers, helpers);
  }

fillView() [10/12]

template<class T >

void edm::fillView ( DetSetVector< T > const &  obj, ProductID const &  id, std::vector< void const *> &  pointers, FillViewHelperVector &  helpers  )

inline

Definition at line 364 of file DetSetVector.h.

References getGTfromDQMFile::obj.

                                                      {
    obj.fillView(id, pointers, helpers);
  }

fillView() [11/12]

template<typename T , typename SORT >

void edm::fillView ( SortedCollection< T, SORT > const &  obj, ProductID const &  id, std::vector< void const *> &  pointers, FillViewHelperVector &  helpers  )

inline

Definition at line 377 of file SortedCollection.h.

References getGTfromDQMFile::obj.

                                                      {
    obj.fillView(id, pointers, helpers);
  }

fillView() [12/12]

template<typename T , typename P >

void edm::fillView ( OwnVector< T, P > const &  obj, ProductID const &  id, std::vector< void const *> &  pointers, FillViewHelperVector &  helpers  )

inline

Definition at line 549 of file OwnVector.h.

References getGTfromDQMFile::obj.

                                                      {
    obj.fillView(id, pointers, helpers);
  }

fillWorkerSummary()

static void edm::fillWorkerSummary ( Worker const *  pw, WorkerSummary &  sum  )

static

Definition at line 1312 of file StreamSchedule.cc.

References fillWorkerSummaryAux().

Referenced by edm::StreamSchedule::getTriggerReport().

{ fillWorkerSummaryAux(*pw, sum); }

fillWorkerSummaryAux()

static void edm::fillWorkerSummaryAux ( Worker const &  w, WorkerSummary &  sum  )

static

Definition at line 1303 of file StreamSchedule.cc.

References edm::WorkerSummary::moduleLabel, edm::WorkerSummary::timesExcept, edm::WorkerSummary::timesFailed, edm::WorkerSummary::timesPassed, edm::WorkerSummary::timesRun, edm::WorkerSummary::timesVisited, and w().

Referenced by fillWorkerSummary().

                                                                        {
    sum.timesVisited += w.timesVisited();
    sum.timesRun += w.timesRun();
    sum.timesPassed += w.timesPassed();
    sum.timesFailed += w.timesFailed();
    sum.timesExcept += w.timesExcept();
    sum.moduleLabel = w.description()->moduleLabel();
  }

find_if_in_all() [1/2]

template<typename ForwardSequence , typename Predicate >

ForwardSequence::const_iterator edm::find_if_in_all ( ForwardSequence const &  s, Predicate const &  p  )

inline

wrappers for std::find

Definition at line 42 of file Algorithms.h.

References AlCaHLTBitMon_ParallelJobs::p, and alignCSCRings::s.

                                                                                                             {
    return std::find_if(s.begin(), s.end(), p);
  }

find_if_in_all() [2/2]

template<typename ForwardSequence , typename Predicate >

ForwardSequence::iterator edm::find_if_in_all ( ForwardSequence &  s, Predicate const &  p  )

inline

Definition at line 47 of file Algorithms.h.

References AlCaHLTBitMon_ParallelJobs::p, and alignCSCRings::s.

                                                                                                 {
    return std::find_if(s.begin(), s.end(), p);
  }

find_in_all() [1/2]

template<typename ForwardSequence , typename Datum >

ForwardSequence::const_iterator edm::find_in_all ( ForwardSequence const &  s, Datum const &  d  )

inline

wrappers for std::find

Definition at line 26 of file Algorithms.h.

References ztail::d, spr::find(), and alignCSCRings::s.

Referenced by edm::RootFile::fillIndexIntoFile(), and edm::BranchIDListHelper::updateFromInput().

                                                                                                      {
    return std::find(s.begin(), s.end(), d);
  }

find_in_all() [2/2]

template<typename ForwardSequence , typename Datum >

ForwardSequence::iterator edm::find_in_all ( ForwardSequence &  s, Datum const &  d  )

inline

Definition at line 31 of file Algorithms.h.

References ztail::d, spr::find(), and alignCSCRings::s.

                                                                                          {
    return std::find(s.begin(), s.end(), d);
  }

findOrAssert() [1/2]

template<typename Key , typename Value >

Value const& edm::findOrAssert ( std::map< Key, Value > const &  m, Key const &  k  )

inline

Definition at line 48 of file Map.h.

References cms::cuda::assert(), ALPAKA_ACCELERATOR_NAMESPACE::vertexFinder::it, dqmdumpme::k, and visualization-live-secondInstance_cfg::m.

                                                                              {
    typename std::map<Key, Value>::const_iterator it = m.find(k);
    if (it == m.end())
      assert("findOrAssert" && 0);
    return it->second;
  }

findOrAssert() [2/2]

template<typename Key , typename Value >

Value& edm::findOrAssert ( std::map< Key, Value > &  m, Key const &  k  )

inline

Definition at line 56 of file Map.h.

References cms::cuda::assert(), ALPAKA_ACCELERATOR_NAMESPACE::vertexFinder::it, dqmdumpme::k, and visualization-live-secondInstance_cfg::m.

                                                                  {
    typename std::map<Key, Value>::const_iterator it = m.find(k);
    if (it == m.end())
      assert("findOrAssert" && 0);
    return it->second;
  }

findOrDefault() [1/3]

template<typename Key , typename Value >

Value const& edm::findOrDefault ( std::map< Key, Value > const &  m, Key const &  k, Value const &  defaultValue  )

inline

Definition at line 24 of file Map.h.

References hltPixelClustersMultiplicity_cfi::defaultValue, ALPAKA_ACCELERATOR_NAMESPACE::vertexFinder::it, dqmdumpme::k, and visualization-live-secondInstance_cfg::m.

Referenced by edm::JobReport::dumpFiles(), and edm::JobReport::JobReportImpl::writeOutputFile().

                                                                                                          {
    typename std::map<Key, Value>::const_iterator it = m.find(k);
    return (it == m.end() ? defaultValue : it->second);
  }

findOrDefault() [2/3]

template<typename Key , typename Value >

Value& edm::findOrDefault ( std::map< Key, Value > &  m, Key const &  k, Value &  defaultValue  )

inline

Definition at line 30 of file Map.h.

References hltPixelClustersMultiplicity_cfi::defaultValue, ALPAKA_ACCELERATOR_NAMESPACE::vertexFinder::it, dqmdumpme::k, and visualization-live-secondInstance_cfg::m.

                                                                                        {
    typename std::map<Key, Value>::const_iterator it = m.find(k);
    return (it == m.end() ? defaultValue : it->second);
  }

findOrDefault() [3/3]

template<typename Key , typename Value >

Value edm::findOrDefault ( std::map< Key, Value > const &  m, Key const &  k  )

inline

Definition at line 39 of file Map.h.

References ALPAKA_ACCELERATOR_NAMESPACE::vertexFinder::it, dqmdumpme::k, and visualization-live-secondInstance_cfg::m.

                                                                        {
    typename std::map<Key, Value>::const_iterator it = m.find(k);
    return (it == m.end() ? Value() : it->second);
  }

findOrInsert()

template<typename Key , typename Value >

Value& edm::findOrInsert ( std::map< Key, Value > &  m, Key const &  k  )

inline

Definition at line 16 of file Map.h.

References dqmdumpme::k, and visualization-live-secondInstance_cfg::m.

                                                                  {
    return m[k];
  }

first()

template<typename T , typename U >

T edm::first

(

std::pair< T, U > const &

p

)

Definition at line 217 of file ParameterSet.cc.

References AlCaHLTBitMon_ParallelJobs::p.

Referenced by edm::TrieNode< T >::_sequentialSearch(), L1TGlobalSummary::analyze(), l1t::GtRecordDump::analyze(), TrackAssociatorByChi2Impl::associateRecoToSim(), edm::EventProcessor::beginJob(), edm::TypeWithDict::byName(), edm::service::ELoutput::emitToken(), edm::EventProcessor::endJob(), edm::ParameterSet::getParameterNames(), PF_PU_FirstVertexTracks::produce(), PFCand_NoPU_WithAM::produce(), stripTemplate(), edm::TrieNode< T >::subNodeByLabel(), edm::storage::StorageAccount::summaryText(), and L1TOccupancyClientHistogramService::updateHistogramEndLS().

                                  {
    return p.first;
  }

FlushMessageLog()

void edm::FlushMessageLog

(

)

Definition at line 34 of file MessageLogger.cc.

References edm::MessageDrop::instance(), edm::MessageLoggerQ::MLqFLS(), and MLSCRIBE_RUNNING_INDICATOR.

Referenced by lhef::logFileAction(), edm::InputFile::logFileAction(), dqm::DQMFileSaverBase::logFileAction(), edm::StreamerInputFile::logFileAction(), dqmservices::DQMFileIterator::logFileAction(), and DQMRootSource::logFileAction().

                         {
    if (MessageDrop::instance()->messageLoggerScribeIsRunning != MLSCRIBE_RUNNING_INDICATOR)
      return;
    edm::MessageLoggerQ::MLqFLS();  // Flush the message log queue
  }

for_all()

template<typename ForwardSequence , typename Func >

Func edm::for_all ( ForwardSequence &  s, Func  f  )

inline

wrapper for std::for_each

Function templates that provide wrappers for standard algorithms, avoiding some duplication and assuring that incommensurate iterators are not used.

Definition at line 14 of file Algorithms.h.

References f, and alignCSCRings::s.

Referenced by edm::WorkerManager::beginJob(), edm::EventProcessor::beginJob(), edm::SubProcess::beginJob(), edm::ParameterSwitch< T >::checkAndGetLabelsAndTypes_(), edm::Path::clearCounters(), edm::SubProcess::clearCounters(), edm::StreamSchedule::clearCounters(), edm::SubProcess::closeOutputFiles(), edm::EventProcessor::closeOutputFiles(), edm::Schedule::closeOutputFiles(), edm::SubProcess::doBeginStream(), edm::SubProcess::doEndStream(), edm::RootOutputTree::fillTTree(), edm::SubProcess::fixBranchIDListsForEDAliases(), edm::SubProcess::keepOnlyConsumedUnscheduledModules(), main(), edm::SubProcess::openOutputFiles(), edm::EventProcessor::openOutputFiles(), edm::Schedule::openOutputFiles(), edm::service::StallMonitor::postEndJob(), edm::EDLooperBase::prepareForNextLoop(), edm::ParameterSetDescription::print(), edm::ParameterSwitch< T >::printNestedContent_(), edm::WorkerManager::resetAll(), edm::eventsetup::EventSetupRecordProvider::resetRecordToResolverPointers(), edm::SubProcess::respondToCloseInputFile(), edm::EventProcessor::respondToCloseInputFile(), edm::Schedule::respondToCloseInputFile(), edm::SubProcess::respondToOpenInputFile(), edm::EventProcessor::respondToOpenInputFile(), edm::Schedule::respondToOpenInputFile(), edm::SubProcess::updateBranchIDListHelper(), edm::eventsetup::EventSetupRecordProvider::usePreferred(), edm::ConfigurationDescriptions::validate(), edm::ParameterSetDescription::validate(), edm::AllowedLabelsDescriptionBase::validate_(), edm::ParameterWildcard< ParameterSetDescription >::validate_(), edm::ParameterWildcard< std::vector< ParameterSet > >::validate_(), edm::ParameterSetDescription::writeCfi(), edm::ParameterDescription< std::vector< ParameterSet > >::writeCfi_(), edm::ConfigurationDescriptions::writeCfis(), and edm::writeParameterValue::writeVector().

                                                  {
    return std::for_each(s.begin(), s.end(), f);
  }

formatFile()

template<typename S , typename T >

S& edm::formatFile	(	T const &	f,
		S &	os
	)

Definition at line 40 of file JobReport.cc.

References MicroEventContent_cff::branch, hcalRecHitTable_cff::doc, and f.

Referenced by print().

                                   {
    tinyxml2::XMLDocument doc;
    if (f.fileHasBeenClosed) {
      os << "\n<State  Value=\"closed\"/>";
    } else {
      os << "\n<State  Value=\"open\"/>";
    }
    os << "\n<LFN>" << doc.NewText(f.logicalFileName.c_str())->Value() << "</LFN>";
    os << "\n<PFN>" << doc.NewText(f.physicalFileName.c_str())->Value() << "</PFN>";
    os << "\n<Catalog>" << doc.NewText(f.catalog.c_str())->Value() << "</Catalog>";
    os << "\n<ModuleLabel>" << doc.NewText(f.moduleLabel.c_str())->Value() << "</ModuleLabel>";
    os << "\n<GUID>" << f.guid << "</GUID>";
    os << "\n<Branches>";
    for (auto const& branch : f.branchNames) {
      os << "\n  <Branch>" << doc.NewText(branch.c_str())->Value() << "</Branch>";
      doc.DeleteChildren();
    }
    os << "\n</Branches>";
    return os;
  }

FreshErrorsExist()

bool edm::FreshErrorsExist

(

unsigned int

iStreamID

)

Definition at line 161 of file MessageSender.cc.

References cms::cuda::assert(), and errorSummaryMaps.

Referenced by HLTLogMonitorFilter::filter(), and edm::LogErrorHarvester::produce().

                                                {
    assert(iStreamID < errorSummaryMaps.size());
    return !errorSummaryMaps[iStreamID].empty();
  }

get() [1/11]

template<typename T >

T const& edm::get	(	ProcessBlock const &	processBlock,
		EDGetToken const &	token
	)

Definition at line 218 of file ProcessBlock.h.

References patZpeak::handle, and unpackBuffers-CaloStage2::token.

                                                                          {
    Handle<T> handle;
    processBlock.getByToken(token, handle);
    // throw if the handle is not valid
    return *handle.product();
  }

get() [2/11]

template<typename T >

T const& edm::get	(	ProcessBlock const &	processBlock,
		EDGetTokenT< T > const &	token
	)

Definition at line 226 of file ProcessBlock.h.

References patZpeak::handle, and unpackBuffers-CaloStage2::token.

                                                                              {
    Handle<T> handle;
    processBlock.getByToken(token, handle);
    // throw if the handle is not valid
    return *handle.product();
  }

get() [3/11]

template<typename T >

T const& edm::get	(	Run const &	event,
		InputTag const &	tag
	)

Definition at line 364 of file Run.h.

References patZpeak::handle, and makeGlobalPositionRcd_cfg::tag.

                                                      {
    Handle<T> handle;
    event.getByLabel(tag, handle);
    // throw if the handle is not valid
    return *handle.product();
  }

get() [4/11]

template<typename T >

T const& edm::get	(	LuminosityBlock const &	event,
		InputTag const &	tag
	)

Definition at line 367 of file LuminosityBlock.h.

References patZpeak::handle, and makeGlobalPositionRcd_cfg::tag.

                                                                  {
    Handle<T> handle;
    event.getByLabel(tag, handle);
    // throw if the handle is not valid
    return *handle.product();
  }

get() [5/11]

template<typename T >

T const& edm::get	(	Run const &	event,
		EDGetToken const &	token
	)

Definition at line 372 of file Run.h.

References patZpeak::handle, and unpackBuffers-CaloStage2::token.

                                                          {
    Handle<T> handle;
    event.getByToken(token, handle);
    // throw if the handle is not valid
    return *handle.product();
  }

get() [6/11]

template<typename T >

T const& edm::get	(	LuminosityBlock const &	event,
		EDGetToken const &	token
	)

Definition at line 375 of file LuminosityBlock.h.

References patZpeak::handle, and unpackBuffers-CaloStage2::token.

                                                                      {
    Handle<T> handle;
    event.getByToken(token, handle);
    // throw if the handle is not valid
    return *handle.product();
  }

get() [7/11]

template<typename T >

T const& edm::get	(	Run const &	event,
		EDGetTokenT< T > const &	token
	)

Definition at line 380 of file Run.h.

References patZpeak::handle, and unpackBuffers-CaloStage2::token.

                                                              {
    Handle<T> handle;
    event.getByToken(token, handle);
    // throw if the handle is not valid
    return *handle.product();
  }

get() [8/11]

template<typename T >

T const& edm::get	(	LuminosityBlock const &	event,
		EDGetTokenT< T > const &	token
	)

Definition at line 383 of file LuminosityBlock.h.

References patZpeak::handle, and unpackBuffers-CaloStage2::token.

                                                                          {
    Handle<T> handle;
    event.getByToken(token, handle);
    // throw if the handle is not valid
    return *handle.product();
  }

get() [9/11]

template<typename T >

T const& edm::get ( Event const &  event, InputTag const &  tag  )

noexcept

Definition at line 668 of file Event.h.

References patZpeak::handle, and makeGlobalPositionRcd_cfg::tag.

Referenced by triggerExpression::Data::setEvent().

                                                                        {
    Handle<T> handle;
    event.getByLabel(tag, handle);
    // throw if the handle is not valid
    return *handle.product();
  }

get() [10/11]

template<typename T >

T const& edm::get ( Event const &  event, EDGetToken const &  token  )

noexcept

Definition at line 676 of file Event.h.

References patZpeak::handle, and unpackBuffers-CaloStage2::token.

                                                                            {
    Handle<T> handle;
    event.getByToken(token, handle);
    // throw if the handle is not valid
    return *handle.product();
  }

get() [11/11]

template<typename T >

T const& edm::get ( Event const &  event, EDGetTokenT< T > const &  token  )

noexcept

Definition at line 684 of file Event.h.

References unpackBuffers-CaloStage2::token.

                                                                                {
    return event.get(token);
  }

get_underlying() [1/4]

template<typename T >

constexpr T & edm::get_underlying

(

propagate_const< T > &

iP

)

Definition at line 103 of file propagate_const.h.

References edm::propagate_const< T >::m_value.

Referenced by cms::cuda::copyAsync(), edm::SharedResourcesRegistry::createAcquirerForSourceDelayedReader(), edm::eventsetup::ESSourceInfo::finder(), get_underlying_safe(), edm::GlobalSchedule::GlobalSchedule(), edm::StreamSchedule::makePathStatusInserters(), edm::ConsumesCollector::operator=(), edm::ProducesCollector::operator=(), and edm::eventsetup::ESProducerInfo::provider().

                                                      {
    return iP.m_value;
  }

get_underlying() [2/4]

template<typename T >

constexpr T const & edm::get_underlying

(

propagate_const< T > const &

iP

)

Definition at line 107 of file propagate_const.h.

References edm::propagate_const< T >::m_value.

                                                                  {
    return iP.m_value;
  }

get_underlying() [3/4]

template<typename T >

constexpr std::decay_t< T > & edm::get_underlying

(

propagate_const_array< T > &

iP

)

Definition at line 120 of file propagate_const_array.h.

References edm::propagate_const_array< T >::m_value.

                                                                        {
    return iP.m_value;
  }

get_underlying() [4/4]

template<typename T >

constexpr std::decay_t< T > const & edm::get_underlying

(

propagate_const_array< T > const &

iP

)

Definition at line 125 of file propagate_const_array.h.

References edm::propagate_const_array< T >::m_value.

                                                                                    {
    return iP.m_value;
  }

get_underlying_safe() [1/12]

template<typename T >

constexpr std::shared_ptr<T>& edm::get_underlying_safe

(

propagate_const< std::shared_ptr< T >> &

iP

)

Definition at line 41 of file get_underlying_safe.h.

References get_underlying().

Referenced by edm::eventsetup::EventSetupRecordProvider::addProxiesToRecordHelper(), edm::RootFile::branchChildren(), edm::ScheduleItems::branchIDListHelper(), edm::root::TFWLiteSelectorMembers::branchIDListHelper(), edm::InputSource::branchIDListHelper(), edm::SubProcess::branchIDListHelper(), edm::RootFile::branchIDListHelper(), edm::EventProcessor::branchIDListHelper(), SerializeDataBuffer::bufferPointer(), edm::ProcessBlock::commit_(), edm::LuminosityBlock::commit_(), edm::Run::commit_(), edm::Event::commit_aux(), XrdAdaptor::XrdStatisticsService::condorUpdate(), edm::WorkerT< T >::doClearModule(), edm::RootPrimaryFileSequence::duplicateChecker(), edm::service::RandomNumberGeneratorService::LabelAndEngine::engine(), edm::RootFile::eventProductProvenanceRetriever(), edm::eventsetup::EventSetupProvider::eventSetupForInstance(), edm::StreamerFileReader::eventSkipperByID(), edm::RootPrimaryFileSequence::eventSkipperByID(), XrdAdaptor::Source::fh(), edm::RootOutputFile::filePtr(), edm::RootFile::fillEventToProcessBlockIndexes(), edm::eventsetup::EventSetupRecordProvider::finder(), XrdAdaptor::ClientRequest::getCurrentSource(), edm::ModuleRegistry::getModule(), edm::ProcessDesc::getProcessPSet(), XrdAdaptor::XrdSiteStatisticsInformation::getStatisticsForSite(), edm::RootFile::indexIntoFileSharedPtr(), edm::EventProcessor::init(), HepMCFileReader::input(), edm::service::RandomNumberGeneratorService::ModuleIDToEngine::labelAndEngine(), edm::EventProcessor::looper(), edm::Schedule::moduleRegistry(), edm::value_ptr< edm::service::MessageLoggerDefaults >::operator->(), edm::JobReport::JobReportImpl::ost(), edm::RootOutputFile::pEventEntryInfoVector(), edm::ScheduleItems::preg(), edm::EventProcessor::preg(), edm::InputSource::processBlockHelper(), edm::ScheduleItems::processConfiguration(), edm::ProductRegistry::productLookup(), edm::VectorInputSource::productRegistry(), edm::InputSource::productRegistry(), edm::EventPrincipal::provRetrieverPtr(), edm::RandomEngineSentry< T >::randomEngine(), edm::Principal::recombine(), edm::root::TFWLiteSelectorMembers::reg(), edm::storage::StorageAccountProxy::releaseStorage(), TStorageFactoryFile::releaseStorage(), edm::eventsetup::EventSetupRecordProvider::resolverProvider(), edm::StreamSchedule::results(), edm::Schedule::resultsInserter(), edm::RootInputFileSequence::rootFile(), edm::RootFile::savedRunAuxiliary(), XrdAdaptor::ClientRequest::self_reference(), edm::service::SimpleMemoryCheck::smapsLineBuffer(), XrdAdaptor::Source::stats(), edm::ScheduleItems::subProcessParentageHelper(), edm::root::TFWLiteSelectorMembers::TFWLiteSelectorMembers(), edm::ScheduleItems::thinnedAssociationsHelper(), edm::root::TFWLiteSelectorMembers::thinnedAssociationsHelper(), edm::InputSource::thinnedAssociationsHelper(), edm::SubProcess::thinnedAssociationsHelper(), edm::EventProcessor::thinnedAssociationsHelper(), and edm::root::TFWLiteSelectorMembers::tree().

                                                                                         {
    return get_underlying(iP);
  }

get_underlying_safe() [2/12]

template<typename T >

constexpr std::shared_ptr<T const> edm::get_underlying_safe

(

propagate_const< std::shared_ptr< T >> const &

iP

)

Definition at line 45 of file get_underlying_safe.h.

References filterCSVwithJSON::copy, and get_underlying().

                                                                                                    {
    std::shared_ptr<T const> copy = get_underlying(iP);
    return copy;
  }

get_underlying_safe() [3/12]

template<typename T >

constexpr std::shared_ptr<T[]>& edm::get_underlying_safe

(

propagate_const_array< std::shared_ptr< T[]>> &

iP

)

Definition at line 51 of file get_underlying_safe.h.

References get_underlying().

                                                                                                   {
    return get_underlying(iP);
  }

get_underlying_safe() [4/12]

template<typename T >

constexpr std::shared_ptr<T const[]> edm::get_underlying_safe

(

propagate_const_array< std::shared_ptr< T[]>> const &

iP

)

Definition at line 55 of file get_underlying_safe.h.

References filterCSVwithJSON::copy, and get_underlying().

                                                                                                              {
    std::shared_ptr<T const[]> copy = get_underlying(iP);
    return copy;
  }

get_underlying_safe() [5/12]

template<typename T >

constexpr T*& edm::get_underlying_safe

(

propagate_const< T *> &

iP

)

Definition at line 62 of file get_underlying_safe.h.

References get_underlying().

                                                             {
    return get_underlying(iP);
  }

get_underlying_safe() [6/12]

template<typename T >

constexpr T const* edm::get_underlying_safe

(

propagate_const< T *> const &

iP

)

Definition at line 66 of file get_underlying_safe.h.

References filterCSVwithJSON::copy, and get_underlying().

                                                                        {
    T const* copy = get_underlying(iP);
    return copy;
  }

get_underlying_safe() [7/12]

template<typename T >

constexpr T* edm::get_underlying_safe

(

propagate_const_array< T[]> &

iP

)

Definition at line 72 of file get_underlying_safe.h.

References get_underlying().

                                                                   {
    return get_underlying(iP);
  }

get_underlying_safe() [8/12]

template<typename T >

constexpr T const* edm::get_underlying_safe

(

propagate_const_array< T[]> const &

iP

)

Definition at line 76 of file get_underlying_safe.h.

References filterCSVwithJSON::copy, and get_underlying().

                                                                               {
    T const* copy = get_underlying(iP);
    return copy;
  }

get_underlying_safe() [9/12]

template<typename T >

constexpr std::unique_ptr<T>& edm::get_underlying_safe

(

propagate_const< std::unique_ptr< T >> &

iP

)

Definition at line 83 of file get_underlying_safe.h.

References get_underlying().

                                                                                         {
    return get_underlying(iP);
  }

get_underlying_safe() [10/12]

template<typename T >

constexpr std::unique_ptr<T const> edm::get_underlying_safe

(

propagate_const< std::unique_ptr< T >> const &

iP

)

Definition at line 88 of file get_underlying_safe.h.

References filterCSVwithJSON::copy, and get_underlying().

                                                                                                    {
    std::unique_ptr<T const> copy = get_underlying(iP);
    return copy;
  }

get_underlying_safe() [11/12]

template<typename T >

constexpr std::unique_ptr<T[]>& edm::get_underlying_safe

(

propagate_const_array< std::unique_ptr< T[]>> &

iP

)

Definition at line 94 of file get_underlying_safe.h.

References get_underlying().

                                                                                                   {
    return get_underlying(iP);
  }

get_underlying_safe() [12/12]

template<typename T >

constexpr std::unique_ptr<T const[]> edm::get_underlying_safe

(

propagate_const_array< std::unique_ptr< T[]>> const &

iP

)

Definition at line 99 of file get_underlying_safe.h.

References filterCSVwithJSON::copy, and get_underlying().

                                                                                                              {
    std::unique_ptr<T const[]> copy = get_underlying(iP);
    return copy;
  }

getAllTriggerNames()

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

(

)

Definition at line 22 of file getAllTriggerNames.cc.

References edm::service::TriggerNamesService::getTrigPaths().

Referenced by edm::core::OutputModuleCore::doPreallocate_(), edm::core::OutputModuleCore::OutputModuleCore(), edm::StreamerOutputModuleCommon::serializeRegistry(), edm::StreamerOutputModuleCommon::StreamerOutputModuleCommon(), and edm::SubProcess::SubProcess().

                                                   {
    Service<service::TriggerNamesService> tns;
    return tns->getTrigPaths();
  }

getAnyPtr()

template<typename T >

std::unique_ptr<T> edm::getAnyPtr ( void *  p, int  offset  )

inline

Definition at line 9 of file getAnyPtr.h.

References hltrates_dqm_sourceclient-live_cfg::offset, and AlCaHLTBitMon_ParallelJobs::p.

                                                         {
    return std::unique_ptr<T>(static_cast<T *>(static_cast<void *>(static_cast<unsigned char *>(p) + offset)));
  }

getEnvironmentVariable()

std::string edm::getEnvironmentVariable ( std::string const &  name, std::string const &  defaultValue = std::string()  )

inline

Definition at line 8 of file GetEnvironmentVariable.h.

References hltPixelClustersMultiplicity_cfi::defaultValue, Skims_PA_cff::name, AlCaHLTBitMon_ParallelJobs::p, and AlCaHLTBitMon_QueryRunRegistry::string.

Referenced by reco::ExpressionEvaluator::ExpressionEvaluator(), and reco::ExpressionEvaluator::~ExpressionEvaluator().

                                                                                                              {
    char* p = std::getenv(name.c_str());
    return (p ? std::string(p) : defaultValue);
  }

getFileFormatVersion()

int edm::getFileFormatVersion

(

)

Definition at line 4 of file GetFileFormatVersion.cc.

Referenced by edm::RootOutputFile::writeFileFormatVersion().

{ return 20; }

getParameterSet()

ParameterSet const & edm::getParameterSet

(

ParameterSetID const &

id

)

Definition at line 918 of file ParameterSet.cc.

References Exception, edm::pset::Registry::instance(), edm::errors::LogicError, and mps_fire::result.

Referenced by edm::service::CondorStatusService::beginPost(), tmtt::TMTrackProducer::beginRun(), edm::ParameterSetEntry::fillPSet(), edm::VParameterSetEntry::fillVPSet(), findBinOfMaximum(), edm::ParameterSet::getParameter(), getProcessParameterSetContainingModule(), edm::service::PrescaleService::postBeginJob(), tt::ProducerSetup::produce(), and edm::core::OutputModuleCore::setEventSelectionInfo().

                                                                {
    ParameterSet const* result = nullptr;
    if (nullptr == (result = pset::Registry::instance()->getMapped(id))) {
      throw Exception(errors::LogicError, "MissingParameterSet:") << "Parameter Set ID '" << id << "' not found.";
    }
    return *result;
  }

getPassID()

std::string edm::getPassID ( )

inline

Definition at line 7 of file GetPassID.h.

References AlCaHLTBitMon_QueryRunRegistry::string.

Referenced by edm::DaqProvenanceHelper::daqInit(), edm::DelayedReaderThrowingSource::DelayedReaderThrowingSource(), edm::ScheduleItems::initMisc(), and edm::LHEProvenanceHelper::lheInit().

                               {
    static std::string const passID;
    // return empty string for now.
    return passID;
  }

getProcessParameterSetContainingModule()

ParameterSet const & edm::getProcessParameterSetContainingModule

(

ModuleDescription const &

moduleDescription

)

Definition at line 926 of file ParameterSet.cc.

References getParameterSet(), and edm::ModuleDescription::mainParameterSetID().

Referenced by SiStripDB2Tree::analyze(), HLTPrescaleRecorder::beginRun(), DQMEventInfo::bookHistograms(), ProbeTreeProducer::endJob(), and TagProbeFitTreeProducer::endJob().

                                                                                                         {
    return getParameterSet(moduleDescription.mainParameterSetID());
  }

getProducerParameterSet()

ParameterSet const * edm::getProducerParameterSet	(	Provenance const &	provenance,
		ProcessHistory const &	processHistory
	)

Definition at line 16 of file getProducerParameterSet.cc.

References Exception, edm::pset::Registry::getMapped(), edm::ParameterSet::getParameterSet(), edm::pset::Registry::instance(), label, LaserDQM_cfg::process, crab_script::provenance, and AlCaHLTBitMon_QueryRunRegistry::string.

Referenced by edmtest::TestFindProduct::analyze().

                                                                                                                  {
    const std::shared_ptr<BranchDescription const>& branchDescription = provenance.constBranchDescriptionPtr();

    if (branchDescription) {
      std::string const& process = branchDescription->processName();
      std::string const& label = branchDescription->moduleLabel();

      for (ProcessConfiguration const& pc : processHistory) {
        if (pc.processName() == process) {
          ParameterSetID const& psetID = pc.parameterSetID();
          pset::Registry const* psetRegistry = pset::Registry::instance();
          ParameterSet const* processPset = psetRegistry->getMapped(psetID);
          if (processPset) {
            return &processPset->getParameterSet(label);
          }
        }
      }
    }
    // This should never happen
    throw cms::Exception("LogicError") << "getProducerParameterSet failed";
    return nullptr;
  }

getProduct()

template<typename T >

T const* edm::getProduct ( RefCore const &  ref )

inline

Definition at line 37 of file RefCoreGet.h.

References runTheMatrix::const, edm::RefCore::isTransient(), edm::RefCore::nullPointerForTransientException(), AlCaHLTBitMon_ParallelJobs::p, edm::refcoreimpl::productGetter(), edm::RefCore::productGetter(), and edm::RefCore::productPtr().

                                                 {
    T const* p = static_cast<T const*>(ref.productPtr());
    if (p != nullptr)
      return p;
    if (ref.isTransient()) {
      ref.nullPointerForTransientException(typeid(T));
    }
    auto productGetter = ref.productGetter();
    if (nullptr == productGetter) {
      p = static_cast<T const*>(ref.productPtr());
      if (p != nullptr) {
        //another thread updated the value since we checked
        return p;
      }
    }
    return refcore::getProduct_<T>(ref, productGetter);
  }

getProductByTag()

template<typename PROD >

std::shared_ptr<Wrapper<PROD> const> edm::getProductByTag ( Principal const &  ep, InputTag const &  tag, ModuleCallingContext const *  mcc  )

inline

Definition at line 293 of file Principal.h.

References SiStripBadComponentsDQMServiceTemplate_cfg::ep, PROD, mps_fire::result, makeGlobalPositionRcd_cfg::tag, and edm::handleimpl::throwConvertTypeError().

                                                                                               {
    TypeID tid = TypeID(typeid(PROD));
    ProductData const* result = ep.findProductByTag(tid, tag, mcc);
    if (result == nullptr) {
      return std::shared_ptr<Wrapper<PROD> const>();
    }

    if (!(result->wrapper()->dynamicTypeInfo() == typeid(PROD))) {
      handleimpl::throwConvertTypeError(typeid(PROD), result->wrapper()->dynamicTypeInfo());
    }
    return std::static_pointer_cast<Wrapper<PROD> const>(result->sharedConstWrapper());
  }

getProductWithCoreFromRef()

template<typename T >

T const* edm::getProductWithCoreFromRef ( RefCore const &  ref, EDProductGetter const *  prodGetter  )

inline

Definition at line 71 of file RefCoreGet.h.

References edm::RefCore::isTransient(), and edm::RefCore::nullPointerForTransientException().

                                                                                                   {
    if (ref.isTransient()) {
      ref.nullPointerForTransientException(typeid(T));
    }
    return refcore::getProductWithCoreFromRef_<T>(ref, prodGetter);
  }

getPSetFromConfig()

std::unique_ptr< edm::ParameterSet > edm::getPSetFromConfig

(

const std::string &

config

)

Definition at line 5 of file ParameterSetReader.cc.

References PyBind11ProcessDesc::parameterSet().

                                                                             {
  return PyBind11ProcessDesc(config, false).parameterSet();
}

getRef()

template<typename C >

helper::MatcherGetRef<C>::ref_type edm::getRef	(	const Handle< C > &	c,
		size_t	k
	)

Definition at line 28 of file getRef.h.

References HltBtagPostValidation_cff::c, edm::helper::MatcherGetRef< C >::getRef(), and dqmdumpme::k.

Referenced by edm::reftobase::Holder< T, REF >::isEqualTo(), edm::reftobase::RefHolder< REF >::isEqualTo(), reco::modules::MatcherBase< C1, C2, M >::produce(), HLTScoutingMuonProducer::produce(), HLTScoutingEgammaProducer::produce(), and AssociatedVariableCollectionSelector< InputCollection, VarCollection, Selector, OutputCollection, StoreContainer, RefAdder >::select().

                                                                               {
    return helper::MatcherGetRef<C>::getRef(c, k);
  }

getRefPtr()

template<typename C , typename T , typename F , typename KEY >

T const* edm::getRefPtr ( RefCore const &  product, KEY const &  iKey  )

inline

Definition at line 86 of file RefItemGet.h.

References edm::refitem::GetRefPtrImpl< C, T, F, KEY >::getRefPtr_().

                                                                     {
    return refitem::GetRefPtrImpl<C, T, F, KEY>::getRefPtr_(product, iKey);
  }

getReleaseVersion()

std::string edm::getReleaseVersion

(

)

Definition at line 7 of file GetReleaseVersion.cc.

References AlCaHLTBitMon_QueryRunRegistry::string, and STRINGIFY.

Referenced by DQMEventInfo::bookHistograms(), DQMProvInfo::bookHistogramsProvInfo(), edm::DaqProvenanceHelper::daqInit(), DQMHarvestingMetadata::dqmEndRun(), edm::storage::StatisticsSenderService::fillUDP(), HcalLaserEventFilter::HcalLaserEventFilter(), edm::ScheduleItems::initMisc(), edm::LHEProvenanceHelper::lheInit(), DQMFileSaver::saveForOffline(), edm::StreamerOutputModuleCommon::serializeRegistry(), HLXMonitor::SetupEventInfo(), TauTagValidation::TauTagValidation(), and TrackParameterAnalyzer::TrackParameterAnalyzer().

                                {
    static std::string const releaseVersion(STRINGIFY(PROJECT_VERSION));
    return releaseVersion;
  }

getTClass()

TClass * edm::getTClass

(

const std::type_info &

ti

)

Definition at line 63 of file ClassFiller.cc.

Referenced by edm::StreamerInputSource::deserializeRegistry(), dumpInitVerbose(), and edm::StreamSerializer::serializeRegistry().

                                            {
    TypeID const type(ti);
    return getRootClass(type.className());
  }

getThinnedProduct()

template<typename T >

std::tuple<T const*, unsigned int> edm::getThinnedProduct ( RefCore const &  ref, unsigned int  key, EDProductGetter const *  prodGetter  )

inline

Definition at line 116 of file RefCoreGet.h.

References edm::RefCore::isTransient(), submitPVResolutionJobs::key, and edm::RefCore::nullPointerForTransientException().

                                                                                                 {
    // The pointer to a thinned collection will never be cached
    // T const* p = static_cast<T const*>(ref.productPtr());
    // if (p != 0) return p;

    if (ref.isTransient()) {
      ref.nullPointerForTransientException(typeid(T));
    }
    return refcore::getThinnedProduct_<T>(ref, key, prodGetter);
  }

getUuid()

std::string edm::getUuid

(

TTree *

uuidTree

)

Definition at line 100 of file CollUtil.cc.

References edm::FileID::fid(), and edm::poolNames::fileIdentifierBranchName().

                                     {
    FileID fid;
    FileID *fidPtr = &fid;
    uuidTree->SetBranchAddress(poolNames::fileIdentifierBranchName().c_str(), &fidPtr);
    uuidTree->GetEntry(0);
    return fid.fid();
  }

getWrapperBasePtr()

std::unique_ptr<WrapperBase> edm::getWrapperBasePtr ( void *  p, int  offset  )

inline

Definition at line 8 of file getWrapperBasePtr.h.

References hltrates_dqm_sourceclient-live_cfg::offset, and AlCaHLTBitMon_ParallelJobs::p.

Referenced by edm::RootFile::dropOnInputAndReorder(), edm::RootOutputFile::fillBranches(), and edm::RootDelayedReader::getProduct_().

                                                                           {
    return getAnyPtr<WrapperBase>(p, offset);
  }

glob2reg()

std::string edm::glob2reg

(

std::string const &

pattern

)

Definition at line 19 of file RegexMatch.cc.

References topSingleLeptonDQM_PU_cfi::pattern, fetchall_from_DQM_v2::regexp, and AlCaHLTBitMon_QueryRunRegistry::string.

Referenced by L1TdeStage2uGT::analyze(), triggerExpression::L1uGTReader::init(), HLTConfigProvider::matched(), regexMatch(), and TriggerResultsFilter::TriggerResultsFilter().

                                               {
    std::string regexp = pattern;
    boost::replace_all(regexp, "*", ".*");
    boost::replace_all(regexp, "?", ".");
    return regexp;
  }

GroupLogStatistics()

void edm::GroupLogStatistics

(

std::string_view

category

)

Definition at line 49 of file MessageLogger.cc.

References validateAlignments::category, edm::MessageLoggerQ::MLqGRP(), and AlCaHLTBitMon_QueryRunRegistry::string.

                                                   {
    std::string* cat_p = new std::string(category);
    edm::MessageLoggerQ::MLqGRP(cat_p);  // Indicate a group summary category
    // Note that the scribe will be responsible for deleting cat_p
  }

HaltMessageLogging()

void edm::HaltMessageLogging

(

)

Definition at line 30 of file MessageLogger.cc.

References edm::MessageLoggerQ::MLqSHT().

Referenced by edm::CmsRunParser::parse().

                            {
    edm::MessageLoggerQ::MLqSHT();  // Shut the logger up
  }

hasDictionary()

bool edm::hasDictionary

(

std::type_info const &

ti

)

Definition at line 809 of file TypeWithDict.cc.

Referenced by checkClassDictionaries(), pat::UserData::checkDictionaries(), checkDictionary(), fwlite::Record::get(), and edm::service::InitRootHandlers::InitRootHandlers().

                                             {
    if (ti.name()[1] == '\0') {
      // returns true for built in types (single character mangled names)
      return true;
    }
    return (TClassTable::GetDict(ti) != nullptr);
  }

hash_combine() [1/2]

template<typename T >

void edm::hash_combine ( std::size_t &  seed, const T &  val  )

inline

Definition at line 25 of file hash_combine.h.

References fileCollector::seed, and heppy_batch::val.

Referenced by hash_combine(), and hash_value().

                                                          {
    seed ^= std::hash<T>()(val) + 0x9e3779b9 + (seed << 6) + (seed >> 2);
  }

hash_combine() [2/2]

template<typename T , typename... Types>

void edm::hash_combine ( std::size_t &  seed, const T &  val, const Types &...  args  )

inline

Definition at line 30 of file hash_combine.h.

References writedatasetfile::args, hash_combine(), fileCollector::seed, and heppy_batch::val.

                                                                                {
    hash_combine(seed, val);
    hash_combine(seed, args...);
  }

hash_value()

template<typename... Types>

std::size_t edm::hash_value ( const Types &...  args )

inline

Definition at line 36 of file hash_combine.h.

References writedatasetfile::args, hash_combine(), and fileCollector::seed.

Referenced by edm::StdPairHasher::operator()(), UniqueSimTrackIdHash::operator()(), and edm::CompactEventAuxiliaryVector::ExtraHash::operator()().

                                                    {
    std::size_t seed{0};
    hash_combine(seed, args...);
    return seed;
  }

hrRealTime()

HRTimeType edm::hrRealTime ( )

inline

Definition at line 91 of file HRRealTime.h.

{ return details::rdtsc(); }

insertSelectedProcesses()

void edm::insertSelectedProcesses	(	BranchDescription const &	desc,
		std::set< std::string > &	processes,
		std::set< std::string > &	processesWithKeptProcessBlockProducts
	)

Definition at line 15 of file insertSelectedProcesses.cc.

References edm::TypeWithDict::byName(), submitPVResolutionJobs::desc, edm::TypeWithDict::getClass(), InProcess, InRun, hltrates_dqm_sourceclient-live_cfg::offset, AlCaHLTBitMon_ParallelJobs::p, and dqmiodatasetharvest::processes.

Referenced by edm::core::OutputModuleCore::selectProducts().

                                                                                         {
    // Select input processes in which mergeable run products were produced
    if (desc.branchType() == InRun && !desc.produced()) {
      // Determine if the product is "mergeable"
      TClass* tClass = desc.wrappedType().getClass();
      void* p = tClass->New();
      TClass* wrapperBaseTClass = TypeWithDict::byName("edm::WrapperBase").getClass();
      int offset = tClass->GetBaseClassOffset(wrapperBaseTClass);
      std::unique_ptr<WrapperBase> edp = getAnyPtr<WrapperBase>(p, offset);
      if (edp->isMergeable()) {
        // record the process names in a set (which is ordered and unique)
        processes.insert(desc.processName());
      }
    }
    if (desc.branchType() == InProcess) {
      processesWithKeptProcessBlockProducts.insert(desc.processName());
    }
  }

installCustomHandler()

void edm::installCustomHandler	(	int	signum,
		CFUNC	func
	)

Definition at line 93 of file UnixSignalHandlers.cc.

References disableAllSigs(), disableRTSigs(), EcalMonitorTask_cff::func, installSig(), and reenableSigs().

Referenced by edm::service::InitRootHandlers::InitRootHandlers(), and edm::service::UnixSignalService::UnixSignalService().

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

installSig()

void edm::installSig	(	int	signum,
		CFUNC	func
	)

Definition at line 105 of file UnixSignalHandlers.cc.

References EcalMonitorTask_cff::func, and 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, nullptr));
  }

is_glob()

bool edm::is_glob

(

std::string const &

pattern

)

Definition at line 17 of file RegexMatch.cc.

References topSingleLeptonDQM_PU_cfi::pattern.

Referenced by L1TdeStage2uGT::analyze(), triggerExpression::L1uGTReader::init(), triggerExpression::PathReader::init(), HLTHighLevel::init(), TriggerTools::initPathNames(), edm::EventSelector::initPathNames(), and hltdqm::passTrig().

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

isAncestor()

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

Definition at line 53 of file ProcessHistory.cc.

References a, and b.

Referenced by JetMatchingEWKFxFx::doVetoStep(), and isDescendant().

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

isDebugEnabled()

bool edm::isDebugEnabled

(

)

Definition at line 12 of file MessageLogger.cc.

References edm::MessageDrop::debugAlwaysSuppressed, and edm::MessageDrop::instance().

Referenced by SiStripQualityHotStripIdentifier::algoAnalyze(), FedChannelConnection::apvPairNumberDebug(), L1GtTriggerMenuLiteProducer::beginRunProduce(), CommissioningHistosUsingDb::buildDetInfo(), JetPlusTrackCorrector::calculateCorr(), SiStripEventSummary::commissioningInfo(), sistrip::SpyUnpacker::createDigis(), sistrip::RawToDigiUnpacker::createDigis(), sistrip::DigiToRaw::createFedBuffers_(), sistrip::DigiToRaw::DigiToRaw(), sistrip::DigiToRawModule::DigiToRawModule(), SiStripBadAPVAlgorithmFromClusterOccupancy::extractBadAPVs(), SiStripBadAPVandHotStripAlgorithmFromClusterOccupancy::extractBadAPVSandStrips(), SiStripHotStripAlgorithmFromClusterOccupancy::extractBadStrips(), sistrip::SpyUtilities::extractFrameInfo(), BSCTrigger::getBSCNum(), HLTMuonL1TFilter::hltFilter(), HLTMuonL1RegionalFilter::hltFilter(), HLTMuonL1TRegionalFilter::hltFilter(), HLTMuonTrackMassFilter::hltFilter(), HLTMuonL2FromL1TPreFilter::hltFilter(), HLTMuonL2PreFilter::hltFilter(), HLTMuonL1Filter::hltFilter(), HLTMuonL1RegionalFilter::HLTMuonL1RegionalFilter(), HLTMuonL1TFilter::HLTMuonL1TFilter(), HLTMuonL1TRegionalFilter::HLTMuonL1TRegionalFilter(), HLTMuonL2FromL1TPreFilter::HLTMuonL2FromL1TPreFilter(), HLTMuonL2PreFilter::HLTMuonL2PreFilter(), FedChannelConnection::i2cAddr(), SiStripFedZeroSuppression::isAValidDigi(), SiStripHotStripAlgorithmFromClusterOccupancy::iterativeSearch(), SiStripBadAPVandHotStripAlgorithmFromClusterOccupancy::iterativeSearch(), JetPlusTrackCorrector::jtaUsingEventData(), L1GtRsObjectKeysOnlineProd::keyL1GtPrescaleFactorsAlgoTrig(), L1GtRsObjectKeysOnlineProd::keyL1GtPrescaleFactorsTechTrig(), L1GtRsObjectKeysOnlineProd::keyL1GtTriggerMaskAlgoTrig(), L1GtRsObjectKeysOnlineProd::keyL1GtTriggerMaskTechTrig(), L1GtRsObjectKeysOnlineProd::keyL1GtTriggerMaskVetoTechTrig(), L1GetHistLimits::l1HistLimits(), FedChannelConnection::lldChannel(), sistrip::RawToDigiUnpacker::locateStartOfFedBuffer(), jpt::Map::Map(), JetPlusTrackCorrector::matchTracks(), L1GtParametersConfigOnlineProd::newObject(), L1GtPrescaleFactorsTechTrigConfigOnlineProd::newObject(), L1GtPrescaleFactorsAlgoTrigConfigOnlineProd::newObject(), L1GtTriggerMaskAlgoTrigConfigOnlineProd::newObject(), L1GtTriggerMaskTechTrigConfigOnlineProd::newObject(), L1GtTriggerMaskVetoTechTrigConfigOnlineProd::newObject(), L1GtPsbSetupConfigOnlineProd::newObject(), L1GtTriggerMenuConfigOnlineProd::newObject(), l1t::TriggerMenuParser::parseAlgorithm(), l1t::TriggerMenuParser::parseAXOL1TL(), l1t::TriggerMenuParser::parseCalo(), L1GtTriggerMenuXmlParser::parseCalo(), l1t::TriggerMenuParser::parseCaloCorr(), L1GtTriggerMenuXmlParser::parseCastor(), l1t::TriggerMenuParser::parseCorrelation(), L1GtTriggerMenuXmlParser::parseCorrelation(), l1t::TriggerMenuParser::parseCorrelationThreeBody(), l1t::TriggerMenuParser::parseCorrelationWithOverlapRemoval(), l1t::TriggerMenuParser::parseEnergySum(), L1GtTriggerMenuXmlParser::parseEnergySum(), l1t::TriggerMenuParser::parseEnergySumCorr(), l1t::TriggerMenuParser::parseEnergySumZdc(), L1GtTriggerMenuXmlParser::parseHfBitCounts(), L1GtTriggerMenuXmlParser::parseHfRingEtSums(), L1GtTriggerMenuXmlParser::parseJetCounts(), l1t::TriggerMenuParser::parseMuon(), L1GtTriggerMenuXmlParser::parseMuon(), l1t::TriggerMenuParser::parseMuonCorr(), l1t::TriggerMenuParser::parseMuonShower(), jpt::Efficiency::print(), QuarkoniaTrackSelector::produce(), sistrip::DigiToRawModule::produce(), BSCTrigger::produce(), L1GlobalTriggerRecordProducer::produce(), TriggerSummaryProducerAOD::produce(), sistrip::RawToDigiModule::RawToDigiModule(), sistrip::RawToDigiUnpacker::RawToDigiUnpacker(), SiStripHotStripAlgorithmFromClusterOccupancy::setNumberOfEvents(), sistrip::SpyDigiConverterModule::SpyDigiConverterModule(), sistrip::SpyUnpacker::SpyUnpacker(), sistrip::SpyUnpackerModule::SpyUnpackerModule(), SiStripFedZeroSuppression::suppress(), sistrip::RawToDigiUnpacker::triggerFed(), L1GtfeExtWord::unpack(), L1GtfeWord::unpack(), L1TcsWord::unpack(), L1GtFdlWord::unpack(), L1GlobalTriggerEvmRawToDigi::unpackHeader(), DaqScopeModeHistosUsingDb::update(), PedestalsHistosUsingDb::update(), PedsFullNoiseHistosUsingDb::update(), ApvTimingHistosUsingDb::update(), sistrip::RawToDigiModule::updateCabling(), sistrip::RawToDigiUnpacker::updateEventSummary(), L1GtTriggerMenuXmlParser::workAlgorithm(), L1GtTriggerMenuXmlParser::workTechTrigger(), L1GtPatternWriter::writePatterns(), sistrip::DigiToRaw::~DigiToRaw(), sistrip::DigiToRawModule::~DigiToRawModule(), sistrip::RawToDigiModule::~RawToDigiModule(), sistrip::RawToDigiUnpacker::~RawToDigiUnpacker(), sistrip::SpyDigiConverterModule::~SpyDigiConverterModule(), sistrip::SpyUnpacker::~SpyUnpacker(), and sistrip::SpyUnpackerModule::~SpyUnpackerModule().

                        {
    return ((!edm::MessageDrop::debugAlwaysSuppressed) && edm::MessageDrop::instance()->debugEnabled);
  }

isDescendant()

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

inline

Definition at line 114 of file ProcessHistory.h.

References a, b, and isAncestor().

{ return isAncestor(b, a); }

isEndTransition()

constexpr bool edm::isEndTransition

(

Transition

iValue

)

Definition at line 37 of file Transition.h.

References EndLuminosityBlock, EndProcessBlock, EndRun, and or.

Referenced by edm::ProductRegistryHelper::addToRegistry(), edm::ProcessBlock::commit_(), edm::LuminosityBlock::commit_(), and edm::Run::commit_().

                                                    {
    return iValue == Transition::EndLuminosityBlock or iValue == Transition::EndRun or
           iValue == Transition::EndProcessBlock;
  }

isErrorEnabled()

bool edm::isErrorEnabled

(

)

Definition at line 28 of file MessageLogger.cc.

References edm::MessageDrop::errorEnabled, and edm::MessageDrop::instance().

{ return edm::MessageDrop::instance()->errorEnabled; }

isFinite() [1/4]

template<typename T >

constexpr bool edm::isFinite

(

T

x

)

Referenced by JetTagPlotter::analyzeTag(), btagbtvdeep::SeedingTrackInfoBuilder::buildSeedingTrackInfo(), ECAL2DPositionCalcWithDepthCorr::calculateAndSetPositionActual(), btagbtvdeep::SortingClass< T >::compare(), SuperClusterHelper::computeLocalCovariances(), reco::EcalClustersGraph::computeShowerShapes(), GEDPhotonProducer::fillPhotonCollection(), TrackingTruthAccumulator::fillSimHits(), PuppiContainer::getRawAlphas(), PuppiContainer::getRMSAvg(), EGammaMvaEleEstimator::IDIsoCombinedMvaValue(), PuppiContainer::initialize(), SiPixelTemplate2D::interpolate(), SiPixelTemplate::interpolate(), mkfit::isFinite(), isFinite(), isNotFinite(), EGammaMvaEleEstimatorCSA14::mvaValue(), EGammaMvaEleEstimator::mvaValue(), TracksClusteringFromDisplacedSeed::nearTracks(), reco::tau::PFRecoTauEnergyAlgorithmPlugin::operator()(), TemplatedInclusiveVertexFinder< InputContainer, VTX >::produce(), PuppiContainer::puppiWeights(), TrackVertexArbitration< VTX >::trackVertexArbitrator(), and svhelper::updateVertexTime().

isFinite() [2/4]

template<>

constexpr bool edm::isFinite

(

float

x

)

Definition at line 14 of file isFinite.h.

References ztail::d, MainPageGenerator::l, ALPAKA_ACCELERATOR_NAMESPACE::pixelClustering::pixelStatus::mask, findQualityFiles::v, and x.

                                   {
    const unsigned int mask = 0x7f800000;
    union {
      unsigned int l;
      float d;
    } v = {.d = x};
    return (v.l & mask) != mask;
  }

isFinite() [3/4]

template<>

constexpr bool edm::isFinite

(

double

x

)

Definition at line 24 of file isFinite.h.

References ztail::d, MainPageGenerator::l, L1DTConfigBti_cff::LL, ALPAKA_ACCELERATOR_NAMESPACE::pixelClustering::pixelStatus::mask, findQualityFiles::v, and x.

                                    {
    const unsigned long long mask = 0x7FF0000000000000LL;
    union {
      unsigned long long l;
      double d;
    } v = {.d = x};
    return (v.l & mask) != mask;
  }

isFinite() [4/4]

template<>

constexpr bool edm::isFinite

(

long double

x

)

Definition at line 34 of file isFinite.h.

References isFinite(), x, and geometryCSVtoXML::xx.

                                         {
    double xx = x;
    return isFinite(xx);
  }

isFwkInfoEnabled()

bool edm::isFwkInfoEnabled

(

)

Definition at line 20 of file MessageLogger.cc.

References edm::MessageDrop::fwkInfoAlwaysSuppressed, and edm::MessageDrop::instance().

Referenced by edm::InputSource::issueReports().

                          {
    return ((!edm::MessageDrop::fwkInfoAlwaysSuppressed) && edm::MessageDrop::instance()->fwkInfoEnabled);
  }

isInfoEnabled()

bool edm::isInfoEnabled

(

)

Definition at line 16 of file MessageLogger.cc.

References edm::MessageDrop::infoAlwaysSuppressed, and edm::MessageDrop::instance().

                       {
    return ((!edm::MessageDrop::infoAlwaysSuppressed) && edm::MessageDrop::instance()->infoEnabled);
  }

isMessageProcessingSetUp()

bool edm::isMessageProcessingSetUp

(

)

Definition at line 42 of file MessageLogger.cc.

References edm::MessageDrop::instance(), and MLSCRIBE_RUNNING_INDICATOR.

                                  {
    //  std::cerr << "isMessageProcessingSetUp: \n";
    //  std::cerr << "messageLoggerScribeIsRunning = "
    //            << (int)MessageDrop::instance()->messageLoggerScribeIsRunning << "\n";
    return (MessageDrop::instance()->messageLoggerScribeIsRunning == MLSCRIBE_RUNNING_INDICATOR);
  }

isNotFinite()

template<typename T >

constexpr bool edm::isNotFinite

(

T

x

)

Definition at line 9 of file isFinite.h.

References isFinite(), and x.

Referenced by HcalSiPMHitResponse::add(), EcalHitResponse::add(), CaloHitResponse::add(), EcalTimeMapDigitizer::add(), Vx3DHLTAnalyzer::analyze(), ElectronCalibration::analyze(), ElectronCalibrationUniv::analyze(), MuonPathAnalyzerInChamber::analyze(), JetTagPlotter::analyzeTag(), TrackDetectorAssociator::associate(), EGammaMvaEleEstimatorCSA14::bindVariables(), EGammaMvaEleEstimator::bindVariables(), CTPPSDiamondRecHitProducerAlgorithm::build(), TransientTrackBuilder::build(), DetIdAssociator::buildMap(), BoostedDoubleSVProducer::calcNsubjettiness(), TwoTrackMinimumDistanceHelixHelix::calculate(), GsfVertexWeightCalculator::calculate(), Cluster3DPCACalculator::calculateAndSetPositionActual(), Basic2DGenericPFlowPositionCalc::calculateAndSetPositionActual(), ApeEstimatorSummary::calculateApe(), GsfElectronAlgo::calculateShowerShape(), PhotonEnergyCalibrator::calibrate(), ElectronEnergyCalibrator::calibrate(), btagbtvdeep::catch_infs(), PrimaryVertexAssignment::chargedHadronVertex(), DeepTauId::checkInputs(), L2TauNNProducerAlpaka::checknan(), L2TauNNProducer::checknan(), TwoBodyDecayEstimator::checkValues(), HcalPulseShapes::convolve(), Qjets::d_ij(), HLTScalersClient::endLuminosityBlock(), FitterFuncs::PulseShapeFunctor::EvalPulseM2(), MagGeometry::fieldInTesla(), EcalRegressionData::fill(), DAClusterizerInZ_vect::fill(), DAClusterizerInZT_vect::fill(), DAClusterizerInZ_vect::fill_vertices(), AlignmentExtendedCorrelationsStore::fillCovariance(), AlignmentExtendedCorrelationsStore::fillCovarianceT(), MatrixFillMap::fillEBMap(), MatrixFillMap::fillEEMap(), ClusterFillMap::fillMap(), DivisiveVertexFinder::findVertexes(), DivisiveVertexFinder::findVertexesAlt(), BSFitter::Fit(), KFTrajectoryFitter::fitOne(), SplitVertexResolution::fitResiduals(), FitterFuncs::PulseShapeFunctor::funcShape(), SCEnergyCorrectorSemiParm::getRegDataECALV1(), SequentialVertexFitter< 5 >::hasNan(), ConversionFastHelix::helixStateAtVertex(), CAHitTripletGenerator::hitNtuplets(), CAHitQuadrupletGenerator::hitNtuplets(), MultiHitGeneratorFromChi2::hitSets(), cms::SubEventGenJetProducer::inputTowers(), HiPuRhoProducer::inputTowers(), VirtualJetProducer::inputTowers(), PhotonConversionTrajectorySeedProducerFromSingleLegAlgo::inspectTrack(), GlobalTrackQualityProducer::kink(), fftjetcms::FFTJetInterface::loadInputCollection(), OptOCOPS::makeMeasurement(), Vx3DHLTAnalyzer::MyFit(), SensitiveDetector::NaNTrap(), CaloSteppingAction::NaNTrap(), reco::mlpf::normalize(), reco::InverseCrosstalkMatrix::operator()(), TtHadLRSignalSelObservables::operator()(), TtSemiLRSignalSelObservables::operator()(), HelixForwardPlaneCrossing::pathLength(), StraightLinePlaneCrossing::pathLength(), EcalUncalibRecHitFixedAlphaBetaAlgo< EBDataFrame >::PerformAnalyticFit(), pat::PATPhotonSlimmer::produce(), TrackFromPackedCandidateProducer::produce(), ShiftedParticleProducer::produce(), ShiftedParticleProducerT< T >::produce(), PhotonIDValueMapProducer::produce(), cms::CkfTrackCandidateMakerBase::produceBase(), pat::PackedCandidate::pseudoPosDefTrack(), CTPPSFastTrackingProducer::ReconstructArm(), IMACalibBlock::riempiMtr(), IMACalibBlock::riempiVtr(), EcalHitResponse::run(), PVFitter::runFitter(), PrimaryVertexSorting::score(), CTPPSFastTrackingProducer::SearchTrack(), SeedGeneratorForCosmics::seeds(), SimpleCosmicBONSeeder::seeds(), HelixArbitraryPlaneCrossing2Order::solutionByDirection(), ConversionFastHelix::straightLineStateAtVertex(), TrackWithVertexSelector::testVertices(), TrackingNtuple::tpHitIndexListLessSort(), KinematicConstrainedVertexUpdator::update(), DAClusterizerInZ_vect::update(), DAClusterizerInZT_vect::update(), PrimaryVertexMonitor::vertexPlots(), GeneralPurposeVertexAnalyzer::vertexPlots(), DAClusterizerInZT_vect::vertices(), GeometricAnnealing::weight(), DeterministicAnnealing::weight(), and VirtualJetProducer::writeJets().

                                  {
    return !isFinite(x);
  }

isSameEvent() [1/2]

bool edm::isSameEvent	(	EventAuxiliary const &	a,
		EventAuxiliary const &	b
	)

Definition at line 15 of file EventAuxiliary.cc.

References a, and b.

Referenced by isSameEvent().

                                                                     {
    return a.id() == b.id() && a.processGUID() == b.processGUID() && a.luminosityBlock() == b.luminosityBlock() &&
           a.time() == b.time() && a.isRealData() == b.isRealData() && a.experimentType() == b.experimentType() &&
           a.bunchCrossing() == b.bunchCrossing() && a.storeNumber() == b.storeNumber();
  }

isSameEvent() [2/2]

bool edm::isSameEvent ( EventPrincipal const &  a, EventPrincipal const &  b  )

inline

Definition at line 205 of file EventPrincipal.h.

References a, b, and isSameEvent().

{ return isSameEvent(a.aux(), b.aux()); }

isThinnedAvailable()

template<typename C , typename KEY >

bool edm::isThinnedAvailable ( RefCore const &  product, KEY const &  iKey  )

inline

Definition at line 116 of file RefItemGet.h.

References edm::refitem::IsThinnedAvailableImpl< C, KEY >::isThinnedAvailable_().

                                                                          {
    return refitem::IsThinnedAvailableImpl<C, KEY>::isThinnedAvailable_(product, iKey);
  }

isTransientEqual()

bool edm::isTransientEqual	(	ParameterSet const &	a,
		ParameterSet const &	b
	)

Definition at line 833 of file ParameterSet.cc.

References a, b, MillePedeFileConverter_cfg::e, f, mps_fire::i, ALPAKA_ACCELERATOR_NAMESPACE::vertexFinder::iv, dqmiolumiharvest::j, dqmdumpme::k, and Pi.

Referenced by edm::eventsetup::EventSetupsController::getESProducerAndRegisterProcess(), edm::eventsetup::EventSetupsController::getESSourceAndRegisterProcess(), and operator==().

                                                                      {
    if (a.tbl().size() != b.tbl().size()) {
      return false;
    }
    if (a.psetTable().size() != b.psetTable().size()) {
      return false;
    }
    if (a.vpsetTable().size() != b.vpsetTable().size()) {
      return false;
    }
    typedef ParameterSet::table::const_iterator Ti;
    for (Ti i = a.tbl().begin(), e = a.tbl().end(), j = b.tbl().begin(), f = b.tbl().end(); i != e && j != f;
         ++i, ++j) {
      if (*i != *j) {
        return false;
      }
    }
    typedef ParameterSet::psettable::const_iterator Pi;
    for (Pi i = a.psetTable().begin(), e = a.psetTable().end(), j = b.psetTable().begin(), f = b.psetTable().end();
         i != e && j != f;
         ++i, ++j) {
      if (i->first != j->first) {
        return false;
      }
      if (i->second.isTracked() != j->second.isTracked()) {
        return false;
      }
      if (!isTransientEqual(i->second.pset(), j->second.pset())) {
        return false;
      }
    }
    typedef ParameterSet::vpsettable::const_iterator PVi;
    for (PVi i = a.vpsetTable().begin(), e = a.vpsetTable().end(), j = b.vpsetTable().begin(), f = b.vpsetTable().end();
         i != e && j != f;
         ++i, ++j) {
      if (i->first != j->first) {
        return false;
      }
      if (i->second.isTracked() != j->second.isTracked()) {
        return false;
      }
      std::vector<ParameterSet> const& iv = i->second.vpset();
      std::vector<ParameterSet> const& jv = j->second.vpset();
      if (iv.size() != jv.size()) {
        return false;
      }
      for (size_t k = 0; k < iv.size(); ++k) {
        if (!isTransientEqual(iv[k], jv[k])) {
          return false;
        }
      }
    }
    return true;
  }

isValidGlobalIdentifier()

bool edm::isValidGlobalIdentifier

(

std::string const &

guid

)

Definition at line 10 of file GlobalIdentifier.cc.

References edm::Guid::isValidString().

Referenced by edm::RootOutputFile::RootOutputFile().

{ return Guid::isValidString(guid); }

isWarningEnabled()

bool edm::isWarningEnabled

(

)

Definition at line 24 of file MessageLogger.cc.

References edm::MessageDrop::instance(), and edm::MessageDrop::warningAlwaysSuppressed.

Referenced by L1GlobalTriggerPSB::receiveGctObjectData(), and L1GlobalTriggerPSB::receiveTechnicalTriggers().

                          {
    return ((!edm::MessageDrop::warningAlwaysSuppressed) && edm::MessageDrop::instance()->warningEnabled);
  }

iterateTrieLeaves()

template<typename V , typename T >

bool edm::iterateTrieLeaves	(	V &	v,
		TrieNode< T > const &	n,
		std::string const &	label = ""
	)

visits only leaf nodes

Definition at line 267 of file Trie.h.

References MillePedeFileConverter_cfg::e, label, dqmiodumpmetadata::n, AlCaHLTBitMon_ParallelJobs::p, and findQualityFiles::v.

                                                                                  {
    typedef TrieNodeIter<T> node_iterator;
    node_iterator e;
    node_iterator p(&n);
    if (p == e)
      return true;
    for (; p != e; ++p) {
      if (iterateTrieLeaves(v, *p, label + (char)p.label()))
        v((*p).value(), label + (char)p.label());
    }
    return false;
  }

kBaseType()

static std::string const edm::kBaseType ( "Source"  )

static

Referenced by edm::stream::EDAnalyzerBase::baseType(), edm::stream::EDFilterBase::baseType(), edm::stream::EDProducerBase::baseType(), and edm::InputSource::baseType().

lessThan() [1/2]

bool edm::lessThan	(	LuminosityBlockRange const &	lh,
		LuminosityBlockRange const &	rh
	)

Definition at line 64 of file LuminosityBlockRange.cc.

References mathSSE::lh, and edm::LuminosityBlockRange::startLumiID().

                                                                                {
    return lh.endLumiID() < rh.startLumiID();
  }

lessThan() [2/2]

bool edm::lessThan	(	EventRange const &	lh,
		EventRange const &	rh
	)

Definition at line 64 of file EventRange.cc.

References cms::cuda::assert(), mathSSE::lh, edm::EventRange::startEventID(), and edm::EventRange::startLumi().

Referenced by distinct(), and edm::EventSkipperByID::skipIt().

                                                            {
    assert((lh.startLumi() == 0) == (rh.startLumi() == 0));
    return lh.endEventID() < rh.startEventID();
  }

lessThanSpecial()

bool edm::lessThanSpecial	(	EventRange const &	lh,
		EventRange const &	rh
	)

Definition at line 56 of file EventRange.cc.

References mathSSE::lh, edm::EventRange::startEventID(), and edm::EventRange::startLumi().

Referenced by edm::EventSkipperByID::skipIt().

                                                                   {
    // First, separate the ranges so that those with 0 lumiID go first.
    if ((lh.startLumi() == 0) != (rh.startLumi() == 0)) {
      return lh.startLumi() == 0;
    }
    return lh.endEventID() < rh.startEventID();
  }

loadCap()

bool edm::loadCap	(	const std::string &	name,
		std::vector< std::string > &	missingDictionaries
	)

Definition at line 16 of file ClassFiller.cc.

References edm::TypeWithDict::byName(), checkClassDictionaries(), FDEBUG, and Skims_PA_cff::name.

Referenced by edm::StreamerInputSource::declareStreamers(), and loadExtraClasses().

                                                                                 {
    FDEBUG(1) << "Loading dictionary for " << name << "\n";
    TypeWithDict typeWithDict = TypeWithDict::byName(name);
    return checkClassDictionaries(missingDictionaries, name, typeWithDict);
  }

loadExtraClasses()

void edm::loadExtraClasses

(

)

Definition at line 33 of file ClassFiller.cc.

References visDQMUpload::context, fileCollector::done, loadCap(), AlCaHLTBitMon_QueryRunRegistry::string, and throwMissingDictionariesException().

Referenced by edm::StreamerInputSource::mergeIntoRegistry().

                          {
    static bool done = false;
    if (done == false) {
      std::vector<std::string> missingDictionaries;
      loadCap(std::string("edm::StreamedProduct"), missingDictionaries);
      loadCap(std::string("std::vector<edm::StreamedProduct>"), missingDictionaries);
      loadCap(std::string("edm::SendEvent"), missingDictionaries);
      loadCap(std::string("std::vector<edm::BranchDescription>"), missingDictionaries);
      loadCap(std::string("edm::SendJobHeader"), missingDictionaries);
      if (!missingDictionaries.empty()) {
        std::string context("Calling loadExtraClasses, checking dictionaries");
        throwMissingDictionariesException(missingDictionaries, context);
      }
    }
    done = true;
  }

LoggedErrorsOnlySummary()

std::vector< ErrorSummaryEntry > edm::LoggedErrorsOnlySummary

(

unsigned int

iStreamID

)

Definition at line 189 of file MessageSender.cc.

References cms::cuda::assert(), MillePedeFileConverter_cfg::e, ELerror, errorSummaryMaps, mps_fire::i, submitPVResolutionJobs::key, jetUpdater_cfi::sort, and findQualityFiles::v.

                                                                               {  //  ChangeLog 2
    std::vector<ErrorSummaryEntry> v;
    assert(iStreamID < errorSummaryMaps.size());
    auto const& errorSummaryMap = errorSummaryMaps[iStreamID];
    auto end = errorSummaryMap.end();
    for (auto i = errorSummaryMap.begin(); i != end; ++i) {
      auto const& key = i->first;
      if (key.severity >= edm::ELerror) {
        ErrorSummaryEntry e{key.category, key.module, key.severity};
        e.count = i->second.value().load(std::memory_order_acquire);
        v.push_back(e);
      }
    }
    std::sort(v.begin(), v.end());
    return v;
  }

LoggedErrorsSummary()

std::vector< ErrorSummaryEntry > edm::LoggedErrorsSummary

(

unsigned int

iStreamID

)

Definition at line 166 of file MessageSender.cc.

References cms::cuda::assert(), MillePedeFileConverter_cfg::e, errorSummaryMaps, mps_fire::i, submitPVResolutionJobs::key, jetUpdater_cfi::sort, and findQualityFiles::v.

Referenced by HLTLogMonitorFilter::filter(), and edm::LogErrorHarvester::produce().

                                                                           {
    assert(iStreamID < errorSummaryMaps.size());
    auto const& errorSummaryMap = errorSummaryMaps[iStreamID];
    std::vector<ErrorSummaryEntry> v;
    auto end = errorSummaryMap.end();
    for (auto i = errorSummaryMap.begin(); i != end; ++i) {
      auto const& key = i->first;
      ErrorSummaryEntry e{key.category, key.module, key.severity};

      e.count = i->second.value().load(std::memory_order_acquire);
      v.push_back(e);
    }
    std::sort(v.begin(), v.end());
    return v;
  }

LogStatistics()

void edm::LogStatistics

(

)

Definition at line 8 of file MessageLogger.cc.

References edm::MessageLoggerQ::MLqSUM().

                       {
    edm::MessageLoggerQ::MLqSUM();  // trigger summary info
  }

longBranchPrint()

void edm::longBranchPrint

(

TTree *

tr

)

Definition at line 89 of file CollUtil.cc.

References gather_cfg::cout, and mps_fire::i.

                                  {
    if (tr != nullptr) {
      Long64_t nB = tr->GetListOfBranches()->GetEntries();
      for (Long64_t i = 0; i < nB; ++i) {
        tr->GetListOfBranches()->At(i)->Print();
      }
    } else {
      std::cout << "Missing Events tree?\n";
    }
  }

lower_bound_all() [1/4]

template<typename ForwardSequence , typename Datum >

ForwardSequence::const_iterator edm::lower_bound_all ( ForwardSequence const &  s, Datum const &  d  )

inline

wrappers for std::lower_bound

Definition at line 69 of file Algorithms.h.

References ztail::d, pfDeepBoostedJetPreprocessParams_cfi::lower_bound, and alignCSCRings::s.

Referenced by edm::RootFile::fillEventHistory(), edm::FileIndex::findEventEntryPosition(), and edm::FileIndex::findPosition().

                                                                                                          {
    return std::lower_bound(s.begin(), s.end(), d);
  }

lower_bound_all() [2/4]

template<typename ForwardSequence , typename Datum >

ForwardSequence::iterator edm::lower_bound_all ( ForwardSequence &  s, Datum const &  d  )

inline

Definition at line 74 of file Algorithms.h.

References ztail::d, pfDeepBoostedJetPreprocessParams_cfi::lower_bound, and alignCSCRings::s.

                                                                                              {
    return std::lower_bound(s.begin(), s.end(), d);
  }

lower_bound_all() [3/4]

template<typename ForwardSequence , typename Datum , typename Predicate >

ForwardSequence::const_iterator edm::lower_bound_all ( ForwardSequence const &  s, Datum const &  d, Predicate  p  )

inline

Definition at line 79 of file Algorithms.h.

References ztail::d, pfDeepBoostedJetPreprocessParams_cfi::lower_bound, AlCaHLTBitMon_ParallelJobs::p, and alignCSCRings::s.

                                                                               {
    return std::lower_bound(s.begin(), s.end(), d, p);
  }

lower_bound_all() [4/4]

template<typename ForwardSequence , typename Datum , typename Predicate >

ForwardSequence::iterator edm::lower_bound_all ( ForwardSequence &  s, Datum const &  d, Predicate  p  )

inline

Definition at line 86 of file Algorithms.h.

References ztail::d, pfDeepBoostedJetPreprocessParams_cfi::lower_bound, AlCaHLTBitMon_ParallelJobs::p, and alignCSCRings::s.

                                                                                                           {
    return std::lower_bound(s.begin(), s.end(), d, p);
  }

make_functor_task()

template<typename F >

FunctorTask<F>* edm::make_functor_task

(

F

f

)

Definition at line 44 of file FunctorTask.h.

References f, and eostools::move().

Referenced by edm::DelayedReaderInputProductResolver::prefetchAsync_(), and edm::StreamSchedule::processOneStreamAsync().

                                         {
    return new FunctorTask<F>(std::move(f));
  }

make_lambda_with_holder()

template<typename F >

auto edm::make_lambda_with_holder	(	WaitingTaskWithArenaHolder	h,
		F &&	f
	)

Definition at line 93 of file WaitingTaskWithArenaHolder.h.

References f, EcalMonitorTask_cff::func, h, and eostools::move().

Referenced by make_waiting_task_with_holder().

                                                                    {
    return [holder = std::move(h), func = std::forward<F>(f)]() mutable {
      try {
        func(holder);
      } catch (...) {
        holder.doneWaiting(std::current_exception());
      }
    };
  }

make_sentry()

template<typename T , typename F >

std::unique_ptr<T, F> edm::make_sentry	(	T *	iObject,
		F	iFunc
	)

NOTE: if iObject is null, then iFunc will not be called.

Definition at line 30 of file make_sentry.h.

Referenced by edm::DelayedReaderInputProductResolver::resolveProduct_(), edm::OutputModuleCommunicatorT< T >::writeLumiAsync(), edm::OutputModuleCommunicatorT< T >::writeProcessBlockAsync(), and edm::OutputModuleCommunicatorT< T >::writeRunAsync().

                                                       {
    return std::unique_ptr<T, F>(iObject, iFunc);
  }

make_shared_noexcept_false()

template<typename T , typename... Args>

std::shared_ptr<T> edm::make_shared_noexcept_false

(

Args &&...

args

)

Definition at line 6 of file make_shared_noexcept_false.h.

References writedatasetfile::args.

                                                              {
#if defined(__APPLE__)
    // libc++ from Apple Clang does not allow non-default destructors
    // in some cases the destructor uses noexcept(false).
    return std::shared_ptr<T>(new T(std::forward<Args>(args)...));
#else
    return std::make_shared<T>(std::forward<Args>(args)...);
#endif
  }

make_waiting_task()

template<typename F >

FunctorWaitingTask<F>* edm::make_waiting_task

(

F

f

)

Definition at line 92 of file WaitingTask.h.

References f, and eostools::move().

Referenced by edm::EventProcessor::beginRunAsync(), edm::Worker::doTransformAsync(), edm::Worker::doWorkAsync(), edm::Worker::doWorkNoPrefetchingAsync(), edm::EventProcessor::handleNextEventForStreamAsync(), edm::waiting_task::detail::WaitingTaskChain< U >::lastTask(), edm::waiting_task::detail::WaitingTaskChain< U, T... >::lastTask(), edm::waiting_task::detail::WaitingTaskChain< Conditional< U >, T... >::lastTask(), make_waiting_task_with_holder(), edm::eventsetup::CallbackExternalWork< T, TAcquireFunc, TAcquireReturn, TProduceFunc, TProduceReturn, TRecord, TDecorator >::makeAcquireTask(), edm::eventsetup::CallbackExternalWork< T, TAcquireFunc, TAcquireReturn, TProduceFunc, TProduceReturn, TRecord, TDecorator >::makeExceptionHandlerTask(), edm::eventsetup::CallbackBase< T, TProduceFunc, TProduceReturn, TRecord, TDecorator >::makeProduceTask(), edm::UnscheduledProductResolver::prefetchAsync_(), edm::TransformingProductResolver::prefetchAsync_(), edm::SwitchProducerProductResolver::prefetchAsync_(), edm::SwitchAliasProductResolver::prefetchAsync_(), edm::eventsetup::CallbackBase< T, TProduceFunc, TProduceReturn, TRecord, TDecorator >::prefetchAsyncImpl(), edm::Worker::prePrefetchSelectionAsync(), edm::StreamSchedule::processOneEventAsync(), edm::GlobalSchedule::processOneGlobalAsync(), edm::StreamSchedule::processOneStreamAsync(), edm::waiting_task::detail::WaitingTaskChain< U, T... >::runLast(), edm::waiting_task::detail::WaitingTaskChain< Conditional< U >, T... >::runLast(), edm::Path::runNextWorkerAsync(), edm::eventsetup::EventSetupRecordIOVQueue::startNewIOVAsync(), edm::EventProcessor::streamEndLumiAsync(), edm::EventProcessor::streamEndRunAsync(), and edm::TransformerBase::transformImpAsync().

                                                {
    return new FunctorWaitingTask<F>(std::move(f));
  }

make_waiting_task_with_holder()

template<typename F >

auto edm::make_waiting_task_with_holder	(	WaitingTaskWithArenaHolder	h,
		F &&	f
	)

Definition at line 104 of file WaitingTaskWithArenaHolder.h.

References f, EcalMonitorTask_cff::func, h, make_lambda_with_holder(), and make_waiting_task().

Referenced by cms::cuda::impl::ScopedContextHolderHelper::pushNextTask().

                                                                          {
    return make_waiting_task(
        [holder = h, func = make_lambda_with_holder(h, std::forward<F>(f))](std::exception_ptr const* excptr) mutable {
          if (excptr) {
            holder.doneWaiting(*excptr);
            return;
          }
          func();
        });
  }

makeAssociativeIterator()

template<typename KeyRefType , typename AC , typename EventType >

AssociativeIterator<KeyRefType, AC, edm::EventItemGetter<KeyRefType, EventType> > edm::makeAssociativeIterator	(	const AC &	map,
		const EventType &	event
	)

Definition at line 247 of file AssociativeIterator.h.

References genParticles_cff::map.

                                             {
    using Getter = edm::EventItemGetter<KeyRefType, EventType>;
    return AssociativeIterator<KeyRefType, AC, Getter>(map, Getter{event});
  }

makeBranchListIndexToProcessIndex()

std::vector< ProcessIndex > edm::makeBranchListIndexToProcessIndex

(

BranchListIndexes const &

branchListIndexes

)

Definition at line 7 of file branchIDToProductID.cc.

References SiStripPI::max.

Referenced by ProvenanceDumper::makeBranchIDListHelper(), and edm::EventPrincipal::updateBranchListIndexes().

                                                                                                        {
    ProcessIndex pix = 0;
    auto const nelem = 1 + *std::max_element(branchListIndexes.begin(), branchListIndexes.end());
    std::vector<ProcessIndex> branchListIndexToProcessIndex(nelem, std::numeric_limits<BranchListIndex>::max());
    for (auto const& blindex : branchListIndexes) {
      branchListIndexToProcessIndex[blindex] = pix;
      ++pix;
    }
    return branchListIndexToProcessIndex;
  }

makeESHandleExceptionFactory()

template<typename T >

std::shared_ptr<ESHandleExceptionFactory> edm::makeESHandleExceptionFactory

(

T &&

iFunctor

)

Definition at line 41 of file FunctorESHandleExceptionFactory.h.

References eostools::move().

Referenced by edm::eventsetup::EventSetupRecord::getHandleImpl< edm::ESHandle, fwliteeswriter::DummyType, fwliteeswriter::FWLWEventSetupRecord >(), edm::eventsetup::EventSetupRecordImpl::getImplementation(), edm::eventsetup::EventSetupRecord::invalidTokenHandle(), and edm::eventsetup::EventSetupRecord::noResolverHandle().

                                                                                     {
    return std::make_shared<FunctorESHandleExceptionFactory<T>>(std::move(iFunctor));
  }

makeESValid()

template<typename U >

auto edm::makeESValid ( const U &  iOtherHandleType )

noexcept

Take a handle (e.g. edm::ESHandle<T>) and create a edm::ESValidHandle<T>. If the argument is an invalid handle, an exception will be thrown.

Definition at line 68 of file ESValidHandle.h.

References edm::esvhhelper::throwIfNotValid().

                                                              {
    esvhhelper::throwIfNotValid(iOtherHandleType.product());
    //because of the check, we know this is valid and do not have to check again
    return ESValidHandle<typename U::value_type>(*iOtherHandleType.product(), iOtherHandleType.description());
  }

makeHandleExceptionFactory()

template<typename T >

std::shared_ptr<HandleExceptionFactory> edm::makeHandleExceptionFactory

(

T &&

iFunctor

)

Definition at line 45 of file FunctorHandleExceptionFactory.h.

References eostools::move().

Referenced by edm::Event::get(), edm::Principal::getByLabel(), fwlite::LuminosityBlockBase::getByLabelImpl(), fwlite::RunBase::getByLabelImpl(), fwlite::EventBase::getByLabelImpl(), edm::EventPrincipal::getByProductID(), fwlite::EventBase::getByTokenImpl(), fwlite::EventBase::getImpl(), and edm::PrincipalGetAdapter::makeFailToGetException().

                                                                                 {
    return std::make_shared<FunctorHandleExceptionFactory<T>>(std::move(iFunctor));
  }

makeInput()

std::unique_ptr<InputSource> edm::makeInput	(	unsigned int	moduleIndex,
		ParameterSet &	params,
		CommonParams const &	common,
		std::shared_ptr< ProductRegistry >	preg,
		std::shared_ptr< BranchIDListHelper >	branchIDListHelper,
		std::shared_ptr< ProcessBlockHelper > const &	processBlockHelper,
		std::shared_ptr< ThinnedAssociationsHelper >	thinnedAssociationsHelper,
		std::shared_ptr< ActivityRegistry >	areg,
		std::shared_ptr< ProcessConfiguration const >	processConfiguration,
		PreallocationConfiguration const &	allocations
	)

Definition at line 119 of file EventProcessor.cc.

References cms::Exception::addContext(), edm::errors::Configuration, beamerCreator::create(), Exception, trigObjTnPSource_cfi::filler, edm::InputSourceFactory::get(), get, edm::ParameterSet::getParameter(), edm::ParameterSet::id(), input, edm::InputSourceFactory::makeInputSource(), submitPVValidationJobs::params, edm::ParameterSet::registerIt(), AlCaHLTBitMon_QueryRunRegistry::string, and edm::convertException::wrap().

Referenced by edm::EventProcessor::init().

                                                                                        {
    ParameterSet* main_input = params.getPSetForUpdate("@main_input");
    if (main_input == nullptr) {
      throw Exception(errors::Configuration)
          << "There must be exactly one source in the configuration.\n"
          << "It is missing (or there are sufficient syntax errors such that it is not recognized as the source)\n";
    }

    std::string modtype(main_input->getParameter<std::string>("@module_type"));

    std::unique_ptr<ParameterSetDescriptionFillerBase> filler(
        ParameterSetDescriptionFillerPluginFactory::get()->create(modtype));
    ConfigurationDescriptions descriptions(filler->baseType(), modtype);
    filler->fill(descriptions);

    try {
      convertException::wrap([&]() { descriptions.validate(*main_input, std::string("source")); });
    } catch (cms::Exception& iException) {
      std::ostringstream ost;
      ost << "Validating configuration of input source of type " << modtype;
      iException.addContext(ost.str());
      throw;
    }

    main_input->registerIt();

    // Fill in "ModuleDescription", in case the input source produces
    // any EDProducts, which would be registered in the ProductRegistry.
    // Also fill in the process history item for this process.
    // There is no module label for the unnamed input source, so
    // just use "source".
    // Only the tracked parameters belong in the process configuration.
    ModuleDescription md(main_input->id(),
                         main_input->getParameter<std::string>("@module_type"),
                         "source",
                         processConfiguration.get(),
                         moduleIndex);

    InputSourceDescription isdesc(md,
                                  preg,
                                  branchIDListHelper,
                                  processBlockHelper,
                                  thinnedAssociationsHelper,
                                  areg,
                                  common.maxEventsInput_,
                                  common.maxLumisInput_,
                                  common.maxSecondsUntilRampdown_,
                                  allocations);

    areg->preSourceConstructionSignal_(md);
    std::unique_ptr<InputSource> input;
    try {
      //even if we have an exception, send the signal
      std::shared_ptr<int> sentry(nullptr, [areg, &md](void*) { areg->postSourceConstructionSignal_(md); });
      convertException::wrap([&]() {
        input = std::unique_ptr<InputSource>(InputSourceFactory::get()->makeInputSource(*main_input, isdesc).release());
        input->preEventReadFromSourceSignal_.connect(std::cref(areg->preEventReadFromSourceSignal_));
        input->postEventReadFromSourceSignal_.connect(std::cref(areg->postEventReadFromSourceSignal_));
      });
    } catch (cms::Exception& iException) {
      std::ostringstream ost;
      ost << "Constructing input source of type " << modtype;
      iException.addContext(ost.str());
      throw;
    }
    return input;
  }

makeModuleTypeResolverMaker()

std::unique_ptr< edm::ModuleTypeResolverMaker const > edm::makeModuleTypeResolverMaker

(

edm::ParameterSet const &

pset

)

Definition at line 8 of file makeModuleTypeResolverMaker.cc.

References get, Skims_PA_cff::name, muonDTDigis_cfi::pset, and AlCaHLTBitMon_QueryRunRegistry::string.

Referenced by edm::test::TestProcessor::TestProcessor().

                                                                                                           {
    auto const& name = pset.getUntrackedParameter<std::string>("@module_type_resolver");
    if (name.empty()) {
      return nullptr;
    }
    return edm::ModuleTypeResolverMakerFactory::get()->create(name);
  }

makeNotFoundException()

static std::shared_ptr<cms::Exception> edm::makeNotFoundException ( char const *  where, KindOfType  kindOfType, TypeID const &  productType, std::string const &  label, std::string const &  instance, std::string const &  process  )

static

Definition at line 53 of file Principal.cc.

References cppFunctionSkipper::exception, instance, label, LaserDQM_cfg::process, PRODUCT_TYPE, and edm::errors::ProductNotFound.

Referenced by edm::Principal::getByLabel().

                                                                                         {
    std::shared_ptr<cms::Exception> exception = std::make_shared<Exception>(errors::ProductNotFound);
    if (kindOfType == PRODUCT_TYPE) {
      *exception << "Principal::" << where
                 << ": Found zero products matching all criteria\nLooking for type: " << productType << "\n"
                 << "Looking for module label: " << label << "\n"
                 << "Looking for productInstanceName: " << instance << "\n"
                 << (process.empty() ? "" : "Looking for process: ") << process << "\n";
    } else {
      *exception << "Principal::" << where
                 << ": Found zero products matching all criteria\nLooking for a container with elements of type: "
                 << productType << "\n"
                 << "Looking for module label: " << label << "\n"
                 << "Looking for productInstanceName: " << instance << "\n"
                 << (process.empty() ? "" : "Looking for process: ") << process << "\n";
    }
    return exception;
  }

makeParameterSets()

void edm::makeParameterSets	(	std::string const &	configtext,
		std::unique_ptr< ParameterSet > &	main
	)

essentially the same as the previous method

Definition at line 19 of file ParameterSetReader.cc.

References edm::cmspybind11::makeParameterSets(), and PyBind11ProcessDesc::parameterSet().

Referenced by makeParameterSets().

                                                                                          {
  edm::cmspybind11::makeParameterSets(configtext, main);
}

makeRefTo()

template<class HandleT >

Ref<typename HandleT::element_type, typename HandleT::element_type::value_type::value_type> edm::makeRefTo ( const HandleT &  iHandle, det_id_type  iDetID, typename HandleT::element_type::value_type::const_iterator  itIter  )

inline

Definition at line 409 of file DetSetVector.h.

References edm::errors::InvalidReference, and edm::Exception::throwThis().

Referenced by makeRefToDetSetVector(), tt::StubAssociator::produce(), trackerDTC::ProducerED::produce(), and TTClusterBuilder< T >::RetrieveRawHits().

                                                                                                               {
    typedef typename HandleT::element_type Vec;
    typename Vec::value_type::collection_type::size_type index = 0;
    typename Vec::const_iterator itFound = iHandle->find(iDetID);
    if (itFound == iHandle->end()) {
      Exception::throwThis(errors::InvalidReference,
                           "an edm::Ref to an edm::DetSetVector was given a DetId, ",
                           iDetID,
                           ", that is not in the DetSetVector");
    }
    index += (itIter - itFound->data.begin());
    if (index >= itFound->data.size()) {
      Exception::throwThis(errors::InvalidReference,
                           "an edm::Ref to a edm::DetSetVector is being made with an interator that is not part of the "
                           "edm::DetSet itself");
    }
    return Ref<typename HandleT::element_type, typename HandleT::element_type::value_type::value_type>(
        iHandle, std::make_pair(iDetID, index));
  }

makeRefToBaseProdFrom()

template<typename T >

RefToBaseProd<T> edm::makeRefToBaseProdFrom	(	RefToBase< T > const &	iRef,
		Event const &	iEvent
	)

Definition at line 34 of file makeRefToBaseProdFrom.h.

References edm::RefToBase< T >::id(), and iEvent.

Referenced by BTagPerformanceAnalyzerMC::getJetWithFlavour(), helper::MasterCollection< edm::View< T > >::MasterCollection(), ConeIsolation::produce(), reco::modulesNew::MCTruthCompositeMatcher::produce(), edmtest::AssociationMapProducer::produce(), DeepFlavourONNXJetTagsProducer::produce(), UnifiedParticleTransformerAK4ONNXJetTagsProducer::produce(), ParticleNetSonicJetTagsProducer::produce(), ParticleTransformerAK4ONNXJetTagsProducer::produce(), DeepCombinedONNXJetTagsProducer::produce(), DeepVertexONNXJetTagsProducer::produce(), DeepDoubleXONNXJetTagsProducer::produce(), BoostedJetONNXJetTagsProducer::produce(), RecoTauGenericJetRegionProducer< JetType, CandType >::produce(), GenJetBCEnergyRatio::produce(), JetTagProducer::produce(), PixelJetPuId::produce(), and reco::modules::JetFlavourIdentifier::produce().

                                                                                        {
    Handle<View<T>> view;
    iEvent.get(iRef.id(), view);

    return RefToBaseProd<T>(view);
  }

makeRefToDetSetRefVector() [1/2]

template<class HandleT >

Ref<typename HandleT::element_type, typename HandleT::element_type::value_type::value_type> edm::makeRefToDetSetRefVector	(	const HandleT &	iHandle,
		det_id_type	iDetID,
		typename HandleT::element_type::value_type::const_iterator	itIter
	)

Definition at line 280 of file DetSetRefVector.h.

Referenced by makeRefToDetSetRefVector().

                                                                                                               {
    typedef typename HandleT::element_type Vec;
    typename Vec::value_type::collection_type::size_type index = 0;
    typename Vec::const_iterator itFound = iHandle->find(iDetID);
    index += (itIter - itFound->data.begin());
    return Ref<typename HandleT::element_type, typename HandleT::element_type::value_type::value_type>(
        iHandle, std::make_pair(iDetID, index));
  }

makeRefToDetSetRefVector() [2/2]

template<class HandleT >

Ref<typename HandleT::element_type, typename HandleT::element_type::value_type::value_type> edm::makeRefToDetSetRefVector	(	const HandleT &	iHandle,
		det_id_type	iDetID,
		typename HandleT::element_type::value_type::iterator	itIter
	)

Definition at line 291 of file DetSetRefVector.h.

References makeRefToDetSetRefVector().

                                                                                                         {
    typedef typename HandleT::element_type Vec;
    typename Vec::detset::const_iterator itIter2 = itIter;
    return makeRefToDetSetRefVector(iHandle, iDetID, itIter2);
  }

makeRefToDetSetVector()

template<class HandleT >

Ref<typename HandleT::element_type, typename HandleT::element_type::value_type::value_type> edm::makeRefToDetSetVector ( const HandleT &  iHandle, det_id_type  iDetID, typename HandleT::element_type::value_type::iterator  itIter  )

inline

Definition at line 432 of file DetSetVector.h.

References makeRefTo().

                                                                               {
    typedef typename HandleT::element_type Vec;
    typename Vec::detset::const_iterator itIter2 = itIter;
    return makeRefTo(iHandle, iDetID, itIter2);
  }

makeRunHelper()

std::unique_ptr< RunHelperBase > edm::makeRunHelper

(

ParameterSet const &

pset

)

Definition at line 12 of file RunHelper.cc.

References muonDTDigis_cfi::pset, writedatasetfile::run, writedatasetfile::runs, and mitigatedMETSequence_cff::U.

                                                                       {
    if (pset.exists("setRunNumber")) {
      RunNumber_t run = pset.getUntrackedParameter<unsigned int>("setRunNumber");
      if (run != 0U) {
        return std::make_unique<SetRunHelper>(pset);
      }
    }
    if (pset.exists("setRunNumberForEachLumi")) {
      std::vector<RunNumber_t> runs = pset.getUntrackedParameter<std::vector<unsigned int>>("setRunNumberForEachLumi");
      if (!runs.empty()) {
        return std::make_unique<SetRunForEachLumiHelper>(pset);
      }
    }
    if (pset.exists("firstLuminosityBlockForEachRun")) {
      if (not pset.getUntrackedParameter<std::vector<LuminosityBlockID>>("firstLuminosityBlockForEachRun").empty()) {
        return std::make_unique<FirstLuminosityBlockForEachRunHelper>(pset);
      }
    }
    return std::make_unique<DefaultRunHelper>();
  }

makeValid()

template<typename U >

auto edm::makeValid ( const U &  iOtherHandleType )

noexcept

Take a handle (e.g. edm::Handle<T> or edm::OrphanHandle<T> and create a edm::ValidHandle<T>. If the argument is an invalid handle, an exception will be thrown.

Definition at line 52 of file ValidHandle.h.

References edm::vhhelper::throwIfNotValid().

Referenced by EtlDigiHitsValidation::analyze(), BtlDigiHitsValidation::analyze(), EtlSimHitsValidation::analyze(), BtlSimHitsValidation::analyze(), EtlLocalRecoValidation::analyze(), BtlLocalRecoValidation::analyze(), MtdEleIsoValidation::analyze(), MtdTracksValidation::analyze(), MtdTracksValidation::checkAcceptance(), GEDPhotonCoreProducer::produce(), and LowPtGsfElectronSCProducer::produce().

                                                            {
    vhhelper::throwIfNotValid(iOtherHandleType.product());
    //because of the check, we know this is valid and do not have to check again
    return ValidHandle<typename U::element_type>(*iOtherHandleType.product(), iOtherHandleType.id());
  }

match()

std::string edm::match	(	BranchDescription const &	a,
		BranchDescription const &	b,
		std::string const &	fileName
	)

Definition at line 352 of file BranchDescription.cc.

References a, b, and MillePedeFileConverter_cfg::fileName.

Referenced by edm::RootOutputFile::beginInputFile(), edm::EventSelector::identical(), ConversionTools::matchedConversion(), ConversionTools::matchedPromptElectron(), edm::ProductRegistry::merge(), reco::modules::MCMatchCandRefSelector::newEvent(), edm::InputTagMatch::operator()(), CosmicMuonLinksProducer::sharedHits(), and edm::ThinnedAssociationsHelper::shouldKeepAssociation().

                                                                                                     {
    std::ostringstream differences;
    if (a.branchName() != b.branchName()) {
      differences << "Branch name '" << b.branchName() << "' does not match '" << a.branchName() << "'.\n";
      // Need not compare components of branch name individually.
      // (a.friendlyClassName() != b.friendlyClassName())
      // (a.moduleLabel() != b.moduleLabel())
      // (a.productInstanceName() != b.productInstanceName())
      // (a.processName() != b.processName())
    }
    if (a.branchType() != b.branchType()) {
      differences << "Branch '" << b.branchName() << "' is a(n) '" << b.branchType() << "' branch\n";
      differences << "    in file '" << fileName << "', but a(n) '" << a.branchType()
                  << "' branch in previous files.\n";
    }
    if (a.branchID() != b.branchID()) {
      differences << "Branch '" << b.branchName() << "' has a branch ID of '" << b.branchID() << "'\n";
      differences << "    in file '" << fileName << "', but '" << a.branchID() << "' in previous files.\n";
    }
    if (a.fullClassName() != b.fullClassName()) {
      differences << "Products on branch '" << b.branchName() << "' have type '" << b.fullClassName() << "'\n";
      differences << "    in file '" << fileName << "', but '" << a.fullClassName() << "' in previous files.\n";
    }
    if (!b.dropped() && a.dropped()) {
      differences << "Branch '" << a.branchName() << "' was dropped in the first input file but is present in '"
                  << fileName << "'.\n";
    }
    return differences.str();
  }

max() [1/2]

LuminosityBlockID const& edm::max ( LuminosityBlockID const &  lh, LuminosityBlockID const &  rh  )

inline

Definition at line 101 of file LuminosityBlockID.h.

References mathSSE::lh.

                                                                                                {
    return (rh < lh ? lh : rh);
  }

max() [2/2]

EventID const& edm::max ( EventID const &  lh, EventID const &  rh  )

inline

Definition at line 118 of file EventID.h.

References mathSSE::lh.

Referenced by edm::helper::Filler< Association< C > >::add(), DTTriggerEfficiencyTest::bookChambHistos(), DTRunConditionVarClient::bookWheelHistos(), TIBLayerBuilder::constructRings(), DTRunConditionVarClient::dqmEndJob(), MuonPFAnalyzer::fillInRange(), merge(), DTLocalTriggerBaseTest::phiRange(), and DTTriggerLutTest::runClientDiagnostic().

{ return (rh < lh ? lh : rh); }

maxIDlength()

const unsigned int edm::maxIDlength

(

200

)

Referenced by edm::ErrorObj::setID().

merge()

bool edm::merge	(	LuminosityBlockRange &	lh,
		LuminosityBlockRange &	rh
	)

Definition at line 72 of file LuminosityBlockRange.cc.

References edm::LuminosityBlockRange::endLumiID(), mathSSE::lh, max(), min(), overlaps(), and edm::LuminosityBlockRange::startLumiID().

Referenced by sortAndRemoveOverlaps().

                                                                 {
    if (overlaps(lh, rh)) {
      LuminosityBlockID begin = min(lh.startLumiID(), rh.startLumiID());
      LuminosityBlockID end = max(lh.endLumiID(), rh.endLumiID());
      rh = lh = LuminosityBlockRange(begin, end);
      return true;
    }
    return false;
  }

min() [1/2]

LuminosityBlockID const& edm::min ( LuminosityBlockID const &  lh, LuminosityBlockID const &  rh  )

inline

Definition at line 97 of file LuminosityBlockID.h.

References mathSSE::lh.

                                                                                                {
    return (rh < lh ? rh : lh);
  }

min() [2/2]

EventID const& edm::min ( EventID const &  lh, EventID const &  rh  )

inline

Definition at line 116 of file EventID.h.

References mathSSE::lh.

Referenced by DTTriggerEfficiencyTest::bookChambHistos(), DTRunConditionVarClient::bookWheelHistos(), DTRunConditionVarClient::dqmEndJob(), DTLocalTriggerTest::fillGlobalSummary(), MuonPFAnalyzer::fillInRange(), merge(), DTLocalTriggerBaseTest::phiRange(), and edm::Lumi3DReWeighting::weight3D().

{ return (rh < lh ? rh : lh); }

moduleName()

std::string edm::moduleName	(	StableProvenance const &	provenance,
		ProcessHistory const &	history
	)

Definition at line 27 of file Provenance.cc.

References edm::ParameterSet::getParameter(), parameterSet(), crab_script::provenance, AlCaHLTBitMon_QueryRunRegistry::string, triggerResults(), and triggerResultsInserter().

Referenced by TopDecaySubset::checkShowerModel(), edm::DaqProvenanceHelper::DaqProvenanceHelper(), edm::service::ELdestination::excludeModule(), edm::LHEProvenanceHelper::fillCommonProcessParameterSet(), edm::service::ELdestination::filterModule(), edm::service::ELdestination::ignoreModule(), edm::InputFile::inputFileOpened(), OniaVtxReProducer::OniaVtxReProducer(), HadronAndPartonSelector::produce(), edm::RootFile::reportOpened(), edm::JobReport::reportPerformanceForModule(), edm::service::ELdestination::respondToModule(), edm::RootOutputFile::RootOutputFile(), and edm::Maker::throwValidationException().

                                                                                          {
    // Trigger results ia a special case
    if (provenance.moduleLabel() == triggerResults) {
      return triggerResultsInserter;
    }
    return parameterSet(provenance, history).getParameter<std::string>("@module_type");
  }

moveFromTo()

template<typename... TArgs, typename ToT >

void edm::moveFromTo	(	ESProducts< TArgs... > &	iFrom,
		ToT &	iTo
	)

Definition at line 134 of file ESProducts.h.

References edm::eventsetup::produce::ProductHolder< TArgs... >::moveTo().

                                                         {
    iFrom.moveTo(iTo);
  }

mustBeNonZero()

EDProductGetter const * edm::mustBeNonZero	(	EDProductGetter const *	prodGetter,
		std::string	refType,
		ProductID const &	productID
	)

Definition at line 65 of file EDProductGetter.cc.

References Exception, and edm::errors::InvalidReference.

                                                                   {
    if (prodGetter != nullptr)
      return prodGetter;
    throw Exception(errors::InvalidReference, refType)
        << "Attempt to construct a " << refType << " with ProductID " << productID << "\n"
        << "but with a null pointer to a product getter.\n"
        << "The product getter pointer passed to the constructor must refer\n"
        << "to a real getter, such as an EventPrincipal.\n";
  }

nextIdentifier()

static Principal::CacheIdentifier_t edm::nextIdentifier ( )

inlinestatic

Definition at line 111 of file Principal.cc.

References s_nextIdentifier.

Referenced by edm::Principal::fillPrincipal().

                                                            {
    return s_nextIdentifier.fetch_add(1, std::memory_order_acq_rel);
  }

nonConsumedUnscheduledModules()

std::vector< ModuleDescription const * > edm::nonConsumedUnscheduledModules	(	edm::PathsAndConsumesOfModulesBase const &	iPnC,
		std::vector< ModuleProcessName > &	consumedByChildren
	)

Definition at line 166 of file PathsAndConsumesOfModules.cc.

References edm::PathsAndConsumesOfModulesBase::allModules(), edmTracerLogToSimpleConfig::allModules, filterCSVwithJSON::copy, makeListRunsInFiles::description, edm::PathsAndConsumesOfModulesBase::endPaths(), spr::find(), edm::PathsAndConsumesOfModulesBase::modulesOnEndPath(), edm::PathsAndConsumesOfModulesBase::modulesOnPath(), or, edm::PathsAndConsumesOfModulesBase::paths(), and AlCaHLTBitMon_QueryRunRegistry::string.

Referenced by edm::EventProcessor::beginJob(), and edm::SubProcess::keepOnlyConsumedUnscheduledModules().

                                                                                                      {
    const std::string kTriggerResults("TriggerResults");

    std::vector<std::string> pathNames = iPnC.paths();
    const unsigned int kFirstEndPathIndex = pathNames.size();
    pathNames.insert(pathNames.end(), iPnC.endPaths().begin(), iPnC.endPaths().end());

    // The goal is to find modules that are not depended upon by
    // scheduled modules. To do that, we identify all modules that are
    // depended upon by scheduled modules, and do a set subtraction.
    //
    // First, denote all scheduled modules (i.e. in Paths and
    // EndPaths) as "consumers".
    std::vector<ModuleDescription const*> consumerModules;
    for (unsigned int pathIndex = 0; pathIndex != pathNames.size(); ++pathIndex) {
      std::vector<ModuleDescription const*> const* moduleDescriptions;
      if (pathIndex < kFirstEndPathIndex) {
        moduleDescriptions = &(iPnC.modulesOnPath(pathIndex));
      } else {
        moduleDescriptions = &(iPnC.modulesOnEndPath(pathIndex - kFirstEndPathIndex));
      }
      std::copy(moduleDescriptions->begin(), moduleDescriptions->end(), std::back_inserter(consumerModules));
    }

    // Then add TriggerResults, and all Paths and EndPaths themselves
    // to the set of "consumers" (even if they don't depend on any
    // data products, they must not be deleted). Also add anything
    // consumed by child SubProcesses to the set of "consumers".
    auto const& allModules = iPnC.allModules();
    for (auto const& description : allModules) {
      if (description->moduleLabel() == kTriggerResults or
          std::find(pathNames.begin(), pathNames.end(), description->moduleLabel()) != pathNames.end()) {
        consumerModules.push_back(description);
      } else if (std::binary_search(consumedByChildren.begin(),
                                    consumedByChildren.end(),
                                    ModuleProcessName{description->moduleLabel(), description->processName()}) or
                 std::binary_search(consumedByChildren.begin(),
                                    consumedByChildren.end(),
                                    ModuleProcessName{description->moduleLabel(), ""})) {
        consumerModules.push_back(description);
      }
    }

    // Find modules that have any data dependence path to any module
    // in consumerModules.
    std::unordered_set<unsigned int> consumedModules;
    for (auto& description : consumerModules) {
      findAllConsumedModules(iPnC, description, consumedModules);
    }

    // All other modules will then be classified as non-consumed, even
    // if they would have dependencies within them.
    std::vector<ModuleDescription const*> unusedModules;
    std::copy_if(allModules.begin(),
                 allModules.end(),
                 std::back_inserter(unusedModules),
                 [&consumedModules](ModuleDescription const* description) {
                   return consumedModules.find(description->id()) == consumedModules.end();
                 });
    return unusedModules;
  }

numEntries()

Long64_t edm::numEntries	(	TFile *	hdl,
		std::string const &	trname
	)

Definition at line 50 of file CollUtil.cc.

References gather_cfg::cout.

Referenced by reco::tau::format_vint(), format_vstring(), edm::RootFile::readEntryDescriptionTree(), edm::RootFile::readParentageTree(), and ProvenanceDumper::work_().

                                                           {
    TTree *tree = (TTree *)hdl->Get(trname.c_str());
    if (tree) {
      return tree->GetEntries();
    } else {
      std::cout << "ERR cannot find a TTree named \"" << trname << "\"" << std::endl;
      return -1;
    }
  }

openFileHdl()

TFile * edm::openFileHdl

(

std::string const &

fname

)

Definition at line 24 of file CollUtil.cc.

References gather_cfg::cout, beamvalidation::exit(), and alignmentValidation::fname.

                                             {
    TFile *hdl = TFile::Open(fname.c_str(), "read");

    if (nullptr == hdl) {
      std::cout << "ERR Could not open file " << fname.c_str() << std::endl;
      exit(1);
    }
    return hdl;
  }

operator &&() [1/8]

std::unique_ptr<ParameterDescriptionNode> edm::operator&&	(	ParameterDescriptionNode const &	node_left,
		ParameterDescriptionNode const &	node_right
	)

Definition at line 185 of file ParameterDescriptionNode.cc.

                                                                                                   {
    return std::make_unique<ANDGroupDescription>(node_left, node_right);
  }

operator &&() [2/8]

std::unique_ptr<ParameterDescriptionNode> edm::operator&&	(	std::unique_ptr< ParameterDescriptionNode >	node_left,
		ParameterDescriptionNode const &	node_right
	)

Definition at line 190 of file ParameterDescriptionNode.cc.

References eostools::move().

                                                                                                   {
    return std::make_unique<ANDGroupDescription>(std::move(node_left), node_right);
  }

operator &&() [3/8]

std::unique_ptr<ParameterDescriptionNode> edm::operator&&	(	ParameterDescriptionNode const &	node_left,
		std::unique_ptr< ParameterDescriptionNode >	node_right
	)

Definition at line 195 of file ParameterDescriptionNode.cc.

References eostools::move().

                                                                                                           {
    return std::make_unique<ANDGroupDescription>(node_left, std::move(node_right));
  }

operator &&() [4/8]

std::unique_ptr<ParameterDescriptionNode> edm::operator&&	(	std::unique_ptr< ParameterDescriptionNode >	node_left,
		std::unique_ptr< ParameterDescriptionNode >	node_right
	)

Definition at line 200 of file ParameterDescriptionNode.cc.

References eostools::move().

                                                                                                           {
    return std::make_unique<ANDGroupDescription>(std::move(node_left), std::move(node_right));
  }

operator &&() [5/8]

std::unique_ptr<ParameterDescriptionNode> edm::operator&&	(	ParameterDescriptionNode const &	node_left,
		ParameterDescriptionNode const &	node_right
	)

Definition at line 185 of file ParameterDescriptionNode.cc.

                                                                                                   {
    return std::make_unique<ANDGroupDescription>(node_left, node_right);
  }

operator &&() [6/8]

std::unique_ptr<ParameterDescriptionNode> edm::operator&&	(	std::unique_ptr< ParameterDescriptionNode >	node_left,
		ParameterDescriptionNode const &	node_right
	)

Definition at line 190 of file ParameterDescriptionNode.cc.

References eostools::move().

                                                                                                   {
    return std::make_unique<ANDGroupDescription>(std::move(node_left), node_right);
  }

operator &&() [7/8]

std::unique_ptr<ParameterDescriptionNode> edm::operator&&	(	ParameterDescriptionNode const &	node_left,
		std::unique_ptr< ParameterDescriptionNode >	node_right
	)

Definition at line 195 of file ParameterDescriptionNode.cc.

References eostools::move().

                                                                                                           {
    return std::make_unique<ANDGroupDescription>(node_left, std::move(node_right));
  }

operator &&() [8/8]

std::unique_ptr<ParameterDescriptionNode> edm::operator&&	(	std::unique_ptr< ParameterDescriptionNode >	node_left,
		std::unique_ptr< ParameterDescriptionNode >	node_right
	)

Definition at line 200 of file ParameterDescriptionNode.cc.

References eostools::move().

                                                                                                           {
    return std::make_unique<ANDGroupDescription>(std::move(node_left), std::move(node_right));
  }

operator!=() [1/38]

bool edm::operator!= ( FileID const &  lh, FileID const &  rh  )

inline

Definition at line 27 of file FileID.h.

References mathSSE::lh.

{ return !(lh == rh); }

operator!=() [2/38]

bool edm::operator!= ( RunLumiEntryInfo const &  a, RunLumiEntryInfo const &  b  )

inline

Definition at line 41 of file RunLumiEntryInfo.h.

References a, and b.

{ return !(a == b); }

operator!=() [3/38]

bool edm::operator!= ( ElementID const &  lh, ElementID const &  rh  )

inline

Definition at line 46 of file ElementID.h.

References mathSSE::lh.

{ return !(lh == rh); }

operator!=() [4/38]

bool edm::operator!= ( EventEntryInfo const &  a, EventEntryInfo const &  b  )

inline

Definition at line 49 of file EventEntryInfo.h.

References a, and b.

{ return !(a == b); }

operator!=() [5/38]

bool edm::operator!= ( ProductID const &  lh, ProductID const &  rh  )

inline

Definition at line 50 of file ProductID.h.

References mathSSE::lh.

{ return !(lh == rh); }

operator!=() [6/38]

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

inline

Definition at line 51 of file BranchKey.h.

References a, and b.

{ return !(a == b); }

operator!=() [7/38]

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

inline

Definition at line 55 of file TypeID.h.

References a, and b.

{ return !(a == b); }

operator!=() [8/38]

template<typename T1 , template< typename X1 > class B1, typename T2 , template< typename X2 > class B2>

bool edm::operator!= ( const zero_allocator< T1, B1 > &  a, const zero_allocator< T2, B2 > &  b  )

inline

Definition at line 57 of file zero_allocator.h.

References a, and b.

                                                                                           {
    return static_cast<B1<T1> >(a) != static_cast<B2<T2> >(b);
  }

operator!=() [9/38]

bool edm::operator!= ( EventEntryDescription const &  a, EventEntryDescription const &  b  )

inline

Definition at line 57 of file EventEntryDescription.h.

References a, and b.

{ return !(a == b); }

operator!=() [10/38]

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

inline

Definition at line 59 of file ProductProvenance.h.

References a, and b.

{ return !(a == b); }

operator!=() [11/38]

bool edm::operator!= ( const TypeIDBase &  a, const TypeIDBase &  b  )

inline

Definition at line 64 of file TypeIDBase.h.

References a, and b.

{ return !(a == b); }

operator!=() [12/38]

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

inline

Definition at line 70 of file Parentage.h.

References a, and b.

{ return !(a == b); }

operator!=() [13/38]

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

inline

Definition at line 71 of file ProcessConfiguration.h.

References a, and b.

{ return !(a == b); }

operator!=() [14/38]

constexpr bool edm::operator!= ( ELseverityLevel const &  e1, ELseverityLevel const &  e2  )

inlinenoexcept

Definition at line 105 of file ELseverityLevel.h.

References StorageManager_cfg::e1.

                                                                                                  {
    return e1.cmp(e2) != 0;
  }

operator!=() [15/38]

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

inline

Definition at line 110 of file ProcessHistory.h.

References a, and b.

{ return !(a == b); }

operator!=() [16/38]

template<typename T >

bool edm::operator!= ( FwdPtr< T > const &  lhs, FwdPtr< T > const &  rhs  )

inline

Definition at line 134 of file FwdPtr.h.

                                                                     {
    return !(lhs == rhs);
  }

operator!=() [17/38]

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

inline

Definition at line 135 of file FileIndex.h.

References mathSSE::lh.

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

operator!=() [18/38]

bool edm::operator!= ( TypeWithDict const &  a, TypeWithDict const &  b  )

inline

Definition at line 141 of file TypeWithDict.h.

References a, and b.

{ return !(a == b); }

operator!=() [19/38]

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

inline

Definition at line 142 of file RefCore.h.

{ return !(lhs == rhs); }

operator!=() [20/38]

template<typename KEY >

bool edm::operator!=	(	RefVectorBase< KEY > const &	lhs,
		RefVectorBase< KEY > const &	rhs
	)

Inequality operator.

Definition at line 143 of file RefVectorBase.h.

                                                                                {
    return !(lhs == rhs);
  }

operator!=() [21/38]

bool edm::operator!= ( TypeWithDict const &  a, std::type_info const &  b  )

inline

Definition at line 145 of file TypeWithDict.h.

References a, and b.

{ return !(a == b); }

operator!=() [22/38]

template<typename T >

bool edm::operator!= ( View< T > const &  lhs, View< T > const &  rhs  )

inline

Definition at line 298 of file View.h.

                                                                 {
    return !(lhs == rhs);
  }

operator!=() [23/38]

bool edm::operator!= ( std::type_info const &  a, TypeWithDict const &  b  )

inline

Definition at line 149 of file TypeWithDict.h.

References a, and b.

{ return !(b == a); }

operator!=() [24/38]

template<typename T >

bool edm::operator!= ( RefToBaseProd< T > const &  lhs, RefToBaseProd< T > const &  rhs  )

inline

Definition at line 164 of file RefToBaseProd.h.

                                                                                   {
    return !(lhs == rhs);
  }

operator!=() [25/38]

template<typename T , typename U >

bool edm::operator!= ( atomic_value_ptr< T > const &  lhs, U const &  rhs  )

inline

Definition at line 168 of file atomic_value_ptr.h.

References edm::atomic_value_ptr< T >::this_type_does_not_support_comparisons().

                                                                       {
    lhs.this_type_does_not_support_comparisons();
    return false;
  }

operator!=() [26/38]

template<typename T , typename U >

bool edm::operator!= ( U const &  lhs, atomic_value_ptr< T > const &  rhs  )

inline

Definition at line 180 of file atomic_value_ptr.h.

References edm::atomic_value_ptr< T >::this_type_does_not_support_comparisons().

                                                                       {
    rhs.this_type_does_not_support_comparisons();
    return false;
  }

operator!=() [27/38]

template<typename C >

bool edm::operator!= ( RefProd< C > const &  lhs, RefProd< C > const &  rhs  )

inline

Definition at line 185 of file RefProd.h.

                                                                       {
    return !(lhs == rhs);
  }

operator!=() [28/38]

template<typename T , typename U >

bool edm::operator!= ( value_ptr< T > const &  lhs, U const &  rhs  )

inline

Definition at line 197 of file value_ptr.h.

References edm::value_ptr< T >::this_type_does_not_support_comparisons().

                                                                {
    lhs.this_type_does_not_support_comparisons();
    return false;
  }

operator!=() [29/38]

bool edm::operator!= ( ProductRegistry const &  a, ProductRegistry const &  b  )

inline

Definition at line 202 of file ProductRegistry.h.

References a, and b.

{ return !(a == b); }

operator!=() [30/38]

bool edm::operator!= ( Entry const &  a, Entry const &  b  )

inline

Definition at line 204 of file Entry.h.

References a, and b.

{ return !(a == b); }

operator!=() [31/38]

template<typename T , typename U >

bool edm::operator!= ( U const &  lhs, value_ptr< T > const &  rhs  )

inline

Definition at line 209 of file value_ptr.h.

References edm::value_ptr< T >::this_type_does_not_support_comparisons().

                                                                {
    rhs.this_type_does_not_support_comparisons();
    return false;
  }

operator!=() [32/38]

template<typename C , typename T , typename F >

bool edm::operator!= ( RefVector< C, T, F > const &  lhs, RefVector< C, T, F > const &  rhs  )

inline

Definition at line 210 of file RefVector.h.

                                                                                       {
    return !(lhs == rhs);
  }

operator!=() [33/38]

template<typename T >

bool edm::operator!= ( Ptr< T > const &  lhs, Ptr< T > const &  rhs  )

inline

Definition at line 243 of file Ptr.h.

                                                               {
    return !(lhs == rhs);
  }

operator!=() [34/38]

template<typename C , typename T , typename F >

bool edm::operator!= ( FwdRef< C, T, F > const &  lhs, FwdRef< C, T, F > const &  rhs  )

inline

Definition at line 246 of file FwdRef.h.

                                                                                 {
    return !(lhs == rhs);
  }

operator!=() [35/38]

template<typename C , typename T , typename F >

bool edm::operator!= ( Ref< C, T, F > const &  lhs, FwdRef< C, T, F > const &  rhs  )

inline

Definition at line 251 of file FwdRef.h.

                                                                              {
    return !(lhs == rhs);
  }

operator!=() [36/38]

template<typename C , typename T , typename F >

bool edm::operator!= ( FwdRef< C, T, F > const &  lhs, Ref< C, T, F > const &  rhs  )

inline

Definition at line 256 of file FwdRef.h.

                                                                              {
    return !(lhs == rhs);
  }

operator!=() [37/38]

bool edm::operator!= ( ParameterSet const &  a, ParameterSet const &  b  )

inline

Definition at line 299 of file ParameterSet.h.

References a, and b.

{ return !(a == b); }

operator!=() [38/38]

template<typename C , typename T , typename F >

bool edm::operator!= ( Ref< C, T, F > const &  lhs, Ref< C, T, F > const &  rhs  )

inline

Definition at line 582 of file Ref.h.

                                                                           {
    return !(lhs == rhs);
  }

operator+() [1/3]

template<typename C >

Association<C> edm::operator+ ( const Association< C > &  a1, const Association< C > &  a2  )

inline

Definition at line 117 of file Association.h.

References a, and testProducerWithPsetDescEmpty_cfi::a2.

                                                                                      {
    Association<C> a = a1;
    a += a2;
    return a;
  }

operator+() [2/3]

template<typename C , typename T , typename F >

RefVectorIterator<C, T, F> edm::operator+ ( typename RefVectorIterator< C, T, F >::difference  n, RefVectorIterator< C, T, F > const &  iter  )

inline

Definition at line 133 of file RefVectorIterator.h.

References dqmiodumpmetadata::n.

                                                                                      {
    return iter + n;
  }

operator+() [3/3]

template<typename T >

ValueMap<T> edm::operator+ ( const ValueMap< T > &  a1, const ValueMap< T > &  a2  )

inline

Definition at line 267 of file ValueMap.h.

References a, and testProducerWithPsetDescEmpty_cfi::a2.

                                                                             {
    ValueMap<T> a = a1;
    a += a2;
    return a;
  }

operator<() [1/29]

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

inline

Definition at line 22 of file EventProcessHistoryID.h.

References edm::EventProcessHistoryID::eventID(), and mathSSE::lh.

                                                                                          {
    return lh.eventID() < rh.eventID();
  }

operator<() [2/29]

bool edm::operator< ( ModuleProcessName const &  a, ModuleProcessName const &  b  )

inline

Definition at line 25 of file ModuleProcessName.h.

References a, and b.

                                                                                {
    return a.processName() == b.processName() ? a.moduleLabel() < b.moduleLabel() : a.processName() < b.processName();
  }

operator<() [3/29]

bool edm::operator< ( RunLumiEntryInfo const &  a, RunLumiEntryInfo const &  b  )

inline

Definition at line 32 of file RunLumiEntryInfo.h.

References a, and b.

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

operator<() [4/29]

bool edm::operator< ( StoredProductProvenance const &  a, StoredProductProvenance const &  b  )

inline

Definition at line 36 of file StoredProductProvenance.h.

References a, and b.

                                                                                            {
    return a.branchID_ < b.branchID_;
  }

operator<() [5/29]

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

inline

Definition at line 38 of file BranchKey.h.

References a, b, funct::false, and funct::true.

                                                                {
    return a.friendlyClassName() < b.friendlyClassName()       ? true
           : a.friendlyClassName() > b.friendlyClassName()     ? false
           : a.moduleLabel() < b.moduleLabel()                 ? true
           : a.moduleLabel() > b.moduleLabel()                 ? false
           : a.productInstanceName() < b.productInstanceName() ? true
           : a.productInstanceName() > b.productInstanceName() ? false
           : a.processName() < b.processName()                 ? true
                                                               : false;
  }

operator<() [6/29]

bool edm::operator< ( EventEntryInfo const &  a, EventEntryInfo const &  b  )

inline

Definition at line 40 of file EventEntryInfo.h.

References a, and b.

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

operator<() [7/29]

bool edm::operator<	(	ElementID const &	lh,
		ElementID const &	rh
	)

Definition at line 11 of file ElementID.cc.

References edm::ElementID::id(), edm::ElementID::index(), and mathSSE::lh.

                                                           {
    return lh.id() < rh.id() || (lh.id() == rh.id() && lh.index() < rh.index());
  }

operator<() [8/29]

bool edm::operator< ( WorkerTimingSummary const &  a, WorkerTimingSummary const &  b  )

inline

Definition at line 48 of file TriggerTimingReport.h.

References a, and b.

                                                                                    {
    return a.moduleLabel < b.moduleLabel;
  }

operator<() [9/29]

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

inline

Definition at line 50 of file ProductProvenance.h.

References a, and b.

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

operator<() [10/29]

bool edm::operator<	(	ProductID const &	lh,
		ProductID const &	rh
	)

Definition at line 11 of file ProductID.cc.

References mathSSE::lh, edm::ProductID::processIndex(), and edm::ProductID::productIndex().

                                                           {
    return lh.processIndex() < rh.processIndex() ||
           (lh.processIndex() == rh.processIndex() && lh.productIndex() < rh.productIndex());
  }

operator<() [11/29]

bool edm::operator< ( WorkerSummary const &  a, WorkerSummary const &  b  )

inline

Definition at line 55 of file TriggerReport.h.

References a, and b.

{ return a.moduleLabel < b.moduleLabel; }

operator<() [12/29]

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

Definition at line 88 of file ProcessConfiguration.cc.

References a, and b.

                                                                               {
    if (a.processName() < b.processName())
      return true;
    if (b.processName() < a.processName())
      return false;
    if (a.parameterSetID() < b.parameterSetID())
      return true;
    if (b.parameterSetID() < a.parameterSetID())
      return false;
    if (a.releaseVersion() < b.releaseVersion())
      return true;
    if (b.releaseVersion() < a.releaseVersion())
      return false;
    if (a.passID() < b.passID())
      return true;
    return false;
  }

operator<() [13/29]

template<class T >

bool edm::operator< ( DetSet< T > const &  x, DetSet< T > const &  y  )

inline

Definition at line 89 of file DetSet.h.

References x.

                                                                {
    return x.detId() < y.detId();
  }

operator<() [14/29]

template<class T >

bool edm::operator< ( DetSet< T > const &  x, det_id_type  y  )

inline

Definition at line 94 of file DetSet.h.

References x.

                                                           {
    return x.detId() < y;
  }

operator<() [15/29]

template<class T >

bool edm::operator< ( det_id_type  x, DetSet< T > const &  y  )

inline

Definition at line 99 of file DetSet.h.

References x.

                                                           {
    return x < y.detId();
  }

operator<() [16/29]

constexpr bool edm::operator< ( ELseverityLevel const &  e1, ELseverityLevel const &  e2  )

inlinenoexcept

Definition at line 108 of file ELseverityLevel.h.

References StorageManager_cfg::e1.

                                                                                                 {
    return e1.cmp(e2) < 0;
  }

operator<() [17/29]

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

Definition at line 185 of file FileIndex.cc.

References edm::FileIndex::Element::event_, mathSSE::lh, edm::FileIndex::Element::lumi_, and edm::FileIndex::Element::run_.

                                                                         {
    if (lh.run_ == rh.run_) {
      if (lh.lumi_ == rh.lumi_) {
        return lh.event_ < rh.event_;
      }
      return lh.lumi_ < rh.lumi_;
    }
    return lh.run_ < rh.run_;
  }

operator<() [18/29]

bool edm::operator< ( TypeWithDict const &  a, TypeWithDict const &  b  )

inline

Definition at line 137 of file TypeWithDict.h.

References a, and b.

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

operator<() [19/29]

template<typename T >

bool edm::operator< ( FwdPtr< T > const &  lhs, FwdPtr< T > const &  rhs  )

inline

The ordering of integer keys guarantees that the ordering of FwdPtrs within a collection will be identical to the ordering of the referenced objects in the collection.

Definition at line 139 of file FwdPtr.h.

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

operator<() [20/29]

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

inline

Definition at line 144 of file RefCore.h.

References edm::RefCore::id(), edm::RefCore::isTransient(), edm::RefCore::productPtr(), and funct::true.

                                                                {
    return lhs.isTransient() ? (rhs.isTransient() ? lhs.productPtr() < rhs.productPtr() : false)
                             : (rhs.isTransient() ? true : lhs.id() < rhs.id());
  }

operator<() [21/29]

template<typename T >

bool edm::operator< ( View< T > const &  lhs, View< T > const &  rhs  )

inline

Definition at line 303 of file View.h.

                                                                {
    return std::lexicographical_compare(lhs.begin(), lhs.end(), rhs.begin(), rhs.end());
  }

operator<() [22/29]

template<typename T >

bool edm::operator< ( RefToBaseProd< T > const &  lhs, RefToBaseProd< T > const &  rhs  )

inline

Definition at line 169 of file RefToBaseProd.h.

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

operator<() [23/29]

template<typename C >

bool edm::operator< ( RefProd< C > const &  lhs, RefProd< C > const &  rhs  )

inline

Definition at line 190 of file RefProd.h.

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

operator<() [24/29]

template<typename T >

bool edm::operator< ( Ptr< T > const &  lhs, Ptr< T > const &  rhs  )

inline

The ordering of integer keys guarantees that the ordering of Ptrs within a collection will be identical to the ordering of the referenced objects in the collection.

Definition at line 248 of file Ptr.h.

                                                              {
    return (lhs.refCore() == rhs.refCore() ? lhs.key() < rhs.key() : lhs.refCore() < rhs.refCore());
  }

operator<() [25/29]

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

Definition at line 301 of file BranchDescription.cc.

References a, and b.

                                                                         {
    if (a.processName() < b.processName())
      return true;
    if (b.processName() < a.processName())
      return false;
    if (a.fullClassName() < b.fullClassName())
      return true;
    if (b.fullClassName() < a.fullClassName())
      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.branchID() < b.branchID())
      return true;
    if (b.branchID() < a.branchID())
      return false;
    if (a.branchAliases() < b.branchAliases())
      return true;
    if (b.branchAliases() < a.branchAliases())
      return false;
    if (a.present() < b.present())
      return true;
    if (b.present() < a.present())
      return false;
    return false;
  }

operator<() [26/29]

template<typename C , typename T , typename F >

bool edm::operator< ( FwdRef< C, T, F > const &  lhs, FwdRef< C, T, F > const &  rhs  )

inline

for inequality operators, ONLY test the forward ref. the ordering of the backward ref is not relevant.

Definition at line 263 of file FwdRef.h.

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

operator<() [27/29]

template<typename C , typename T , typename F >

bool edm::operator< ( Ref< C, T, F > const &  lhs, FwdRef< C, T, F > const &  rhs  )

inline

Definition at line 268 of file FwdRef.h.

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

operator<() [28/29]

template<typename C , typename T , typename F >

bool edm::operator< ( FwdRef< C, T, F > const &  lhs, Ref< C, T, F > const &  rhs  )

inline

Definition at line 273 of file FwdRef.h.

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

operator<() [29/29]

template<typename C , typename T , typename F >

bool edm::operator< ( Ref< C, T, F > const &  lhs, Ref< C, T, F > const &  rhs  )

inline

the definition and use of compare_key<> guarantees that the ordering of Refs within a collection will be identical to the ordering of the referenced objects in the collection.

Definition at line 587 of file Ref.h.

                                                                          {
    return (lhs.refCore() == rhs.refCore() ? compare_key<C>(lhs.key(), rhs.key()) : lhs.refCore() < rhs.refCore());
  }

operator<<() [1/67]

std::ostream & edm::operator<<	(	std::ostream &	os,
		TimeOfDay const &	tod
	)

Definition at line 30 of file TimeOfDay.cc.

References SiStripPI::min, topSingleLeptonDQM_PU_cfi::pattern, cms::alpakatools::detail::power(), hcalRecHitTable_cff::precision, cmsswSequenceInfo::tp, and edm::TimeOfDay::tv_.

                                                               {
    auto oldflags = os.flags();  // save the stream format flags so they can be restored
    auto oldfill = os.fill();    // save the stream fill character so it can be restored
    struct tm timebuf;
    localtime_r(&tod.tv_.tv_sec, &timebuf);
    typedef std::ostreambuf_iterator<char, std::char_traits<char> > Iter;
    std::time_put<char, Iter> const& tp = std::use_facet<std::time_put<char, Iter> >(std::locale());
    int precision = os.precision();
    Iter begin(os);
    if (precision == 0) {
      char const pattern[] = "%d-%b-%Y %H:%M:%S %Z";
      tp.put(begin, os, ' ', &timebuf, pattern, pattern + sizeof(pattern) - 1);
    } else {
      char const pattern[] = "%d-%b-%Y %H:%M:%S.";
      tp.put(begin, os, ' ', &timebuf, pattern, pattern + sizeof(pattern) - 1);
      precision = std::min(precision, 6);
      os << std::setfill('0') << std::setw(precision) << tod.tv_.tv_usec / power[precision] << ' ';
      tp.put(begin, os, ' ', &timebuf, 'Z');
    }
    os.flags(oldflags);
    os.fill(oldfill);
    return os;
  }

operator<<() [2/67]

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

Definition at line 5 of file ParameterSetBlob.cc.

References edm::ParameterSetBlob::pset().

                                                                       {
    os << blob.pset();
    return os;
  }

operator<<() [3/67]

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

Definition at line 5 of file FileID.cc.

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

operator<<() [4/67]

std::ostream & edm::operator<<	(	std::ostream &	os,
		PlaceInPathContext const &	ppc
	)

Definition at line 10 of file PlaceInPathContext.cc.

References edm::PlaceInPathContext::pathContext(), and edm::PlaceInPathContext::placeInPath().

                                                                        {
    os << "PlaceInPathContext " << ppc.placeInPath() << "\n";
    if (ppc.pathContext()) {
      os << "    " << *ppc.pathContext();
    }
    return os;
  }

operator<<() [5/67]

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

Definition at line 9 of file BranchType.cc.

References BranchTypeToString().

                                                                       {
    os << BranchTypeToString(branchType);
    return os;
  }

operator<<() [6/67]

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

Definition at line 12 of file BranchID.cc.

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

operator<<() [7/67]

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

inline

Definition at line 34 of file RunLumiEntryInfo.h.

References AlCaHLTBitMon_ParallelJobs::p.

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

operator<<() [8/67]

std::ostream & edm::operator<<	(	std::ostream &	os,
		InternalContext const &	ic
	)

Definition at line 11 of file InternalContext.cc.

References edm::InternalContext::eventID(), and edm::InternalContext::moduleCallingContext().

                                                                    {
    os << "InternalContext " << ic.eventID() << "\n";
    if (ic.moduleCallingContext()) {
      os << "    " << *ic.moduleCallingContext();
    }
    return os;
  }

operator<<() [9/67]

std::ostream & edm::operator<<	(	std::ostream &	out,
		const reco::GenParticleRef &	genRef
	)

Definition at line 95 of file GenParticlesHelper.cc.

References edm::Ref< C, T, F >::key(), and MillePedeFileConverter_cfg::out.

                                                                            {
    if (!out)
      return out;

    out << "key:" << genRef.key() << " pt:" << genRef->pt();

    return out;
  }

operator<<() [10/67]

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

Definition at line 47 of file FileFormatVersion.cc.

References alignCSCRings::ff.

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

operator<<() [11/67]

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

inline

Definition at line 42 of file EventEntryInfo.h.

References AlCaHLTBitMon_ParallelJobs::p.

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

operator<<() [12/67]

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

Definition at line 14 of file PathContext.cc.

References edm::PathContext::kEndPath, edm::PathContext::pathID(), edm::PathContext::pathName(), edm::PathContext::pathType(), and edm::PathContext::streamContext().

                                                                {
    os << "PathContext: pathName = " << pc.pathName() << " pathID = " << pc.pathID();
    if (pc.pathType() == PathContext::PathType::kEndPath) {
      os << " (EndPath)\n";
    } else {
      os << "\n";
    }
    if (pc.streamContext()) {
      os << "    " << *pc.streamContext();
    }
    return os;
  }

operator<<() [13/67]

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

Definition at line 27 of file ProcessContext.cc.

References edm::ProcessContext::isSubProcess(), edm::ProcessConfiguration::parameterSetID(), edm::ProcessContext::parentProcessContext(), edm::ProcessContext::processConfiguration(), and edm::ProcessConfiguration::processName().

                                                                   {
    os << "ProcessContext: ";
    if (pc.processConfiguration()) {
      os << pc.processConfiguration()->processName() << " " << pc.processConfiguration()->parameterSetID() << "\n";
    } else {
      os << "invalid\n";
      return os;
    }
    if (pc.isSubProcess()) {
      os << "    parent " << pc.parentProcessContext();
    }
    return os;
  }

operator<<() [14/67]

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

inline

Definition at line 50 of file EventEntryDescription.h.

References AlCaHLTBitMon_ParallelJobs::p.

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

operator<<() [15/67]

std::ostream& edm::operator<< ( std::ostream &  iOS, ESResolverIndex const &  iIndex  )

inline

Definition at line 50 of file ESIndices.h.

References edm::ESResolverIndex::value().

                                                                                {
    iOS << iIndex.value();
    return iOS;
  }

operator<<() [16/67]

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

Definition at line 15 of file ElementID.cc.

                                                              {
    os << id.id() << ":" << id.index();
    return os;
  }

operator<<() [17/67]

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

inline

Definition at line 52 of file ProductProvenance.h.

References AlCaHLTBitMon_ParallelJobs::p.

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

operator<<() [18/67]

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

Definition at line 17 of file BranchKey.cc.

                                                              {
    os << "BranchKey(" << bk.friendlyClassName() << ", " << bk.moduleLabel() << ", " << bk.productInstanceName() << ", "
       << bk.processName() << ')';
    return os;
  }

operator<<() [19/67]

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

Definition at line 6 of file ProductID.cc.

                                                              {
    os << id.processIndex() << ":" << id.productIndex();
    return os;
  }

operator<<() [20/67]

std::ostream & edm::operator<<	(	std::ostream &	oStream,
		RunID const &	iID
	)

Definition at line 5 of file RunID.cc.

References edm::RunID::run().

                                                                {
    oStream << "run: " << iID.run();
    return oStream;
  }

operator<<() [21/67]

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

inline

Definition at line 56 of file RunAuxiliary.h.

References AlCaHLTBitMon_ParallelJobs::p.

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

operator<<() [22/67]

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

Definition at line 117 of file TypeID.cc.

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

operator<<() [23/67]

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

Definition at line 86 of file ParentContext.cc.

References edm::ParentContext::globalContext(), edm::ParentContext::internalContext(), edm::ParentContext::kGlobal, edm::ParentContext::kInternal, edm::ParentContext::kInvalid, edm::ParentContext::kModule, edm::ParentContext::kPlaceInPath, edm::ParentContext::kStream, edm::ParentContext::moduleCallingContext(), edm::ParentContext::placeInPathContext(), edm::ParentContext::streamContext(), and edm::ParentContext::type().

                                                                  {
    if (pc.type() == ParentContext::Type::kGlobal && pc.globalContext()) {
      os << *pc.globalContext();
    } else if (pc.type() == ParentContext::Type::kInternal && pc.internalContext()) {
      os << *pc.internalContext();
    } else if (pc.type() == ParentContext::Type::kModule && pc.moduleCallingContext()) {
      os << *pc.moduleCallingContext();
    } else if (pc.type() == ParentContext::Type::kPlaceInPath && pc.placeInPathContext()) {
      os << *pc.placeInPathContext();
    } else if (pc.type() == ParentContext::Type::kStream && pc.streamContext()) {
      os << *pc.streamContext();
    } else if (pc.type() == ParentContext::Type::kInvalid) {
      os << "ParentContext invalid\n";
    }
    return os;
  }

operator<<() [24/67]

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

Definition at line 120 of file ProductSelector.cc.

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

operator<<() [25/67]

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

inline

Definition at line 61 of file LuminosityBlockAuxiliary.h.

References AlCaHLTBitMon_ParallelJobs::p.

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

operator<<() [26/67]

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

inline

Definition at line 63 of file Parentage.h.

References AlCaHLTBitMon_ParallelJobs::p.

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

operator<<() [27/67]

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

inline

Definition at line 65 of file StableProvenance.h.

References AlCaHLTBitMon_ParallelJobs::p.

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

operator<<() [28/67]

std::ostream & edm::operator<<	(	std::ostream &	oStream,
		LuminosityBlockRange const &	iID
	)

Definition at line 43 of file LuminosityBlockRange.cc.

                                                                             {
    oStream << "'" << r.startRun() << ":" << r.startLumi() << "-" << r.endRun() << ":" << r.endLumi() << "'";
    return oStream;
  }

operator<<() [29/67]

std::ostream & edm::operator<<	(	std::ostream &	oStream,
		EventRange const &	iID
	)

Definition at line 27 of file EventRange.cc.

                                                                   {
    if (r.startLumi() == 0) {
      oStream << "'" << r.startRun() << ":" << r.startEvent() << "-" << r.endRun() << ":" << r.endEvent() << "'";
    } else {
      oStream << "'" << r.startRun() << ":" << r.startLumi() << ":" << r.startEvent() << "-" << r.endRun() << ":"
              << r.endLumi() << ":" << r.endEvent() << "'";
    }
    return oStream;
  }

operator<<() [30/67]

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

Definition at line 202 of file InputTag.cc.

References LaserDQM_cfg::process, AlCaHLTBitMon_QueryRunRegistry::string, and makeGlobalPositionRcd_cfg::tag.

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

operator<<() [31/67]

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

Definition at line 106 of file ProcessConfiguration.cc.

References edm::ProcessConfiguration::parameterSetID(), edm::ProcessConfiguration::passID(), edm::ProcessConfiguration::processName(), and edm::ProcessConfiguration::releaseVersion().

                                                                         {
    os << pc.processName() << ' ' << pc.parameterSetID() << ' ' << pc.releaseVersion() << ' ' << pc.passID();
    return os;
  }

operator<<() [32/67]

std::ostream & edm::operator<<	(	std::ostream &	t,
		OStreamColumn const &	c
	)

Definition at line 12 of file OStreamColumn.cc.

References HltBtagPostValidation_cff::c, and submitPVValidationJobs::t.

                                                                {
    t << std::setw(c.width_) << c.title_;
    return t;
  }

operator<<() [33/67]

std::ostream& edm::operator<< ( std::ostream &  iOS, ESTokenIndex const &  iIndex  )

inline

Definition at line 75 of file ESIndices.h.

References edm::ESTokenIndex::value().

                                                                             {
    iOS << iIndex.value();
    return iOS;
  }

operator<<() [34/67]

std::ostream & edm::operator<<	(	std::ostream &	os,
		GlobalContext const &	gc
	)

Definition at line 29 of file GlobalContext.cc.

References edm::GlobalContext::kAccessInputProcessBlock, edm::GlobalContext::kBeginJob, edm::GlobalContext::kBeginLuminosityBlock, edm::GlobalContext::kBeginProcessBlock, edm::GlobalContext::kBeginRun, edm::GlobalContext::kEndJob, edm::GlobalContext::kEndLuminosityBlock, edm::GlobalContext::kEndProcessBlock, edm::GlobalContext::kEndRun, edm::GlobalContext::kWriteLuminosityBlock, edm::GlobalContext::kWriteProcessBlock, edm::GlobalContext::kWriteRun, edm::GlobalContext::luminosityBlockID(), edm::GlobalContext::luminosityBlockIndex(), edm::Timestamp::microsecondOffset(), edm::GlobalContext::processContext(), edm::GlobalContext::runIndex(), edm::GlobalContext::timestamp(), edm::GlobalContext::transition(), edm::Timestamp::unixTime(), edm::RunIndex::value(), and edm::LuminosityBlockIndex::value().

                                                                  {
    os << "GlobalContext: transition = ";
    switch (gc.transition()) {
      case GlobalContext::Transition::kBeginJob:
        os << "BeginJob";
        break;
      case GlobalContext::Transition::kBeginProcessBlock:
        os << "BeginProcessBlock";
        break;
      case GlobalContext::Transition::kAccessInputProcessBlock:
        os << "AccessInputProcessBlock";
        break;
      case GlobalContext::Transition::kBeginRun:
        os << "BeginRun";
        break;
      case GlobalContext::Transition::kBeginLuminosityBlock:
        os << "BeginLuminosityBlock";
        break;
      case GlobalContext::Transition::kEndLuminosityBlock:
        os << "EndLuminosityBlock";
        break;
      case GlobalContext::Transition::kEndRun:
        os << "EndRun";
        break;
      case GlobalContext::Transition::kEndProcessBlock:
        os << "EndProcessBlock";
        break;
      case GlobalContext::Transition::kEndJob:
        os << "EndJob";
        break;
      case GlobalContext::Transition::kWriteProcessBlock:
        os << "WriteProcessBlock";
        break;
      case GlobalContext::Transition::kWriteRun:
        os << "WriteRun";
        break;
      case GlobalContext::Transition::kWriteLuminosityBlock:
        os << "WriteLuminosityBlock";
        break;
    }
    os << "\n    " << gc.luminosityBlockID() << "\n    runIndex = " << gc.runIndex().value()
       << "  luminosityBlockIndex = " << gc.luminosityBlockIndex().value()
       << "  unixTime = " << gc.timestamp().unixTime() << " microsecondOffset = " << gc.timestamp().microsecondOffset()
       << "\n";
    if (gc.processContext()) {
      os << "    " << *gc.processContext();
    }
    return os;
  }

operator<<() [35/67]

template<typename E >

std::ostream& edm::operator<<	(	std::ostream &	t,
		OStreamColumnEntry< E > const &	ce
	)

Definition at line 78 of file OStreamColumn.h.

References submitPVValidationJobs::t.

                                                                         {
    t << std::setw(ce.col.width_) << ce.t;
    return t;
  }

operator<<() [36/67]

std::ostream & edm::operator<<	(	std::ostream &	os,
		StreamContext const &	sc
	)

Definition at line 33 of file StreamContext.cc.

References edm::StreamContext::eventID(), edm::StreamContext::kBeginLuminosityBlock, edm::StreamContext::kBeginRun, edm::StreamContext::kBeginStream, edm::StreamContext::kEndLuminosityBlock, edm::StreamContext::kEndRun, edm::StreamContext::kEndStream, edm::StreamContext::kEvent, edm::StreamContext::kInvalid, edm::StreamContext::luminosityBlockIndex(), edm::Timestamp::microsecondOffset(), edm::StreamContext::processContext(), edm::StreamContext::runIndex(), edm::StreamContext::streamID(), edm::StreamContext::timestamp(), edm::StreamContext::transition(), edm::Timestamp::unixTime(), edm::RunIndex::value(), and edm::LuminosityBlockIndex::value().

                                                                  {
    os << "StreamContext: StreamID = " << sc.streamID() << " transition = ";
    switch (sc.transition()) {
      case StreamContext::Transition::kBeginStream:
        os << "BeginStream";
        break;
      case StreamContext::Transition::kBeginRun:
        os << "BeginRun";
        break;
      case StreamContext::Transition::kBeginLuminosityBlock:
        os << "BeginLuminosityBlock";
        break;
      case StreamContext::Transition::kEvent:
        os << "Event";
        break;
      case StreamContext::Transition::kEndLuminosityBlock:
        os << "EndLuminosityBlock";
        break;
      case StreamContext::Transition::kEndRun:
        os << "EndRun";
        break;
      case StreamContext::Transition::kEndStream:
        os << "EndStream";
        break;
      case StreamContext::Transition::kInvalid:
        os << "Invalid";
        break;
    }
    os << "\n    " << sc.eventID() << "\n    runIndex = " << sc.runIndex().value()
       << "  luminosityBlockIndex = " << sc.luminosityBlockIndex().value()
       << "  unixTime = " << sc.timestamp().unixTime() << " microsecondOffset = " << sc.timestamp().microsecondOffset()
       << "\n";
    if (sc.processContext()) {
      os << "    " << *sc.processContext();
    }
    return os;
  }

operator<<() [37/67]

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

inline

Definition at line 85 of file ModuleDescription.h.

References AlCaHLTBitMon_ParallelJobs::p.

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

operator<<() [38/67]

std::ostream& edm::operator<<	(	std::ostream &	os,
		ParameterSetEntry const &	psetEntry
	)

Definition at line 92 of file ParameterSetEntry.cc.

References edm::ParameterSetEntry::dump().

                                                                             {
    os << psetEntry.dump();
    return os;
  }

operator<<() [39/67]

std::ostream & edm::operator<<	(	std::ostream &	oStream,
		LuminosityBlockID const &	iID
	)

Definition at line 20 of file LuminosityBlockID.cc.

References edm::LuminosityBlockID::luminosityBlock(), and edm::LuminosityBlockID::run().

                                                                            {
    oStream << "run: " << iID.run() << " luminosityBlock: " << iID.luminosityBlock();
    return oStream;
  }

operator<<() [40/67]

std::ostream & edm::operator<<	(	std::ostream &	os,
		ModuleCallingContext const &	mcc
	)

Definition at line 144 of file ModuleCallingContext.cc.

References edm::ModuleCallingContext::kInvalid, edm::ParentContext::kModule, edm::ModuleCallingContext::kPrefetching, edm::ModuleCallingContext::kRunning, edm::ModuleCallingContext::moduleCallingContext(), edm::ModuleCallingContext::moduleDescription(), edm::ModuleCallingContext::parent(), edm::ModuleCallingContext::previousModuleOnThread(), edm::ModuleCallingContext::state(), and edm::ModuleCallingContext::type().

                                                                          {
    os << "ModuleCallingContext state = ";
    switch (mcc.state()) {
      case ModuleCallingContext::State::kInvalid:
        os << "Invalid";
        break;
      case ModuleCallingContext::State::kPrefetching:
        os << "Prefetching";
        break;
      case ModuleCallingContext::State::kRunning:
        os << "Running";
        break;
    }
    os << "\n";
    if (mcc.state() == ModuleCallingContext::State::kInvalid) {
      return os;
    }
    if (mcc.moduleDescription()) {
      os << "    moduleDescription: " << *mcc.moduleDescription() << "\n";
    }
    os << "    " << mcc.parent();
    if (mcc.previousModuleOnThread()) {
      if (mcc.type() == ParentContext::Type::kModule && mcc.moduleCallingContext() == mcc.previousModuleOnThread()) {
        os << "    previousModuleOnThread: same as parent module\n";
      } else {
        os << "    previousModuleOnThread: " << *mcc.previousModuleOnThread();
      }
    }
    return os;
  }

operator<<() [41/67]

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

inline

Definition at line 97 of file Provenance.h.

References AlCaHLTBitMon_ParallelJobs::p.

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

operator<<() [42/67]

std::ostream& edm::operator<< ( std::ostream &  iOS, ESRecordIndex const &  iIndex  )

inline

Definition at line 102 of file ESIndices.h.

References edm::ESRecordIndex::value().

                                                                              {
    iOS << iIndex.value();
    return iOS;
  }

operator<<() [43/67]

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

inline

Formatted printout of trigger table.

Definition at line 102 of file HLTGlobalStatus.h.

References ValidationMatrix::hlt, mps_fire::i, dqmiodumpmetadata::n, and submitPVValidationJobs::text.

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

operator<<() [44/67]

std::ostream& edm::operator<<	(	std::ostream &	os,
		JobReport::RunReport const &	f
	)

Definition at line 105 of file JobReport.cc.

References f, and print().

{ return print(os, f); }

operator<<() [45/67]

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

inline

Definition at line 106 of file EventAuxiliary.h.

References AlCaHLTBitMon_ParallelJobs::p.

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

operator<<() [46/67]

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

Definition at line 5 of file EventID.cc.

References edm::EventID::event(), edm::EventID::luminosityBlock(), and edm::EventID::run().

                                                                  {
    oStream << "run: " << iID.run() << " lumi: " << iID.luminosityBlock() << " event: " << iID.event();
    return oStream;
  }

operator<<() [47/67]

template<class T >

ErrorObj& edm::operator<< ( ErrorObj &  e, const T &  t  )

inline

operator<<() [48/67]

std::ostream & edm::operator<<	(	std::ostream &	os,
		ESInputTag const &	tag
	)

Definition at line 64 of file ESInputTag.cc.

References makeGlobalPositionRcd_cfg::tag.

                                                                {
    os << "Module label: " << tag.module() << " Data label: " << tag.data();
    return os;
  }

operator<<() [49/67]

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

Definition at line 65 of file ProcessHistory.cc.

References copy_all().

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

operator<<() [50/67]

ErrorObj & edm::operator<<	(	ErrorObj &	e,
		const char	s[]
	)

Definition at line 259 of file ErrorObj.cc.

References MillePedeFileConverter_cfg::e, and alignCSCRings::s.

{ return e.opltlt(s); }

operator<<() [51/67]

std::ostream& edm::operator<< ( std::ostream &  os, const edm::FileInPath &  fip  )

inline

Definition at line 132 of file FileInPath.h.

References edm::FileInPath::write().

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

operator<<() [52/67]

std::ostream& edm::operator<<	(	std::ostream &	os,
		VParameterSetEntry const &	vpsetEntry
	)

Definition at line 135 of file VParameterSetEntry.cc.

References edm::VParameterSetEntry::dump().

                                                                               {
    os << vpsetEntry.dump();
    return os;
  }

operator<<() [53/67]

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

Definition at line 213 of file FileIndex.cc.

References edm::FileIndex::begin(), edm::FileIndex::end(), ALPAKA_ACCELERATOR_NAMESPACE::vertexFinder::it, edm::FileIndex::kEvent, edm::FileIndex::kLumi, and edm::FileIndex::kRun.

                                                                     {
    os << "\nPrinting FileIndex contents.  This includes a list of all Runs, LuminosityBlocks\n"
       << "and Events stored in the root file.\n\n";
    os << std::setw(15) << "Run" << std::setw(15) << "Lumi" << std::setw(15) << "Event" << std::setw(15)
       << "TTree Entry"
       << "\n";
    for (std::vector<FileIndex::Element>::const_iterator it = fileIndex.begin(), itEnd = fileIndex.end(); it != itEnd;
         ++it) {
      if (it->getEntryType() == FileIndex::kEvent) {
        os << std::setw(15) << it->run_ << std::setw(15) << it->lumi_ << std::setw(15) << it->event_ << std::setw(15)
           << it->entry_ << "\n";
      } else if (it->getEntryType() == FileIndex::kLumi) {
        os << std::setw(15) << it->run_ << std::setw(15) << it->lumi_ << std::setw(15) << " " << std::setw(15)
           << it->entry_ << "  (LuminosityBlock)"
           << "\n";
      } else if (it->getEntryType() == FileIndex::kRun) {
        os << std::setw(15) << it->run_ << std::setw(15) << " " << std::setw(15) << " " << std::setw(15) << it->entry_
           << "  (Run)"
           << "\n";
      }
    }
    return os;
  }

operator<<() [54/67]

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

Definition at line 827 of file TypeWithDict.cc.

References edm::TypeWithDict::print().

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

operator<<() [55/67]

std::ostream& edm::operator<< ( std::ostream &  os, const CompactEventAuxiliaryVector::CompactEventAuxiliary &  p  )

inline

Definition at line 155 of file CompactEventAuxiliaryVector.h.

References AlCaHLTBitMon_ParallelJobs::p.

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

operator<<() [56/67]

std::ostream& edm::operator<< ( std::ostream &  os, const CompactEventAuxiliaryVector::CompactEventAuxiliaryExtra &  p  )

inline

Definition at line 160 of file CompactEventAuxiliaryVector.h.

References AlCaHLTBitMon_ParallelJobs::p.

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

operator<<() [57/67]

std::ostream& edm::operator<< ( std::ostream &  os, ProductResolverBase const &  phb  )

inline

Definition at line 198 of file ProductResolverBase.h.

References edm::ProductResolverBase::write().

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

operator<<() [58/67]

std::ostream& edm::operator<< ( std::ostream &  os, ProductRegistry const &  pr  )

inline

Definition at line 204 of file ProductRegistry.h.

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

operator<<() [59/67]

template<int I>

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

inline

Definition at line 210 of file Hash.h.

References h.

                                                                  {
    return h.print(os);
  }

operator<<() [60/67]

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

inline

Definition at line 245 of file BranchDescription.h.

References AlCaHLTBitMon_ParallelJobs::p.

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

operator<<() [61/67]

template<typename PROD >

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

inline

Definition at line 247 of file PrincipalGetAdapter.h.

References h.

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

operator<<() [62/67]

template<typename T , std::size_t N>

std::ostream& edm::operator<<	(	std::ostream &	out,
		edm::StdArray< T, N > const &	array
	)

Definition at line 247 of file StdArray.h.

References mps_check::array, ALPAKA_ACCELERATOR_NAMESPACE::brokenline::constexpr(), mps_fire::i, N, and MillePedeFileConverter_cfg::out.

                                                                          {
    out << "{";
    if constexpr (N > 0) {
      out << " " << array[0];
    }
    for (std::size_t i = 1; i < N; ++i)
      out << ", " << array[i];
    out << " }";
    return out;
  }

operator<<() [63/67]

template<typename C , typename T , typename F >

std::ostream& edm::operator<<	(	std::ostream &	os,
		RefVector< C, T, F > const &	r
	)

Definition at line 256 of file RefVector.h.

References MillePedeFileConverter_cfg::e, and mps_fire::i.

                                                                      {
    for (typename RefVector<C, T, F>::const_iterator i = r.begin(), e = r.end(); i != e; ++i) {
      os << *i << '\n';
    }
    return os;
  }

operator<<() [64/67]

std::ostream & edm::operator<<	(	std::ostream &	os,
		JobReport::InputFile const &	f
	)

Definition at line 103 of file JobReport.cc.

References f, and print().

{ return print(os, f); }

operator<<() [65/67]

std::ostream & edm::operator<<	(	std::ostream &	os,
		JobReport::OutputFile const &	f
	)

Definition at line 104 of file JobReport.cc.

References f, and print().

{ return print(os, f); }

operator<<() [66/67]

std::ostream& edm::operator<<	(	std::ostream &	os,
		ParameterSet const &	pset
	)

Definition at line 912 of file ParameterSet.cc.

References muonDTDigis_cfi::pset.

                                                                   {
    os << pset.dump();
    return os;
  }

operator<<() [67/67]

std::ostream& edm::operator<<	(	std::ostream &	os,
		Entry const &	entry
	)

Definition at line 1188 of file Entry.cc.

References MillePedeFileConverter_cfg::e, mps_splice::entry, mps_fire::i, ALPAKA_ACCELERATOR_NAMESPACE::vertexFinder::it, kTint32, kTPSet, kTstringHex, kTstringRaw, kTuint32, kTVESInputTag, kTVInputTag, kTvstringHex, kTvstringRaw, alignCSCRings::s, AlCaHLTBitMon_QueryRunRegistry::string, makeListRunsInFiles::strings, triggerMatcherToHLTDebug_cfi::tags, and typeFromCode().

                                                             {
    os << typeFromCode(entry.typeCode()) << " " << (entry.isTracked() ? "tracked " : "untracked ") << " = ";

    // now handle the difficult cases
    switch (entry.typeCode()) {
      case kTPSet:  // ParameterSet
      {
        os << entry.getPSet();
        break;
      }
      case 'p':  // vector<ParameterSet>
      {
        // Make sure we get the representation of each contained
        // ParameterSet including *only* tracked parameters
        std::vector<ParameterSet> whole = entry.getVPSet();
        std::vector<ParameterSet>::const_iterator i = whole.begin();
        std::vector<ParameterSet>::const_iterator e = whole.end();
        std::string start = "";
        std::string const between(",\n");
        os << "{" << std::endl;
        for (; i != e; ++i) {
          os << start << *i;
          start = between;
        }
        if (!whole.empty()) {
          os << std::endl;
        }
        os << "}";
        break;
      }
      case kTstringRaw: {
        os << "'" << entry.getString() << "'";
        break;
      }
      case kTvstringRaw: {
        os << "{";
        std::string_view start = "'";
        std::string_view const between(",'");
        std::vector<std::string> strings = entry.getVString();
        for (auto const& s : strings) {
          os << start << s << "'";
          start = between;
        }
        os << "}";
        break;
      }
      case kTstringHex: {
        os << "'" << entry.getString() << "'";
        break;
      }
      case kTvstringHex: {
        os << "{";
        std::string_view start = "'";
        std::string_view const between(",'");
        std::vector<std::string> strings = entry.getVString();
        for (auto const& s : strings) {
          os << start << s << "'";
          start = between;
        }
        os << "}";
        break;
      }
      case kTint32: {
        os << entry.getInt32();
        break;
      }
      case kTuint32: {
        os << entry.getUInt32();
        break;
      }
      case kTVInputTag: {
        //VInputTag needs to be treated seperately because it is encode like
        // vector<string> rather than using the individual encodings of each InputTag
        os << "{";
        std::string start = "";
        std::string const between(",");
        std::vector<InputTag> tags = entry.getVInputTag();
        for (std::vector<InputTag>::const_iterator it = tags.begin(), itEnd = tags.end(); it != itEnd; ++it) {
          os << start << it->encode();
          start = between;
        }
        os << "}";
        break;
      }
      case kTVESInputTag: {
        //VESInputTag needs to be treated seperately because it is encode like
        // vector<string> rather than using the individual encodings of each ESInputTag
        os << "{";
        std::string start = "";
        std::string const between(",");
        std::vector<ESInputTag> tags = entry.getVESInputTag();
        for (std::vector<ESInputTag>::const_iterator it = tags.begin(), itEnd = tags.end(); it != itEnd; ++it) {
          os << start << it->encode();
          start = between;
        }
        os << "}";
        break;
      }
      default: {
        os << entry.rep_;
        break;
      }
    }

    return os;
  }

operator<=() [1/3]

constexpr bool edm::operator<= ( ELseverityLevel const &  e1, ELseverityLevel const &  e2  )

inlinenoexcept

Definition at line 111 of file ELseverityLevel.h.

References StorageManager_cfg::e1.

                                                                                                  {
    return e1.cmp(e2) <= 0;
  }

operator<=() [2/3]

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

inline

Definition at line 131 of file FileIndex.h.

References mathSSE::lh.

{ return !(rh < lh); }

operator<=() [3/3]

template<typename T >

bool edm::operator<= ( View< T > const &  lhs, View< T > const &  rhs  )

inline

Definition at line 308 of file View.h.

                                                                 {
    return !(rhs < lhs);
  }

operator==() [1/44]

bool edm::operator== ( FileID const &  lh, FileID const &  rh  )

inline

Definition at line 25 of file FileID.h.

References edm::FileID::fid(), and mathSSE::lh.

{ return lh.fid() == rh.fid(); }

operator==() [2/44]

bool edm::operator==	(	RunLumiEntryInfo const &	a,
		RunLumiEntryInfo const &	b
	)

Definition at line 15 of file RunLumiEntryInfo.cc.

References a, and b.

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

operator==() [3/44]

bool edm::operator== ( ElementID const &  lh, ElementID const &  rh  )

inline

Definition at line 42 of file ElementID.h.

References edm::ElementID::id(), edm::ElementID::index(), and mathSSE::lh.

                                                                   {
    return lh.index() == rh.index() && lh.id() == rh.id();
  }

operator==() [4/44]

bool edm::operator== ( ProductID const &  lh, ProductID const &  rh  )

inline

Definition at line 47 of file ProductID.h.

References mathSSE::lh, edm::ProductID::processIndex(), and edm::ProductID::productIndex().

                                                                   {
    return lh.processIndex() == rh.processIndex() && lh.productIndex() == rh.productIndex();
  }

operator==() [5/44]

bool edm::operator==	(	EventEntryInfo const &	a,
		EventEntryInfo const &	b
	)

Definition at line 19 of file EventEntryInfo.cc.

References a, and b.

                                                                    {
    return a.branchID() == b.branchID() && a.productID() == b.productID() &&
           a.entryDescriptionID() == b.entryDescriptionID();
  }

operator==() [6/44]

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

inline

Definition at line 49 of file BranchKey.h.

References a, and b.

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

operator==() [7/44]

template<typename T1 , template< typename X1 > class B1, typename T2 , template< typename X2 > class B2>

bool edm::operator== ( const zero_allocator< T1, B1 > &  a, const zero_allocator< T2, B2 > &  b  )

inline

Definition at line 53 of file zero_allocator.h.

References a, and b.

                                                                                           {
    return static_cast<B1<T1> >(a) == static_cast<B2<T2> >(b);
  }

operator==() [8/44]

bool edm::operator==	(	EventEntryDescription const &	a,
		EventEntryDescription const &	b
	)

Definition at line 31 of file EventEntryDescription.cc.

References a, and b.

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

operator==() [9/44]

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

Definition at line 52 of file ProductProvenance.cc.

References a, and b.

                                                                          {
    return a.branchID() == b.branchID() && a.parentageID() == b.parentageID();
  }

operator==() [10/44]

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

inline

Definition at line 66 of file ProcessConfiguration.h.

References a, and b.

                                                                                       {
    return a.processName() == b.processName() && a.parameterSetID() == b.parameterSetID() &&
           a.releaseVersion() == b.releaseVersion() && a.passID() == b.passID();
  }

operator==() [11/44]

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

Definition at line 34 of file Parentage.cc.

References a, and b.

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

operator==() [12/44]

bool edm::operator==	(	StableProvenance const &	a,
		StableProvenance const &	b
	)

Definition at line 23 of file StableProvenance.cc.

References a, and b.

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

operator==() [13/44]

template<class T >

bool edm::operator== ( RefToBaseVector< T > const &  a, RefToBaseVector< T > const &  b  )

inline

Definition at line 97 of file RefToBaseVector.h.

References a, b, and cond::serialization::equal().

                                                                                   {
    if (a.isInvalid() && b.isInvalid())
      return true;
    if (a.isInvalid() || b.isInvalid())
      return false;
    return a.size() == b.size() && std::equal(a.begin(), a.end(), b.begin());
  }

operator==() [14/44]

constexpr bool edm::operator== ( ELseverityLevel const &  e1, ELseverityLevel const &  e2  )

inlinenoexcept

Definition at line 102 of file ELseverityLevel.h.

References StorageManager_cfg::e1.

Referenced by checkForModuleDependencyCorrectness().

                                                                                                  {
    return e1.cmp(e2) == 0;
  }

operator==() [15/44]

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

Definition at line 51 of file Provenance.cc.

References a, and b.

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

operator==() [16/44]

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

inline

Definition at line 108 of file ProcessHistory.h.

References a, and b.

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

operator==() [17/44]

template<typename T >

bool edm::operator== ( FwdPtr< T > const &  lhs, FwdPtr< T > const &  rhs  )

inline

Definition at line 128 of file FwdPtr.h.

                                                                     {
    return (lhs.ptr() == rhs.ptr() || lhs.backPtr() == rhs.ptr() || lhs.ptr() == rhs.backPtr() ||
            lhs.backPtr() == rhs.backPtr());
  }

operator==() [18/44]

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

inline

Definition at line 133 of file FileIndex.h.

References mathSSE::lh.

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

operator==() [19/44]

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

inline

Definition at line 137 of file RefCore.h.

References edm::RefCore::id(), edm::RefCore::isTransient(), and edm::RefCore::productPtr().

                                                                 {
    return lhs.isTransient() == rhs.isTransient() &&
           (lhs.isTransient() ? lhs.productPtr() == rhs.productPtr() : lhs.id() == rhs.id());
  }

operator==() [20/44]

template<typename KEY >

bool edm::operator==	(	RefVectorBase< KEY > const &	lhs,
		RefVectorBase< KEY > const &	rhs
	)

Equality operator.

Definition at line 137 of file RefVectorBase.h.

References edm::RefVectorBase< KEY >::keys(), and edm::RefVectorBase< KEY >::refCore().

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

operator==() [21/44]

bool edm::operator==	(	TypeWithDict const &	a,
		TypeWithDict const &	b
	)

Definition at line 817 of file TypeWithDict.cc.

References a, and b.

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

operator==() [22/44]

bool edm::operator== ( edm::FileInPath const &  a, edm::FileInPath const &  b  )

inline

Definition at line 142 of file FileInPath.h.

References a, and b.

                                                                         {
    return a.location() == b.location() && a.relativePath() == b.relativePath();
  }

operator==() [23/44]

bool edm::operator==	(	TypeWithDict const &	a,
		std::type_info const &	b
	)

Definition at line 819 of file TypeWithDict.cc.

References a, b, and edm::TypeID::className().

                                                                {
    if (*a.ti_ == typeid(TypeWithDict::dummyType) || a.isPointer() || a.isArray()) {
      // No accurate type_info
      return a.name() == TypeID(b).className();
    }
    return *a.ti_ == b;
  }

operator==() [24/44]

template<typename T >

bool edm::operator== ( View< T > const &  lhs, View< T > const &  rhs  )

inline

Definition at line 293 of file View.h.

References cond::serialization::equal().

                                                                 {
    return lhs.size() == rhs.size() && std::equal(lhs.begin(), lhs.end(), rhs.begin());
  }

operator==() [25/44]

bool edm::operator== ( std::type_info const &  a, TypeWithDict const &  b  )

inline

Definition at line 147 of file TypeWithDict.h.

References a, and b.

{ return b == a; }

operator==() [26/44]

template<typename T >

bool edm::operator== ( RefToBaseProd< T > const &  lhs, RefToBaseProd< T > const &  rhs  )

inline

Definition at line 159 of file RefToBaseProd.h.

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

operator==() [27/44]

template<typename T , typename U >

bool edm::operator== ( atomic_value_ptr< T > const &  lhs, U const &  rhs  )

inline

Definition at line 162 of file atomic_value_ptr.h.

References edm::atomic_value_ptr< T >::this_type_does_not_support_comparisons().

                                                                       {
    lhs.this_type_does_not_support_comparisons();
    return false;
  }

operator==() [28/44]

template<typename T , typename U >

bool edm::operator== ( U const &  lhs, atomic_value_ptr< T > const &  rhs  )

inline

Definition at line 174 of file atomic_value_ptr.h.

References edm::atomic_value_ptr< T >::this_type_does_not_support_comparisons().

                                                                       {
    rhs.this_type_does_not_support_comparisons();
    return false;
  }

operator==() [29/44]

template<typename C >

bool edm::operator== ( RefProd< C > const &  lhs, RefProd< C > const &  rhs  )

inline

Definition at line 180 of file RefProd.h.

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

operator==() [30/44]

template<typename T , typename U >

bool edm::operator== ( value_ptr< T > const &  lhs, U const &  rhs  )

inline

Definition at line 191 of file value_ptr.h.

References edm::value_ptr< T >::this_type_does_not_support_comparisons().

                                                                {
    lhs.this_type_does_not_support_comparisons();
    return false;
  }

operator==() [31/44]

bool edm::operator== ( ProductRegistry const &  a, ProductRegistry const &  b  )

inline

Definition at line 198 of file ProductRegistry.h.

References a, and b.

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

operator==() [32/44]

bool edm::operator== ( Entry const &  a, Entry const &  b  )

inline

Definition at line 202 of file Entry.h.

References a, and b.

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

operator==() [33/44]

template<typename T , typename U >

bool edm::operator== ( U const &  lhs, value_ptr< T > const &  rhs  )

inline

Definition at line 203 of file value_ptr.h.

References edm::value_ptr< T >::this_type_does_not_support_comparisons().

                                                                {
    rhs.this_type_does_not_support_comparisons();
    return false;
  }

operator==() [34/44]

template<typename C , typename T , typename F >

bool edm::operator== ( RefVector< C, T, F > const &  lhs, RefVector< C, T, F > const &  rhs  )

inline

Definition at line 205 of file RefVector.h.

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

operator==() [35/44]

template<typename C , typename T , typename F >

bool edm::operator== ( FwdRef< C, T, F > const &  lhs, FwdRef< C, T, F > const &  rhs  )

inline

for two FwdRefs to be equal, both the "forward" and the "backward" Refs must be the same

Definition at line 227 of file FwdRef.h.

References edm::FwdRef< C, T, F >::backRef(), and edm::FwdRef< C, T, F >::ref().

                                                                                 {
    return (lhs.ref() == rhs.ref()) && (lhs.backRef() == rhs.backRef());
  }

operator==() [36/44]

template<typename C , typename T , typename F >

bool edm::operator== ( Ref< C, T, F > const &  lhs, FwdRef< C, T, F > const &  rhs  )

inline

for a FwdRef to equal a Ref, EITHER the "forward" or the "backward" Refs must equal to the test ref

Definition at line 234 of file FwdRef.h.

References edm::FwdRef< C, T, F >::backRef(), and edm::FwdRef< C, T, F >::ref().

                                                                              {
    return (lhs == rhs.ref()) || (lhs == rhs.backRef());
  }

operator==() [37/44]

template<class T , class U , std::size_t N>

constexpr bool edm::operator==	(	StdArray< T, N > const &	lhs,
		StdArray< U, N > const &	rhs
	)

Definition at line 237 of file StdArray.h.

References mps_fire::i, and N.

                                                                                  {
    for (std::size_t i = 0; i < N; ++i) {
      if (lhs[i] != rhs[i])
        return false;
    }
    return true;
  }

operator==() [38/44]

template<typename T >

bool edm::operator== ( Ptr< T > const &  lhs, Ptr< T > const &  rhs  )

inline

Definition at line 238 of file Ptr.h.

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

operator==() [39/44]

template<typename C , typename T , typename F >

bool edm::operator== ( FwdRef< C, T, F > const &  lhs, Ref< C, T, F > const &  rhs  )

inline

for a FwdRef to equal a Ref, EITHER the "forward" or the "backward" Refs must equal to the test ref

Definition at line 241 of file FwdRef.h.

References edm::FwdRef< C, T, F >::backRef(), and edm::FwdRef< C, T, F >::ref().

                                                                              {
    return (lhs.ref() == rhs) || (lhs.backRef() == rhs);
  }

operator==() [40/44]

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

Definition at line 348 of file BranchDescription.cc.

References a, b, and combinable().

                                                                          {
    return combinable(a, b) && (a.dropped() == b.dropped()) && (a.branchAliases() == b.branchAliases());
  }

operator==() [41/44]

bool edm::operator==	(	ParameterSet const &	a,
		ParameterSet const &	b
	)

Definition at line 826 of file ParameterSet.cc.

References a, b, and isTransientEqual().

                                                                {
    if (a.isRegistered() && b.isRegistered()) {
      return (a.id() == b.id());
    }
    return isTransientEqual(a.trackedPart(), b.trackedPart());
  }

operator==() [42/44]

template<typename T , typename SORT , typename ALLOC >

bool edm::operator== ( SortedCollection< T, SORT > const &  c, std::vector< T, ALLOC > const &  v  )

inline

Definition at line 359 of file SortedCollection.h.

References HltBtagPostValidation_cff::c, cond::serialization::equal(), and findQualityFiles::v.

                                                                                           {
    return c.size() == v.size() && std::equal(v.begin(), v.end(), c.begin());
  }

operator==() [43/44]

template<typename T , typename SORT >

bool edm::operator== ( SortedCollection< T, SORT > const &  a, SortedCollection< T, SORT > const &  b  )

inline

Definition at line 368 of file SortedCollection.h.

References a, b, and cond::serialization::equal().

                                                                                                 {
    return a.size() == b.size() && std::equal(a.begin(), a.end(), b.begin());
  }

operator==() [44/44]

template<typename C , typename T , typename F >

bool edm::operator== ( Ref< C, T, F > const &  lhs, Ref< C, T, F > const &  rhs  )

inline

Definition at line 577 of file Ref.h.

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

operator>() [1/5]

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

inline

Definition at line 53 of file TypeID.h.

References a, and b.

{ return b < a; }

operator>() [2/5]

bool edm::operator> ( const TypeIDBase &  a, const TypeIDBase &  b  )

inline

Definition at line 62 of file TypeIDBase.h.

References a, and b.

{ return b < a; }

operator>() [3/5]

constexpr bool edm::operator> ( ELseverityLevel const &  e1, ELseverityLevel const &  e2  )

inlinenoexcept

Definition at line 114 of file ELseverityLevel.h.

References StorageManager_cfg::e1.

                                                                                                 {
    return e1.cmp(e2) > 0;
  }

operator>() [4/5]

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

inline

Definition at line 127 of file FileIndex.h.

References mathSSE::lh.

{ return rh < lh; }

operator>() [5/5]

template<typename T >

bool edm::operator> ( View< T > const &  lhs, View< T > const &  rhs  )

inline

Definition at line 313 of file View.h.

                                                                {
    return rhs < lhs;
  }

operator>=() [1/3]

constexpr bool edm::operator>= ( ELseverityLevel const &  e1, ELseverityLevel const &  e2  )

inlinenoexcept

Definition at line 117 of file ELseverityLevel.h.

References StorageManager_cfg::e1.

                                                                                                  {
    return e1.cmp(e2) >= 0;
  }

operator>=() [2/3]

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

inline

Definition at line 129 of file FileIndex.h.

References mathSSE::lh.

{ return !(lh < rh); }

operator>=() [3/3]

template<typename T >

bool edm::operator>= ( View< T > const &  lhs, View< T > const &  rhs  )

inline

Definition at line 318 of file View.h.

                                                                 {
    return !(lhs < rhs);
  }

operator>>() [1/9]

std::istream& edm::operator>> ( std::istream &  is, FileInPath &  fip  )

inline

Definition at line 137 of file FileInPath.h.

References edm::FileInPath::read().

                                                                 {
    fip.read(is);
    return is;
  }

operator>>() [2/9]

std::unique_ptr< ParameterDescriptionCases< bool > > edm::operator>>	(	bool	caseValue,
		ParameterDescriptionNode const &	node
	)

Definition at line 136 of file ParameterDescriptionNode.cc.

References edm::ParameterDescriptionNode::clone(), and eostools::move().

                                                                                                                  {
    std::unique_ptr<ParameterDescriptionNode> clonedNode(node.clone());
    return caseValue >> std::move(clonedNode);
  }

operator>>() [3/9]

std::unique_ptr< ParameterDescriptionCases< int > > edm::operator>>	(	int	caseValue,
		ParameterDescriptionNode const &	node
	)

Definition at line 141 of file ParameterDescriptionNode.cc.

References edm::ParameterDescriptionNode::clone(), and eostools::move().

                                                                                                                {
    std::unique_ptr<ParameterDescriptionNode> clonedNode(node.clone());
    return caseValue >> std::move(clonedNode);
  }

operator>>() [4/9]

std::unique_ptr< ParameterDescriptionCases< std::string > > edm::operator>>	(	std::string const &	caseValue,
		ParameterDescriptionNode const &	node
	)

Definition at line 146 of file ParameterDescriptionNode.cc.

References edm::ParameterDescriptionNode::clone(), and eostools::move().

                                                                                                           {
    std::unique_ptr<ParameterDescriptionNode> clonedNode(node.clone());
    return caseValue >> std::move(clonedNode);
  }

operator>>() [5/9]

std::unique_ptr< ParameterDescriptionCases< std::string > > edm::operator>>	(	char const *	caseValue,
		ParameterDescriptionNode const &	node
	)

Definition at line 152 of file ParameterDescriptionNode.cc.

References edm::ParameterDescriptionNode::clone(), and eostools::move().

                                                                                                           {
    std::unique_ptr<ParameterDescriptionNode> clonedNode(node.clone());
    return caseValue >> std::move(clonedNode);
  }

operator>>() [6/9]

std::unique_ptr< ParameterDescriptionCases< bool > > edm::operator>>	(	bool	caseValue,
		std::unique_ptr< ParameterDescriptionNode >	node
	)

Definition at line 158 of file ParameterDescriptionNode.cc.

References eostools::move().

                                                                                                            {
    return std::unique_ptr<ParameterDescriptionCases<bool>>(
        new ParameterDescriptionCases<bool>(caseValue, std::move(node)));
  }

operator>>() [7/9]

std::unique_ptr< ParameterDescriptionCases< int > > edm::operator>>	(	int	caseValue,
		std::unique_ptr< ParameterDescriptionNode >	node
	)

Definition at line 164 of file ParameterDescriptionNode.cc.

References eostools::move().

                                                                                                           {
    return std::unique_ptr<ParameterDescriptionCases<int>>(
        new ParameterDescriptionCases<int>(caseValue, std::move(node)));
  }

operator>>() [8/9]

std::unique_ptr< ParameterDescriptionCases< std::string > > edm::operator>>	(	std::string const &	caseValue,
		std::unique_ptr< ParameterDescriptionNode >	node
	)

Definition at line 170 of file ParameterDescriptionNode.cc.

References eostools::move().

                                                                                                                   {
    return std::unique_ptr<ParameterDescriptionCases<std::string>>(
        new ParameterDescriptionCases<std::string>(caseValue, std::move(node)));
  }

operator>>() [9/9]

std::unique_ptr< ParameterDescriptionCases< std::string > > edm::operator>>	(	char const *	caseValue,
		std::unique_ptr< ParameterDescriptionNode >	node
	)

Definition at line 176 of file ParameterDescriptionNode.cc.

References eostools::move(), and AlCaHLTBitMon_QueryRunRegistry::string.

                                                                                                                   {
    std::string caseValueString(caseValue);
    return std::unique_ptr<ParameterDescriptionCases<std::string>>(
        new ParameterDescriptionCases<std::string>(caseValue, std::move(node)));
  }

operator^() [1/4]

std::unique_ptr< ParameterDescriptionNode > edm::operator^	(	ParameterDescriptionNode const &	node_left,
		ParameterDescriptionNode const &	node_right
	)

Definition at line 229 of file ParameterDescriptionNode.cc.

                                                                                                  {
    return std::make_unique<XORGroupDescription>(node_left, node_right);
  }

operator^() [2/4]

std::unique_ptr< ParameterDescriptionNode > edm::operator^	(	std::unique_ptr< ParameterDescriptionNode >	node_left,
		ParameterDescriptionNode const &	node_right
	)

Definition at line 234 of file ParameterDescriptionNode.cc.

References eostools::move().

                                                                                                  {
    return std::make_unique<XORGroupDescription>(std::move(node_left), node_right);
  }

operator^() [3/4]

std::unique_ptr< ParameterDescriptionNode > edm::operator^	(	ParameterDescriptionNode const &	node_left,
		std::unique_ptr< ParameterDescriptionNode >	node_right
	)

Definition at line 239 of file ParameterDescriptionNode.cc.

References eostools::move().

                                                                                                          {
    return std::make_unique<XORGroupDescription>(node_left, std::move(node_right));
  }

operator^() [4/4]

std::unique_ptr< ParameterDescriptionNode > edm::operator^	(	std::unique_ptr< ParameterDescriptionNode >	node_left,
		std::unique_ptr< ParameterDescriptionNode >	node_right
	)

Definition at line 244 of file ParameterDescriptionNode.cc.

References eostools::move().

                                                                                                          {
    return std::make_unique<XORGroupDescription>(std::move(node_left), std::move(node_right));
  }

operator||() [1/7]

std::unique_ptr< ParameterDescriptionCases< bool > > edm::operator||	(	std::unique_ptr< ParameterDescriptionCases< bool > >	left,
		std::unique_ptr< ParameterDescriptionCases< bool > >	right
	)

Definition at line 6 of file ParameterDescriptionCases.cc.

References genParticles_cff::map, and eostools::move().

                                                                                                                   {
    std::unique_ptr<std::map<bool, edm::value_ptr<ParameterDescriptionNode> > > rightCases = right->caseMap();
    for (std::map<bool, edm::value_ptr<ParameterDescriptionNode> >::const_iterator iter = rightCases->begin(),
                                                                                   iEnd = rightCases->end();
         iter != iEnd;
         ++iter) {
      bool caseValue = iter->first;
      std::unique_ptr<ParameterDescriptionNode> node(iter->second->clone());
      left->insert(caseValue, std::move(node));
    }
    return left;
  }

operator||() [2/7]

std::unique_ptr< ParameterDescriptionCases< int > > edm::operator||	(	std::unique_ptr< ParameterDescriptionCases< int > >	left,
		std::unique_ptr< ParameterDescriptionCases< int > >	right
	)

Definition at line 20 of file ParameterDescriptionCases.cc.

References genParticles_cff::map, and eostools::move().

                                                                                                                    {
    std::unique_ptr<std::map<int, edm::value_ptr<ParameterDescriptionNode> > > rightCases = right->caseMap();
    for (std::map<int, edm::value_ptr<ParameterDescriptionNode> >::const_iterator iter = rightCases->begin(),
                                                                                  iEnd = rightCases->end();
         iter != iEnd;
         ++iter) {
      int caseValue = iter->first;
      std::unique_ptr<ParameterDescriptionNode> node(iter->second->clone());
      left->insert(caseValue, std::move(node));
    }
    return left;
  }

operator||() [3/7]

std::unique_ptr< ParameterDescriptionCases< std::string > > edm::operator||	(	std::unique_ptr< ParameterDescriptionCases< std::string > >	left,
		std::unique_ptr< ParameterDescriptionCases< std::string > >	right
	)

Definition at line 34 of file ParameterDescriptionCases.cc.

References genParticles_cff::map, eostools::move(), and AlCaHLTBitMon_QueryRunRegistry::string.

                                                                  {
    std::unique_ptr<std::map<std::string, edm::value_ptr<ParameterDescriptionNode> > > rightCases = right->caseMap();
    for (std::map<std::string, edm::value_ptr<ParameterDescriptionNode> >::const_iterator iter = rightCases->begin(),
                                                                                          iEnd = rightCases->end();
         iter != iEnd;
         ++iter) {
      std::string caseValue = iter->first;
      std::unique_ptr<ParameterDescriptionNode> node(iter->second->clone());
      left->insert(caseValue, std::move(node));
    }
    return left;
  }

operator||() [4/7]

std::unique_ptr< ParameterDescriptionNode > edm::operator||	(	ParameterDescriptionNode const &	node_left,
		ParameterDescriptionNode const &	node_right
	)

Definition at line 207 of file ParameterDescriptionNode.cc.

                                                                                                   {
    return std::make_unique<ORGroupDescription>(node_left, node_right);
  }

operator||() [5/7]

std::unique_ptr< ParameterDescriptionNode > edm::operator||	(	std::unique_ptr< ParameterDescriptionNode >	node_left,
		ParameterDescriptionNode const &	node_right
	)

Definition at line 212 of file ParameterDescriptionNode.cc.

References eostools::move().

                                                                                                   {
    return std::make_unique<ORGroupDescription>(std::move(node_left), node_right);
  }

operator||() [6/7]

std::unique_ptr< ParameterDescriptionNode > edm::operator||	(	ParameterDescriptionNode const &	node_left,
		std::unique_ptr< ParameterDescriptionNode >	node_right
	)

Definition at line 217 of file ParameterDescriptionNode.cc.

References eostools::move().

                                                                                                           {
    return std::make_unique<ORGroupDescription>(node_left, std::move(node_right));
  }

operator||() [7/7]

std::unique_ptr< ParameterDescriptionNode > edm::operator||	(	std::unique_ptr< ParameterDescriptionNode >	node_left,
		std::unique_ptr< ParameterDescriptionNode >	node_right
	)

Definition at line 222 of file ParameterDescriptionNode.cc.

References eostools::move().

                                                                                                           {
    return std::make_unique<ORGroupDescription>(std::move(node_left), std::move(node_right));
  }

ourSerial()

static std::atomic<int> edm::ourSerial ( 0  )

static

Referenced by edm::ErrorObj::set().

overlaps() [1/2]

bool edm::overlaps	(	LuminosityBlockRange const &	lh,
		LuminosityBlockRange const &	rh
	)

Definition at line 62 of file LuminosityBlockRange.cc.

References distinct(), and mathSSE::lh.

{ return !distinct(lh, rh); }

overlaps() [2/2]

bool edm::overlaps	(	EventRange const &	lh,
		EventRange const &	rh
	)

Definition at line 51 of file EventRange.cc.

References cms::cuda::assert(), distinct(), mathSSE::lh, and edm::EventRange::startLumi().

Referenced by merge().

                                                            {
    assert((lh.startLumi() == 0) == (rh.startLumi() == 0));
    return !distinct(lh, rh);
  }

parameterSet()

ParameterSet const & edm::parameterSet	(	StableProvenance const &	provenance,
		ProcessHistory const &	history
	)

Definition at line 11 of file Provenance.cc.

References edm::ParameterSet::existsAs(), edm::ProcessHistory::getConfigurationForProcess(), edm::pset::Registry::getMapped(), edm::ParameterSet::getParameterSet(), edm::pset::Registry::instance(), label, edm::ProcessConfiguration::parameterSetID(), crab_script::provenance, source(), AlCaHLTBitMon_QueryRunRegistry::string, and triggerResults().

Referenced by edm::ScheduleItems::addCPRandTNS(), TauTagValidation::analyze(), BeamHaloPropagatorESProducer::BeamHaloPropagatorESProducer(), reco::tau::PFRecoTauDiscriminationByMVAIsolationRun2::beginEvent(), BenchmarkAnalyzer::BenchmarkAnalyzer(), CandidateBenchmarkAnalyzer::CandidateBenchmarkAnalyzer(), TopDecaySubset::checkShowerModel(), CTPPSPixelLocalTrackProducer::CTPPSPixelLocalTrackProducer(), HLTTauRefProducer::doPFTaus(), ensureAvailableAccelerators(), edm::EventProcessor::EventProcessor(), PFJetMonitor::fill(), PFCandidateMonitor::fill(), MatchCandidateBenchmark::fillOne(), edm::ScheduleItems::finishSchedule(), EcalSelectiveReadoutProducer::getBinOfMax(), L1TTauOffline::getProbeTaus(), GlobalMuonProducer::GlobalMuonProducer(), edm::EventProcessor::init(), edm::ScheduleItems::initMisc(), edm::ScheduleItems::initModules(), edm::ScheduleItems::initSchedule(), edm::ScheduleItems::initServices(), L2MuonCandidateProducer::L2MuonCandidateProducer(), L2MuonProducer::L2MuonProducer(), L3MuonCandidateProducer::L3MuonCandidateProducer(), L3MuonCleaner::L3MuonCleaner(), L3MuonProducer::L3MuonProducer(), L3TkMuonProducer::L3TkMuonProducer(), PFB::match(), DeepTauIdBase< TritonEDProducer<> >::matchDiscriminatorIndices(), MatchMETBenchmarkAnalyzer::MatchMETBenchmarkAnalyzer(), METBenchmarkAnalyzer::METBenchmarkAnalyzer(), moduleName(), MuonSeedMerger::MuonSeedMerger(), MuonTrackLoader::MuonTrackLoader(), OniaVtxReProducer::OniaVtxReProducer(), PFCandidateBenchmarkAnalyzer::PFCandidateBenchmarkAnalyzer(), PFCandidateDQMAnalyzer::PFCandidateDQMAnalyzer(), PFCandidateManagerAnalyzer::PFCandidateManagerAnalyzer(), PFClient::PFClient(), PFClient_JetRes::PFClient_JetRes(), PFJetDQMAnalyzer::PFJetDQMAnalyzer(), PFMETDQMAnalyzer::PFMETDQMAnalyzer(), PFMuonDQMAnalyzer::PFMuonDQMAnalyzer(), popSubProcessVParameterSet(), pat::PATTauProducer::produce(), DeepFlavourTagInfoProducer::produce(), HadronAndPartonSelector::produce(), GsfElectronProducer::produce(), RPixPlaneCombinatoryTracking::RPixPlaneCombinatoryTracking(), RPixRoadFinder::RPixRoadFinder(), PFTauSelectorDefinition::select(), SETMuonSeedProducer::SETMuonSeedProducer(), PFJetMonitor::setParameters(), PFMETMonitor::setParameters(), PFCandidateMonitor::setParameters(), SETPatternRecognition::SETPatternRecognition(), SETSeedFinder::SETSeedFinder(), CandidateBenchmark::setup(), MatchCandidateBenchmark::setup(), PFJetMonitor::setup(), PFMETMonitor::setup(), PFCandidateMonitor::setup(), SmartPropagatorESProducer::SmartPropagatorESProducer(), StandAloneMuonProducer::StandAloneMuonProducer(), edm::SubProcess::SubProcess(), TevMuonProducer::TevMuonProducer(), TracksToTrajectories::TracksToTrajectories(), TrackTransformerForCosmicMuons::TrackTransformerForCosmicMuons(), and TrackTransformerForGlobalCosmicMuons::TrackTransformerForGlobalCosmicMuons().

                                                                                                      {
    ProcessConfiguration pc;
    history.getConfigurationForProcess(provenance.processName(), pc);
    ParameterSet const& processParameterSet = *pset::Registry::instance()->getMapped(pc.parameterSetID());
    std::string const& label = provenance.moduleLabel();
    if (!processParameterSet.existsAs<ParameterSet>(label)) {
      // Trigger results and input sources are special cases
      if (label == triggerResults) {
        return processParameterSet.getParameterSet("@trigger_paths");
      } else if (label == source) {
        return processParameterSet.getParameterSet("@main_input");
      }
    }
    return processParameterSet.getParameterSet(label);
  }

ParameterSet::getParameter< std::string >() [1/2]

template<>

std::string edm::ParameterSet::getParameter< std::string >

(

std::string const &

name

)

const

Definition at line 1014 of file ParameterSet.cc.

References Skims_PA_cff::name.

                                                                             {
    return retrieve(name).getString();
  }

ParameterSet::getParameter< std::string >() [2/2]

template<>

std::string edm::ParameterSet::getParameter< std::string >

(

char const *

name

)

const

Definition at line 1596 of file ParameterSet.cc.

References Skims_PA_cff::name.

                                                                        {
    return retrieve(name).getString();
  }

ParameterSet::getParameter< std::vector< double > >() [1/2]

template<>

std::vector<double> edm::ParameterSet::getParameter< std::vector< double > >

(

std::string const &

name

)

const

Definition at line 1006 of file ParameterSet.cc.

References Skims_PA_cff::name.

                                                                                              {
    return retrieve(name).getVDouble();
  }

ParameterSet::getParameter< std::vector< double > >() [2/2]

template<>

std::vector<double> edm::ParameterSet::getParameter< std::vector< double > >

(

char const *

name

)

const

Definition at line 1588 of file ParameterSet.cc.

References Skims_PA_cff::name.

                                                                                         {
    return retrieve(name).getVDouble();
  }

ParameterSet::getParameter< std::vector< ESInputTag > >() [1/2]

template<>

std::vector<ESInputTag> edm::ParameterSet::getParameter< std::vector< ESInputTag > >

(

std::string const &

name

)

const

Definition at line 1079 of file ParameterSet.cc.

References Skims_PA_cff::name.

                                                                                                      {
    return retrieve(name).getVESInputTag();
  }

ParameterSet::getParameter< std::vector< ESInputTag > >() [2/2]

template<>

std::vector<ESInputTag> edm::ParameterSet::getParameter< std::vector< ESInputTag > >

(

char const *

name

)

const

Definition at line 1661 of file ParameterSet.cc.

References Skims_PA_cff::name.

                                                                                                 {
    return retrieve(name).getVESInputTag();
  }

ParameterSet::getParameter< std::vector< EventID > >() [1/2]

template<>

std::vector<EventID> edm::ParameterSet::getParameter< std::vector< EventID > >

(

std::string const &

name

)

const

Definition at line 1095 of file ParameterSet.cc.

References Skims_PA_cff::name.

                                                                                                {
    return retrieve(name).getVEventID();
  }

ParameterSet::getParameter< std::vector< EventID > >() [2/2]

template<>

std::vector<EventID> edm::ParameterSet::getParameter< std::vector< EventID > >

(

char const *

name

)

const

Definition at line 1677 of file ParameterSet.cc.

References Skims_PA_cff::name.

                                                                                           {
    return retrieve(name).getVEventID();
  }

ParameterSet::getParameter< std::vector< EventRange > >() [1/2]

template<>

std::vector<EventRange> edm::ParameterSet::getParameter< std::vector< EventRange > >

(

std::string const &

name

)

const

Definition at line 1128 of file ParameterSet.cc.

References Skims_PA_cff::name.

                                                                                                      {
    return retrieve(name).getVEventRange();
  }

ParameterSet::getParameter< std::vector< EventRange > >() [2/2]

template<>

std::vector<EventRange> edm::ParameterSet::getParameter< std::vector< EventRange > >

(

char const *

name

)

const

Definition at line 1709 of file ParameterSet.cc.

References Skims_PA_cff::name.

                                                                                                 {
    return retrieve(name).getVEventRange();
  }

ParameterSet::getParameter< std::vector< InputTag > >() [1/2]

template<>

std::vector<InputTag> edm::ParameterSet::getParameter< std::vector< InputTag > >

(

std::string const &

name

)

const

Definition at line 1063 of file ParameterSet.cc.

References Skims_PA_cff::name.

                                                                                                  {
    return retrieve(name).getVInputTag();
  }

ParameterSet::getParameter< std::vector< InputTag > >() [2/2]

template<>

std::vector<InputTag> edm::ParameterSet::getParameter< std::vector< InputTag > >

(

char const *

name

)

const

Definition at line 1645 of file ParameterSet.cc.

References Skims_PA_cff::name.

                                                                                             {
    return retrieve(name).getVInputTag();
  }

ParameterSet::getParameter< std::vector< int > >() [1/2]

template<>

std::vector<int> edm::ParameterSet::getParameter< std::vector< int > >

(

std::string const &

name

)

const

Definition at line 953 of file ParameterSet.cc.

References Skims_PA_cff::name.

                                                                                        {
    return retrieve(name).getVInt32();
  }

ParameterSet::getParameter< std::vector< int > >() [2/2]

template<>

std::vector<int> edm::ParameterSet::getParameter< std::vector< int > >

(

char const *

name

)

const

Definition at line 1536 of file ParameterSet.cc.

References Skims_PA_cff::name.

                                                                                   {
    return retrieve(name).getVInt32();
  }

ParameterSet::getParameter< std::vector< long long > >() [1/2]

template<>

std::vector<long long> edm::ParameterSet::getParameter< std::vector< long long > >

(

std::string const &

name

)

const

Definition at line 966 of file ParameterSet.cc.

References Skims_PA_cff::name.

                                                                                                    {
    return retrieve(name).getVInt64();
  }

ParameterSet::getParameter< std::vector< long long > >() [2/2]

template<>

std::vector<long long> edm::ParameterSet::getParameter< std::vector< long long > >

(

char const *

name

)

const

Definition at line 1549 of file ParameterSet.cc.

References Skims_PA_cff::name.

                                                                                               {
    return retrieve(name).getVInt64();
  }

ParameterSet::getParameter< std::vector< LuminosityBlockID > >() [1/2]

template<>

std::vector<LuminosityBlockID> edm::ParameterSet::getParameter< std::vector< LuminosityBlockID > >

(

std::string const &

name

)

const

Definition at line 1111 of file ParameterSet.cc.

References Skims_PA_cff::name.

                                   {
    return retrieve(name).getVLuminosityBlockID();
  }

ParameterSet::getParameter< std::vector< LuminosityBlockID > >() [2/2]

template<>

std::vector<LuminosityBlockID> edm::ParameterSet::getParameter< std::vector< LuminosityBlockID > >

(

char const *

name

)

const

Definition at line 1693 of file ParameterSet.cc.

References Skims_PA_cff::name.

                                                                                                               {
    return retrieve(name).getVLuminosityBlockID();
  }

ParameterSet::getParameter< std::vector< LuminosityBlockRange > >() [1/2]

template<>

std::vector<LuminosityBlockRange> edm::ParameterSet::getParameter< std::vector< LuminosityBlockRange > >

(

std::string const &

name

)

const

Definition at line 1144 of file ParameterSet.cc.

References Skims_PA_cff::name.

                                   {
    return retrieve(name).getVLuminosityBlockRange();
  }

ParameterSet::getParameter< std::vector< LuminosityBlockRange > >() [2/2]

template<>

std::vector<LuminosityBlockRange> edm::ParameterSet::getParameter< std::vector< LuminosityBlockRange > >

(

char const *

name

)

const

Definition at line 1725 of file ParameterSet.cc.

References Skims_PA_cff::name.

                              {
    return retrieve(name).getVLuminosityBlockRange();
  }

ParameterSet::getParameter< std::vector< PdtEntry > >() [1/2]

template<>

std::vector<PdtEntry> edm::ParameterSet::getParameter< std::vector< PdtEntry > > ( char const *  name ) const

inline

Definition at line 118 of file PdtEntry.h.

References MillePedeFileConverter_cfg::e, edm::pdtentry::getPdtEntryVector(), and Skims_PA_cff::name.

                                                                                                   {
    Entry const &e = retrieve(name);
    return pdtentry::getPdtEntryVector(e, name);
  }

ParameterSet::getParameter< std::vector< PdtEntry > >() [2/2]

template<>

std::vector<PdtEntry> edm::ParameterSet::getParameter< std::vector< PdtEntry > > ( std::string const &  name ) const

inline

Definition at line 96 of file PdtEntry.h.

References MillePedeFileConverter_cfg::e, edm::pdtentry::getPdtEntryVector(), and Skims_PA_cff::name.

                                                                                                        {
    Entry const &e = retrieve(name);
    return pdtentry::getPdtEntryVector(e, name.c_str());
  }

ParameterSet::getParameter< std::vector< std::string > >() [1/2]

template<>

std::vector<std::string> edm::ParameterSet::getParameter< std::vector< std::string > >

(

std::string const &

name

)

const

Definition at line 1019 of file ParameterSet.cc.

References Skims_PA_cff::name.

                                                                                                    {
    return retrieve(name).getVString();
  }

ParameterSet::getParameter< std::vector< std::string > >() [2/2]

template<>

std::vector<std::string> edm::ParameterSet::getParameter< std::vector< std::string > >

(

char const *

name

)

const

Definition at line 1601 of file ParameterSet.cc.

References Skims_PA_cff::name.

                                                                                               {
    return retrieve(name).getVString();
  }

ParameterSet::getParameter< std::vector< unsigned int > >() [1/2]

template<>

std::vector<unsigned int> edm::ParameterSet::getParameter< std::vector< unsigned int > >

(

std::string const &

name

)

const

Definition at line 979 of file ParameterSet.cc.

References Skims_PA_cff::name.

                                                                                                          {
    return retrieve(name).getVUInt32();
  }

ParameterSet::getParameter< std::vector< unsigned int > >() [2/2]

template<>

std::vector<unsigned int> edm::ParameterSet::getParameter< std::vector< unsigned int > >

(

char const *

name

)

const

Definition at line 1562 of file ParameterSet.cc.

References Skims_PA_cff::name.

                                                                                                     {
    return retrieve(name).getVUInt32();
  }

ParameterSet::getParameter< std::vector< unsigned long long > >() [1/2]

template<>

std::vector<unsigned long long> edm::ParameterSet::getParameter< std::vector< unsigned long long > >

(

std::string const &

name

)

const

Definition at line 992 of file ParameterSet.cc.

References Skims_PA_cff::name.

                                   {
    return retrieve(name).getVUInt64();
  }

ParameterSet::getParameter< std::vector< unsigned long long > >() [2/2]

template<>

std::vector<unsigned long long> edm::ParameterSet::getParameter< std::vector< unsigned long long > >

(

char const *

name

)

const

Definition at line 1575 of file ParameterSet.cc.

References Skims_PA_cff::name.

                                                                                                                 {
    return retrieve(name).getVUInt64();
  }

ParameterSet::getParameterNamesForType< std::vector< PdtEntry > >()

template<>

std::vector<std::string> edm::ParameterSet::getParameterNamesForType< std::vector< PdtEntry > > ( bool  trackiness ) const

inline

Definition at line 147 of file PdtEntry.h.

References filterCSVwithJSON::copy, and makeListRunsInFiles::strings.

                                                                                                               {
    std::vector<std::string> ints = getParameterNamesForType<std::vector<int>>(trackiness);
    std::vector<std::string> strings = getParameterNamesForType<std::vector<std::string>>(trackiness);
    std::copy(strings.begin(), strings.end(), std::back_insert_iterator<std::vector<std::string>>(ints));
    return ints;
  }

ParameterSet::getUntrackedParameter< std::string >() [1/4]

template<>

std::string edm::ParameterSet::getUntrackedParameter< std::string >	(	std::string const &	name,
		std::string const &	defaultValue
	)		const

Definition at line 1317 of file ParameterSet.cc.

References hltPixelClustersMultiplicity_cfi::defaultValue, edm::Entry::getString(), and Skims_PA_cff::name.

                                                                                                    {
    Entry const* entryPtr = retrieveUntracked(name);
    return entryPtr == nullptr ? defaultValue : entryPtr->getString();
  }

ParameterSet::getUntrackedParameter< std::string >() [2/4]

template<>

std::string edm::ParameterSet::getUntrackedParameter< std::string >

(

std::string const &

name

)

const

Definition at line 1324 of file ParameterSet.cc.

References Skims_PA_cff::name.

                                                                                      {
    return getEntryPointerOrThrow_(name)->getString();
  }

ParameterSet::getUntrackedParameter< std::string >() [3/4]

template<>

std::string edm::ParameterSet::getUntrackedParameter< std::string >	(	char const *	name,
		std::string const &	defaultValue
	)		const

Definition at line 1896 of file ParameterSet.cc.

References hltPixelClustersMultiplicity_cfi::defaultValue, edm::Entry::getString(), and Skims_PA_cff::name.

                                                                                                    {
    Entry const* entryPtr = retrieveUntracked(name);
    return entryPtr == nullptr ? defaultValue : entryPtr->getString();
  }

ParameterSet::getUntrackedParameter< std::string >() [4/4]

template<>

std::string edm::ParameterSet::getUntrackedParameter< std::string >

(

char const *

name

)

const

Definition at line 1903 of file ParameterSet.cc.

References Skims_PA_cff::name.

                                                                                 {
    return getEntryPointerOrThrow_(name)->getString();
  }

ParameterSet::getUntrackedParameter< std::vector< double > >() [1/4]

template<>

std::vector<double> edm::ParameterSet::getUntrackedParameter< std::vector< double > >	(	std::string const &	name,
		std::vector< double > const &	defaultValue
	)		const

Definition at line 1302 of file ParameterSet.cc.

References hltPixelClustersMultiplicity_cfi::defaultValue, edm::Entry::getVDouble(), and Skims_PA_cff::name.

                                                                          {
    Entry const* entryPtr = retrieveUntracked(name);
    return entryPtr == nullptr ? defaultValue : entryPtr->getVDouble();
  }

ParameterSet::getUntrackedParameter< std::vector< double > >() [2/4]

template<>

std::vector<double> edm::ParameterSet::getUntrackedParameter< std::vector< double > >

(

std::string const &

name

)

const

Definition at line 1309 of file ParameterSet.cc.

References Skims_PA_cff::name.

                                                                                                       {
    return getEntryPointerOrThrow_(name)->getVDouble();
  }

ParameterSet::getUntrackedParameter< std::vector< double > >() [3/4]

template<>

std::vector<double> edm::ParameterSet::getUntrackedParameter< std::vector< double > >

(

char const *

name

)

const

Definition at line 1888 of file ParameterSet.cc.

References Skims_PA_cff::name.

                                                                                                  {
    return getEntryPointerOrThrow_(name)->getVDouble();
  }

ParameterSet::getUntrackedParameter< std::vector< double > >() [4/4]

template<>

std::vector<double> edm::ParameterSet::getUntrackedParameter< std::vector< double > >	(	char const *	name,
		std::vector< double > const &	defaultValue
	)		const

Definition at line 1881 of file ParameterSet.cc.

References hltPixelClustersMultiplicity_cfi::defaultValue, edm::Entry::getVDouble(), and Skims_PA_cff::name.

                                                                     {
    Entry const* entryPtr = retrieveUntracked(name);
    return entryPtr == nullptr ? defaultValue : entryPtr->getVDouble();
  }

ParameterSet::getUntrackedParameter< std::vector< ESInputTag > >() [1/4]

template<>

std::vector<ESInputTag> edm::ParameterSet::getUntrackedParameter< std::vector< ESInputTag > >	(	std::string const &	name,
		std::vector< ESInputTag > const &	defaultValue
	)		const

Definition at line 1398 of file ParameterSet.cc.

References hltPixelClustersMultiplicity_cfi::defaultValue, edm::Entry::getVESInputTag(), and Skims_PA_cff::name.

                                                                              {
    Entry const* entryPtr = retrieveUntracked(name);
    return entryPtr == nullptr ? defaultValue : entryPtr->getVESInputTag();
  }

ParameterSet::getUntrackedParameter< std::vector< ESInputTag > >() [2/4]

template<>

std::vector<ESInputTag> edm::ParameterSet::getUntrackedParameter< std::vector< ESInputTag > >

(

std::string const &

name

)

const

Definition at line 1405 of file ParameterSet.cc.

References Skims_PA_cff::name.

                                                                                                               {
    return getEntryPointerOrThrow_(name)->getVESInputTag();
  }

ParameterSet::getUntrackedParameter< std::vector< ESInputTag > >() [3/4]

template<>

std::vector<ESInputTag> edm::ParameterSet::getUntrackedParameter< std::vector< ESInputTag > >	(	char const *	name,
		std::vector< ESInputTag > const &	defaultValue
	)		const

Definition at line 1974 of file ParameterSet.cc.

References hltPixelClustersMultiplicity_cfi::defaultValue, edm::Entry::getVESInputTag(), and Skims_PA_cff::name.

                                                                         {
    Entry const* entryPtr = retrieveUntracked(name);
    return entryPtr == nullptr ? defaultValue : entryPtr->getVESInputTag();
  }

ParameterSet::getUntrackedParameter< std::vector< ESInputTag > >() [4/4]

template<>

std::vector<ESInputTag> edm::ParameterSet::getUntrackedParameter< std::vector< ESInputTag > >

(

char const *

name

)

const

Definition at line 1981 of file ParameterSet.cc.

References Skims_PA_cff::name.

                                                                                                          {
    return getEntryPointerOrThrow_(name)->getVESInputTag();
  }

ParameterSet::getUntrackedParameter< std::vector< EventID > >() [1/4]

template<>

std::vector<EventID> edm::ParameterSet::getUntrackedParameter< std::vector< EventID > >

(

std::string const &

name

)

const

Definition at line 1431 of file ParameterSet.cc.

References Skims_PA_cff::name.

                                                                                                         {
    return getEntryPointerOrThrow_(name)->getVEventID();
  }

ParameterSet::getUntrackedParameter< std::vector< EventID > >() [2/4]

template<>

std::vector<EventID> edm::ParameterSet::getUntrackedParameter< std::vector< EventID > >	(	std::string const &	name,
		std::vector< EventID > const &	defaultValue
	)		const

Definition at line 1424 of file ParameterSet.cc.

References hltPixelClustersMultiplicity_cfi::defaultValue, edm::Entry::getVEventID(), and Skims_PA_cff::name.

                                                                           {
    Entry const* entryPtr = retrieveUntracked(name);
    return entryPtr == nullptr ? defaultValue : entryPtr->getVEventID();
  }

ParameterSet::getUntrackedParameter< std::vector< EventID > >() [3/4]

template<>

std::vector<EventID> edm::ParameterSet::getUntrackedParameter< std::vector< EventID > >	(	char const *	name,
		std::vector< EventID > const &	defaultValue
	)		const

Definition at line 2000 of file ParameterSet.cc.

References hltPixelClustersMultiplicity_cfi::defaultValue, edm::Entry::getVEventID(), and Skims_PA_cff::name.

                                                                      {
    Entry const* entryPtr = retrieveUntracked(name);
    return entryPtr == nullptr ? defaultValue : entryPtr->getVEventID();
  }

ParameterSet::getUntrackedParameter< std::vector< EventID > >() [4/4]

template<>

std::vector<EventID> edm::ParameterSet::getUntrackedParameter< std::vector< EventID > >

(

char const *

name

)

const

Definition at line 2007 of file ParameterSet.cc.

References Skims_PA_cff::name.

                                                                                                    {
    return getEntryPointerOrThrow_(name)->getVEventID();
  }

ParameterSet::getUntrackedParameter< std::vector< EventRange > >() [1/4]

template<>

std::vector<EventRange> edm::ParameterSet::getUntrackedParameter< std::vector< EventRange > >	(	std::string const &	name,
		std::vector< EventRange > const &	defaultValue
	)		const

Definition at line 1479 of file ParameterSet.cc.

References hltPixelClustersMultiplicity_cfi::defaultValue, edm::Entry::getVEventRange(), and Skims_PA_cff::name.

                                                                              {
    Entry const* entryPtr = retrieveUntracked(name);
    return entryPtr == nullptr ? defaultValue : entryPtr->getVEventRange();
  }

ParameterSet::getUntrackedParameter< std::vector< EventRange > >() [2/4]

template<>

std::vector<EventRange> edm::ParameterSet::getUntrackedParameter< std::vector< EventRange > >

(

std::string const &

name

)

const

Definition at line 1486 of file ParameterSet.cc.

References Skims_PA_cff::name.

                                                                                                               {
    return getEntryPointerOrThrow_(name)->getVEventRange();
  }

ParameterSet::getUntrackedParameter< std::vector< EventRange > >() [3/4]

template<>

std::vector<EventRange> edm::ParameterSet::getUntrackedParameter< std::vector< EventRange > >	(	char const *	name,
		std::vector< EventRange > const &	defaultValue
	)		const

Definition at line 2054 of file ParameterSet.cc.

References hltPixelClustersMultiplicity_cfi::defaultValue, edm::Entry::getVEventRange(), and Skims_PA_cff::name.

                                                                         {
    Entry const* entryPtr = retrieveUntracked(name);
    return entryPtr == nullptr ? defaultValue : entryPtr->getVEventRange();
  }

ParameterSet::getUntrackedParameter< std::vector< EventRange > >() [4/4]

template<>

std::vector<EventRange> edm::ParameterSet::getUntrackedParameter< std::vector< EventRange > >

(

char const *

name

)

const

Definition at line 2061 of file ParameterSet.cc.

References Skims_PA_cff::name.

                                                                                                          {
    return getEntryPointerOrThrow_(name)->getVEventRange();
  }

ParameterSet::getUntrackedParameter< std::vector< InputTag > >() [1/4]

template<>

std::vector<InputTag> edm::ParameterSet::getUntrackedParameter< std::vector< InputTag > >

(

std::string const &

name

)

const

Definition at line 1378 of file ParameterSet.cc.

References Skims_PA_cff::name.

                                                                                                           {
    return getEntryPointerOrThrow_(name)->getVInputTag();
  }

ParameterSet::getUntrackedParameter< std::vector< InputTag > >() [2/4]

template<>

std::vector<InputTag> edm::ParameterSet::getUntrackedParameter< std::vector< InputTag > >	(	std::string const &	name,
		std::vector< InputTag > const &	defaultValue
	)		const

Definition at line 1371 of file ParameterSet.cc.

References hltPixelClustersMultiplicity_cfi::defaultValue, edm::Entry::getVInputTag(), and Skims_PA_cff::name.

                                                                            {
    Entry const* entryPtr = retrieveUntracked(name);
    return entryPtr == nullptr ? defaultValue : entryPtr->getVInputTag();
  }

ParameterSet::getUntrackedParameter< std::vector< InputTag > >() [3/4]

template<>

std::vector<InputTag> edm::ParameterSet::getUntrackedParameter< std::vector< InputTag > >

(

char const *

name

)

const

Definition at line 1955 of file ParameterSet.cc.

References Skims_PA_cff::name.

                                                                                                      {
    return getEntryPointerOrThrow_(name)->getVInputTag();
  }

ParameterSet::getUntrackedParameter< std::vector< InputTag > >() [4/4]

template<>

std::vector<InputTag> edm::ParameterSet::getUntrackedParameter< std::vector< InputTag > >	(	char const *	name,
		std::vector< InputTag > const &	defaultValue
	)		const

Definition at line 1948 of file ParameterSet.cc.

References hltPixelClustersMultiplicity_cfi::defaultValue, edm::Entry::getVInputTag(), and Skims_PA_cff::name.

                                                                       {
    Entry const* entryPtr = retrieveUntracked(name);
    return entryPtr == nullptr ? defaultValue : entryPtr->getVInputTag();
  }

ParameterSet::getUntrackedParameter< std::vector< int > >() [1/4]

template<>

std::vector<int> edm::ParameterSet::getUntrackedParameter< std::vector< int > >	(	std::string const &	name,
		std::vector< int > const &	defaultValue
	)		const

Definition at line 1193 of file ParameterSet.cc.

References hltPixelClustersMultiplicity_cfi::defaultValue, edm::Entry::getVInt32(), and Skims_PA_cff::name.

                                                                                                                    {
    Entry const* entryPtr = retrieveUntracked(name);
    return entryPtr == nullptr ? defaultValue : entryPtr->getVInt32();
  }

ParameterSet::getUntrackedParameter< std::vector< int > >() [2/4]

template<>

std::vector<int> edm::ParameterSet::getUntrackedParameter< std::vector< int > >

(

std::string const &

name

)

const

Definition at line 1200 of file ParameterSet.cc.

References Skims_PA_cff::name.

                                                                                                 {
    return getEntryPointerOrThrow_(name)->getVInt32();
  }

ParameterSet::getUntrackedParameter< std::vector< int > >() [3/4]

template<>

std::vector<int> edm::ParameterSet::getUntrackedParameter< std::vector< int > >	(	char const *	name,
		std::vector< int > const &	defaultValue
	)		const

Definition at line 1774 of file ParameterSet.cc.

References hltPixelClustersMultiplicity_cfi::defaultValue, edm::Entry::getVInt32(), and Skims_PA_cff::name.

                                                                                                                    {
    Entry const* entryPtr = retrieveUntracked(name);
    return entryPtr == nullptr ? defaultValue : entryPtr->getVInt32();
  }

ParameterSet::getUntrackedParameter< std::vector< int > >() [4/4]

template<>

std::vector<int> edm::ParameterSet::getUntrackedParameter< std::vector< int > >

(

char const *

name

)

const

Definition at line 1781 of file ParameterSet.cc.

References Skims_PA_cff::name.

                                                                                            {
    return getEntryPointerOrThrow_(name)->getVInt32();
  }

ParameterSet::getUntrackedParameter< std::vector< long long > >() [1/4]

template<>

std::vector<long long> edm::ParameterSet::getUntrackedParameter< std::vector< long long > >

(

std::string const &

name

)

const

Definition at line 1283 of file ParameterSet.cc.

References Skims_PA_cff::name.

                                                                                                             {
    return getEntryPointerOrThrow_(name)->getVInt64();
  }

ParameterSet::getUntrackedParameter< std::vector< long long > >() [2/4]

template<>

std::vector<long long> edm::ParameterSet::getUntrackedParameter< std::vector< long long > >	(	std::string const &	name,
		std::vector< long long > const &	defaultValue
	)		const

Definition at line 1276 of file ParameterSet.cc.

References hltPixelClustersMultiplicity_cfi::defaultValue, edm::Entry::getVInt64(), and Skims_PA_cff::name.

                                                                             {
    Entry const* entryPtr = retrieveUntracked(name);
    return entryPtr == nullptr ? defaultValue : entryPtr->getVInt64();
  }

ParameterSet::getUntrackedParameter< std::vector< long long > >() [3/4]

template<>

std::vector<long long> edm::ParameterSet::getUntrackedParameter< std::vector< long long > >

(

char const *

name

)

const

Definition at line 1862 of file ParameterSet.cc.

References Skims_PA_cff::name.

                                                                                                        {
    return getEntryPointerOrThrow_(name)->getVInt64();
  }

ParameterSet::getUntrackedParameter< std::vector< long long > >() [4/4]

template<>

std::vector<long long> edm::ParameterSet::getUntrackedParameter< std::vector< long long > >	(	char const *	name,
		std::vector< long long > const &	defaultValue
	)		const

Definition at line 1855 of file ParameterSet.cc.

References hltPixelClustersMultiplicity_cfi::defaultValue, edm::Entry::getVInt64(), and Skims_PA_cff::name.

                                                                        {
    Entry const* entryPtr = retrieveUntracked(name);
    return entryPtr == nullptr ? defaultValue : entryPtr->getVInt64();
  }

ParameterSet::getUntrackedParameter< std::vector< LuminosityBlockID > >() [1/4]

template<>

std::vector<LuminosityBlockID> edm::ParameterSet::getUntrackedParameter< std::vector< LuminosityBlockID > >

(

std::string const &

name

)

const

Definition at line 1458 of file ParameterSet.cc.

References Skims_PA_cff::name.

                                   {
    return getEntryPointerOrThrow_(name)->getVLuminosityBlockID();
  }

ParameterSet::getUntrackedParameter< std::vector< LuminosityBlockID > >() [2/4]

template<>

std::vector<LuminosityBlockID> edm::ParameterSet::getUntrackedParameter< std::vector< LuminosityBlockID > >	(	std::string const &	name,
		std::vector< LuminosityBlockID > const &	defaultValue
	)		const

Definition at line 1451 of file ParameterSet.cc.

References hltPixelClustersMultiplicity_cfi::defaultValue, edm::Entry::getVLuminosityBlockID(), and Skims_PA_cff::name.

                                                                                     {
    Entry const* entryPtr = retrieveUntracked(name);
    return entryPtr == nullptr ? defaultValue : entryPtr->getVLuminosityBlockID();
  }

ParameterSet::getUntrackedParameter< std::vector< LuminosityBlockID > >() [3/4]

template<>

std::vector<LuminosityBlockID> edm::ParameterSet::getUntrackedParameter< std::vector< LuminosityBlockID > >

(

char const *

name

)

const

Definition at line 2034 of file ParameterSet.cc.

References Skims_PA_cff::name.

                              {
    return getEntryPointerOrThrow_(name)->getVLuminosityBlockID();
  }

ParameterSet::getUntrackedParameter< std::vector< LuminosityBlockID > >() [4/4]

template<>

std::vector<LuminosityBlockID> edm::ParameterSet::getUntrackedParameter< std::vector< LuminosityBlockID > >	(	char const *	name,
		std::vector< LuminosityBlockID > const &	defaultValue
	)		const

Definition at line 2027 of file ParameterSet.cc.

References hltPixelClustersMultiplicity_cfi::defaultValue, edm::Entry::getVLuminosityBlockID(), and Skims_PA_cff::name.

                                                                                {
    Entry const* entryPtr = retrieveUntracked(name);
    return entryPtr == nullptr ? defaultValue : entryPtr->getVLuminosityBlockID();
  }

ParameterSet::getUntrackedParameter< std::vector< LuminosityBlockRange > >() [1/4]

template<>

std::vector<LuminosityBlockRange> edm::ParameterSet::getUntrackedParameter< std::vector< LuminosityBlockRange > >	(	std::string const &	name,
		std::vector< LuminosityBlockRange > const &	defaultValue
	)		const

Definition at line 1506 of file ParameterSet.cc.

References hltPixelClustersMultiplicity_cfi::defaultValue, edm::Entry::getVLuminosityBlockRange(), and Skims_PA_cff::name.

                                                                                        {
    Entry const* entryPtr = retrieveUntracked(name);
    return entryPtr == nullptr ? defaultValue : entryPtr->getVLuminosityBlockRange();
  }

ParameterSet::getUntrackedParameter< std::vector< LuminosityBlockRange > >() [2/4]

template<>

std::vector<LuminosityBlockRange> edm::ParameterSet::getUntrackedParameter< std::vector< LuminosityBlockRange > >

(

std::string const &

name

)

const

Definition at line 1513 of file ParameterSet.cc.

References Skims_PA_cff::name.

                                   {
    return getEntryPointerOrThrow_(name)->getVLuminosityBlockRange();
  }

ParameterSet::getUntrackedParameter< std::vector< LuminosityBlockRange > >() [3/4]

template<>

std::vector<LuminosityBlockRange> edm::ParameterSet::getUntrackedParameter< std::vector< LuminosityBlockRange > >	(	char const *	name,
		std::vector< LuminosityBlockRange > const &	defaultValue
	)		const

Definition at line 2081 of file ParameterSet.cc.

References hltPixelClustersMultiplicity_cfi::defaultValue, edm::Entry::getVLuminosityBlockRange(), and Skims_PA_cff::name.

                                                                                   {
    Entry const* entryPtr = retrieveUntracked(name);
    return entryPtr == nullptr ? defaultValue : entryPtr->getVLuminosityBlockRange();
  }

ParameterSet::getUntrackedParameter< std::vector< LuminosityBlockRange > >() [4/4]

template<>

std::vector<LuminosityBlockRange> edm::ParameterSet::getUntrackedParameter< std::vector< LuminosityBlockRange > >

(

char const *

name

)

const

Definition at line 2088 of file ParameterSet.cc.

References Skims_PA_cff::name.

                              {
    return getEntryPointerOrThrow_(name)->getVLuminosityBlockRange();
  }

ParameterSet::getUntrackedParameter< std::vector< PdtEntry > >() [1/4]

template<>

std::vector<PdtEntry> edm::ParameterSet::getUntrackedParameter< std::vector< PdtEntry > > ( char const *  name ) const

inline

Definition at line 124 of file PdtEntry.h.

References MillePedeFileConverter_cfg::e, edm::pdtentry::getPdtEntryVector(), and Skims_PA_cff::name.

                                                                                                            {
    Entry const *e = getEntryPointerOrThrow_(name);
    return pdtentry::getPdtEntryVector(*e, name);
  }

ParameterSet::getUntrackedParameter< std::vector< PdtEntry > >() [2/4]

template<>

std::vector<PdtEntry> edm::ParameterSet::getUntrackedParameter< std::vector< PdtEntry > > ( char const *  name, std::vector< PdtEntry > const &  defaultValue  ) const

inline

Definition at line 130 of file PdtEntry.h.

References hltPixelClustersMultiplicity_cfi::defaultValue, MillePedeFileConverter_cfg::e, edm::pdtentry::getPdtEntryVector(), and Skims_PA_cff::name.

                                                                       {
    Entry const *e = retrieveUntracked(name);
    if (e == nullptr)
      return defaultValue;
    return pdtentry::getPdtEntryVector(*e, name);
  }

ParameterSet::getUntrackedParameter< std::vector< PdtEntry > >() [3/4]

template<>

std::vector<PdtEntry> edm::ParameterSet::getUntrackedParameter< std::vector< PdtEntry > > ( std::string const &  name, std::vector< PdtEntry > const &  defaultValue  ) const

inline

Definition at line 109 of file PdtEntry.h.

References hltPixelClustersMultiplicity_cfi::defaultValue, MillePedeFileConverter_cfg::e, edm::pdtentry::getPdtEntryVector(), and Skims_PA_cff::name.

                                                                            {
    Entry const *e = retrieveUntracked(name);
    if (e == nullptr)
      return defaultValue;
    return pdtentry::getPdtEntryVector(*e, name.c_str());
  }

ParameterSet::getUntrackedParameter< std::vector< PdtEntry > >() [4/4]

template<>

std::vector<PdtEntry> edm::ParameterSet::getUntrackedParameter< std::vector< PdtEntry > > ( std::string const &  name ) const

inline

Definition at line 102 of file PdtEntry.h.

References MillePedeFileConverter_cfg::e, edm::pdtentry::getPdtEntryVector(), and Skims_PA_cff::name.

                                   {
    Entry const *e = getEntryPointerOrThrow_(name);
    return pdtentry::getPdtEntryVector(*e, name.c_str());
  }

ParameterSet::getUntrackedParameter< std::vector< std::string > >() [1/4]

template<>

std::vector<std::string> edm::ParameterSet::getUntrackedParameter< std::vector< std::string > >	(	std::string const &	name,
		std::vector< std::string > const &	defaultValue
	)		const

Definition at line 1329 of file ParameterSet.cc.

References hltPixelClustersMultiplicity_cfi::defaultValue, edm::Entry::getVString(), and Skims_PA_cff::name.

                                                                             {
    Entry const* entryPtr = retrieveUntracked(name);
    return entryPtr == nullptr ? defaultValue : entryPtr->getVString();
  }

ParameterSet::getUntrackedParameter< std::vector< std::string > >() [2/4]

template<>

std::vector<std::string> edm::ParameterSet::getUntrackedParameter< std::vector< std::string > >

(

std::string const &

name

)

const

Definition at line 1336 of file ParameterSet.cc.

References Skims_PA_cff::name.

                                   {
    return getEntryPointerOrThrow_(name)->getVString();
  }

ParameterSet::getUntrackedParameter< std::vector< std::string > >() [3/4]

template<>

std::vector<std::string> edm::ParameterSet::getUntrackedParameter< std::vector< std::string > >	(	char const *	name,
		std::vector< std::string > const &	defaultValue
	)		const

Definition at line 1908 of file ParameterSet.cc.

References hltPixelClustersMultiplicity_cfi::defaultValue, edm::Entry::getVString(), and Skims_PA_cff::name.

                                                                        {
    Entry const* entryPtr = retrieveUntracked(name);
    return entryPtr == nullptr ? defaultValue : entryPtr->getVString();
  }

ParameterSet::getUntrackedParameter< std::vector< std::string > >() [4/4]

template<>

std::vector<std::string> edm::ParameterSet::getUntrackedParameter< std::vector< std::string > >

(

char const *

name

)

const

Definition at line 1915 of file ParameterSet.cc.

References Skims_PA_cff::name.

                                                                                                        {
    return getEntryPointerOrThrow_(name)->getVString();
  }

ParameterSet::getUntrackedParameter< std::vector< unsigned int > >() [1/4]

template<>

std::vector<unsigned int> edm::ParameterSet::getUntrackedParameter< std::vector< unsigned int > >

(

std::string const &

name

)

const

Definition at line 1227 of file ParameterSet.cc.

References Skims_PA_cff::name.

                                   {
    return getEntryPointerOrThrow_(name)->getVUInt32();
  }

ParameterSet::getUntrackedParameter< std::vector< unsigned int > >() [2/4]

template<>

std::vector<unsigned int> edm::ParameterSet::getUntrackedParameter< std::vector< unsigned int > >	(	std::string const &	name,
		std::vector< unsigned int > const &	defaultValue
	)		const

Definition at line 1220 of file ParameterSet.cc.

References hltPixelClustersMultiplicity_cfi::defaultValue, edm::Entry::getVUInt32(), and Skims_PA_cff::name.

                                                                                {
    Entry const* entryPtr = retrieveUntracked(name);
    return entryPtr == nullptr ? defaultValue : entryPtr->getVUInt32();
  }

ParameterSet::getUntrackedParameter< std::vector< unsigned int > >() [3/4]

template<>

std::vector<unsigned int> edm::ParameterSet::getUntrackedParameter< std::vector< unsigned int > >	(	char const *	name,
		std::vector< unsigned int > const &	defaultValue
	)		const

Definition at line 1801 of file ParameterSet.cc.

References hltPixelClustersMultiplicity_cfi::defaultValue, edm::Entry::getVUInt32(), and Skims_PA_cff::name.

                                                                           {
    Entry const* entryPtr = retrieveUntracked(name);
    return entryPtr == nullptr ? defaultValue : entryPtr->getVUInt32();
  }

ParameterSet::getUntrackedParameter< std::vector< unsigned int > >() [4/4]

template<>

std::vector<unsigned int> edm::ParameterSet::getUntrackedParameter< std::vector< unsigned int > >

(

char const *

name

)

const

Definition at line 1808 of file ParameterSet.cc.

References Skims_PA_cff::name.

                                                                                                              {
    return getEntryPointerOrThrow_(name)->getVUInt32();
  }

ParameterSet::getUntrackedParameter< std::vector< unsigned long long > >() [1/4]

template<>

std::vector<unsigned long long> edm::ParameterSet::getUntrackedParameter< std::vector< unsigned long long > >

(

std::string const &

name

)

const

Definition at line 1255 of file ParameterSet.cc.

References Skims_PA_cff::name.

                                   {
    return getEntryPointerOrThrow_(name)->getVUInt64();
  }

ParameterSet::getUntrackedParameter< std::vector< unsigned long long > >() [2/4]

template<>

std::vector<unsigned long long> edm::ParameterSet::getUntrackedParameter< std::vector< unsigned long long > >	(	std::string const &	name,
		std::vector< unsigned long long > const &	defaultValue
	)		const

Definition at line 1248 of file ParameterSet.cc.

References hltPixelClustersMultiplicity_cfi::defaultValue, edm::Entry::getVUInt64(), and Skims_PA_cff::name.

                                                                                      {
    Entry const* entryPtr = retrieveUntracked(name);
    return entryPtr == nullptr ? defaultValue : entryPtr->getVUInt64();
  }

ParameterSet::getUntrackedParameter< std::vector< unsigned long long > >() [3/4]

template<>

std::vector<unsigned long long> edm::ParameterSet::getUntrackedParameter< std::vector< unsigned long long > >

(

char const *

name

)

const

Definition at line 1835 of file ParameterSet.cc.

References Skims_PA_cff::name.

                              {
    return getEntryPointerOrThrow_(name)->getVUInt64();
  }

ParameterSet::getUntrackedParameter< std::vector< unsigned long long > >() [4/4]

template<>

std::vector<unsigned long long> edm::ParameterSet::getUntrackedParameter< std::vector< unsigned long long > >	(	char const *	name,
		std::vector< unsigned long long > const &	defaultValue
	)		const

Definition at line 1828 of file ParameterSet.cc.

References hltPixelClustersMultiplicity_cfi::defaultValue, edm::Entry::getVUInt64(), and Skims_PA_cff::name.

                                                                                 {
    Entry const* entryPtr = retrieveUntracked(name);
    return entryPtr == nullptr ? defaultValue : entryPtr->getVUInt64();
  }

parameterTypeEnumToString()

std::string edm::parameterTypeEnumToString

(

ParameterTypes

iType

)

Definition at line 67 of file ParameterDescriptionNode.cc.

References cms::cuda::assert(), k_stringRaw, k_vstringRaw, TYPE_TO_NAME, TYPE_TO_NAME2, muonProducer_cfi::VInputTag, and HistogramManager_cfi::VPSet().

Referenced by edm::ParameterSwitchBase::insertAndCheckTypes(), edm::ParameterWildcardBase::print_(), edm::ParameterDescriptionBase::print_(), edm::ParameterSwitch< T >::print_(), edm::AllowedLabelsDescriptionBase::printNestedContentBase_(), edm::ORGroupDescription::throwIfDuplicateTypes(), edm::IfExistsDescription::throwIfDuplicateTypes(), edm::ANDGroupDescription::throwIfDuplicateTypes(), edm::ParameterWildcardBase::throwIfInvalidPattern(), edm::ParameterSetDescription::throwIfWildcardCollision(), edm::ParameterDescriptionBase::throwMissingRequiredNoDefault(), edm::ParameterDescriptionBase::throwParameterWrongTrackiness(), edm::ParameterDescriptionBase::throwParameterWrongType(), edm::ParameterWildcardBase::validateMatchingNames(), and edm::ParameterDescriptionBase::writeCfi_().

                                                            {
    switch (iType) {
      TYPE_TO_NAME(int32);
      TYPE_TO_NAME(vint32);
      TYPE_TO_NAME(uint32);
      TYPE_TO_NAME(vuint32);
      TYPE_TO_NAME(int64);
      TYPE_TO_NAME(vint64);
      TYPE_TO_NAME(uint64);
      TYPE_TO_NAME(vuint64);
      TYPE_TO_NAME(double);
      TYPE_TO_NAME(vdouble);
      TYPE_TO_NAME(bool);
      TYPE_TO_NAME2(k_stringRaw, string);
      TYPE_TO_NAME2(k_vstringRaw, vstring);
      TYPE_TO_NAME(EventID);
      TYPE_TO_NAME(VEventID);
      TYPE_TO_NAME(LuminosityBlockID);
      TYPE_TO_NAME(VLuminosityBlockID);
      TYPE_TO_NAME(InputTag);
      TYPE_TO_NAME(VInputTag);
      TYPE_TO_NAME(ESInputTag);
      TYPE_TO_NAME(VESInputTag);
      TYPE_TO_NAME(FileInPath);
      TYPE_TO_NAME(PSet);
      TYPE_TO_NAME(VPSet);
      TYPE_TO_NAME(LuminosityBlockRange);
      TYPE_TO_NAME(VLuminosityBlockRange);
      TYPE_TO_NAME(EventRange);
      TYPE_TO_NAME(VEventRange);
      default:
        assert(false);
    }
    return "";
  }

ParameterTypeToEnum::toEnum< std::string >()

template<>

ParameterTypes edm::ParameterTypeToEnum::toEnum< std::string >

(

)

Definition at line 46 of file ParameterDescriptionNode.cc.

ParameterTypeToEnum::toEnum< std::vector< double > >()

template<>

ParameterTypes edm::ParameterTypeToEnum::toEnum< std::vector< double > >

(

)

Definition at line 44 of file ParameterDescriptionNode.cc.

ParameterTypeToEnum::toEnum< std::vector< ESInputTag > >()

template<>

ParameterTypes edm::ParameterTypeToEnum::toEnum< std::vector< ESInputTag > >

(

)

Definition at line 55 of file ParameterDescriptionNode.cc.

ParameterTypeToEnum::toEnum< std::vector< EventID > >()

template<>

ParameterTypes edm::ParameterTypeToEnum::toEnum< std::vector< EventID > >

(

)

Definition at line 49 of file ParameterDescriptionNode.cc.

ParameterTypeToEnum::toEnum< std::vector< EventRange > >()

template<>

ParameterTypes edm::ParameterTypeToEnum::toEnum< std::vector< EventRange > >

(

)

Definition at line 60 of file ParameterDescriptionNode.cc.

ParameterTypeToEnum::toEnum< std::vector< InputTag > >()

template<>

ParameterTypes edm::ParameterTypeToEnum::toEnum< std::vector< InputTag > >

(

)

Definition at line 53 of file ParameterDescriptionNode.cc.

ParameterTypeToEnum::toEnum< std::vector< int > >()

template<>

ParameterTypes edm::ParameterTypeToEnum::toEnum< std::vector< int > >

(

)

Definition at line 36 of file ParameterDescriptionNode.cc.

ParameterTypeToEnum::toEnum< std::vector< long long > >()

template<>

ParameterTypes edm::ParameterTypeToEnum::toEnum< std::vector< long long > >

(

)

Definition at line 40 of file ParameterDescriptionNode.cc.

ParameterTypeToEnum::toEnum< std::vector< LuminosityBlockID > >()

template<>

ParameterTypes edm::ParameterTypeToEnum::toEnum< std::vector< LuminosityBlockID > >

(

)

Definition at line 51 of file ParameterDescriptionNode.cc.

ParameterTypeToEnum::toEnum< std::vector< LuminosityBlockRange > >()

template<>

ParameterTypes edm::ParameterTypeToEnum::toEnum< std::vector< LuminosityBlockRange > >

(

)

Definition at line 58 of file ParameterDescriptionNode.cc.

ParameterTypeToEnum::toEnum< std::vector< std::string > >()

template<>

ParameterTypes edm::ParameterTypeToEnum::toEnum< std::vector< std::string > >

(

)

Definition at line 47 of file ParameterDescriptionNode.cc.

ParameterTypeToEnum::toEnum< std::vector< unsigned > >()

template<>

ParameterTypes edm::ParameterTypeToEnum::toEnum< std::vector< unsigned > >

(

)

Definition at line 38 of file ParameterDescriptionNode.cc.

ParameterTypeToEnum::toEnum< std::vector< unsigned long long > >()

template<>

ParameterTypes edm::ParameterTypeToEnum::toEnum< std::vector< unsigned long long > >

(

)

Definition at line 42 of file ParameterDescriptionNode.cc.

pointerToBase()

template<typename T >

void const* edm::pointerToBase	(	std::type_info const &	baseTypeInfo,
		T const *	address
	)

Definition at line 47 of file OffsetToBase.h.

References runTheMatrix::const, hltrates_dqm_sourceclient-live_cfg::offset, and edm::OffsetToBase< T >::offsetToBase().

Referenced by edm::reftobase::RefHolder< REF >::pointerToType(), edm::detail::reallyfillPtrVector(), and edm::detail::reallySetPtr().

                                                                                {
    OffsetToBase<T> offsetToBase;
    int offset = offsetToBase.offsetToBase(baseTypeInfo);
    void const* ptr = address;
    return static_cast<char const*>(ptr) + offset;
  }

popSubProcessVParameterSet()

std::vector< ParameterSet > edm::popSubProcessVParameterSet

(

ParameterSet &

parameterSet

)

Definition at line 804 of file SubProcess.cc.

References edm::ParameterSet::getUntrackedParameter(), parameterSet(), and edm::ParameterSet::popVParameterSet().

Referenced by edm::EventProcessor::init(), and edm::SubProcess::SubProcess().

                                                                                 {
    std::vector<std::string> subProcesses =
        parameterSet.getUntrackedParameter<std::vector<std::string>>("@all_subprocesses");
    if (!subProcesses.empty()) {
      return parameterSet.popVParameterSet("subProcesses");
    }
    return {};
  }

postIndexIntoFilePrintEventLists()

static void edm::postIndexIntoFilePrintEventLists ( TFile *  tfl, FileFormatVersion const &  fileFormatVersion, TTree *  metaDataTree  )

static

Definition at line 156 of file CollUtil.cc.

References cms::cuda::assert(), edm::IndexIntoFile::begin(), gather_cfg::cout, edm::IndexIntoFile::end(), edm::EventID::event(), edm::poolNames::eventTreeName(), edm::IndexIntoFile::firstAppearanceOrder, edm::EventAuxiliary::id(), edm::poolNames::indexIntoFileBranchName(), ALPAKA_ACCELERATOR_NAMESPACE::vertexFinder::it, edm::IndexIntoFile::iterationWillBeInEntryOrder(), edm::IndexIntoFile::kEvent, edm::IndexIntoFile::kLumi, edm::IndexIntoFile::kRun, AlCaHLTBitMon_QueryRunRegistry::string, and submitPVValidationJobs::t.

Referenced by printEventLists().

                                                                    {
    IndexIntoFile indexIntoFile;
    IndexIntoFile *findexPtr = &indexIntoFile;
    if (metaDataTree->FindBranch(poolNames::indexIntoFileBranchName().c_str()) != nullptr) {
      TBranch *fndx = metaDataTree->GetBranch(poolNames::indexIntoFileBranchName().c_str());
      fndx->SetAddress(&findexPtr);
      fndx->GetEntry(0);
    } else {
      std::cout << "IndexIntoFile not found.  If this input file was created with release 1_8_0 or later\n"
                   "this indicates a problem with the file.  This condition should be expected with\n"
                   "files created with earlier releases and printout of the event list will fail.\n";
      return;
    }
    //need to read event # from the EventAuxiliary branch
    TTree *eventsTree = dynamic_cast<TTree *>(tfl->Get(poolNames::eventTreeName().c_str()));
    TBranch *eventAuxBranch = nullptr;
    assert(nullptr != eventsTree);
    char const *const kEventAuxiliaryBranchName = "EventAuxiliary";
    if (eventsTree->FindBranch(kEventAuxiliaryBranchName) != nullptr) {
      eventAuxBranch = eventsTree->GetBranch(kEventAuxiliaryBranchName);
    } else {
      std::cout << "Failed to find " << kEventAuxiliaryBranchName
                << " branch in Events TTree.  Something is wrong with this file." << std::endl;
      return;
    }
    EventAuxiliary eventAuxiliary;
    EventAuxiliary *eAPtr = &eventAuxiliary;
    eventAuxBranch->SetAddress(&eAPtr);
    std::cout << "\nPrinting IndexIntoFile contents.  This includes a list of all Runs, LuminosityBlocks\n"
              << "and Events stored in the root file.\n\n";
    std::cout << std::setw(15) << "Run" << std::setw(15) << "Lumi" << std::setw(15) << "Event" << std::setw(15)
              << "TTree Entry"
              << "\n";

    for (IndexIntoFile::IndexIntoFileItr it = indexIntoFile.begin(IndexIntoFile::firstAppearanceOrder),
                                         itEnd = indexIntoFile.end(IndexIntoFile::firstAppearanceOrder);
         it != itEnd;
         ++it) {
      IndexIntoFile::EntryType t = it.getEntryType();
      std::cout << std::setw(15) << it.run() << std::setw(15) << it.lumi();
      EventNumber_t eventNum = 0;
      std::string type;
      switch (t) {
        case IndexIntoFile::kRun:
          type = "(Run)";
          break;
        case IndexIntoFile::kLumi:
          type = "(Lumi)";
          break;
        case IndexIntoFile::kEvent:
          eventAuxBranch->GetEntry(it.entry());
          eventNum = eventAuxiliary.id().event();
          break;
        default:
          break;
      }
      std::cout << std::setw(15) << eventNum << std::setw(15) << it.entry() << " " << type << std::endl;
    }

    std::cout << "\nFileFormatVersion = " << fileFormatVersion << ".  ";
    if (fileFormatVersion.fastCopyPossible())
      std::cout << "This version supports fast copy\n";
    else
      std::cout << "This version does not support fast copy\n";

    if (indexIntoFile.iterationWillBeInEntryOrder(IndexIntoFile::firstAppearanceOrder)) {
      std::cout << "Events are sorted such that fast copy is possible in the \"noEventSort = false\" mode\n";
    } else {
      std::cout << "Events are sorted such that fast copy is NOT possible in the \"noEventSort = false\" mode\n";
    }

    // This will not work unless the other nonpersistent parts of the Index are filled first
    // I did not have time to implement this yet.
    // if (indexIntoFile.iterationWillBeInEntryOrder(IndexIntoFile::numericalOrder)) {
    //   std::cout << "Events are sorted such that fast copy is possible in the \"noEventSort\" mode\n";
    // } else {
    //   std::cout << "Events are sorted such that fast copy is NOT possible in the \"noEventSort\" mode\n";
    // }
    std::cout << "(Note that other factors can prevent fast copy from occurring)\n\n";
  }

postIndexIntoFilePrintEventsInLumis()

static void edm::postIndexIntoFilePrintEventsInLumis ( TFile *  tfl, FileFormatVersion const &  fileFormatVersion, TTree *  metaDataTree  )

static

Definition at line 303 of file CollUtil.cc.

References edm::IndexIntoFile::begin(), gather_cfg::cout, edm::IndexIntoFile::end(), edm::IndexIntoFile::firstAppearanceOrder, edm::poolNames::indexIntoFileBranchName(), ALPAKA_ACCELERATOR_NAMESPACE::vertexFinder::it, edm::IndexIntoFile::kEvent, edm::IndexIntoFile::kLumi, edm::IndexIntoFile::kRun, createIOVlist::nEvents, and submitPVValidationJobs::t.

Referenced by printEventsInLumis().

                                                                       {
    IndexIntoFile indexIntoFile;
    IndexIntoFile *findexPtr = &indexIntoFile;
    if (metaDataTree->FindBranch(poolNames::indexIntoFileBranchName().c_str()) != nullptr) {
      TBranch *fndx = metaDataTree->GetBranch(poolNames::indexIntoFileBranchName().c_str());
      fndx->SetAddress(&findexPtr);
      fndx->GetEntry(0);
    } else {
      std::cout << "IndexIntoFile not found.  If this input file was created with release 1_8_0 or later\n"
                   "this indicates a problem with the file.  This condition should be expected with\n"
                   "files created with earlier releases and printout of the event list will fail.\n";
      return;
    }
    std::cout << "\n"
              << std::setw(15) << "Run" << std::setw(15) << "Lumi" << std::setw(15) << "# Events"
              << "\n";

    unsigned long nEvents = 0;
    unsigned long runID = 0;
    unsigned long lumiID = 0;

    for (IndexIntoFile::IndexIntoFileItr it = indexIntoFile.begin(IndexIntoFile::firstAppearanceOrder),
                                         itEnd = indexIntoFile.end(IndexIntoFile::firstAppearanceOrder);
         it != itEnd;
         ++it) {
      IndexIntoFile::EntryType t = it.getEntryType();
      switch (t) {
        case IndexIntoFile::kRun:
          break;
        case IndexIntoFile::kLumi:
          if (runID != it.run() || lumiID != it.lumi()) {
            //print the previous one
            if (lumiID != 0) {
              std::cout << std::setw(15) << runID << std::setw(15) << lumiID << std::setw(15) << nEvents << "\n";
            }
            nEvents = 0;
            runID = it.run();
            lumiID = it.lumi();
          }
          break;
        case IndexIntoFile::kEvent:
          ++nEvents;
          break;
        default:
          break;
      }
    }
    //print the last one
    if (lumiID != 0) {
      std::cout << std::setw(15) << runID << std::setw(15) << lumiID << std::setw(15) << nEvents << "\n";
    }
    std::cout << "\n";
  }

preIndexIntoFilePrintEventLists()

static void edm::preIndexIntoFilePrintEventLists ( TFile *  , FileFormatVersion const &  fileFormatVersion, TTree *  metaDataTree  )

static

Definition at line 117 of file CollUtil.cc.

References gather_cfg::cout, and edm::poolNames::fileIndexBranchName().

Referenced by printEventLists().

                                                                   {
    FileIndex fileIndex;
    FileIndex *findexPtr = &fileIndex;
    if (metaDataTree->FindBranch(poolNames::fileIndexBranchName().c_str()) != nullptr) {
      TBranch *fndx = metaDataTree->GetBranch(poolNames::fileIndexBranchName().c_str());
      fndx->SetAddress(&findexPtr);
      fndx->GetEntry(0);
    } else {
      std::cout << "FileIndex not found.  If this input file was created with release 1_8_0 or later\n"
                   "this indicates a problem with the file.  This condition should be expected with\n"
                   "files created with earlier releases and printout of the event list will fail.\n";
      return;
    }

    std::cout << "\n" << fileIndex;

    std::cout << "\nFileFormatVersion = " << fileFormatVersion << ".  ";
    if (fileFormatVersion.fastCopyPossible())
      std::cout << "This version supports fast copy\n";
    else
      std::cout << "This version does not support fast copy\n";

    if (fileIndex.allEventsInEntryOrder()) {
      std::cout << "Events are sorted such that fast copy is possible in the \"noEventSort = False\" mode\n";
    } else {
      std::cout << "Events are sorted such that fast copy is NOT possible in the \"noEventSort = False\" mode\n";
    }

    fileIndex.sortBy_Run_Lumi_EventEntry();
    if (fileIndex.allEventsInEntryOrder()) {
      std::cout << "Events are sorted such that fast copy is possible in the \"noEventSort\" mode\n";
    } else {
      std::cout << "Events are sorted such that fast copy is NOT possible in the \"noEventSort\" mode\n";
    }
    std::cout << "(Note that other factors can prevent fast copy from occurring)\n\n";
  }

preIndexIntoFilePrintEventsInLumis()

static void edm::preIndexIntoFilePrintEventsInLumis ( TFile *  , FileFormatVersion const &  fileFormatVersion, TTree *  metaDataTree  )

static

Definition at line 257 of file CollUtil.cc.

References edm::FileIndex::begin(), gather_cfg::cout, edm::FileIndex::end(), edm::poolNames::fileIndexBranchName(), ALPAKA_ACCELERATOR_NAMESPACE::vertexFinder::it, edm::FileIndex::kEvent, edm::FileIndex::kLumi, and createIOVlist::nEvents.

Referenced by printEventsInLumis().

                                                                      {
    FileIndex fileIndex;
    FileIndex *findexPtr = &fileIndex;
    if (metaDataTree->FindBranch(poolNames::fileIndexBranchName().c_str()) != nullptr) {
      TBranch *fndx = metaDataTree->GetBranch(poolNames::fileIndexBranchName().c_str());
      fndx->SetAddress(&findexPtr);
      fndx->GetEntry(0);
    } else {
      std::cout << "FileIndex not found.  If this input file was created with release 1_8_0 or later\n"
                   "this indicates a problem with the file.  This condition should be expected with\n"
                   "files created with earlier releases and printout of the event list will fail.\n";
      return;
    }

    std::cout << "\n"
              << std::setw(15) << "Run" << std::setw(15) << "Lumi" << std::setw(15) << "# Events"
              << "\n";
    unsigned long nEvents = 0;
    unsigned long runID = 0;
    unsigned long lumiID = 0;
    for (std::vector<FileIndex::Element>::const_iterator it = fileIndex.begin(), itEnd = fileIndex.end(); it != itEnd;
         ++it) {
      if (it->getEntryType() == FileIndex::kEvent) {
        ++nEvents;
      } else if (it->getEntryType() == FileIndex::kLumi) {
        if (runID != it->run_ || lumiID != it->lumi_) {
          //print the previous one
          if (lumiID != 0) {
            std::cout << std::setw(15) << runID << std::setw(15) << lumiID << std::setw(15) << nEvents << "\n";
          }
          nEvents = 0;
          runID = it->run_;
          lumiID = it->lumi_;
        }
      }
    }
    //print the last one
    if (lumiID != 0) {
      std::cout << std::setw(15) << runID << std::setw(15) << lumiID << std::setw(15) << nEvents << "\n";
    }

    std::cout << "\n";
  }

print() [1/3]

template<typename S >

S& edm::print	(	S &	os,
		JobReport::InputFile const &	f
	)

Definition at line 66 of file JobReport.cc.

References hcalRecHitTable_cff::doc, f, and formatFile().

Referenced by operator<<().

                                               {
    tinyxml2::XMLDocument doc;
    os << "\n<InputFile>";
    formatFile(f, os);
    os << "\n<InputType>" << f.inputType << "</InputType>";
    os << "\n<InputSourceClass>" << doc.NewText(f.inputSourceClassName.c_str())->Value() << "</InputSourceClass>";
    os << "\n<EventsRead>" << f.numEventsRead << "</EventsRead>";
    return os;
  }

print() [2/3]

template<typename S >

S& edm::print	(	S &	os,
		JobReport::OutputFile const &	f
	)

Definition at line 77 of file JobReport.cc.

References hcalRecHitTable_cff::doc, f, and formatFile().

                                                {
    tinyxml2::XMLDocument doc;
    formatFile(f, os);
    os << "\n<OutputModuleClass>" << doc.NewText(f.outputModuleClassName.c_str())->Value() << "</OutputModuleClass>";
    os << "\n<TotalEvents>" << f.numEventsWritten << "</TotalEvents>\n";
    os << "\n<DataType>" << doc.NewText(f.dataType.c_str())->Value() << "</DataType>\n";
    os << "\n<BranchHash>" << doc.NewText(f.branchHash.c_str())->Value() << "</BranchHash>\n";
    return os;
  }

print() [3/3]

template<typename S >

S& edm::print	(	S &	os,
		JobReport::RunReport const &	rep
	)

Definition at line 88 of file JobReport.cc.

References SiStripPI::max, and cuy::rep.

                                                 {
    os << "\n<Run ID=\"" << rep.runNumber << "\">\n";

    for (auto const& il : rep.lumiSectionsToNEvents) {
      if (std::numeric_limits<unsigned long>::max() == il.second) {
        os << "   <LumiSection ID=\"" << il.first << "\"/>\n";

      } else {
        os << "   <LumiSection ID=\"" << il.first << "\" NEvents=\"" << il.second << "\"/>\n";
      }
    }
    os << "</Run>\n";
    return os;
  }

printBranchNames()

void edm::printBranchNames

(

TTree *

tree

)

Definition at line 74 of file CollUtil.cc.

References gather_cfg::cout, mps_fire::i, and L1DTConfigBti_cff::LL.

                                     {
    if (tree != nullptr) {
      Long64_t nB = tree->GetListOfBranches()->GetEntries();
      for (Long64_t i = 0; i < nB; ++i) {
        Long64_t size = 0LL;
        TBranch *btemp = (TBranch *)tree->GetListOfBranches()->At(i);
        addBranchSizes(btemp, size);
        std::cout << "Branch " << i << " of " << tree->GetName() << " tree: " << btemp->GetName()
                  << " Total size = " << size << " Compressed size = " << branchCompressedSizes(btemp) << std::endl;
      }
    } else {
      std::cout << "Missing Events tree?\n";
    }
  }

printCmsException()

void edm::printCmsException	(	cms::Exception &	e,
		edm::JobReport *	jobRep = nullptr,
		int	rc = -1
	)

Definition at line 12 of file ExceptionMessages.cc.

References MillePedeFileConverter_cfg::e, edm::JobReport::reportError(), and AlCaHLTBitMon_QueryRunRegistry::string.

Referenced by addContextAndPrintException().

                                                                            {
    std::string shortDesc("Fatal Exception");
    std::ostringstream longDesc;
    longDesc << e.explainSelf();
    LogAbsolute(shortDesc) << "----- Begin " << shortDesc << " " << std::setprecision(0) << TimeOfDay()
                           << "-----------------------\n"
                           << longDesc.str() << "----- End " << shortDesc
                           << " -------------------------------------------------";
    if (jobRep)
      jobRep->reportError(shortDesc, longDesc.str(), rc);
  } catch (...) {
  }

printCmsExceptionWarning()

void edm::printCmsExceptionWarning	(	char const *	behavior,
		cms::Exception const &	e
	)

Definition at line 25 of file ExceptionMessages.cc.

References MillePedeFileConverter_cfg::e, and AlCaHLTBitMon_QueryRunRegistry::string.

Referenced by edm::EDLooperBase::doDuringLoop(), edm::StreamSchedule::finishedPaths(), edm::Path::handleWorkerFailure(), and edm::Worker::shouldRethrowException().

                                                                                 {
    std::string shortDesc(behavior);
    shortDesc += " Exception";
    std::ostringstream longDesc;
    longDesc << e.explainSelf();
    LogPrint(shortDesc) << "----- Begin " << shortDesc << " " << std::setprecision(0) << TimeOfDay()
                        << "-----------------------\n"
                        << longDesc.str() << "----- End " << shortDesc
                        << " -------------------------------------------------";
  } catch (...) {
  }

printEventLists()

void edm::printEventLists

(

TFile *

tfl

)

Definition at line 239 of file CollUtil.cc.

References cms::cuda::assert(), edm::poolNames::fileFormatVersionBranchName(), edm::FileFormatVersion::hasIndexIntoFile(), edm::poolNames::metaDataTreeName(), postIndexIntoFilePrintEventLists(), and preIndexIntoFilePrintEventLists().

                                   {
    TTree *metaDataTree = dynamic_cast<TTree *>(tfl->Get(poolNames::metaDataTreeName().c_str()));
    assert(nullptr != metaDataTree);

    FileFormatVersion fileFormatVersion;
    FileFormatVersion *fftPtr = &fileFormatVersion;
    if (metaDataTree->FindBranch(poolNames::fileFormatVersionBranchName().c_str()) != nullptr) {
      TBranch *fft = metaDataTree->GetBranch(poolNames::fileFormatVersionBranchName().c_str());
      fft->SetAddress(&fftPtr);
      fft->GetEntry(0);
    }
    if (fileFormatVersion.hasIndexIntoFile()) {
      postIndexIntoFilePrintEventLists(tfl, fileFormatVersion, metaDataTree);
    } else {
      preIndexIntoFilePrintEventLists(tfl, fileFormatVersion, metaDataTree);
    }
  }

printEventsInLumis()

void edm::printEventsInLumis

(

TFile *

tfl

)

Definition at line 359 of file CollUtil.cc.

References cms::cuda::assert(), edm::poolNames::fileFormatVersionBranchName(), edm::FileFormatVersion::hasIndexIntoFile(), edm::poolNames::metaDataTreeName(), postIndexIntoFilePrintEventsInLumis(), and preIndexIntoFilePrintEventsInLumis().

                                      {
    TTree *metaDataTree = dynamic_cast<TTree *>(tfl->Get(poolNames::metaDataTreeName().c_str()));
    assert(nullptr != metaDataTree);

    FileFormatVersion fileFormatVersion;
    FileFormatVersion *fftPtr = &fileFormatVersion;
    if (metaDataTree->FindBranch(poolNames::fileFormatVersionBranchName().c_str()) != nullptr) {
      TBranch *fft = metaDataTree->GetBranch(poolNames::fileFormatVersionBranchName().c_str());
      fft->SetAddress(&fftPtr);
      fft->GetEntry(0);
    }
    if (fileFormatVersion.hasIndexIntoFile()) {
      postIndexIntoFilePrintEventsInLumis(tfl, fileFormatVersion, metaDataTree);
    } else {
      preIndexIntoFilePrintEventsInLumis(tfl, fileFormatVersion, metaDataTree);
    }
  }

printTrees()

void edm::printTrees

(

TFile *

hdl

)

Definition at line 35 of file CollUtil.cc.

References HLT_2024v12_cff::Class, submitPVResolutionJobs::key, and getGTfromDQMFile::obj.

                              {
    hdl->ls();
    TList *keylist = hdl->GetListOfKeys();
    TIterator *iter = keylist->MakeIterator();
    TKey *key = nullptr;
    while ((key = (TKey *)iter->Next())) {
      TObject *obj = hdl->Get(key->GetName());
      if (obj->IsA() == TTree::Class()) {
        obj->Print();
      }
    }
    return;
  }

printUuids()

void edm::printUuids

(

TTree *

uuidTree

)

Definition at line 108 of file CollUtil.cc.

References gather_cfg::cout, edm::FileID::fid(), and edm::poolNames::fileIdentifierBranchName().

                                   {
    FileID fid;
    FileID *fidPtr = &fid;
    uuidTree->SetBranchAddress(poolNames::fileIdentifierBranchName().c_str(), &fidPtr);
    uuidTree->GetEntry(0);

    std::cout << "UUID: " << fid.fid() << std::endl;
  }

processGUID()

Guid const & edm::processGUID

(

)

Definition at line 4 of file processGUID.cc.

Referenced by edm::IDGeneratorSourceBase< PuttableSourceBase >::doReadEvent(), edm::IDGeneratorSourceBase< PuttableSourceBase >::doReadEventWithDelayedReader(), edm::service::CondorStatusService::firstUpdate(), and evf::evtn::makeEventAuxiliary().

                            {
    static Guid const guid;
    return guid;
  }

productIDToBranchID()

BranchID edm::productIDToBranchID	(	ProductID const &	pid,
		BranchIDLists const &	lists,
		BranchListIndexes const &	indexes
	)

Definition at line 11 of file ProductIDToBranchID.cc.

References edm::ProductID::isValid(), edm::ProductID::processIndex(), and edm::ProductID::productIndex().

Referenced by edm::EventPrincipal::pidToBid(), fwlite::internal::BranchMapReaderStrategyV11::productToBranchID(), and fwlite::internal::BranchMapReaderStrategyV17::productToBranchID().

                                                                                                                   {
    if (pid.isValid()) {
      size_t procIndex = pid.processIndex() - 1;
      if (procIndex < indexes.size()) {
        BranchListIndex blix = indexes[procIndex];
        if (blix < lists.size()) {
          BranchIDList const& blist = lists[blix];
          size_t prodIndex = pid.productIndex() - 1;
          if (prodIndex < blist.size()) {
            BranchID::value_type bid = blist[prodIndex];
            return BranchID(bid);
          }
        }
      }
    }
    return BranchID();
  }

public_base_classes()

bool edm::public_base_classes	(	std::vector< std::string > &	missingDictionaries,
		TypeID const &	typeID,
		std::vector< TypeID > &	baseTypes
	)

Definition at line 320 of file DictionaryTools.cc.

References newFWLiteAna::base, checkDictionary(), edm::TypeWithDict::name(), search_all(), edm::TypeID::typeInfo(), and edm::TypeWithDict::typeInfo().

Referenced by edm::ProductRegistry::checkDictionariesOfConsumedTypes(), edm::ProductRegistry::initializeLookupTables(), edm::ProductResolverIndexHelper::insert(), and edm::productholderindexhelper::typeIsViewCompatible().

                                                         {
    if (!checkDictionary(missingDictionaries, typeID)) {
      return false;
    }
    TypeWithDict typeWithDict(typeID.typeInfo());

    if (!typeWithDict.isClass()) {
      return true;
    }

    // No need to check into base classes of standard library
    // classes.
    if (TClassEdit::IsStdClass(typeWithDict.name().c_str())) {
      return true;
    }

    TypeBases bases(typeWithDict);
    bool returnValue = true;
    for (auto const& basex : bases) {
      BaseWithDict base(basex);
      if (!base.isPublic()) {
        continue;
      }
      TypeWithDict baseRflxType = base.typeOf();
      if (!checkDictionary(missingDictionaries, baseRflxType.name(), baseRflxType)) {
        returnValue = false;
        continue;
      }
      TypeID baseType{baseRflxType.typeInfo()};
      // Check to make sure this base appears only once in the
      // inheritance hierarchy.
      if (!search_all(baseTypes, baseType)) {
        // Save the type and recursive look for its base types
        baseTypes.push_back(baseType);
        if (!public_base_classes(missingDictionaries, baseType, baseTypes)) {
          returnValue = false;
          continue;
        }
      }
      // For now just ignore it if the class appears twice,
      // After some more testing we may decide to uncomment the following
      // exception.
      //
      //else {
      //  throw Exception(errors::UnimplementedFeature)
      //    << "DataFormats/Common/src/DictionaryTools.cc in function public_base_classes.\n"
      //    << "Encountered class that has a public base class that appears\n"
      //    << "multiple times in its inheritance heirarchy.\n"
      //    << "Please contact the EDM Framework group with details about\n"
      //    << "this exception. It was our hope that this complicated situation\n"
      //    << "would not occur. There are three possible solutions. 1. Change\n"
      //    << "the class design so the public base class does not appear multiple\n"
      //    << "times in the inheritance heirarchy. In many cases, this is a\n"
      //    << "sign of bad design. 2. Modify the code that supports Views to\n"
      //    << "ignore these base classes, but not supply support for creating a\n"
      //    << "View of this base class. 3. Improve the View infrastructure to\n"
      //    << "deal with this case. Class name of base class: " << baseType.Name() << "\n\n";
      //}
    }
    return returnValue;
  }

pythonToCppException()

void edm::pythonToCppException	(	const std::string &	iType,
		const std::string &	error
	)

Definition at line 6 of file PyBind11Wrapper.cc.

References edm::errors::Configuration, relativeConstraints::error, Exception, and edm::errors::UnavailableAccelerator.

Referenced by PyBind11ProcessDesc::read(), edm::cmspybind11::readPSetsFrom(), and FWPathsPopup::scheduleReloadEvent().

                                                                            {
    auto colon = error.find(':');
    if (colon != std::string::npos) {
      if (error.substr(0, colon) == "EDMException") {
        auto errorNameStart = error.find('{');
        auto errorNameEnd = error.find('}');
        if (errorNameStart != std::string::npos and errorNameEnd != std::string::npos) {
          auto errorName = error.substr(errorNameStart + 1, errorNameEnd - errorNameStart - 1);
          if ("Configuration" == errorName) {
            auto newLine = error.find('\n', errorNameEnd + 1);
            if (newLine == std::string::npos) {
              newLine = errorNameEnd + 1;
            }
            throw edm::Exception(edm::errors::Configuration) << error.substr(newLine + 1, std::string::npos);
          } else if ("UnavailableAccelerator" == errorName) {
            auto newLine = error.find('\n', errorNameEnd + 1);
            if (newLine == std::string::npos) {
              newLine = errorNameEnd + 1;
            }
            throw edm::Exception(edm::errors::UnavailableAccelerator) << error.substr(newLine + 1, std::string::npos);
          }
        }
      }
    }
    throw cms::Exception(iType) << " unknown python problem occurred.\n" << error << std::endl;
  }

read_from_cin()

void edm::read_from_cin

(

std::string &

output

)

Definition at line 25 of file Parse.cc.

References mps_splice::line, and AlCaHLTBitMon_QueryRunRegistry::string.

                                        {
    std::string line;
    while (getline(std::cin, line)) {
      output += line;
      output += '\n';
    }
  }

read_whole_file()

std::string edm::read_whole_file

(

std::string const &

filename

)

only does the yacc interpretation

Definition at line 10 of file Parse.cc.

References edmScanValgrind::buffer, edm::errors::Configuration, Exception, corrVsCorr::filename, input, mps_fire::result, and AlCaHLTBitMon_QueryRunRegistry::string.

                                                       {
    std::string result;
    std::ifstream input(filename.c_str());
    if (!input) {
      throw edm::Exception(errors::Configuration, "MissingFile") << "Cannot read file " << filename;
    }
    std::string buffer;
    while (getline(input, buffer)) {
      // getline strips newlines; we have to put them back by hand.
      result += buffer;
      result += '\n';
    }
    return result;
  }

readConfig() [1/2]

std::unique_ptr< edm::ParameterSet > edm::readConfig	(	std::string const &	config,
		const std::vector< std::string > &	args
	)

same, but with arguments

Definition at line 11 of file ParameterSetReader.cc.

References writedatasetfile::args, PyBind11ProcessDesc::parameterSet(), and edm::cmspybind11::readConfig().

                                                                                                        {
  return edm::cmspybind11::readConfig(config, args);
}

readConfig() [2/2]

std::unique_ptr< edm::ParameterSet > edm::readConfig

(

std::string const &

config

)

Definition at line 15 of file ParameterSetReader.cc.

References PyBind11ProcessDesc::parameterSet(), and edm::cmspybind11::readConfig().

Referenced by readConfig().

                                                                      {
  return edm::cmspybind11::readConfig(config);
}

readPSetsFrom()

std::unique_ptr< edm::ParameterSet > edm::readPSetsFrom

(

std::string const &

fileOrString

)

finds all the PSets used in the top level module referred as a file or as a string containing python commands. These PSets are bundled into a top level PSet from which they can be retrieved

Definition at line 23 of file ParameterSetReader.cc.

References nnet::cast(), MillePedeFileConverter_cfg::e, cond::persistency::import(), edm::python::initializePyBind11Module(), makePSetsFromFile(), makePSetsFromString(), resolutioncreator_cfi::object, Python11ParameterSet::pset(), pythonToCppException(), and edm::cmspybind11::readPSetsFrom().

Referenced by main(), and readPSetsFrom().

                                                                               {
  return edm::cmspybind11::readPSetsFrom(fileOrString);
}

reenableSigs()

void edm::reenableSigs

(

sigset_t *

oldset

)

Definition at line 72 of file UnixSignalHandlers.cc.

References MUST_BE_ZERO.

Referenced by installCustomHandler().

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

refToPtr()

template<typename C >

Ptr<typename C::value_type> edm::refToPtr

(

Ref< C, typename C::value_type, refhelper::FindUsingAdvance< C, typename C::value_type > > const &

ref

)

Definition at line 18 of file RefToPtr.h.

Referenced by ParticleLevelProducer::addGenJet(), EgammaHLTFilteredObjProducer< OutCollType >::addObj(), PFEGammaAlgo::attachPSClusters(), PFEGammaProducer::createSingleLegConversions(), EGammaMvaEleEstimator::isoMvaValue(), noPuUtils::isVertexAssociated(), reco::tau::PFRecoTauChargedHadronFromPFCandidatePlugin::operator()(), ParticleLevelProducer::produce(), pat::PATTauSlimmer::produce(), IsolatedTrackCleaner::produce(), pat::PATSecondaryVertexSlimmer::produce(), pat::PackedPFCandidateRefMixer::produce(), pat::PATGenJetSlimmer::produce(), pat::PATMuonSlimmer::produce(), TauGenJetProducer::produce(), pat::PATJetSlimmer::produce(), JetSubstructurePacker::produce(), VertexProducer::produce(), PFTauPrimaryVertexProducerBase::produce(), EgammaHLTPhase2ExtraProducer::produce(), L1TCorrelatorLayer1Producer::putEgObjects(), edmtest::OtherThingAlgorithm::run(), and PFEGammaToCandidate::run().

                                                                                                    {
    typedef typename C::value_type T;
    if (ref.isNull()) {
      return Ptr<T>();
    }
    if (ref.isTransient()) {
      return Ptr<T>(ref.get(), ref.key());
    } else {
      //Another thread could change this value so get only once
      EDProductGetter const* getter = ref.productGetter();
      if (getter) {
        return Ptr<T>(ref.id(), ref.key(), getter);
      }
    }
    return Ptr<T>(ref.id(), ref.get(), ref.key());
  }

regexMatch() [1/2]

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

Definition at line 26 of file RegexMatch.cc.

References mps_fire::i, oniaPATMuonsWithTrigger_cff::matches, fetchall_from_DQM_v2::regexp, and makeListRunsInFiles::strings.

Referenced by triggerExpression::PathReader::init(), HLTHighLevel::init(), TriggerTools::initPathNames(), edm::EventSelector::initPathNames(), hltdqm::passTrig(), regexMatch(), dqmservices::DQMStreamerReader::setMatchTriggerSel(), and dqmservices::TriggerSelector::TreeElement::TreeElement().

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

regexMatch() [2/2]

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

Definition at line 37 of file RegexMatch.cc.

References glob2reg(), topSingleLeptonDQM_PU_cfi::pattern, regexMatch(), fetchall_from_DQM_v2::regexp, and makeListRunsInFiles::strings.

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

replaceString()

void edm::replaceString	(	std::string &	demangledName,
		std::string const &	from,
		std::string const &	to
	)

Definition at line 85 of file TypeDemangler.cc.

Referenced by edm::TypeWithDict::cppName(), L1GtVhdlTemplateFile::findAndReplaceString(), L1GtVhdlTemplateFile::substitute(), and typeDemangle().

                                                                                           {
    // from must not be a substring of to.
    std::string::size_type length = from.size();
    std::string::size_type pos = 0;
    while ((pos = demangledName.find(from, pos)) != std::string::npos) {
      demangledName.replace(pos, length, to);
    }
  }

resolveSymbolicLinks()

void edm::resolveSymbolicLinks

(

std::string &

fullPath

)

Definition at line 48 of file resolveSymbolicLinks.cc.

References newFWLiteAna::found, and contentValuesFiles::fullPath.

                                                 {
    bool found = resolveOneSymbolicLink(fullPath);
    if (found) {
      resolveSymbolicLinks(fullPath);
    }
  }

s_filler_0__LINE__()

static const edm::ParameterSetDescriptionFillerPluginFactory::PMaker<edm::ParameterSetDescriptionFiller< HiMixingModule > > edm::s_filler_0__LINE__ ( "HiMixingModule"  )

static

s_maker__LINE__()

static const edm::MakerPluginFactory ::PMaker< edm::WorkerMaker< HiMixingModule > > edm::s_maker__LINE__ ( "HiMixingModule"  )

static

search_all()

template<typename ForwardSequence , typename Datum >

bool edm::search_all ( ForwardSequence const &  s, Datum const &  d  )

inline

Definition at line 36 of file Algorithms.h.

References ztail::d, spr::find(), and alignCSCRings::s.

Referenced by edm::eventsetup::EventSetupRecordProvider::add(), edm::WorkerManager::addToAllWorkers(), edm::service::ThreadSafeLogMessageLoggerScribe::configure_statistics(), edm::StreamSchedule::fillWorkers(), edm::service::TriggerNamesService::getTrigPaths(), edm::Schedule::limitOutput(), edm::MainParameterSet::MainParameterSet(), and public_base_classes().

                                                                   {
    return std::find(s.begin(), s.end(), d) != s.end();
  }

search_if_in_all()

template<typename ForwardSequence , typename Predicate >

bool edm::search_if_in_all ( ForwardSequence const &  s, Predicate const &  p  )

inline

Definition at line 52 of file Algorithms.h.

References AlCaHLTBitMon_ParallelJobs::p, and alignCSCRings::s.

                                                                             {
    return std::find_if(s.begin(), s.end(), p) != s.end();
  }

second()

template<typename T , typename U >

U edm::second

(

std::pair< T, U > const &

p

)

Definition at line 222 of file ParameterSet.cc.

References AlCaHLTBitMon_ParallelJobs::p.

Referenced by FilterOR::accept(), HGCDigitizer::accumulate(), CaloTruthAccumulator::accumulateEvent(), MtdTruthAccumulator::accumulateEvent(), TkTrackingRegionsMargin< float >::add(), FWTrackHitsDetailView::addModules(), FWConvTrackHitsDetailView::addModules(), PrintGeomSummary::addName(), BaseProtonTransport::addPartToHepMC(), Hector::addPartToHepMC(), SurveyInputTrackerFromDB::addSurveyInfo(), SurveyMisalignmentInput::addSurveyInfo(), gen::EvtGenInterface::addToHepMC(), algorithm(), EcalPreshowerGeometry::alignmentTransformIndexLocal(), PFCandConnector::analyseNuclearWPrim(), PFCandConnector::analyseNuclearWSec(), SiStripDetVOffHandler::analyze(), RPCGeometryServTest::analyze(), DTOccupancyEfficiency::analyze(), EcalDQMonitorTask::analyze(), L1TGlobalSummary::analyze(), edmtest::AssociationMapAnalyzer::analyze(), DTPreCalibrationTask::analyze(), BxTiming::analyze(), DTNoiseCalibration::analyze(), HcalQIEDataCheck::analyze(), HGCalTestGuardRing::analyze(), HcalPedestalWidthsCheck::analyze(), MuonPathConfirmator::analyze(), DTNoiseTask::analyze(), HeavyFlavorValidation::analyze(), HcalRaddamMuon::analyze(), L1TRPCTPG::analyze(), l1t::GtRecordDump::analyze(), HLTScalers::analyze(), HcalHBHEMuonAnalyzer::analyze(), DTDigiTask::analyze(), HLTExoticaSubAnalysis::analyze(), EcalSelectiveReadoutValidation::analyzeEB(), EcalSelectiveReadoutValidation::analyzeEE(), CaloSimHitAnalysis::analyzeHits(), L1GtAnalyzer::analyzeL1GtUtilsCore(), SiStripBadAPVAlgorithmFromClusterOccupancy::AnalyzeOccupancy(), SiStripBadAPVandHotStripAlgorithmFromClusterOccupancy::AnalyzeOccupancy(), HGCalTBAnalyzer::analyzeRecHits(), HGCalTimingAnalyzer::analyzeSimHits(), HGCalTB23Analyzer::analyzeSimHits(), HGCalTBAnalyzer::analyzeSimHits(), HcalHBHEMuonHighEtaAnalyzer::analyzeTracks(), SurveyDataConverter::applyFineSurveyInfo(), ticl::assignPCAtoTracksters(), TrackerHitAssociator::associateHit(), L1GtTriggerMenuTester::associateL1SeedsHltPath(), VertexAssociatorByPositionAndTracks::associateRecoToSim(), TSToSimTSHitLCAssociatorByEnergyScoreImpl::associateRecoToSim(), TrackAssociatorByChi2Impl::associateRecoToSim(), VertexAssociatorByPositionAndTracks::associateSimToReco(), TSToSimTSHitLCAssociatorByEnergyScoreImpl::associateSimToReco(), cms::alpakatools::AtomicPairCounter::AtomicPairCounter(), JetHtPlotConfiguration::autoExpandEnvironmentVariables(), Tracker_OldtoNewConverter::beginJob(), GctFormatTranslateV35::blockToRctEmCand(), GctFormatTranslateV38::blockToRctEmCand(), GctFormatTranslateMCLegacy::blockToRctEmCand(), SiStripGainFromCalibTree::bookDQMHistos(), QIE11Task::bookHistograms(), BxTiming::bookHistograms(), SiStripGainsCalibTreeWorker::bookHistograms(), SiStripGainsPCLWorker::bookHistograms(), CSCGeometryParsFromDD::build(), RunRangeDependentPedeLabeler::buildRunRangeDependencyMap(), SeedFromGenericPairOrTriplet::buildSeed(), CocoaUnitDefinition::BuildUnitsTable(), ALIUnitDefinition::BuildUnitsTable(), CSCEventData::calcALCTcrc(), FWInvMassDialog::Calculate(), JetPartonMatching::calculate(), ClusterShapeAlgo::Calculate_Covariances(), ClusterShapeAlgo::Calculate_e3x2(), ClusterShapeAlgo::Calculate_e3x3(), ClusterShapeAlgo::Calculate_e4x4(), ClusterShapeAlgo::Calculate_e5x5(), MultipleAlgoIterator::calculatePedestal(), ReflectedIterator::calculatePedestal(), PileUpSubtractor::calculatePedestal(), PedeLabelerBase::calibrationParamFromLabel(), cert_plot(), GEMCSCSegAlgoRR::chainHitsToSegm(), HiggsValidation::MonitoredDecays::channel(), checkForModuleDependencyCorrectness(), AlignmentTwoBodyDecayTrackSelector::checkMETMass(), OniaPhotonConversionProducer::checkTkVtxCompatibility(), IsoTrig::chgIsolation(), SiStripAPVRestorer::cleaner_LocalMinimumAdder(), SiStripAPVRestorer::cleaner_MonotonyChecker(), PFMuonAlgo::cleanPunchThroughAndFakes(), TrackCleaner::cleanTracks(), PixelTrackCleanerBySharedHits::cleanTracks(), EcalClusterToolsT< noZS >::cluster2ndMoments(), SimplePlan1RechitCombiner::combine(), AlignableObjectId::commonGeometry(), AlignableObjectId::commonObjectIdProvider(), L1MuGMTExtendedCand::compareRank(), L1TLSBlock::computeErrorFromRange(), GaussianSumUtilities1D::computeMode(), SiStripFecCabling::connections(), DDHGCalTBModuleX::constructBlocks(), DDHCalBarrelAlgo::constructGeneralVolume(), DDHCalEndcapAlgo::constructGeneralVolume(), DDHCalBarrelAlgo::constructInsideDetectors(), DDHCalBarrelAlgo::constructInsideLayers(), DDHCalEndcapModuleAlgo::constructInsideModule(), DDHCalEndcapAlgo::constructInsideModule(), DDHCalEndcapModuleAlgo::constructInsideModule0(), DDHCalEndcapAlgo::constructInsideModule0(), DDHCalBarrelAlgo::constructInsideSector(), DDHCalEndcapAlgo::constructInsideSector(), DDAHcalModuleAlgo::constructLayers(), DDHGCalTBModule::constructLayers(), DDHGCalTBModuleX::constructLayers(), DDHGCalModule::constructLayers(), DDHGCalModuleAlgo::constructLayers(), DDHGCalEEAlgo::constructLayers(), DDHGCalHEAlgo::constructLayers(), DDHGCalHEFileAlgo::constructLayers(), DDHGCalEEFileAlgo::constructLayers(), DDHGCalMixLayer::constructLayers(), DDHGCalSiliconModule::constructLayers(), DDHGCalMixRotatedCassette::constructLayers(), DDHGCalMixRotatedLayer::constructLayers(), DDHGCalSiliconRotatedCassette::constructLayers(), DDHGCalSiliconRotatedModule::constructLayers(), DDHCalBarrelAlgo::constructMidLayer(), DDHCalEndcapModuleAlgo::constructScintLayer(), DDHCalEndcapAlgo::constructScintLayer(), DDHCalBarrelAlgo::constructSideLayer(), SiPixelStatusHarvester::constructTag(), CaloTowersCreationAlgo::convert(), GctFormatTranslateV35::convertBlock(), GctFormatTranslateMCLegacy::convertBlock(), GctFormatTranslateV38::convertBlock(), convertHB(), FFTJetCorrectorSequence< Jet, InitialConverter, FinalConverter >::correct(), MuonPathAssociator::correlateMPaths(), LatencyHistosUsingDb::create(), PFAlgo::createCandidatesHCAL(), PFCand_AssoMapAlgos::createMappings(), PF_PU_AssoMapAlgos::createMappings(), HFSimpleTimeCheck::determineAnodeStatus(), Phase2TrackerDigitizerAlgorithm::digitize(), SurveyPxbDicer::doDice(), HLTTauRefProducer::doPFTaus(), VectorDoublet< Vector3D, Vector3D >::dot(), SiPixelStatusHarvester::dqmEndRun(), AlcaBeamMonitor::dqmEndRun(), drawMap(), DTSC::DTSectCollsort2(), MuScleFit::duringFastLoop(), ZeeCalibration::duringLoop(), EcalClusterToolsT< noZS >::e2nd(), EcalDQMonitorTask::EcalDQMonitorTask(), EcalClusterToolsT< noZS >::eMax(), edm::service::ELoutput::emitToken(), iterator_pair_as_a_range< I >::end(), DTT0Calibration::endJob(), SplitVertexResolution::endJob(), GeneralPurposeTrackAnalyzer::endJob(), DMRChecker::endJob(), AlcaBeamMonitorClient::endRun(), cond::serialization::equal(), cond::serialization::access< T, typename std::enable_if< std::is_integral< T >::value or std::is_enum< T >::value >::type >::equal_(), cond::serialization::access< T, typename std::enable_if< std::is_floating_point< T >::value >::type >::equal_(), cond::serialization::access< std::string >::equal_(), cond::serialization::access< std::bitset< N > >::equal_(), cond::serialization::access< std::pair< T, U > >::equal_(), cond::serialization::equal_tuple< N, Ts >::equal_(), cond::serialization::access< std::tuple< Ts... > >::equal_(), cond::serialization::access< T, typename std::enable_if< std::is_pointer< T >::value >::type >::equal_(), cond::serialization::access< T[N]>::equal_(), cond::serialization::access< std::array< T, N > >::equal_(), cond::serialization::access< std::forward_list< T > >::equal_(), HGCGuardRing::exclude(), trklet::MatchEngine::execute(), DDHGCalCell::execute(), DDHGCalWafer8::execute(), DDTOBRodAlgo::execute(), DDTrackerXYZPosAlgo::execute(), DDTrackerZPosAlgo::execute(), DDTIDModulePosAlgo::execute(), trklet::MatchCalculator::execute(), DDHGCalPassivePartial::execute(), DDHGCalWaferP::execute(), DDTrackerAngular::execute(), DDTrackerLinear::execute(), DDTrackerPhiAlgo::execute(), DDTrackerPhiAltAlgo::execute(), DDHGCalWaferPartialRotated::execute(), DDTIDRingAlgo::execute(), trklet::MatchProcessor::execute(), DDHCalLinearXY::execute(), DDHGCalPassiveFull::execute(), DDPixFwdDiskAlgo::execute(), DDTECOptoHybAlgo::execute(), DDTECPhiAlgo::execute(), DDTECPhiAltAlgo::execute(), DDTIDAxialCableAlgo::execute(), DDTIDModuleAlgo::execute(), DDTOBRadCableAlgo::execute(), DDTOBAxCableAlgo::execute(), DDRPDPosition::execute(), DDPixPhase1FwdDiskAlgo::execute(), trklet::PurgeDuplicate::execute(), DDHGCalWaferF::execute(), DDHGCalWaferFullRotated::execute(), DDHCalTBZposAlgo::execute(), DDPixBarLayerAlgo::execute(), DDPixBarLayerUpgradeAlgo::execute(), DDTIBLayerAlgo::execute(), DDBHMAngular::execute(), DDHCalForwardAlgo::execute(), DDTECCoolAlgo::execute(), DDHCalTBCableAlgo::execute(), DDHCalFibreBundle::execute(), DDTECModuleAlgo::execute(), DDPixFwdBladesNew::execute(), DDTrackerIrregularRingAlgo::execute(), DDTrackerRingAlgo::execute(), DDPixFwdBlades::execute(), CommissioningHistograms::extractHistograms(), TrackTimeValueMapProducer::extractTrackVertexTime(), PropagateToMuon::extrapolate(), BPHWriteSpecificDecay::fill(), templateHelper::SiPixelTemplateHeaderInfo< PayloadType, StoreType, TransientType, myType, myParam >::fill(), SiPixelGainCalibrationReadDQMFile::fillDatabase(), SiPixelGainCalibrationRejectNoisyAndDead::fillDatabase(), GenParticleProducer::fillDaughters(), DTLocalTriggerTest::fillGlobalSummary(), edm::RootFile::fillIndexIntoFile(), EcalEBPhase2TrigPrimAlgo::fillMap(), EcalEBTrigPrimTestAlgo::fillMap(), EcalTrigPrimFunctionalAlgo::fillMap(), SiStripCMMonitorPlugin::fillMaps(), SiStripNoisesDQM::fillMEsForLayer(), SiStripLorentzAngleDQM::fillMEsForLayer(), SiStripPedestalsDQM::fillMEsForLayer(), SiStripQualityDQM::fillMEsForLayer(), SiStripThresholdDQM::fillMEsForLayer(), SiStripApvGainsDQM::fillMEsForLayer(), SiStripBackPlaneCorrectionDQM::fillMEsForLayer(), SiPixelUtility::fillPaveText(), RunDCSHVDat::fillTheMapByTime(), ttbarEventSelector::filter(), JetHTJetPlusHOFilter::filter(), CSCDigiValidator::filter(), Hector::filterD1(), Hector::filterFP420(), Hector::filterZDC(), MtdTruthAccumulator::finalizeEvent(), mkfit::MkBuilder::find_tracks_in_layers(), Phase2L1GMT::Tauto3Mu::FindCloset3Mu(), EcalTBCrystalMap::findCrystalAngles(), MaterialBudgetVolume::findLV(), HoughGrouping::findTheMaxima(), mkfit::MkBuilder::findTracksStandard(), SymmetryFit::findUsableMinMax(), CosmicMuonSmoother::fit(), KFTrajectoryFitter::fitOne(), JetCoreClusterSplitter::fittingSplit(), alpgen::fixEventHiggsTTbar(), alpgen::fixEventSingleTop(), alpgen::fixEventTTbar(), NuclearTester::fwdEstimate(), SiStripApvGainFromFileBuilder::gain_from_maps(), SiStripGainsPCLHarvester::gainQualityMonitor(), DTMeantimerPatternReco::geometryFilter(), edm::RangeMap< det_id_type, edm::OwnVector< B > >::get(), DTTPGParameters::get(), DTLVStatus::get(), DTRangeT0::get(), DTHVStatus::get(), edm::helper::IndexRangeAssociation::get(), DTTtrig::get(), DTDeadFlag::get(), DTMtime::get(), DTStatusFlag::get(), DTPerformance::get(), GctFormatTranslateBase::getBlockDescription(), CalibrationInterface< T, CO >::getCalibData(), lumi::fPoly::getCorrection(), SiStripPsuDetIdMap::getDcuId(), SiStripPsuDetIdMap::getDetectorLocation(), hcaldqm::quantity::getEid_FED(), hcaldqm::quantity::getEid_FEDuTCA(), l1t::L1TGlobalUtil::getFinalDecisionByBit(), l1t::L1TGlobalUtil::getFinalDecisionByName(), LMFCorrCoefDat::getFlag(), metsig::SignAlgoResolutions::getfunc(), l1t::L1TGlobalUtil::getInitialDecisionByBit(), l1t::L1TGlobalUtil::getInitialDecisionByName(), l1t::L1TGlobalUtil::getIntermDecisionByBit(), l1t::L1TGlobalUtil::getIntermDecisionByName(), trklet::PurgeDuplicate::getInventedCoords(), trklet::PurgeDuplicate::getInventedCoordsExtended(), trklet::PurgeDuplicate::getInventedSeedingStub(), EcalLaserDbService::getLaserCorrection(), HcalLayerDepthMap::getLayerDepth(), G4muDarkBremsstrahlungModel::GetMadgraphData(), l1t::L1TGlobalUtil::getMaskByBit(), l1t::L1TGlobalUtil::getMaskByName(), PileUpSubtractor::getMeanAtTower(), FillInfoPopConSourceHandler::getNewObjects(), trigger::TriggerEventWithRefs::getObjects(), HcalDDDRecConstants::getOneEtaBin(), LMFRunIOV::getParameters(), HcalDDDSimConstants::getPhis(), HcalDDDRecConstants::getPhis(), PileUpSubtractor::getPileUpAtTower(), l1t::L1TGlobalUtil::getPrescaleByBit(), l1t::L1TGlobalUtil::getPrescaleByName(), SimpleL1MuGMTCand::getRank(), OMTFConfiguration::getRegionNumberFromMap(), HcalDDDRecConstants::getRZ(), LMFCorrCoefDat::getSeqID(), LMFCorrCoefDat::getSequence(), PileUpSubtractor::getSigmaAtTower(), RPCSeedPattern::getSpecialAlgorithmErrorMatrix(), SiStripBaseCondObjDQM::getSummaryMEs(), HcalDDDRecConstants::getThickActive(), ZIterativeAlgorithmWithFit::getWeight(), hgcal::ClusterTools::getWidths(), AlcaBeamMonitor::globalEndLuminosityBlock(), HcalPiecewiseLinearFunctor::HcalPiecewiseLinearFunctor(), HcalTopology::HcalTopology(), HGCalPassivePartial::HGCalPassivePartial(), PixelTripletLargeTipGenerator::hitTriplets(), HLTCommonConfig::HLTCommonConfig(), HLTEgammaEtFilterPairs::hltFilter(), HLTJetSortedVBFFilter< T >::hltFilter(), SimTrackManager::idSavedTrack(), L1MuGMTLUT::Init(), init_filter(), HcalDDDRecConstants::initialize(), L1GtUtils::LogicalExpressionL1Results::initialize(), edm::ParentageRegistry::insertMapped(), TRange< int >::inside(), muonisolation::Range< float >::inside(), PixelRecoRange< float >::inside(), HGCGuardRing::insidePolygon(), EcalTBDaqFormatter::interpretRawData(), EcalTB07DaqFormatter::interpretRawData(), APVCyclePhaseProducerFromL1TS::isBadRun(), TtGenEvent::isFullLeptonic(), GEMSegmentAlgorithm::isGoodToMerge(), AntiElectronIDCut2::isInEcalCrack(), RPCFw::isMajor(), MuonPathAssociator::isNotAPrimo(), CSCDDUMap::item(), CSCChamberMap::item(), CSCCrateMap::item(), TtEvent::jetLeptonCombination(), L1GtUtils::LogicalExpressionL1Results::l1Results(), HcalIndexLookup::largestIndex(), fftjetcms::LinInterpolatedTable1D::LinInterpolatedTable1D(), TmpSimEvent::load(), dqmservices::DQMFileIterator::LumiEntry::load_json(), dqmservices::DQMFileIterator::EorEntry::load_json(), CalorimetryManager::loadFromEcalBarrel(), CalorimetryManager::loadFromEcalEndcap(), CalorimetryManager::loadFromHcal(), HcalFlexiHardcodeGeometryLoader::makeHECells(), HGCalDDDConstants::maskCell(), match(), cms::DDFilteredView::match(), JetPartonMatching::matchingPtOrderedMinDist(), TRange< int >::max(), muonisolation::Range< float >::max(), PixelRecoRange< float >::max(), TRange< int >::mean(), PixelRecoRange< float >::mean(), muonisolation::Range< float >::mean(), lhef::LHEReader::next(), Quantile::next(), MultipleAlgoIterator::offsetCorrectJets(), ReflectedIterator::offsetCorrectJets(), PileUpSubtractor::offsetCorrectJets(), DDValuePair::operator const double &(), DDValuePair::operator double &(), PhysicsTools::AtomicId::operator!=(), CastorDbASCIIIO::DetIdLess::operator()(), Cluster1DMerger< T >::operator()(), pixeltemp::Cluster1DMerger< reco::Track >::operator()(), CheckHitPattern::operator()(), CastorDbASCIIIO::CastorElectronicsIdLess::operator()(), reco::tau::RecoTauPiZeroStripPlugin::operator()(), reco::tau::RecoTauPiZeroStripPlugin2::operator()(), reco::tau::RecoTauPiZeroStripPlugin3::operator()(), L1MuDTEUX::EUX_Comp::operator()(), L1MuBMEUX::EUX_Comp::operator()(), PhysicsTools::AtomicId::operator<(), operator<<(), PhysicsTools::AtomicId::operator<=(), PhysicsTools::AtomicId::operator==(), PhysicsTools::AtomicId::operator>(), PhysicsTools::AtomicId::operator>=(), ClusterClusterMapping::overlap(), CovarianceParameterization::pack(), cms::alpakatools::AtomicPairCounter::pack(), reco::modules::TrackerTrackHitFilter::parseStoN(), PartitionGenerator::partitions(), L1MuBMAssignmentUnit::PhiAU(), L1MuDTAssignmentUnit::PhiAU(), PhiBorderFinder::PhiBorderFinder(), MuonG4Numbering::PhysicalVolumeToBaseNumber(), HiggsValidation::MonitoredDecays::position(), SiStripRegionCabling::position(), DDHGCalHEAlgo::positionMix(), DDHGCalHEFileAlgo::positionMix(), DDHGCalMixLayer::positionMix(), DDHGCalMixRotatedCassette::positionMix(), DDHGCalMixRotatedLayer::positionMix(), DDHGCalSiliconRotatedCassette::positionPassive(), DDAHcalModuleAlgo::positionSensitive(), DDHGCalTBModule::positionSensitive(), DDHGCalEEAlgo::positionSensitive(), DDHGCalTBModuleX::positionSensitive(), DDHGCalEEFileAlgo::positionSensitive(), DDHGCalSiliconModule::positionSensitive(), DDHGCalSiliconRotatedCassette::positionSensitive(), DDHGCalSiliconRotatedModule::positionSensitive(), DDHGCalHEAlgo::positionSensitive(), DDHGCalHEFileAlgo::positionSensitive(), Quantile::prev(), TtFullLeptonicEvent::print(), TrackerHitAssociator::printDetBnchEvtTrk(), edm::PluginDescription< T >::printNestedContent_(), PixelTemplateSmearerBase::process(), hcalCalib::Process(), cscdqm::EventProcessor::processCSC(), DDLSpecPar::processElement(), DDLNumeric::processElement(), TTTrackAssociator< T >::produce(), PATTauIDEmbedder::produce(), TtFullLepKinSolutionProducer::produce(), PATTauHybridProducer::produce(), CandOneToManyDeltaRMatcher::produce(), PFConversionProducer::produce(), HcalRawToDigi::produce(), PFTrackProducer::produce(), EgammaHLTEleL1TrackIsolProducer::produce(), DTFakeT0ESProducer::produce(), L1ExtraParticleMapProd::produce(), TtbarTrackProducer::produce(), SimTrackstersProducer::produce(), PF_PU_FirstVertexTracks::produce(), RunManagerMTWorker::produce(), JetPlusTrackProducerAA::produce(), PFCand_NoPU_WithAM::produce(), HLTScoutingMuonProducer::produce(), TPStubValueMapProducer::produce(), pat::PATTauProducer::produce(), HFPreReconstructor::produce(), PixelJetPuId::produce(), reco::PhysObjectMatcher< C1, C2, S, D, Q >::produce(), BoostedDoubleSVProducer::produce(), BTagProbabilityToDiscriminator::produce(), NuclearTrackCorrector::produce(), AlCaHcalHBHEMuonProducer::produce(), L1TCorrelatorLayer1Producer::produce(), GsfElectronProducer::produce(), L1MuDTTrack::rank(), L1MuBMTrack::rank(), L1MuGMTExtendedCand::rankRef(), emtf::Forest::rankVariables(), RBorderFinder::RBorderFinder(), RunSummaryRead::readData(), L1TriggerScalerRead::readData(), SiStripDetVOffBuilder::readLastValueFromFile(), FedRawDataInputSource::readWorker(), DAQSource::readWorker(), RealQuadEquation::RealQuadEquation(), GroupedDAFHitCollector::recHits(), CSCEfficiency::recHitSegment_Efficiencies(), CSCEfficiency::recSimHitEfficiency(), SiStripDetVOffBuilder::reduce(), SiStripDetVOffBuilder::reduction(), CandidateSeededTrackingRegionsProducer::regions(), PointSeededTrackingRegionsProducer::regions(), L1MuonSeededTrackingRegionsProducer::regions(), jsoncollector::FastMonitor::registerGlobalMonitorable(), MuonPathAssociator::removeSharingFits(), L1GtUtils::LogicalExpressionL1Results::reset(), l1t::L1TGlobalUtil::resetDecisionVectors(), L1TOccupancyClientHistogramService::resetHisto(), l1t::L1TGlobalUtil::resetPrescaleVectors(), l1t::L1TGlobalUtil::retrieveL1Event(), l1t::L1TGlobalUtil::retrieveL1Setup(), TkTrackingRegionsMargin< float >::right(), EcalClusterToolsT< noZS >::roundnessBarrelSuperClusters(), EcalClusterToolsT< noZS >::roundnessBarrelSuperClustersUserExtended(), reco::modules::TrackerTrackHitFilter::Rule::Rule(), PixelCPEClusterRepair::Rule::Rule(), EcalEBTrigPrimTestAlgo::run(), DTTSS::run(), EcalEBPhase2TrigPrimAlgo::run(), DTTSM::run(), DTSC::run(), MillePedeAlignmentAlgorithm::run(), EcalTrigPrimFunctionalAlgo::run_part2(), DTLocalTriggerLutTest::runClientDiagnostic(), DTTriggerEfficiencyTest::runClientDiagnostic(), SortCollectionSelector< InputCollection, Comparator, OutputCollection, StoreContainer, RefAdder >::select(), FWTableView::selectCollection(), MuScleFit::selectMuons(), PhotonConversionTrajectorySeedProducerFromSingleLegAlgo::selectPriVtxCompatibleWithTrack(), DTLVStatus::set(), DTTPGParameters::set(), DTRangeT0::set(), DTHVStatus::set(), DTTtrig::set(), DTDeadFlag::set(), DTStatusFlag::set(), DTMtime::set(), DTPerformance::set(), TrackInformation::setCrossedBoundary(), EcalDeadCellTriggerPrimitiveFilter::setEvtRecHitstatus(), FWEventItemsManager::setFrom(), InitialGrouping::setInChannels(), TrapezoidalGrouping::setInChannels(), DDLSolid::setReference(), ShallowTree::ShallowTree(), ConvBremSeedProducer::sharedHits(), MuonPathAssociator::shareFit(), muonisolation::Range< float >::sort(), PixelRecoRange< float >::sort(), TRange< int >::sort(), edm::OneToManyWithQualityGeneric< TrackingVertexCollection, edm::View< reco::Vertex >, double, unsigned int >::sort(), PF_PU_AssoMapAlgos::SortAssociationMap(), PFCand_AssoMapAlgos::SortPFCandAssociationMap(), DTTSM::sortTSM2(), DTTSS::sortTSS2(), DAClusterizerInZ_vect::split(), DAClusterizerInZT_vect::split(), CombinationGenerator< T >::splitInTwoCollections(), trklet::MatchEngineUnit::step(), AlCaHcalIsotrkProducer::storeEnergy(), L1MuGMTLUT::PortDecoder::str(), StringBasedNTupler::StringBasedNTupler(), RPCDigiL1Link::strip(), StripCPE::StripCPE(), magneticfield::MagGeoBuilder::summary(), MagGeoBuilderFromDDD::summary(), PixelRecoRange< float >::swap(), trigger::swap(), CompositeLogicalTrajectoryFilter::TBC(), TwoBodyDecayTrajectoryFactory::trajectories(), L3MuonTrajectoryBuilder::trajectories(), GsfTrajectorySmoother::trajectory(), CovarianceParameterization::unpack(), LatencyHistosUsingDb::update(), MonopoleSteppingAction::update(), SiTrackerMultiRecHitUpdator::update(), viewNameFrom(), HGCalDDDConstants::waferType(), HGCalDDDConstants::waferTypeRotation(), HGCalWaferMask::waferXY(), WeightedMeanFitter::weightedMeanOutlierRejection(), WeightedMeanFitter::weightedMeanOutlierRejectionBeamSpot(), MuonAssociatorByHitsHelper::write_matched_simtracks(), trklet::TrackletConfigBuilder::writeASMemories(), trklet::TrackletConfigBuilder::writeILMemories(), VirtualJetProducer::writeJets(), trklet::TrackletConfigBuilder::writeSPMemories(), and trklet::VMProjectionsMemory::writeVMPROJ().

                                   {
    return p.second;
  }

separator()

static std::string const edm::separator ( ":"  )

static

Referenced by edm::InputTag::encode(), edm::InputTag::InputTag(), and tokenize().

setIsMergeable()

void edm::setIsMergeable

(

BranchDescription &

desc

)

Definition at line 15 of file setIsMergeable.cc.

References edm::TypeWithDict::byName(), submitPVResolutionJobs::desc, edm::TypeWithDict::getClass(), InLumi, InRun, hltrates_dqm_sourceclient-live_cfg::offset, or, and AlCaHLTBitMon_ParallelJobs::p.

Referenced by edm::ProductRegistryHelper::addToRegistry(), edm::Schedule::finishSetup(), edm::RootFile::RootFile(), TFWLiteSelectorBasic::setupNewFile(), and ProvenanceDumper::work_().

                                               {
    // Save some time here with the knowledge that the isMergeable
    // data member can only be true for run or lumi products.
    // It defaults to false. Also if it is true that means it
    // was already set.
    // Set it only for branches that are present
    if (desc.present() and (desc.branchType() == InRun or desc.branchType() == InLumi)) {
      if (!desc.isMergeable()) {
        TClass* wrapperBaseTClass = TypeWithDict::byName("edm::WrapperBase").getClass();
        TClass* tClass = desc.wrappedType().getClass();
        void* p = tClass->New();
        int offset = tClass->GetBaseClassOffset(wrapperBaseTClass);
        std::unique_ptr<WrapperBase> wrapperBase = getAnyPtr<WrapperBase>(p, offset);
        if (wrapperBase->isMergeable()) {
          desc.setIsMergeable(true);
        }
      }
    }
  }

setMaxLoggedErrorsSummaryIndicies()

void edm::setMaxLoggedErrorsSummaryIndicies

(

unsigned int

iMax

)

Definition at line 187 of file MessageSender.cc.

References errorSummaryMaps.

Referenced by edm::service::MessageLogger::MessageLogger().

{ errorSummaryMaps.resize(iMax); }

setNThreads()

unsigned int edm::setNThreads	(	unsigned int	iNThreads,
		unsigned int	iStackSize,
		std::unique_ptr< ThreadsController > &	oPtr
	)

Definition at line 11 of file setNThreads.cc.

                                                                                                                    {
    //stack size is given in KB but passed in as bytes
    iStackSize *= 1024;

    oPtr.reset();
    if (0 == iNThreads) {
      //Allow TBB to decide how many threads. This is normally the number of CPUs in the machine.
      iNThreads = oneapi::tbb::this_task_arena::max_concurrency();
    }
    oPtr = std::make_unique<ThreadsController>(static_cast<int>(iNThreads), iStackSize);

    return iNThreads;
  }

setPtr() [1/6]

template<typename T , typename A >

void edm::setPtr	(	std::vector< T, A > const &	obj,
		std::type_info const &	iToType,
		unsigned long	iIndex,
		void const *&	oPtr
	)

Definition at line 67 of file setPtr.h.

References getGTfromDQMFile::obj, and edm::detail::reallySetPtr().

                                                                                                                {
    detail::reallySetPtr(obj, iToType, iIndex, oPtr);
  }

setPtr() [2/6]

template<typename T , typename A >

void edm::setPtr	(	std::list< T, A > const &	obj,
		std::type_info const &	iToType,
		unsigned long	iIndex,
		void const *&	oPtr
	)

Definition at line 72 of file setPtr.h.

References getGTfromDQMFile::obj, and edm::detail::reallySetPtr().

                                                                                                              {
    detail::reallySetPtr(obj, iToType, iIndex, oPtr);
  }

setPtr() [3/6]

template<typename T , typename A >

void edm::setPtr	(	std::deque< T, A > const &	obj,
		std::type_info const &	iToType,
		unsigned long	iIndex,
		void const *&	oPtr
	)

Definition at line 77 of file setPtr.h.

References getGTfromDQMFile::obj, and edm::detail::reallySetPtr().

                                                                                                               {
    detail::reallySetPtr(obj, iToType, iIndex, oPtr);
  }

setPtr() [4/6]

template<typename T , typename A , typename Comp >

void edm::setPtr	(	std::set< T, A, Comp > const &	obj,
		std::type_info const &	iToType,
		unsigned long	iIndex,
		void const *&	oPtr
	)

Definition at line 82 of file setPtr.h.

References getGTfromDQMFile::obj, and edm::detail::reallySetPtr().

                                                                                                                   {
    detail::reallySetPtr(obj, iToType, iIndex, oPtr);
  }

setPtr() [5/6]

template<typename T , typename SORT >

void edm::setPtr ( SortedCollection< T, SORT > const &  obj, std::type_info const &  toType, unsigned long  index, void const *&  ptr  )

inline

Definition at line 386 of file SortedCollection.h.

References getGTfromDQMFile::obj.

                                       {
    obj.setPtr(toType, index, ptr);
  }

setPtr() [6/6]

template<typename T , typename P >

void edm::setPtr ( OwnVector< T, P > const &  obj, std::type_info const &  toType, unsigned long  index, void const *&  ptr  )

inline

Definition at line 569 of file OwnVector.h.

References getGTfromDQMFile::obj.

                                                                                                                    {
    obj.setPtr(toType, index, ptr);
  }

setRefCoreStreamer() [1/2]

void edm::setRefCoreStreamer

(

bool

resetAll = false

)

Definition at line 83 of file RefCoreStreamer.cc.

References edm::EDProductGetter::switchProductGetter().

Referenced by edm::StreamerInputSource::deserializeEvent(), edm::RootDelayedReader::getProduct_(), and edm::RootOutputTree::writeTTree().

{ EDProductGetter::switchProductGetter(nullptr); }

setRefCoreStreamer() [2/2]

EDProductGetter const * edm::setRefCoreStreamer

(

EDProductGetter const *

ep

)

Definition at line 85 of file RefCoreStreamer.cc.

References SiStripBadComponentsDQMServiceTemplate_cfg::ep, and edm::EDProductGetter::switchProductGetter().

                                                                       {
    EDProductGetter const* returnValue = nullptr;
    if (ep != nullptr) {
      returnValue = edm::EDProductGetter::switchProductGetter(ep);
    }
    return returnValue;
  }

setRefCoreStreamerInTClass()

void edm::setRefCoreStreamerInTClass

(

)

Definition at line 68 of file RefCoreStreamer.cc.

Referenced by edm::service::InitRootHandlers::InitRootHandlers().

                                    {
    {
      TClass* tClass = TClass::GetClass("edm::RefCore");
      if (tClass->GetStreamer() == nullptr) {
        tClass->AdoptStreamer(new RefCoreStreamer());
      }
    }
    {
      TClass* tClass = TClass::GetClass("edm::RefCoreWithIndex");
      if (tClass->GetStreamer() == nullptr) {
        tClass->AdoptStreamer(new RefCoreWithIndexStreamer());
      }
    }
  }

setStandAloneMessageThreshold()

void edm::setStandAloneMessageThreshold

(

edm::messagelogger::ELseverityLevel const &

severity

)

Definition at line 68 of file MessageLogger.cc.

References ErrorSummaryFilter_cfi::severity, and edm::MessageLoggerQ::standAloneThreshold().

                                                                                      {
    edm::MessageLoggerQ::standAloneThreshold(severity);
  }

setThreadOptions()

void edm::setThreadOptions	(	ThreadsInfo const &	threadsInfo,
		edm::ParameterSet &	pset
	)

Definition at line 30 of file ThreadsInfo.cc.

References edm::ParameterSet::addUntrackedParameter(), edm::ThreadsInfo::nThreads_, muonDTDigis_cfi::pset, and edm::ThreadsInfo::stackSize_.

                                                                               {
    edm::ParameterSet newOp;
    if (pset.exists("options")) {
      newOp = pset.getUntrackedParameterSet("options");
    }
    newOp.addUntrackedParameter<unsigned int>("numberOfThreads", threadsInfo.nThreads_);
    newOp.addUntrackedParameter<unsigned int>("sizeOfStackForThreadsInKB", threadsInfo.stackSize_);
    pset.insertParameterSet(true, "options", edm::ParameterSetEntry(newOp, false));
  }

setupSiteLocalConfig()

ServiceRegistry::Operate edm::setupSiteLocalConfig

(

)

Definition at line 15 of file setupSiteLocalConfig.cc.

References edm::ServiceRegistry::createContaining(), eostools::move(), and edm::ServiceRegistry::Operate.

Referenced by main().

                                                {
    std::unique_ptr<edm::SiteLocalConfig> slcptr =
        std::make_unique<edm::service::SiteLocalConfigService>(edm::ParameterSet());
    auto slc = std::make_shared<edm::serviceregistry::ServiceWrapper<edm::SiteLocalConfig> >(std::move(slcptr));
    edm::ServiceToken slcToken = edm::ServiceRegistry::createContaining(slc);
    return edm::ServiceRegistry::Operate(slcToken);
  }

sigInventory()

void edm::sigInventory

(

)

Definition at line 135 of file UnixSignalHandlers.cc.

References DMR_cfg::cerr, dqmdumpme::k, and 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));
  }

sort_all() [1/2]

template<typename RandomAccessSequence >

void edm::sort_all ( RandomAccessSequence &  s )

inline

wrappers for std::sort

Definition at line 92 of file Algorithms.h.

References alignCSCRings::s, and jetUpdater_cfi::sort.

Referenced by CompareToObjectMapRecord::analyze(), edm::EventContentAnalyzer::EventContentAnalyzer(), CaloVNoiseSignalGenerator::fillDetIds(), edm::Schedule::fillModuleAndConsumesInfo(), edm::PoolOutputModule::fillSelectedItemList(), edm::SystemTimeKeeper::fillTriggerTimingReport(), edm::Schedule::getTriggerReport(), edm::ProductSelector::initialize(), edm::MixingModule::MixingModule(), ConvertObjectMapRecord::produce(), edm::RootOutputFile::RootOutputFile(), edm::ProductRegistry::setFrozen(), sortAndRemoveOverlaps(), ProvenanceDumper::work_(), and edmplugin::CacheParser::write().

                                                {
    std::sort(s.begin(), s.end());
  }

sort_all() [2/2]

template<typename RandomAccessSequence , typename Predicate >

void edm::sort_all ( RandomAccessSequence &  s, Predicate  p  )

inline

Definition at line 97 of file Algorithms.h.

References AlCaHLTBitMon_ParallelJobs::p, alignCSCRings::s, and jetUpdater_cfi::sort.

                                                             {
    std::sort(s.begin(), s.end(), p);
  }

sortAndRemoveOverlaps() [1/2]

std::vector< LuminosityBlockRange > & edm::sortAndRemoveOverlaps

(

std::vector< LuminosityBlockRange > &

lumiRange

)

Definition at line 89 of file LuminosityBlockRange.cc.

References MillePedeFileConverter_cfg::e, mps_fire::i, beamSpotPI::lumiRange, merge(), sort_all(), and mitigatedMETSequence_cff::U.

                                                                                                     {
    if (lumiRange.size() <= 1U)
      return lumiRange;
    sort_all(lumiRange, sortByStartLuminosityBlockID);
    for (std::vector<LuminosityBlockRange>::iterator i = lumiRange.begin() + 1, e = lumiRange.end(); i != e; ++i) {
      std::vector<LuminosityBlockRange>::iterator iprev = i - 1;
      if (merge(*iprev, *i)) {
        i = lumiRange.erase(iprev);
        e = lumiRange.end();
      }
    }
    return lumiRange;
  }

sortAndRemoveOverlaps() [2/2]

std::vector< EventRange > & edm::sortAndRemoveOverlaps

(

std::vector< EventRange > &

eventRange

)

Definition at line 98 of file EventRange.cc.

References MillePedeFileConverter_cfg::e, unittestinputsource_cfi::eventRange, mps_fire::i, sort_all(), and mitigatedMETSequence_cff::U.

Referenced by edm::service::CondorStatusService::beginPost(), and edm::EventSkipperByID::EventSkipperByID().

                                                                                  {
    if (eventRange.size() <= 1U)
      return eventRange;
    sort_all(eventRange, sortByStartEventIDSpecial);
    for (std::vector<EventRange>::iterator i = eventRange.begin() + 1, e = eventRange.end(); i != e; ++i) {
      std::vector<EventRange>::iterator iprev = i - 1;
      if (mergeSpecial(*iprev, *i)) {
        i = eventRange.erase(iprev);
        e = eventRange.end();
      }
    }
    return eventRange;
  }

source()

static std::string const edm::source ( "source"  )

static

Referenced by edm::PreMixingModule::doPileUp(), edm::DataMixingModule::doPileUp(), edm::MixingModule::doPileUp(), edm::eventsetup::EventSetupRecordImpl::EventSetupRecordImpl(), edm::InputSource::EventSourceSentry::EventSourceSentry(), edm::InputSource::FileCloseSentry::FileCloseSentry(), edm::InputSource::FileOpenSentry::FileOpenSentry(), edm::Guid::fromBinary(), edm::Guid::fromString(), edm::Guid::isValidString(), parameterSet(), edm::Principal::Principal(), and edm::RootFile::RootFile().

split() [1/2]

template<class OutIter >

bool edm::split	(	OutIter	result,
		std::string_view	string_to_split,
		char	first,
		char	sep,
		char	last
	)

Definition at line 70 of file split.h.

References b, contextual_find(), contextual_find_not(), mps_fire::dest, MillePedeFileConverter_cfg::e, dqmdumpme::first, dqmdumpme::last, and alignCSCRings::s.

Referenced by edm::ParameterSetConverter::convertParameterSets(), decode(), decode_deprecated(), and edm::VParameterSetEntry::VParameterSetEntry().

                                                                               {
  using str_c_iter = std::string_view::const_iterator;
  str_c_iter b = s.cbegin(), e = s.cend();

  if (static_cast<unsigned int>(e - b) < 2u)
    return false;

  if (*b == first)
    ++b;
  else
    return false;

  if (*--e != last)
    return false;

  // invariant:  we've found all items in [b..boi)
  for (str_c_iter  //boi = std::find_if(b, e, is_not_a(sep))
           boi = contextual_find_not(b, e, first, sep, last),
           eoi;
       boi != e
       //; boi = std::find_if(eoi, e, is_not_a(sep))
       ;
       boi = contextual_find_not(eoi, e, first, sep, last)) {
    // find end of current item:
    //eoi = std::find_if(boi, e, is_a(sep));
    eoi = contextual_find(boi, e, first, sep, last);

    // copy the item formed from characters in [boi..eoi):
    *dest++ = std::string_view(boi, eoi - boi);
  }  // for

  return true;
}  // split< >()

split() [2/2]

template<typename FUNC >

bool edm::split	(	std::string_view	string_to_split,
		char	first,
		char	sep,
		char	last,
		FUNC	f
	)

Definition at line 105 of file split.h.

References b, contextual_find(), contextual_find_not(), MillePedeFileConverter_cfg::e, f, dqmdumpme::first, dqmdumpme::last, and alignCSCRings::s.

                                                                         {
  using str_c_iter = std::string_view::const_iterator;
  str_c_iter b = s.cbegin(), e = s.cend();

  if (static_cast<unsigned int>(e - b) < 2u)
    return false;

  if (*b == first)
    ++b;
  else
    return false;

  if (*--e != last)
    return false;

  // invariant:  we've found all items in [b..boi)
  for (str_c_iter boi = contextual_find_not(b, e, first, sep, last), eoi; boi != e;
       boi = contextual_find_not(eoi, e, first, sep, last)) {
    // find end of current item:
    eoi = contextual_find(boi, e, first, sep, last);

    // copy the item formed from characters in [boi..eoi):
    if (not f(std::string_view(boi, eoi - boi))) {
      return false;
    }
  }  // for

  return true;
}  // split< >()

squelchStandAloneMessageCategory()

void edm::squelchStandAloneMessageCategory

(

std::string const &

category

)

Definition at line 71 of file MessageLogger.cc.

References validateAlignments::category, and edm::MessageLoggerQ::squelch().

{ edm::MessageLoggerQ::squelch(category); }

stable_sort_all() [1/2]

template<typename RandomAccessSequence >

void edm::stable_sort_all ( RandomAccessSequence &  s )

inline

wrappers for std::stable_sort

Definition at line 103 of file Algorithms.h.

References alignCSCRings::s.

Referenced by edm::RootFile::fillIndexIntoFile(), edm::IndexIntoFile::fillRunOrLumiIndexes(), edm::FileIndex::sortBy_Run_Lumi_Event(), edm::FileIndex::sortBy_Run_Lumi_EventEntry(), and edm::IndexIntoFile::sortVector_Run_Or_Lumi_Entries().

                                                       {
    std::stable_sort(s.begin(), s.end());
  }

stable_sort_all() [2/2]

template<typename RandomAccessSequence , typename Predicate >

void edm::stable_sort_all ( RandomAccessSequence &  s, Predicate  p  )

inline

Definition at line 108 of file Algorithms.h.

References AlCaHLTBitMon_ParallelJobs::p, and alignCSCRings::s.

                                                                    {
    std::stable_sort(s.begin(), s.end(), p);
  }

stemFromPath()

std::string_view edm::stemFromPath

(

std::string_view

path

)

Definition at line 4 of file stemFromPath.cc.

References castor_dqm_sourceclient_file_cfg::path.

Referenced by edm::RootFile::validateFile().

                                                   {
    auto begin = path.rfind('/');
    if (begin == std::string_view::npos) {
      begin = path.rfind(':');
      if (begin == std::string_view::npos) {
        // shouldn't really happen?
        begin = 0;
      } else {
        begin += 1;
      }
    } else {
      begin += 1;
    }
    auto end = path.find('.', begin);
    return path.substr(begin, end - begin);
  }

stripNamespace()

std::string edm::stripNamespace

(

std::string const &

theName

)

Definition at line 87 of file TypeID.cc.

References cms::cuda::assert(), HltBtagPostValidation_cff::c, and hcalRecHitTable_cff::depth.

Referenced by edm::TypeWithDict::byName(), and edm::TypeWithDict::unscopedName().

                                                     {
    // Find last colon
    std::string::size_type colonIndex = theName.rfind(':');
    if (colonIndex == std::string::npos) {
      // No colons, so no namespace to strip
      return theName;
    }
    std::string::size_type bracketIndex = theName.rfind('>');
    if (bracketIndex == std::string::npos || bracketIndex < colonIndex) {
      // No '>' after last colon.  Strip up to and including last colon.
      return theName.substr(colonIndex + 1);
    }
    // There is a '>' after the last colon.
    int depth = 1;
    for (size_t index = bracketIndex; index != 0; --index) {
      char c = theName[index - 1];
      if (c == '>') {
        ++depth;
      } else if (c == '<') {
        --depth;
        assert(depth >= 0);
      } else if (depth == 0 && c == ':') {
        return theName.substr(index);
      }
    }
    return theName;
  }

stripTemplate()

bool edm::stripTemplate

(

std::string &

theName

)

Definition at line 61 of file TypeID.cc.

References cms::cuda::assert(), first(), heavyIonCSV_trainingSettings::idx, and AlCaHLTBitMon_QueryRunRegistry::string.

Referenced by edm::TypeID::userClassName().

                                         {
    std::string const spec("<,>");
    char const space = ' ';
    std::string::size_type idx = theName.find_first_of(spec);
    if (idx == std::string::npos) {
      return false;
    }
    std::string::size_type first = 0;
    std::string::size_type after = idx;
    if (theName[idx] == '<') {
      after = theName.rfind('>');
      assert(after != std::string::npos);
      first = ++idx;
    } else {
      theName = theName.substr(0, idx);
    }
    std::string::size_type idxa = after;
    while (space == theName[--idxa])
      --after;
    std::string::size_type idxf = first;
    while (space == theName[idxf++])
      ++first;
    theName = theName.substr(first, after - first);
    return true;
  }

subProcessDoGlobalBeginTransitionAsync() [1/3]

template<typename T >

void edm::subProcessDoGlobalBeginTransitionAsync ( WaitingTaskHolder  iHolder, SubProcess &  iSubProcess, LumiTransitionInfo const &  iTransitionInfo, bool    )

inline

Definition at line 36 of file globalTransitionAsync.h.

References edm::SubProcess::doBeginLuminosityBlockAsync(), and eostools::move().

                                                           {
    iSubProcess.doBeginLuminosityBlockAsync(std::move(iHolder), iTransitionInfo);
  }

subProcessDoGlobalBeginTransitionAsync() [2/3]

template<typename T >

void edm::subProcessDoGlobalBeginTransitionAsync ( WaitingTaskHolder  iHolder, SubProcess &  iSubProcess, RunTransitionInfo const &  iTransitionInfo, bool    )

inline

Definition at line 44 of file globalTransitionAsync.h.

References edm::SubProcess::doBeginRunAsync(), and eostools::move().

                                                           {
    iSubProcess.doBeginRunAsync(std::move(iHolder), iTransitionInfo);
  }

subProcessDoGlobalBeginTransitionAsync() [3/3]

template<typename Traits >

void edm::subProcessDoGlobalBeginTransitionAsync ( WaitingTaskHolder  iHolder, SubProcess &  iSubProcess, ProcessBlockTransitionInfo const &  iTransitionInfo, bool  cleaningUpAfterException  )

inline

Definition at line 52 of file globalTransitionAsync.h.

References edm::SubProcess::doBeginProcessBlockAsync(), and eostools::move().

                                                                                    {
    iSubProcess.doBeginProcessBlockAsync<Traits>(std::move(iHolder), iTransitionInfo, cleaningUpAfterException);
  }

subProcessDoGlobalEndTransitionAsync() [1/3]

void edm::subProcessDoGlobalEndTransitionAsync ( WaitingTaskHolder  iHolder, SubProcess &  iSubProcess, LumiTransitionInfo const &  iTransitionInfo, bool  cleaningUpAfterException  )

inline

Definition at line 59 of file globalTransitionAsync.h.

References edm::SubProcess::doEndLuminosityBlockAsync(), and eostools::move().

Referenced by endGlobalTransitionAsync().

                                                                                  {
    iSubProcess.doEndLuminosityBlockAsync(std::move(iHolder), iTransitionInfo, cleaningUpAfterException);
  }

subProcessDoGlobalEndTransitionAsync() [2/3]

void edm::subProcessDoGlobalEndTransitionAsync ( WaitingTaskHolder  iHolder, SubProcess &  iSubProcess, RunTransitionInfo const &  iTransitionInfo, bool  cleaningUpAfterException  )

inline

Definition at line 66 of file globalTransitionAsync.h.

References edm::SubProcess::doEndRunAsync(), and eostools::move().

                                                                                  {
    iSubProcess.doEndRunAsync(std::move(iHolder), iTransitionInfo, cleaningUpAfterException);
  }

subProcessDoGlobalEndTransitionAsync() [3/3]

void edm::subProcessDoGlobalEndTransitionAsync ( WaitingTaskHolder  iHolder, SubProcess &  iSubProcess, ProcessBlockTransitionInfo const &  iTransitionInfo, bool  cleaningUpAfterException  )

inline

Definition at line 73 of file globalTransitionAsync.h.

References edm::SubProcess::doEndProcessBlockAsync(), and eostools::move().

                                                                                  {
    iSubProcess.doEndProcessBlockAsync(std::move(iHolder), iTransitionInfo, cleaningUpAfterException);
  }

subProcessDoStreamBeginTransitionAsync() [1/2]

void edm::subProcessDoStreamBeginTransitionAsync ( WaitingTaskHolder  iHolder, SubProcess &  iSubProcess, unsigned int  i, LumiTransitionInfo const &  iTransitionInfo  )

inline

Definition at line 33 of file streamTransitionAsync.h.

References edm::SubProcess::doStreamBeginLuminosityBlockAsync(), mps_fire::i, and eostools::move().

Referenced by beginStreamTransitionAsync().

                                                                                                {
    iSubProcess.doStreamBeginLuminosityBlockAsync(std::move(iHolder), i, iTransitionInfo);
  }

subProcessDoStreamBeginTransitionAsync() [2/2]

void edm::subProcessDoStreamBeginTransitionAsync ( WaitingTaskHolder  iHolder, SubProcess &  iSubProcess, unsigned int  i, RunTransitionInfo const &  iTransitionInfo  )

inline

Definition at line 40 of file streamTransitionAsync.h.

References edm::SubProcess::doStreamBeginRunAsync(), mps_fire::i, and eostools::move().

                                                                                               {
    iSubProcess.doStreamBeginRunAsync(std::move(iHolder), i, iTransitionInfo);
  }

subProcessDoStreamEndTransitionAsync() [1/2]

void edm::subProcessDoStreamEndTransitionAsync ( WaitingTaskHolder  iHolder, SubProcess &  iSubProcess, unsigned int  i, LumiTransitionInfo const &  iTransitionInfo, bool  cleaningUpAfterException  )

inline

Definition at line 47 of file streamTransitionAsync.h.

References edm::SubProcess::doStreamEndLuminosityBlockAsync(), mps_fire::i, and eostools::move().

Referenced by endStreamTransitionAsync().

                                                                                  {
    iSubProcess.doStreamEndLuminosityBlockAsync(std::move(iHolder), i, iTransitionInfo, cleaningUpAfterException);
  }

subProcessDoStreamEndTransitionAsync() [2/2]

void edm::subProcessDoStreamEndTransitionAsync ( WaitingTaskHolder  iHolder, SubProcess &  iSubProcess, unsigned int  i, RunTransitionInfo const &  iTransitionInfo, bool  cleaningUpAfterException  )

inline

Definition at line 55 of file streamTransitionAsync.h.

References edm::SubProcess::doStreamEndRunAsync(), mps_fire::i, and eostools::move().

                                                                                  {
    iSubProcess.doStreamEndRunAsync(std::move(iHolder), i, iTransitionInfo, cleaningUpAfterException);
  }

swap() [1/40]

void edm::swap ( ElementID &  a, ElementID &  b  )

inline

Definition at line 40 of file ElementID.h.

References a, and b.

{ a.swap(b); }

swap() [2/40]

void edm::swap ( ProductID &  a, ProductID &  b  )

inline

Definition at line 45 of file ProductID.h.

References a, and b.

{ a.swap(b); }

swap() [3/40]

void edm::swap ( OrphanHandleBase &  a, OrphanHandleBase &  b  )

inline

Definition at line 58 of file OrphanHandleBase.h.

References a, and b.

Referenced by edm::OrphanHandleBase::swap().

{ a.swap(b); }

swap() [4/40]

void edm::swap ( Parentage &  a, Parentage &  b  )

inline

Definition at line 61 of file Parentage.h.

References a, and b.

{ a.swap(b); }

swap() [5/40]

template<class T , class P >

void edm::swap ( CloningPtr< T, P > &  a, CloningPtr< T, P > &  b  )

inline

Definition at line 61 of file CloningPtr.h.

References a, and b.

Referenced by edm::CloningPtr< T, P >::swap().

                                                             {
    a.swap(b);
  }

swap() [6/40]

void edm::swap ( ProductData &  a, ProductData &  b  )

inline

Definition at line 76 of file ProductData.h.

References a, and b.

Referenced by edm::ProductData::swap().

{ a.swap(b); }

swap() [7/40]

void edm::swap ( TriggerResults &  lhs, TriggerResults &  rhs  )

inline

Definition at line 87 of file TriggerResults.h.

References edm::TriggerResults::swap().

{ lhs.swap(rhs); }

swap() [8/40]

template<class T >

void edm::swap ( RefToBaseVector< T > &  a, RefToBaseVector< T > &  b  )

inline

Definition at line 92 of file RefToBaseVector.h.

References a, and b.

Referenced by edm::RefToBaseVector< reco::Track >::operator=(), and edm::RefToBaseVector< reco::Track >::swap().

                                                                 {
    a.swap(b);
  }

swap() [9/40]

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

inline

Free swap function.

Definition at line 99 of file HLTGlobalStatus.h.

References edm::HLTGlobalStatus::swap().

{ lhs.swap(rhs); }

swap() [10/40]

void edm::swap ( ESHandleBase &  a, ESHandleBase &  b  )

inline

Definition at line 100 of file ESHandle.h.

References a, and b.

Referenced by edm::ESHandleBase::swap().

{ a.swap(b); }

swap() [11/40]

void edm::swap ( BasicHandle &  a, BasicHandle &  b  )

inlinenoexcept

Definition at line 104 of file BasicHandle.h.

References a, and b.

Referenced by edm::BasicHandle::swap().

{ a.swap(b); }

swap() [12/40]

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

inline

Definition at line 106 of file ProcessHistory.h.

References a, and b.

{ a.swap(b); }

swap() [13/40]

template<class T >

void edm::swap ( DetSet< T > &  a, DetSet< T > &  b  )

inline

Definition at line 110 of file DetSet.h.

References a, and b.

Referenced by edm::DetSet< StripDigiSimLink >::swap().

                                               {
    a.swap(b);
  }

swap() [14/40]

template<typename C >

void edm::swap ( Association< C > &  lhs, Association< C > &  rhs  )

inline

Definition at line 112 of file Association.h.

References edm::Association< C >::swap().

Referenced by CMSTopTagger::_split_once(), MkFitGeometryESProducer::GapCollector::add_interval(), EcalCosmicsHists::analyze(), DiMuonValidation::analyze(), tnp::TagProbePairMaker::arbitrate(), MkFitOutputConverter::backwardFit(), edm::EventProcessor::beginJob(), BitonicMerge(), SiPixelPhase1Analyzer::BookForwardBins(), HGCalGeometryLoader::buildGeom(), HGCalTBGeometryLoader::buildGeom(), HDetIdAssociator::buildMap(), VectorHitBuilderAlgorithm::buildVectorHit(), calCSVariables(), MuonPathAnalyzerInChamber::calculateFitParameters(), MillePedeAlignmentAlgorithm::callMille2D(), checkPhiInSymRange(), GEMEfficiencyAnalyzer::checkPropagationDirection(), FWCaloDataProxyBuilderBase::clearCaloDataSelection(), MtdSimCluster::clearHitsAndFractions(), SimCluster::clearHitsAndFractions(), SimCluster::clearHitsEnergy(), MtdSimCluster::clearHitsTime(), hybridBitonicSortUtils::compAndSwap(), PileupJetIdAlgo::computeIdVariables(), MVAJetPuId::computeIdVariables(), AlignmentCorrelationsStore::correlations(), AlignmentExtendedCorrelationsStore::correlations(), AlignmentCorrelationsStore::correlationsAvailable(), AlignmentExtendedCorrelationsStore::correlationsAvailable(), CaloDetIdAssociator::crossedElement(), MSLayer::crossing(), ThirdHitPredictionFromCircle::curvature(), DiskSectorBounds::DiskSectorBounds(), trackerTFP::MiniHoughTransform::dlb(), PulseChiSqSNNLS::DoFit(), edm::IndexIntoFile::doneFileInitialization(), EmissionVetoHook1::doVetoFSREmission(), L1TStage2CaloLayer1::dqmAnalyze(), LA_Filler_Fitter::fill(), HeavyFlavorDQMAnalyzer::fillComponentHistogramsLeadSoft(), MuGEMMuonExtTableProducer::fillTable(), mkfit::MkBuilder::filter_comb_cands(), CaloTruthAccumulator::finalizeEvent(), MtdTruthAccumulator::finalizeEvent(), external::HEPTopTaggerV2_fixed_R::FindHardSubst(), contrib::CMSBoostedTauSeedingAlgorithm::findSubjets(), calo::multifit::fnnls(), FourPointPlaneBounds::FourPointPlaneBounds(), AlignmentExtendedCorrelationsStore::getCorrelations(), EgHLTOfflineSummaryClient::getEgHLTFiltersToMon_(), EgHLTOfflineSource::getHLTFilterNamesUsed(), hitfit::Constraint_Intermed_Labels::has_labels(), HGCDigitizer::HGCDigitizer(), npstat::HistoAxis::HistoAxis(), npstat::HistoND< Numeric, Axis >::HistoND(), PixelTripletNoTipGenerator::hitTriplets(), PixelTripletHLTGenerator::hitTriplets(), PixelTripletLargeTipGenerator::hitTriplets(), HLTDisplacedtktktkVtxProducer::HLTDisplacedtktktkVtxProducer(), edm::IndexIntoFile::IndexIntoFileItr::IndexIntoFileItr(), HGCDigitizer::initializeEvent(), edm::IndexIntoFile::inputFileClosed(), dqmstorepb::ROOTFilePB_Histo::InternalSwap(), dqmstorepb::ROOTFilePB::InternalSwap(), DTROS25Unpacker::interpretRawData(), npstat::Interval< Numeric >::Interval(), HcalInterpolatedTableFunctor::inverse(), HcalPiecewiseLinearFunctor::inverse(), fireworks::invertBox(), edm::SubProcess::keepOnlyConsumedUnscheduledModules(), CosmicClusterAlgo::makeCluster(), reco::PFBlock::matrix2vector(), reco::PFDisplacedVertexCandidate::matrix2vector(), KDTreeLinkerAlgo< reco::PFRecHit const *>::medianSearch(), PFEGammaAlgo::mergeROsByAnyLink(), PulseChiSqSNNLS::NNLSConstrainParameter(), MahiFit::nnlsConstrainParameter(), PulseChiSqSNNLS::NNLSUnconstrainParameter(), MahiFit::nnlsUnconstrainParameter(), npstat::NUHistoAxis::NUHistoAxis(), ThirdHitRZPrediction< Propagator >::operator()(), ThirdHitPredictionFromCircle::operator()(), npstat::Interval< Numeric >::operator*=(), npstat::Interval< Numeric >::operator/=(), magneticfield::interpolation::binary_ifstream::operator=(), edm::EDCollection< T >::operator=(), l1tpf::corrector::operator=(), DeepCopyPointerByClone< FullConvolutionWithMaterial >::operator=(), DeepCopyPointer< T >::operator=(), cond::serialization::unique_void_ptr::operator=(), edm::WaitingTaskWithArenaHolder::operator=(), edm::WaitingTaskHolder::operator=(), TempTrajectory::operator=(), edm::RefToBaseProd< T >::operator=(), Trajectory::operator=(), TrajectoryMeasurement::operator=(), edm::soa::Table< edm::soa::col::Pt, edm::soa::col::Eta, edm::soa::col::Phi, edm::soa::col::Vz >::operator=(), CovarianceParameterization::pack(), PhiBorderFinder::PhiBorderFinder(), PhiMemoryImage::PhiMemoryImage(), edm::ParameterSet::popParameterSet(), edm::ParameterSet::popVParameterSet(), edm::service::StallMonitor::postBeginJob(), L1TMuonBarrelKalmanRegionModule::process(), PrimitiveSelection::process(), trackerTFP::ZHoughTransform::produce(), trackerTFP::MiniHoughTransform::produce(), StripCompactDigiSimLinksProducer::produce(), FWRecoGeometryESProducer::produce(), MkFitEventOfHitsProducer::produce(), FakeTrackProducer< T >::produce(), PFElecTkProducer::produce(), VirtualJetProducer::produce(), CaloGeometryDBEP< T, U >::produceAligned(), FastjetJetProducer::produceTrackJets(), ThirdHitPredictionFromInvParabola::rangeRPhi(), reco::GhostTrackVertexFinder::reassignTracks(), reco::GhostTrackVertexFinder::recursiveMerge(), MultiHitGeneratorFromChi2::refit2Hits(), reco::GhostTrackVertexFinder::refitGhostTrack(), HGCal3DClustering::reset(), HGCalImagingAlgo::reset(), CMSTopTagger::result(), SubjetFilterAlgorithm::run(), TICLLayerTileT< T >::searchBoxEtaPhi(), SimpleCosmicBONSeeder::seeds(), mkfit::MkFinder::selectHitIndicesV2(), SiStripBaseCondObjDQM::selectModules(), npstat::Interval< Numeric >::setBounds(), AlignmentCorrelationsStore::setCorrelations(), AlignmentExtendedCorrelationsStore::setCorrelations(), emtf::shuffle(), SimpleConeBounds::SimpleConeBounds(), SimpleCylinderBounds::SimpleCylinderBounds(), SimpleDiskBounds::SimpleDiskBounds(), HelixArbitraryPlaneCrossing2Order::solutionByDirection(), hitfit::Top_Decaykin::solve_nu(), hitfit::Top_Decaykin::solve_nu_tmass(), muonisolation::Range< float >::sort(), PixelRecoRange< float >::sort(), TRange< int >::sort(), EcalDccWeightBuilder::sort(), DynamicTruncation::sort(), emtf::sort_uGMT_muons(), SimTrackManager::storeTracks(), trackerDTC::Stub::Stub(), FWGUIManager::subviewSwapped(), edm::MergeableCounter::swap(), PixelFitter::swap(), PixelTrackFilter::swap(), PhiMemoryImage::swap(), edm::reftobase::Holder< T, REF >::swap(), edm::reftobase::RefHolder< REF >::swap(), PixelRecoRange< float >::swap(), edm::ElementID::swap(), CastorElectronicsMap::swap(), edm::ProductID::swap(), HcalDataFrameContainer< Digi >::swap(), GenFilterInfo::swap(), HcalFrontEndMap::swap(), edm::HepMCProduct::swap(), edm::HepMC3Product::swap(), HcalDcsMap::swap(), edm::ErrorObj::swap(), HcalSiPMCharacteristics::swap(), HcalElectronicsMap::swap(), edm::ContainerMask< T >::swap(), FWConfiguration::swap(), lhef::HEPRUP::swap(), SiPixelClusterShapeCache::swap(), edm::Handle< GenericObject >::swap(), TrackingRegionsSeedingLayerSets::swap(), edm::eventsetup::DataKey::swap(), edm::FileInPath::swap(), edm::Handle< FWGenericObject >::swap(), EcalMatacqDigi::swap(), edm::Provenance::swap(), edm::RefToBaseProd< T >::swap(), edmNew::dstvdetails::DetSetVectorTrans::swap(), edm::Exception::swap(), edm::VecArray< std::pair< int, int >, 9 >::swap(), edm::RefProd< Phase2TrackerCluster1Ds >::swap(), GenLumiInfoProduct::swap(), SeedingLayerSetsHits::swap(), edm::StdArray< T, N >::swap(), edm::SoATuple< edm::EDConsumerBase::TokenLookupInfo, bool, edm::EDConsumerBase::LabelPlacement, edm::KindOfType >::swap(), l1extra::L1ParticleMap::swap(), edmNew::DetSetVector< SiStripCluster >::swap(), edm::eventsetup::EventSetupRecordProvider::swapFinder(), FWCustomIconsButton::swapIcons(), timestudy::SleepingServer::threadWork(), npstat::ArrayND< Numeric >::transpose(), TrapezoidalCartesianMFGrid::uncheckedValueInTesla(), npstat::UniformAxis::UniformAxis(), CovarianceParameterization::unpack(), CaloSD::update(), edm::service::SimpleMemoryCheck::update(), DQMBasicNet::updateLocalObject(), and reco::GhostTrackVertexFinder::vertices().

                                                             {
    lhs.swap(rhs);
  }

swap() [15/40]

void edm::swap ( HandleBase &  a, HandleBase &  b  )

inline

Definition at line 114 of file HandleBase.h.

References a, and b.

Referenced by edm::HandleBase::swap().

{ a.swap(b); }

swap() [16/40]

void edm::swap ( ErrorObj &  a, ErrorObj &  b  )

inline

Definition at line 125 of file ErrorObj.h.

References a, and b.

{ a.swap(b); }

swap() [17/40]

template<class T >

void edm::swap ( EDCollection< T > &  a, EDCollection< T > &  b  )

inline

Definition at line 129 of file EDCollection.h.

References a, and b.

                                                           {
    a.swap(b);
  }

swap() [18/40]

void edm::swap ( FileInPath &  a, FileInPath &  b  )

inline

Definition at line 130 of file FileInPath.h.

References a, and b.

{ a.swap(b); }

swap() [19/40]

template<typename K , typename T >

void edm::swap ( MapOfVectors< K, T > &  lhs, MapOfVectors< K, T > &  rhs  )

inline

Definition at line 142 of file MapOfVectors.h.

References edm::MapOfVectors< K, T >::swap().

                                                                     {
    lhs.swap(rhs);
  }

swap() [20/40]

template<typename KEY >

void edm::swap ( RefVectorBase< KEY > &  a, RefVectorBase< KEY > &  b  )

inline

swap two vectors

Definition at line 149 of file RefVectorBase.h.

References a, and b.

                                                                 {
    a.swap(b);
  }

swap() [21/40]

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

inline

Definition at line 155 of file RefCore.h.

References edm::RefCore::swap().

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

{ lhs.swap(rhs); }

swap() [22/40]

void edm::swap ( edm::RefCoreWithIndex &  lhs, edm::RefCoreWithIndex &  rhs  )

inline

Definition at line 157 of file RefCoreWithIndex.h.

References edm::RefCoreWithIndex::swap().

Referenced by edm::RefCoreWithIndex::swap().

{ lhs.swap(rhs); }

swap() [23/40]

template<typename C , typename T , typename F >

void edm::swap ( RefVector< C, T, F > &  a, RefVector< C, T, F > &  b  )

inlinenoexcept

Definition at line 172 of file RefVector.h.

References a, and b.

                                                                          {
    a.swap(b);
  }

swap() [24/40]

template<typename T >

void edm::swap ( edm::RefToBaseProd< T > const &  lhs, edm::RefToBaseProd< T > const &  rhs  )

inline

Definition at line 174 of file RefToBaseProd.h.

References edm::RefToBaseProd< T >::swap().

                                                                                   {
    lhs.swap(rhs);
  }

swap() [25/40]

template<typename T >

void edm::swap ( value_ptr< T > &  vp1, value_ptr< T > &  vp2  )

inline

Definition at line 181 of file value_ptr.h.

References edm::value_ptr< T >::swap().

Referenced by edm::value_ptr< edm::service::MessageLoggerDefaults >::swap().

                                                         {
    vp1.swap(vp2);
  }

swap() [26/40]

void edm::swap ( DataFrameContainer &  lhs, DataFrameContainer &  rhs  )

inline

Definition at line 194 of file DataFrameContainer.h.

References edm::DataFrameContainer::swap().

Referenced by edm::DataFrameContainer::swap().

{ lhs.swap(rhs); }

swap() [27/40]

template<typename C >

void edm::swap ( RefProd< C > const &  lhs, RefProd< C > const &  rhs  )

inline

Definition at line 195 of file RefProd.h.

                                                                 {
    lhs.swap(rhs);
  }

swap() [28/40]

template<int I>

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

inline

Definition at line 205 of file Hash.h.

References a, and b.

                                           {
    a.swap(b);
  }

swap() [29/40]

template<typename T >

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

inline

Definition at line 213 of file PtrVector.h.

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

                                                         {
    lhs.swap(rhs);
  }

swap() [30/40]

template<typename ID , typename C , typename P >

void edm::swap ( RangeMap< ID, C, P > &  a, RangeMap< ID, C, P > &  b  )

inline

Definition at line 215 of file RangeMap.h.

References a, and b.

                                                                 {
    a.swap(b);
  }

swap() [31/40]

template<typename T , typename C >

void edm::swap ( DetSetRefVector< T, C > &  a, DetSetRefVector< T, C > &  b  )

inline

Definition at line 253 of file DetSetRefVector.h.

References a, and b.

                                                                       {
    a.swap(b);
  }

swap() [32/40]

template<typename T >

void edm::swap ( ValueMap< T > &  lhs, ValueMap< T > &  rhs  )

inline

Definition at line 275 of file ValueMap.h.

References edm::ValueMap< T >::swap().

                                                       {
    lhs.swap(rhs);
  }

swap() [33/40]

template<typename KeyRefProd , typename CVal , typename KeyRef , typename SizeType , typename KeyReferenceHelper >

void edm::swap ( AssociationVector< KeyRefProd, CVal, KeyRef, SizeType, KeyReferenceHelper > &  a, AssociationVector< KeyRefProd, CVal, KeyRef, SizeType, KeyReferenceHelper > &  b  )

inline

Definition at line 280 of file AssociationVector.h.

References a, and b.

                                                                                                 {
    a.swap(b);
  }

swap() [34/40]

void edm::swap ( ParameterSet &  a, ParameterSet &  b  )

inline

Definition at line 293 of file ParameterSet.h.

References a, and b.

{ a.swap(b); }

swap() [35/40]

template<typename C >

void edm::swap ( MultiAssociation< C > &  lhs, MultiAssociation< C > &  rhs  )

inline

Definition at line 306 of file MultiAssociation.h.

                                                                       {
    lhs.swap(rhs);
  }

swap() [36/40]

template<typename T >

void edm::swap ( View< T > &  lhs, View< T > &  rhs  )

inline

Definition at line 324 of file View.h.

                                               {
    lhs.swap(rhs);
  }

swap() [37/40]

template<typename T , typename SORT >

void edm::swap ( SortedCollection< T, SORT > &  a, SortedCollection< T, SORT > &  b  )

inline

Definition at line 336 of file SortedCollection.h.

References a, and b.

Referenced by edm::SortedCollection< EcalRecHit >::operator=().

                                                                               {
    a.swap(b);
  }

swap() [38/40]

template<class T >

void edm::swap ( RefToBase< T > &  a, RefToBase< T > &  b  )

inline

Definition at line 345 of file RefToBase.h.

References a, and b.

Referenced by edm::RefToBase< TrajectorySeed >::swap().

                                                     {
    a.swap(b);
  }

swap() [39/40]

template<class T >

void edm::swap ( DetSetVector< T > &  a, DetSetVector< T > &  b  )

inline

Definition at line 378 of file DetSetVector.h.

References a, and b.

                                                           {
    a.swap(b);
  }

swap() [40/40]

template<typename T , typename P >

void edm::swap ( OwnVector< T, P > &  a, OwnVector< T, P > &  b  )

inlinenoexcept

Definition at line 540 of file OwnVector.h.

References a, and b.

Referenced by edm::OwnVector< TrackingRegion >::operator=().

                                                                    {
    a.swap(b);
  }

syncWait()

template<typename F >

std::exception_ptr edm::syncWait

(

F &&

iFunc

)

Definition at line 15 of file include_first_syncWait.h.

References watchdog::group, and dqmdumpme::last.

Referenced by edm::SecondaryEventProvider::setupPileUpEvent().

                                                     {
    std::exception_ptr exceptPtr{};
    oneapi::tbb::task_group group;
    FinalWaitingTask last{group};
    group.run([&]() { iFunc(WaitingTaskHolder(group, &last)); });  //group.run

    return last.waitNoThrow();
  }

thinnedRefFrom()

template<typename C , typename T , typename F >

Ref<C, T, F> edm::thinnedRefFrom	(	Ref< C, T, F > const &	parent,
		RefProd< C > const &	thinned,
		edm::EDProductGetter const &	prodGetter
	)

Return a Ref to thinned collection corresponding to an element of the Ref to parent collection.

Definition at line 129 of file RefItemGet.h.

References edm::EDProductGetter::getThinnedKeyFrom(), edm::RefProd< C >::id(), and class-composition::parent.

Referenced by edmtest::ThinningTestAnalyzer::analyze(), edmtest::ThinningDSVTestAnalyzer::analyze(), edmtest::ThinnedRefFromTestAnalyzer::analyze(), edm::ThinnedRefSet< C >::Filler::insert(), and edmtest::ThinningTestAnalyzer::testVectors().

                                                                    {
    if (parent.id() == thinned.id()) {
      return parent;
    }

    auto thinnedKey = prodGetter.getThinnedKeyFrom(parent.id(), parent.key(), thinned.id());
    if (std::holds_alternative<unsigned int>(thinnedKey)) {
      return Ref<C, T, F>(thinned, std::get<unsigned int>(thinnedKey));
    } else if (std::holds_alternative<detail::GetThinnedKeyFromExceptionFactory>(thinnedKey)) {
      auto ex = std::get<detail::GetThinnedKeyFromExceptionFactory>(thinnedKey)();
      ex.addContext("Calling edm::thinnedRefFrom()");
      throw ex;
    }

    return Ref<C, T, F>();
  }

threadOptions()

ThreadsInfo edm::threadOptions

(

edm::ParameterSet const &

pset

)

Definition at line 11 of file ThreadsInfo.cc.

References edm::ThreadsInfo::nThreads_, muonDTDigis_cfi::pset, and edm::ThreadsInfo::stackSize_.

                                                         {
    // default values
    ThreadsInfo threadsInfo;

    // Note: it is important to not check the type or trackedness in
    // exists() call to ensure that the getUntrackedParameter() calls
    // will fail if the parameters have an incorrect type
    if (pset.exists("options")) {
      auto const& ops = pset.getUntrackedParameterSet("options");
      if (ops.exists("numberOfThreads")) {
        threadsInfo.nThreads_ = ops.getUntrackedParameter<unsigned int>("numberOfThreads");
      }
      if (ops.exists("sizeOfStackForThreadsInKB")) {
        threadsInfo.stackSize_ = ops.getUntrackedParameter<unsigned int>("sizeOfStackForThreadsInKB");
      }
    }
    return threadsInfo;
  }

throwAmbiguousException()

static void edm::throwAmbiguousException ( const char *  where, TypeID const &  productType, std::string const &  label, std::string const &  instance, std::string const &  process  )

static

Definition at line 77 of file Principal.cc.

References cppFunctionSkipper::exception, instance, label, and LaserDQM_cfg::process.

Referenced by edm::Principal::findProductByLabel().

                                                                {
    cms::Exception exception("AmbiguousProduct");
    exception << "Principal::" << where
              << ": More than 1 product matches all criteria\nLooking for type: " << productType << "\n"
              << "Looking for module label: " << label << "\n"
              << "Looking for productInstanceName: " << instance << "\n"
              << (process.empty() ? "" : "Looking for process: ") << process << "\n"
              << "This can only occur with get function calls using a Handle<View> argument.\n"
              << "Try a get not using a View or change the instance name of one of the products";
    throw exception;
  }

throwExceptionWithText()

void edm::throwExceptionWithText

(

char const *

txt

)

Definition at line 268 of file BranchDescription.cc.

References MillePedeFileConverter_cfg::e, and edm::errors::LogicError.

Referenced by edm::BranchDescription::throwIfInvalid_().

                                               {
    Exception e(errors::LogicError);
    e << "Problem using an incomplete BranchDescription\n"
      << txt << "\nPlease report this error to the FWCore developers";
    throw e;
  }

throwMissingDictionariesException() [1/4]

void edm::throwMissingDictionariesException	(	std::vector< std::string > &	missingDictionaries,
		std::string const &	context
	)

Definition at line 194 of file DictionaryTools.cc.

References visDQMUpload::context, and relativeConstraints::empty.

Referenced by edm::ProductRegistryHelper::addToRegistry(), edm::ProductRegistry::checkDictionariesOfConsumedTypes(), edm::StreamerInputSource::declareStreamers(), edm::ProductRegistry::initializeLookupTables(), edm::core::OutputModuleCore::keepThisBranch(), and loadExtraClasses().

                                                                                                              {
    std::vector<std::string> empty;
    throwMissingDictionariesException(missingDictionaries, context, empty);
  }

throwMissingDictionariesException() [2/4]

void edm::throwMissingDictionariesException	(	std::vector< std::string > &	missingDictionaries,
		std::string const &	context,
		std::vector< std::string > &	producedTypes
	)

Definition at line 199 of file DictionaryTools.cc.

References addToMissingDictionariesException(), visDQMUpload::context, edm::errors::DictionaryNotFound, cppFunctionSkipper::exception, B2GTnPMonitor_cfi::item, jetUpdater_cfi::sort, and tier0::unique().

                                                                              {
    edm::Exception exception(errors::DictionaryNotFound);
    addToMissingDictionariesException(exception, missingDictionaries, context);

    if (!producedTypes.empty()) {
      std::sort(producedTypes.begin(), producedTypes.end());
      producedTypes.erase(std::unique(producedTypes.begin(), producedTypes.end()), producedTypes.end());

      std::ostringstream ostr;
      for (auto const& item : producedTypes) {
        ostr << "  " << item << "\n";
      }
      exception << "\nA type listed above might or might not be the same as a\n"
                << "type declared by a producer module with the function \'produces\'.\n"
                << "Instead it might be the type of a data member, base class,\n"
                << "wrapped type, or other object needed by a produced type. Below\n"
                << "is some additional information which lists the types declared\n"
                << "to be produced by a producer module that are associated with\n"
                << "the types whose dictionaries were not found:\n\n"
                << ostr.str() << "\n";
    }
    throw exception;
  }

throwMissingDictionariesException() [3/4]

void edm::throwMissingDictionariesException	(	std::vector< std::string > &	missingDictionaries,
		std::string const &	context,
		std::vector< std::string > &	producedTypes,
		std::vector< std::string > &	branchNames,
		bool	fromStreamerSource = false
	)

Definition at line 225 of file DictionaryTools.cc.

References addToMissingDictionariesException(), haddnano::branchNames, visDQMUpload::context, edm::errors::DictionaryNotFound, cppFunctionSkipper::exception, B2GTnPMonitor_cfi::item, jetUpdater_cfi::sort, and tier0::unique().

                                                                  {
    edm::Exception exception(errors::DictionaryNotFound);
    addToMissingDictionariesException(exception, missingDictionaries, context);

    if (!producedTypes.empty()) {
      std::sort(producedTypes.begin(), producedTypes.end());
      producedTypes.erase(std::unique(producedTypes.begin(), producedTypes.end()), producedTypes.end());

      std::ostringstream ostr;
      for (auto const& item : producedTypes) {
        ostr << "  " << item << "\n";
      }
      if (fromStreamerSource) {
        exception << "\nA type listed above might or might not be the same as a\n"
                  << "type stored in the Event. Instead it might be the type of\n"
                  << "a data member, base class, wrapped type, or other object\n"
                  << "needed by a stored type. Below is some additional information\n"
                  << "which lists the stored types associated with the types whose\n"
                  << "dictionaries were not found:\n\n"
                  << ostr.str() << "\n";
      } else {
        exception << "\nA type listed above might or might not be the same as a\n"
                  << "type stored in the Event (or Lumi or Run). Instead it might\n"
                  << "be the type of a data member, base class, wrapped type, or\n"
                  << "other object needed by a stored type. Below is some additional\n"
                  << "information which lists the stored types associated with the\n"
                  << "types whose dictionaries were not found:\n\n"
                  << ostr.str() << "\n";
      }
    }

    if (!branchNames.empty()) {
      std::sort(branchNames.begin(), branchNames.end());
      branchNames.erase(std::unique(branchNames.begin(), branchNames.end()), branchNames.end());

      std::ostringstream ostr;
      for (auto const& item : branchNames) {
        ostr << "  " << item << "\n";
      }
      if (fromStreamerSource) {
        exception << "Missing dictionaries are associated with these branch names:\n\n" << ostr.str() << "\n";
      } else {
        exception << "Missing dictionaries are associated with these branch names:\n\n"
                  << ostr.str() << "\n"
                  << "If you do not need these branches and they are not produced\n"
                  << "in the current process, an alternate solution to adding\n"
                  << "dictionaries is to drop these branches on input using the\n"
                  << "inputCommands parameter of the PoolSource.";
      }
    }
    throw exception;
  }

throwMissingDictionariesException() [4/4]

void edm::throwMissingDictionariesException	(	std::vector< std::string > &	missingDictionaries,
		std::string const &	context,
		std::set< std::string > &	producedTypes,
		bool	consumedWithView
	)

Definition at line 282 of file DictionaryTools.cc.

References addToMissingDictionariesException(), visDQMUpload::context, edm::errors::DictionaryNotFound, cppFunctionSkipper::exception, and B2GTnPMonitor_cfi::item.

                                                                {
    edm::Exception exception(errors::DictionaryNotFound);
    addToMissingDictionariesException(exception, missingDictionaries, context);

    if (!producedTypes.empty()) {
      std::ostringstream ostr;
      for (auto const& item : producedTypes) {
        ostr << "  " << item << "\n";
      }
      if (consumedWithView) {
        exception << "\nThe list of types above was generated while checking for\n"
                  << "dictionaries related to products declared to be consumed\n"
                  << "using a View. They will be either the type or a base class\n"
                  << "of the type declared in a consumes declaration as the template\n"
                  << "parameter of a View. Below is some additional information\n"
                  << "which lists the type of the template parameter of the View.\n"
                  << "(It will be the same type unless the missing dictionary is\n"
                  << "for a base type):\n\n"
                  << ostr.str() << "\n";
      } else {
        exception << "\nThe list of types above was generated while checking for\n"
                  << "dictionaries related to products declared to be consumed.\n"
                  << "A type listed above might or might not be a type declared\n"
                  << "to be consumed. Instead it might be the type of a data member,\n"
                  << "base class, wrapped type or other object needed by a consumed\n"
                  << "type.  Below is some additional information which lists\n"
                  << "the types declared to be consumed by a module and which\n"
                  << "are associated with the types whose dictionaries were not\n"
                  << "found:\n\n"
                  << ostr.str() << "\n";
      }
    }
    throw exception;
  }

throwProductDeletedException()

static void edm::throwProductDeletedException ( ProductID const &  pid, edm::EventPrincipal::ConstProductResolverPtr const  phb  )

static

Definition at line 244 of file EventPrincipal.cc.

References cppFunctionSkipper::exception.

Referenced by edm::EventPrincipal::getByProductID().

                                                                                               {
    ProductDeletedException exception;
    exception << "get by product ID: The product with given id: " << pid << "\ntype: " << phb->productType()
              << "\nproduct instance name: " << phb->productInstanceName() << "\nprocess name: " << phb->processName()
              << "\nwas already deleted. This is a configuration error. Please change the configuration of the module "
                 "which caused this exception to state it reads this data.";
    throw exception;
  }

throwProductNotFoundException()

static void edm::throwProductNotFoundException ( char const *  where, errors::ErrorCodes  error, BranchID const &  bid  )

static

Definition at line 48 of file Principal.cc.

References relativeConstraints::error, and Exception.

Referenced by edm::Principal::getProvenance(), and edm::Principal::getStableProvenance().

                                                                                                            {
    throw Exception(error, "InvalidID") << "Principal::" << where << ": no product with given branch id: " << bid
                                        << "\n";
  }

throwTypeException()

static void edm::throwTypeException ( std::string const &  function, std::string const &  typeName  )

static

Definition at line 48 of file TypeWithDict.cc.

References edm::errors::DictionaryNotFound, Exception, and dqmiodumpindices::typeName.

Referenced by edm::TypeWithDict::TypeWithDict().

                                                                                       {
    throw Exception(errors::DictionaryNotFound) << "Function " << function << ",\n"
                                                << "no data dictionary found for type:\n\n"
                                                << typeName << "\nMost likely the dictionary was never generated,\n"
                                                << "but it may be that it was generated in the wrong package.\n"
                                                << "Please add (or move) the specification\n"
                                                << "<class name=\"whatever\"/>\n"
                                                << "to the appropriate classes_def.xml file.\n"
                                                << "If the class is a template instance, you may need\n"
                                                << "to define a dummy variable of this type in classes.h.\n"
                                                << "Also, if this class has any transient members,\n"
                                                << "you need to specify them in classes_def.xml.";
  }

tokenize()

std::vector< std::string > edm::tokenize	(	std::string const &	input,
		std::string const &	separator
	)

breaks the input string into tokens, delimited by the separator

Definition at line 52 of file Parse.cc.

References copy_all(), input, mps_fire::result, and separator().

Referenced by MomentumDependentPedeLabeler::buildMomentumDependencyMap(), RunRangeDependentPedeLabeler::buildRunRangeDependencyMap(), decode(), editESInputTag(), editInputTag(), editVInputTag(), edm::ESInputTag::ESInputTag(), edm::FileInPath::findFile(), edm::FileInPath::initialize_(), edm::InputTag::InputTag(), align::makeNonOverlappingRunRanges(), and MultiEventFilter::MultiEventFilter().

                                                                                    {
    typedef boost::char_separator<char> separator_t;
    typedef boost::tokenizer<separator_t> tokenizer_t;

    std::vector<std::string> result;
    separator_t sep(separator.c_str(), "", boost::keep_empty_tokens);  // separator for elements in path
    tokenizer_t tokens(input, sep);
    copy_all(tokens, std::back_inserter<std::vector<std::string> >(result));
    return result;
  }

toPython11List()

template<typename T >

pybind11::list edm::toPython11List

(

const std::vector< T > &

v

)

Definition at line 17 of file PyBind11Wrapper.h.

References nnet::cast(), mps_fire::result, and findQualityFiles::v.

Referenced by Python11ParameterSet::getParameters().

                                                     {
    pybind11::list result = pybind11::cast(v);
    return result;
  }

toVector()

template<typename T >

std::vector<T> edm::toVector

(

pybind11::list &

l

)

Definition at line 24 of file PyBind11Wrapper.h.

References mps_fire::i, MainPageGenerator::l, and mps_fire::result.

                                         {
    std::vector<T> result;
    result.reserve(l.size());
    for (unsigned i = 0; i < l.size(); ++i) {
      result.push_back(l[i].cast<T>());
    }
    return result;
  }

transitionName() [1/2]

std::string_view edm::transitionName

(

GlobalContext::Transition

iTrans

)

Definition at line 121 of file GlobalContext.cc.

References edm::GlobalContext::kAccessInputProcessBlock, edm::GlobalContext::kBeginJob, edm::GlobalContext::kBeginLuminosityBlock, edm::GlobalContext::kBeginProcessBlock, edm::GlobalContext::kBeginRun, edm::GlobalContext::kEndJob, edm::GlobalContext::kEndLuminosityBlock, edm::GlobalContext::kEndProcessBlock, edm::GlobalContext::kEndRun, edm::GlobalContext::kWriteLuminosityBlock, edm::GlobalContext::kWriteProcessBlock, and edm::GlobalContext::kWriteRun.

Referenced by edm::UnscheduledCallProducer::addContextToException(), edm::service::Tracer::postModuleGlobalPrefetching(), edm::service::Tracer::postModuleStreamPrefetching(), edm::service::Tracer::preModuleGlobalPrefetching(), edm::service::Tracer::preModuleStreamPrefetching(), edm::GlobalSchedule::processOneGlobalAsync(), and edm::StreamSchedule::processOneStreamAsync().

                                                                {
    switch (iTrans) {
      case GlobalContext::Transition::kBeginJob:
        return "begin Job";
      case GlobalContext::Transition::kBeginProcessBlock:
        return "begin ProcessBlock";
      case GlobalContext::Transition::kAccessInputProcessBlock:
        return "access input ProcessBlock";
      case GlobalContext::Transition::kBeginRun:
        return "global begin Run";
      case GlobalContext::Transition::kBeginLuminosityBlock:
        return "global begin LuminosityBlock";
      case GlobalContext::Transition::kEndLuminosityBlock:
        return "global end LuminosityBlock";
      case GlobalContext::Transition::kEndRun:
        return "global end Run";
      case GlobalContext::Transition::kEndProcessBlock:
        return "end ProcessBlock";
      case GlobalContext::Transition::kEndJob:
        return "endJob";
      case GlobalContext::Transition::kWriteProcessBlock:
        return "write ProcessBlock";
      case GlobalContext::Transition::kWriteRun:
        return "write Run";
      case GlobalContext::Transition::kWriteLuminosityBlock:
        return "write LuminosityBlock";
    }
    return "Unknown";
  }

transitionName() [2/2]

std::string_view edm::transitionName

(

StreamContext::Transition

iTrans

)

Definition at line 103 of file StreamContext.cc.

References edm::StreamContext::kBeginLuminosityBlock, edm::StreamContext::kBeginRun, edm::StreamContext::kBeginStream, edm::StreamContext::kEndLuminosityBlock, edm::StreamContext::kEndRun, edm::StreamContext::kEndStream, edm::StreamContext::kEvent, and edm::StreamContext::kInvalid.

                                                                {
    switch (iTrans) {
      case StreamContext::Transition::kBeginStream:
        return "begin Stream";
      case StreamContext::Transition::kBeginRun:
        return "stream begin Run";
      case StreamContext::Transition::kBeginLuminosityBlock:
        return "stream begin LuminosityBlock";
      case StreamContext::Transition::kEvent:
        return "Event";
      case StreamContext::Transition::kEndLuminosityBlock:
        return "stream end LuminosityBlock";
      case StreamContext::Transition::kEndRun:
        return "stream end Run";
      case StreamContext::Transition::kEndStream:
        return "end Stream";
      case StreamContext::Transition::kInvalid:
        return "Invalid";
    }
    return "Unknown";
  }

triggerResults()

static std::string const edm::triggerResults ( "TriggerResults"  )

static

Referenced by HLTVertexPerformanceAnalyzer::analyze(), HLTBTagPerformanceAnalyzer::analyze(), JetAnalyzer::analyze(), METAnalyzer::analyze(), edm::service::TriggerNamesService::getTrigPaths(), moduleName(), parameterSet(), edm::StreamerOutputModuleCommon::serializeEvent(), edm::StreamerOutputModuleCommon::setHltMask(), edm::Event::triggerNames(), edm::EventBase::triggerNames_(), edm::Event::triggerResultsByName(), and edm::StreamerOutputModuleBase::write().

triggerResultsInserter()

static std::string const edm::triggerResultsInserter ( "TriggerResultsInserter"  )

static

Referenced by moduleName().

tryThinnedRefFrom()

template<typename C , typename T , typename F >

Ref<C, T, F> edm::tryThinnedRefFrom	(	Ref< C, T, F > const &	parent,
		RefProd< C > const &	thinned,
		edm::EDProductGetter const &	prodGetter
	)

Return a Ref to thinned collection corresponding to an element of the Ref to parent collection.

Definition at line 157 of file RefItemGet.h.

References edm::EDProductGetter::getThinnedKeyFrom(), edm::RefProd< C >::id(), and class-composition::parent.

Referenced by edmtest::ThinnedRefFromTestAnalyzer::analyze(), and edm::ThinnedRefSet< C >::Filler::insert().

                                                                       {
    if (parent.id() == thinned.id()) {
      return parent;
    }

    auto thinnedKey = prodGetter.getThinnedKeyFrom(parent.id(), parent.key(), thinned.id());
    if (std::holds_alternative<unsigned int>(thinnedKey)) {
      return Ref<C, T, F>(thinned, std::get<unsigned int>(thinnedKey));
    }

    return Ref<C, T, F>();
  }

tryToGetProductWithCoreFromRef()

template<typename T >

T const* edm::tryToGetProductWithCoreFromRef ( RefCore const &  ref, EDProductGetter const *  prodGetter  )

inline

Definition at line 97 of file RefCoreGet.h.

References edm::RefCore::isTransient(), and edm::RefCore::nullPointerForTransientException().

                                                                                                        {
    if (ref.isTransient()) {
      ref.nullPointerForTransientException(typeid(T));
    }
    return refcore::tryToGetProductWithCoreFromRef_<T>(ref, prodGetter);
  }

typeDemangle()

std::string edm::typeDemangle

(

char const *

mangledName

)

Definition at line 94 of file TypeDemangler.cc.

References symbols::demangled, Exception, free(), replaceString(), mps_update::status, and AlCaHLTBitMon_QueryRunRegistry::string.

Referenced by reco::modules::TrackerTrackHitFilter::checkStoN(), PhysicsTools::VarProcessor::deriv(), PhysicsTools::MVAComputer::evalInternal(), edm::ServiceRegistry::get(), edm::serviceregistry::ServicesManager::get(), L1RegionData< T1 >::getEtaPhiRegions(), edm::ServiceRegistry::isAvailable(), DetSetCounterSelector::operator()(), and edm::serviceregistry::ServicesManager::ServicesManager().

                                                  {
    int status = 0;
    size_t* const nullSize = nullptr;
    char* const null = nullptr;

    // The demangled C style string is allocated with malloc, so it must be deleted with free().
    char* demangled = abi::__cxa_demangle(mangledName, null, nullSize, &status);
    if (status != 0) {
      throw cms::Exception("Demangling error") << " '" << mangledName << "'\n";
    }
    std::string demangledName(demangled);
    free(demangled);
    // We must use the same conventions previously used by REFLEX.
    // The order of these is important.
    // No space after comma
    replaceString(demangledName, ", ", ",");
    // No space before opening square bracket
    replaceString(demangledName, " [", "[");
    // clang libc++ uses __1:: namespace
    replaceString(demangledName, "std::__1::", "std::");
    // new gcc abi uses __cxx11:: namespace
    replaceString(demangledName, "std::__cxx11::", "std::");
    // Strip default allocator
    std::string const allocator(",std::allocator<");
    removeParameter(demangledName, allocator);
    // Strip default comparator
    std::string const comparator(",std::less<");
    removeParameter(demangledName, comparator);
    // Put const qualifier before identifier.
    constBeforeIdentifier(demangledName);
    // No two consecutive '>'
    replaceString(demangledName, ">>", "> >");
    // No u or l qualifiers for integers.
    reformatter(demangledName, "(.*[<,][0-9]+)[ul]l*([,>].*)", "$1$2");
    // For ROOT 6 and beyond, replace 'unsigned long long' with 'ULong64_t'
    replaceString(demangledName, "unsigned long long", "ULong64_t");
    // For ROOT 6 and beyond, replace 'long long' with 'Long64_t'
    replaceString(demangledName, "long long", "Long64_t");
    return demangledName;
  }

uniqueSharedResourceName()

std::string edm::uniqueSharedResourceName

(

)

Definition at line 20 of file SharedResourceNames.cc.

References contentValuesCheck::ss.

Referenced by edm::HadronizerFilter< HAD, DEC >::HadronizerFilter(), and edm::GeneratorFilter< HAD, DEC >::init().

                                        {
  std::stringstream ss;
  ss << "uniqueSharedResourceName" << counter.fetch_add(1);
  return ss.str();
}

untaintString()

bool edm::untaintString	(	char const *	pattern,
		char const *	regexp
	)

Definition at line 12 of file RegexMatch.cc.

References topSingleLeptonDQM_PU_cfi::pattern, and fetchall_from_DQM_v2::regexp.

                                                              {
    std::regex rexp(regexp);
    return std::regex_match(pattern, rexp);
  }

validateTopLevelParameterSets()

void edm::validateTopLevelParameterSets

(

ParameterSet *

processParameterSet

)

Definition at line 143 of file validateTopLevelParameterSets.cc.

References cms::Exception::addContext(), edm::ParameterSet::addUntrackedParameter(), edm::errors::Configuration, makeListRunsInFiles::description, Exception, fillMaxEventsDescription(), fillMaxLuminosityBlocksDescription(), fillMaxSecondsUntilRampdownDescription(), fillOptionsDescription(), edm::ParameterSet::getParameter(), edm::ParameterSet::getPSetForUpdate(), SimL1EmulatorRepack_CalouGT_cff::processName, muonDTDigis_cfi::pset, crabTemplate::psetName, and AlCaHLTBitMon_QueryRunRegistry::string.

Referenced by edm::EventProcessor::init(), edm::SubProcess::SubProcess(), and edm::test::TestProcessor::TestProcessor().

                                                                        {
    std::string processName = processParameterSet->getParameter<std::string>("@process_name");

    std::vector<std::string> psetNames{"options", "maxEvents", "maxLuminosityBlocks", "maxSecondsUntilRampdown"};

    for (auto const& psetName : psetNames) {
      bool isTracked{false};
      ParameterSet* pset = processParameterSet->getPSetForUpdate(psetName, isTracked);
      if (pset == nullptr) {
        ParameterSet emptyPset;
        processParameterSet->addUntrackedParameter<ParameterSet>(psetName, emptyPset);
        pset = processParameterSet->getPSetForUpdate(psetName, isTracked);
      }
      if (isTracked) {
        throw Exception(errors::Configuration) << "In the configuration the top level parameter set named \'"
                                               << psetName << "\' in process \'" << processName << "\' is tracked.\n"
                                               << "It must be untracked";
      }

      ParameterSetDescription description;
      if (psetName == "options") {
        fillOptionsDescription(description);
      } else if (psetName == "maxEvents") {
        fillMaxEventsDescription(description);
      } else if (psetName == "maxLuminosityBlocks") {
        fillMaxLuminosityBlocksDescription(description);
      } else if (psetName == "maxSecondsUntilRampdown") {
        fillMaxSecondsUntilRampdownDescription(description);
      }

      try {
        description.validate(*pset);
      } catch (cms::Exception& ex) {
        std::ostringstream ost;
        ost << "Validating top level \'" << psetName << "\' ParameterSet for process \'" << processName << "\'";
        ex.addContext(ost.str());
        throw;
      }
    }
  }

vector_transform()

template<typename InputType , typename Function >

auto edm::vector_transform	(	std::vector< InputType > const &	input,
		Function	predicate
	)		-> std::vector< typename std::remove_cv<typename std::remove_reference<decltype(predicate(input.front()))>::type>::type>

Definition at line 11 of file transform.h.

References input, and convertSQLitetoXML_cfg::output.

Referenced by CaloSimHitAnalysis::CaloSimHitAnalysis(), CaloSimHitStudy::CaloSimHitStudy(), reco::modules::CandCombinerBase::CandCombinerBase(), EcalSimHitDump::EcalSimHitDump(), EcalSimHitStudy::EcalSimHitStudy(), EGammaCutBasedEleIdAnalyzer::EGammaCutBasedEleIdAnalyzer(), ElectronSeedProducer::ElectronSeedProducer(), HLTConfigData::extract(), HGCalHitValidation::HGCalHitValidation(), HGCalSimHitStudy::HGCalSimHitStudy(), HGCGeometryValidation::HGCGeometryValidation(), HLTBTagPerformanceAnalyzer::HLTBTagPerformanceAnalyzer(), HLTVertexPerformanceAnalyzer::HLTVertexPerformanceAnalyzer(), HOSimHitStudy::HOSimHitStudy(), JetSubstructurePacker::JetSubstructurePacker(), LowPtGsfElectronSeedValueMapsProducer::LowPtGsfElectronSeedValueMapsProducer(), MultiTrackSelector::MultiTrackSelector(), MultiTrackValidator::MultiTrackValidator(), pat::PATGenericParticleProducer::PATGenericParticleProducer(), pat::PATJetProducer::PATJetProducer(), pat::PATJetUpdater::PATJetUpdater(), pat::PATPFParticleProducer::PATPFParticleProducer(), pat::PATSingleVertexSelector::PATSingleVertexSelector(), PATTauIDEmbedder::PATTauIDEmbedder(), pat::PATTauProducer::PATTauProducer(), pat::PATPhotonProducer::readIsolationLabels(), pat::PATMuonProducer::readIsolationLabels(), pat::PATElectronProducer::readIsolationLabels(), ReducedESRecHitCollectionProducer::ReducedESRecHitCollectionProducer(), ReducedRecHitCollectionProducer::ReducedRecHitCollectionProducer(), SeedCombiner::SeedCombiner(), SiStripClusterizer::SiStripClusterizer(), TagAndProbeBtagTriggerMonitor::TagAndProbeBtagTriggerMonitor(), edmtest::ThinningDSVTestAnalyzer::ThinningDSVTestAnalyzer(), TICLCandidateFromTrackstersProducer::TICLCandidateFromTrackstersProducer(), TICLTrackstersEdgesValidation::TICLTrackstersEdgesValidation(), TrackerDpgAnalysis::TrackerDpgAnalysis(), TrackingMonitor::TrackingMonitor(), TrackingNtuple::TrackingNtuple(), TriggerResultsFilter::TriggerResultsFilter(), and ValidationMisalignedTracker::ValidationMisalignedTracker().

                                                                                                       {
    using ReturnType =
        typename std::remove_cv<typename std::remove_reference<decltype(predicate(input.front()))>::type>::type;
    std::vector<ReturnType> output;
    output.reserve(input.size());
    for (auto const& element : input)
      output.push_back(predicate(element));
    return output;
  }

walkTrie()

template<typename V , typename T >

void edm::walkTrie	(	V &	v,
		TrieNode< T > const &	n,
		std::string const &	label = ""
	)

visit each node of the trie

Definition at line 256 of file Trie.h.

References MillePedeFileConverter_cfg::e, label, dqmiodumpmetadata::n, AlCaHLTBitMon_ParallelJobs::p, and findQualityFiles::v.

                                                                         {
    typedef TrieNodeIter<T> node_iterator;
    node_iterator e;
    for (node_iterator p(&n); p != e; ++p) {
      v((*p).value(), label + (char)p.label());
      walkTrie(v, *p, label + (char)p.label());
    }
  }

withoutQuotes()

std::string edm::withoutQuotes

(

std::string const &

from

)

Definition at line 33 of file Parse.cc.

References mps_fire::result, and AlCaHLTBitMon_QueryRunRegistry::string.

                                                 {
    std::string result = from;
    if (!result.empty()) {
      // get rid of leading quotes
      if (result[0] == '"' || result[0] == '\'') {
        result.erase(0, 1);
      }
    }

    if (!result.empty()) {
      // and trailing quotes
      int lastpos = result.size() - 1;
      if (result[lastpos] == '"' || result[lastpos] == '\'') {
        result.erase(lastpos, 1);
      }
    }
    return result;
  }

wrappedClassName()

std::string edm::wrappedClassName

(

std::string const &

iFullName

)

Definition at line 4 of file WrappedClassName.cc.

References className(), and AlCaHLTBitMon_QueryRunRegistry::string.

Referenced by edm::StreamerInputSource::buildClassCache(), edm::ProductRegistry::checkDictionariesOfConsumedTypes(), checkDictionaryOfWrappedType(), BareRootProductGetter::createNewBuffer(), edm::StreamerInputSource::declareStreamers(), FWFileEntry::getBranchName(), fwlite::DataGetterHelper::getByBranchDescription(), edm::productholderindexhelper::getContainedType(), edm::root::FWLiteDelayedReader::getTheProduct(), edm::BranchDescription::initFromDictionary(), and FWFileEntry::runFilter().

                                                         {
    std::string const wrapperBegin("edm::Wrapper<");
    std::string const wrapperEnd1(">");
    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

debugit

debugvalue edm::debugit

Definition at line 10 of file DebugMacros.cc.

Referenced by edm::ExceptionToActionTable::addDefaults(), edm::RootDebug::RootDebug(), and edm::RootDebug::~RootDebug().

ELdebug

constexpr const ELseverityLevel edm::ELdebug {ELseverityLevel::ELsev_success}

Definition at line 82 of file ELseverityLevel.h.

Referenced by edm::service::ELoutput::log(), and edm::ErrorObj::setSeverity().

ELerror

constexpr const ELseverityLevel edm::ELerror {ELseverityLevel::ELsev_error}

Definition at line 90 of file ELseverityLevel.h.

Referenced by LoggedErrorsOnlySummary().

ELfwkInfo

constexpr const ELseverityLevel edm::ELfwkInfo {ELseverityLevel::ELsev_fwkInfo}

Definition at line 86 of file ELseverityLevel.h.

ELhighestSeverity

constexpr const ELseverityLevel edm::ELhighestSeverity {ELseverityLevel::ELsev_highestSeverity}

Definition at line 96 of file ELseverityLevel.h.

Referenced by edm::service::ThreadSafeLogMessageLoggerScribe::configure_errorlog_new(), edm::service::ThreadSafeLogMessageLoggerScribe::configure_ordinary_destinations(), and edm::ErrorObj::setSeverity().

ELinfo

constexpr const ELseverityLevel edm::ELinfo {ELseverityLevel::ELsev_info}

Definition at line 84 of file ELseverityLevel.h.

ELsevere

constexpr const ELseverityLevel edm::ELsevere {ELseverityLevel::ELsev_severe}

Definition at line 94 of file ELseverityLevel.h.

Referenced by edm::service::ELoutput::log(), and edm::ErrorObj::setSeverity().

ELunspecified

constexpr const ELseverityLevel edm::ELunspecified {ELseverityLevel::ELsev_unspecified}

Definition at line 92 of file ELseverityLevel.h.

ELwarning

constexpr const ELseverityLevel edm::ELwarning {ELseverityLevel::ELsev_warning}

Definition at line 88 of file ELseverityLevel.h.

Referenced by edm::service::ELdestination::changeFile(), edm::service::ELdestination::flush(), and edm::MessageSender::ErrorObjDeleter::operator()().

ELzeroSeverity

constexpr const ELseverityLevel edm::ELzeroSeverity {ELseverityLevel::ELsev_zeroSeverity}

Definition at line 80 of file ELseverityLevel.h.

Referenced by edm::service::ThreadSafeLogMessageLoggerScribe::makeDestinationCtrl(), and edm::ErrorObj::setSeverity().

invalidEventNumber

EventNumber_t const edm::invalidEventNumber = 0U

Definition at line 16 of file RunLumiEventNumber.h.

Referenced by edm::EventPrincipal::commonFillEventPrincipal(), FWGUIManager::eventIdChanged(), edmtest::ExceptionThrowingProducer::globalBeginLuminosityBlock(), edmtest::ExceptionThrowingProducer::globalBeginRun(), edmtest::ExceptionThrowingProducer::globalEndLuminosityBlock(), edmtest::ExceptionThrowingProducer::globalEndRun(), edmtest::ExceptionThrowingProducer::streamBeginLuminosityBlock(), edmtest::ExceptionThrowingProducer::streamBeginRun(), edmtest::ExceptionThrowingProducer::streamEndLuminosityBlock(), and edmtest::ExceptionThrowingProducer::streamEndRun().

invalidLuminosityBlockNumber

LuminosityBlockNumber_t const edm::invalidLuminosityBlockNumber = 0U

Definition at line 17 of file RunLumiEventNumber.h.

Referenced by edmtest::ExceptionThrowingProducer::globalBeginRun(), edmtest::ExceptionThrowingProducer::globalEndRun(), FWGUIManager::lumiIdChanged(), edmtest::ExceptionThrowingProducer::streamBeginRun(), and edmtest::ExceptionThrowingProducer::streamEndRun().

invalidRunNumber

RunNumber_t const edm::invalidRunNumber = 0U

Definition at line 18 of file RunLumiEventNumber.h.

Referenced by FWGUIManager::runIdChanged().

kAveEventPerSec

unsigned long long constexpr edm::kAveEventPerSec = 200ULL

static

Definition at line 38 of file IDGeneratorSourceBase.cc.

Referenced by edm::IDGeneratorSourceBase< PuttableSourceBase >::fillDescription().

kJobReportEndElement

constexpr std::string_view edm::kJobReportEndElement = "</FrameworkJobReport>\n"

static

Definition at line 305 of file JobReport.cc.

Referenced by edm::JobReport::temporarilyCloseXML(), and edm::JobReport::~JobReport().

kMinSizeOfComment

constexpr int edm::kMinSizeOfComment = 8

static

Definition at line 306 of file JobReport.cc.

Referenced by edm::JobReport::~JobReport().

kNanoSecPerSec

unsigned long long constexpr edm::kNanoSecPerSec = 1000000000ULL

static

Definition at line 37 of file IDGeneratorSourceBase.cc.

Referenced by edm::IDGeneratorSourceBase< PuttableSourceBase >::fillDescription().

MLSCRIBE_RUNNING_INDICATOR

const unsigned char edm::MLSCRIBE_RUNNING_INDICATOR = 29

static

Definition at line 83 of file MessageDrop.h.

Referenced by FlushMessageLog(), isMessageProcessingSetUp(), run_app(), and edm::service::SingleThreadMSPresence::SingleThreadMSPresence().

module_type_desc

constexpr const char* edm::module_type_desc[]

Initial value:

{
      "Unknown", "Source", "ESSource", "ESProducer", "EDAnalyzer", "EDProducer", "EDFilter", "OutputModule"}

Definition at line 19 of file EDMModuleType.h.

Referenced by edmModuleType(), DependencyGraph::edmModuleType(), edmModuleTypeEnum(), and DependencyGraph::edmModuleTypeEnum().

numberOfRunLumiEventProductTrees

constexpr unsigned int edm::numberOfRunLumiEventProductTrees = 3

Definition at line 15 of file BranchType.h.

Referenced by edm::PoolOutputModule::respondToOpenInputFile(), and edm::RootFile::RootFile().

s_defaultNumberOfThreads

constexpr unsigned int edm::s_defaultNumberOfThreads = 1

Definition at line 9 of file ThreadsInfo.h.

Referenced by fillOptionsDescription().

s_defaultSizeOfStackForThreadsInKB

constexpr unsigned int edm::s_defaultSizeOfStackForThreadsInKB = 10 * 1024

Definition at line 10 of file ThreadsInfo.h.

s_emptyCache

const std::vector<void const*> edm::s_emptyCache {}

static

Definition at line 184 of file PtrVectorBase.cc.

Referenced by edm::PtrVectorBase::emptyCache().

s_emptyProcessHistory

ProcessHistory const edm::s_emptyProcessHistory

static

Definition at line 34 of file Principal.cc.

Referenced by edm::Principal::fillPrincipal().

s_nextIdentifier

std::atomic<Principal::CacheIdentifier_t> edm::s_nextIdentifier {1}

static

Definition at line 110 of file Principal.cc.

Referenced by nextIdentifier().

s_productGetter

thread_local EDProductGetter const* edm::s_productGetter = nullptr

Definition at line 77 of file EDProductGetter.cc.

Referenced by edm::EDProductGetter::assignEDProductGetter(), and edm::EDProductGetter::switchProductGetter().

shift

unsigned int const edm::shift = 8 * sizeof(unsigned int)

static

Definition at line 7 of file LuminosityBlockID.cc.

Referenced by algorithm(), EcalEBPhase2TPParamProducer::analyze(), L1TCSCTF::analyze(), EcalTPGParamBuilder::analyze(), CTPPSDiamondDQMSource::analyze(), HcalTriggerPrimitiveAlgo::analyze(), HcalTriggerPrimitiveAlgo::analyzeHF(), HcalTriggerPrimitiveAlgo::analyzeHFQIE10(), HcalTriggerPrimitiveAlgo::analyzeQIE11(), RigidBodyAlignmentParameters::apply(), BeamSpotAlignmentParameters::apply(), TwoBowedSurfacesAlignmentParameters::apply(), MuScleFitUtils::applyScale(), cms::cuda::HistoContainer< T, NBINS, SIZE, S, I, NHISTS >::bin(), cms::alpakatools::HistoContainer< T, NBINS, SIZE, S, I, NHISTS >::bin(), CSCTFTrackBuilder::buildTracks(), barrelUtil::calculatePhiWindow(), HGCalDDDConstants::cassetteShiftScintillator(), HGCalDDDConstants::cassetteShiftSilicon(), HGCalDDDConstants::cellHex(), hcal::reconstruction::compute_pulse_shape_value(), EcalEBPhase2TPParamProducer::computeLinearizerParam(), EcalTPGParamBuilder::computeLinearizerParam(), MuonPathAssociator::correlateMPaths(), DEutils< T >::DEDigi(), trklet::MatchProcessor::execute(), DDCutTubsFromPoints::execute(), Phase2Tracker::extract64(), Py8toJetInput::fillJetAlgoInput(), HGCROCChannelDataFrame< D >::fillPacket(), pat::MET::findMETTotalShift(), MiniFloatConverter::float32to16round(), trackerTFP::Format< v, p >::Format(), l1t::GtRecordDump::formatAsym(), l1t::GtRecordDump::formatCentrality(), l1t::GtRecordDump::formatHMB(), RPCTBMuon::PACOut::fromBits(), RPCTBMuon::TBOut::fromBits(), RPCTBMuon::TCOut::fromBits(), RPCTBMuon::HSBOut::fromBits(), RPCTBMuon::FSBOut::fromBits(), PtAssignmentEngineAux2016::getEtaFromEtaInt(), PtAssignmentEngineAux2016::getEtaInt(), UCTCTP7RawData5BX::getHFFeatureBits(), UCTCTP7RawData::getHFFeatureBits(), UCTCTP7RawData5BX_HCALFB::getHFFeatureBits(), UCTCTP7RawData_HCALFB::getHFFeatureBits(), HGCTriggerDetId::getMaskedId(), popcon::EcalLaser_weekly_Linearization::getNewObjects(), popcon::EcalLaser_weekly_Linearization_Check::getNewObjects(), popcon::EcalTPGPedfromFile::getNewObjects(), popcon::EcalTPGLinPed::getNewObjects(), OptOModifiedRhomboidPrism::getRotatedPlate(), HcalDDDSimConstants::getShift(), gpuClustering::pixelStatus::getStatus(), ALPAKA_ACCELERATOR_NAMESPACE::pixelClustering::pixelStatus::getStatus(), HIPplots::GetSubDet(), HGCSample::getWord(), RigidBodyAlignmentParameters::globalParameters(), BeamSpotAlignmentParameters::globalParameters(), PatternGenerator::groupPatterns(), HcalDDDSimConstants::HcalCellTypes(), PixelTripletNoTipGenerator::hitTriplets(), trklet::MatchEngineUnit::init(), SiPixelDigitizerAlgorithm::PixelEfficiencies::init_from_db(), EcalUncalibRecHitTimingCCAlgo::interpolatePulse(), FFTJetPFPileupCleaner::isRemovable(), trklet::Settings::krinvpars(), l1t::l1t_pack_int(), L1TTwinMuxRawToDigi::L1TTwinMuxRawToDigi(), npstat::ArrayND< Numeric >::linearFill(), npstat::ArrayND< Numeric >::linearFillLoop(), fftjetcms::LinInterpolatedTable1D::LinInterpolatedTable1D(), L1MuDTPtaLut::load(), L1TMuonBarrelParamsHelper::load_pt(), pixelTopology::Phase1::localX(), pixelTopology::Phase1::localY(), trklet::L1TStub::lorentzcor(), MuonPathAnalyticAnalyzer::MuonPathAnalyticAnalyzer(), MuonPathAnalyzerInChamber::MuonPathAnalyzerInChamber(), MuonPathAssociator::MuonPathAssociator(), MuonPathConfirmator::MuonPathConfirmator(), MuonPathFitter::MuonPathFitter(), MuonPathSLFitter::MuonPathSLFitter(), HcalPulseShapes::normalizeShift(), HGCalHistoSeedingImpl::Navigator::offset(), ALPAKA_ACCELERATOR_NAMESPACE::ecal::raw::Kernel_unpack::operator()(), SiPixelCluster::PixelPos::operator+(), FTLCluster::FTLHitPos::operator+(), HcalTTPDigiProducer::produce(), pat::PATMETSlimmer::produce(), ShiftedMETcorrInputProducer::produce(), ShiftedPFCandidateProducerByMatchedObject::produce(), ShiftedJetProducerByMatchedObjectT< T >::produce(), ShiftedParticleProducer::produce(), ShiftedPFCandidateProducerForPFMVAMEt::produce(), ShiftedPFCandidateProducerForNoPileUpPFMEt::produce(), ShiftedPFCandidateProducerForPFNoPUMEt::produce(), ShiftedParticleProducerT< T >::produce(), l1t::GenToInputProducer::produce(), ShiftedJetProducerT< T, Textractor >::produce(), trklet::ProjectionTemp::ProjectionTemp(), gpuClustering::pixelStatus::promote(), ALPAKA_ACCELERATOR_NAMESPACE::pixelClustering::pixelStatus::promote(), pat::PATMETSlimmer::OneMETShift::readAndSet(), HGCROCChannelDataFrame< D >::readPacket(), PseudoBayesGrouping::RecognisePatternsByLayerPairs(), HFPreRecAlgo::reconstruct(), CrossSectionHandler::releaseParameters(), CSCTFSectorProcessor::run(), CSCTFSPCoreLogic::run(), HFRecHitAuxSetter::setAux(), UCTCTP7RawData5BX::setHFFeatureBits(), UCTCTP7RawData::setHFFeatureBits(), UCTCTP7RawData5BX_HCALFB::setHFFeatureBits(), UCTCTP7RawData_HCALFB::setHFFeatureBits(), HGCTriggerDetId::setMaskedId(), HcalTriggerPrimitiveAlgo::setNCTScaleShift(), BackgroundHandler::setParameters(), HcalTriggerPrimitiveAlgo::setRCTScaleShift(), FFTJetPFPileupCleaner::setRemovalBit(), pat::MET::setUncShift(), HGCSample::setWord(), pat::MET::shiftedP2(), pat::MET::shiftedP2_74x(), pat::MET::shiftedP3(), pat::MET::shiftedP3_74x(), pat::MET::shiftedP4(), pat::MET::shiftedP4_74x(), pat::MET::shiftedPhi(), pat::MET::shiftedPt(), pat::MET::shiftedPx(), pat::MET::shiftedPy(), pat::MET::shiftedSumEt(), pat::MET::shiftedSumEt_74x(), AlignmentProducerBase::simpleMisalignment(), IdealResult::solve(), DTTracoChip::storeCorr(), DTTracoChip::storeUncorr(), RPCTBMuon::PACOut::toBits(), RPCTBMuon::TBOut::toBits(), RPCTBMuon::TCOut::toBits(), RPCTBMuon::HSBOut::toBits(), RPCTBMuon::FSBOut::toBits(), HeterogeneousHGCalHEFCellPositionsConditions::transfer_data_to_heterogeneous_pointers_(), HeterogeneousHGCalHEFConditionsWrapper::transfer_data_to_heterogeneous_pointers_params_(), RigidBodyAlignmentParameters::translation(), BeamSpotAlignmentParameters::translation(), DCCEEEventBlock::unpack(), DCCEBEventBlock::unpack(), CSCTFEvent::unpack(), pat::PackedGenParticle::unpack(), pat::PackedCandidate::unpack(), LatencyHistosUsingDb::update(), Alignable::update(), Alignable::updateMother(), edm::LuminosityBlockID::value(), CastorCORData::wasMarkAndPassZS(), and HcalPulseShapes::Y11206().

shutdown_flag

volatile std::atomic< bool > edm::shutdown_flag {false}

Definition at line 22 of file UnixSignalHandlers.cc.

Referenced by edm::EventProcessor::checkForAsyncStopRequest(), DAQSource::checkNext(), evf::EvFBuildingThrottle::dowork(), ep_sigusr2(), dqmservices::DQMProtobufReader::getNextItemType(), evf::EvFDaqDirector::initRun(), FedRawDataInputSource::nextEvent(), evf::FastMonitoringService::preGlobalEndLumi(), dqmservices::DQMStreamerReader::prepareNextFile(), FedRawDataInputSource::readSupervisor(), DAQSource::readSupervisor(), and evf::GlobalEvFOutputEventWriter::throttledCheck().