HLT enums. More...

Namespaces
	clonehelper

	convertException

	detail

	details

	detailsTrie

	dqh

	dsrvdetail

	edmmltest

	errors

	es

	eventsetup

	evtSel

	exception_actions

	extensioncord

	fillDetails

	friendlyname

	global

	graph

	handleimpl

	hash_detail

	helper

	helpers

	hlt

	impl

	limited

	maker

	math_private

	messagedrop

	MixingCache

	module

	multicore

	one

	pathStatusExpression

	pdtentry

	poolNames

	principal_get_adapter_detail

	producerbasehelper

	productholderindexhelper

	pset

	python

	rec_dep

	refcore

	refcoreimpl

	refhelper

	refitem

	reftobase

	releaseversion

	root

	roottree

	service

	serviceregistry

	signalslot

	soa

	soahelper

	storage

	stream

	test

	threadLocalException

	typelookup

	waitingtask

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

struct	BeginLuminosityBlockProducer

struct	BeginRunProducer

class	BMixingModule

class	BoolCache

class	BranchChildren

class	BranchDescription

class	BranchID

class	BranchIDListHelper

class	BranchKey

struct	BranchToCount

class	CallNTimesNoWait

class	CallOnceNoWait

class	CFWriter

struct	CheckAbility

struct	CheckAbility< ABILITY >

struct	CheckAbility< ABILITY, T, VArgs... >

struct	ClonePolicy

class	CloningPtr

class	Comment

struct	CommonParams

class	Compare_Index

class	Compare_Index_Run

class	Compare_Run_Lumi_EventEntry

struct	CompareRefDetSet

class	ConditionsInEventBlock

class	ConditionsInLumiBlock

class	ConditionsInRunBlock

class	ConfigurationDescriptions

struct	ConfigurationHandshake

class	ConstProductRegistry

class	ConstPtrCache

class	ConstRespectingPtr

class	ConsumesCollector

class	ConsumesInfo

class	ContainerMask

class	ContainerMaskTraits

class	ContainerMaskTraits< edmNew::DetSetVector< T > >

struct	CopyPolicy

class	CosMuoGenProducer

class	CountAndLimit

class	CPUServiceBase

class	CPUTimer

class	CurrentModuleOnThread

class	CustomStreamer

struct	DaqProvenanceHelper

class	DataFrame

class	DataFrameContainer

class	DataManagingProductResolver

class	DataMixingEcalDigiWorkerProd

class	DataMixingEMDigiWorker

class	DataMixingEMWorker

class	DataMixingGeneralTrackWorker

class	DataMixingHcalDigiWorker

class	DataMixingHcalDigiWorkerProd

class	DataMixingHcalWorker

class	DataMixingModule

class	DataMixingMuonWorker

class	DataMixingPileupCopy

class	DataMixingSiPixelMCDigiWorker

class	DataMixingSiPixelWorker

class	DataMixingSiStripMCDigiWorker

class	DataMixingSiStripRawWorker

class	DataMixingSiStripWorker

class	DataMixingTrackingParticleWorker

class	debugging_allocator

struct	debugvalue

class	DefaultRunHelper

class	DelayedReader

class	DescriptionFillerForESProducers

class	DescriptionFillerForESSources

class	DescriptionFillerForServices

class	DetSet

class	DetSetRefVector

class	DetSetVector

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	EDAnalyzer

class	EDCollection

class	EDConsumerBase

class	EDFilter

class	EDGetToken

class	EDGetTokenT

class	EDLooper

class	EDLooperBase

class	EdmEventItemGetter
	Helper class that fetches some type of Ref given ProductID and index, using the edm::Event. More...

class	EDProducer

class	EDProductGetter

class	EDPutToken

class	EDPutTokenT

class	ELextendedID

class	ELseverityLevel

struct	ELslProxy

class	EmbeddedRootSource

class	EmptyESSource

class	EmptyGroupDescription

class	EmptySource

class	EmptyWaitingTask

struct	EndLuminosityBlockProducer

class	EndPathStatus

class	EndPathStatusInserter

struct	EndRunProducer

class	Entry

class	ErrorObj

struct	ErrorSummaryEntry

class	ESHandle

class	ESHandleBase

class	ESHandleExceptionFactory

class	ESInputTag

class	ESOutlet

class	ESProducer

class	ESProducerLooper

struct	ESProducts

class	ESProxyFactoryProducer

class	ESRecordAuxiliary

class	ESTransientHandle

class	ESWatcher

class	Event

class	EventAcquireSignalsSentry

class	EventAux

class	EventAuxiliary

class	EventAuxiliaryHistoryProducer

class	EventBase

class	EventContentAnalyzer

class	EventEntryDescription

class	EventEntryInfo

class	EventForOutput

class	EventID

class	EventPrincipal

class	EventProcessHistoryID

class	EventProcessor

class	EventRange

class	EventSelector

class	EventSetup

class	EventSetupCacheIdentifierChecker

class	EventSetupRecordDataGetter

class	EventSetupRecordIntervalFinder

class	EventSignalsSentry

class	EventSkipperByID

struct	EventSummary

class	EventTime

struct	EventTimingSummary

class	Exception

class	ExceptionCollector

class	ExceptionToActionTable

class	ExpoRandomPGunProducer

class	ExpoRandomPtGunProducer

class	ExtensionCord

struct	ExternalWork

class	Factory

class	FileBlock

class	FileCatalogItem

class	FileFormatVersion

class	FileID

class	FileIndex

class	FileInPath

class	FileLocator

class	FileRandomKEThetaGunProducer

struct	FilledProductPtr

class	FilterObjectWrapper

class	FilterValueMapWrapper

class	FilterWrapper

class	FixedPUGenerator

class	FlatBaseThetaGunProducer

class	FlatEGunASCIIWriter

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

class	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	FWLiteFilterWrapper

class	GaussRandomPThetaGunProducer

class	GeneratorFilter

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::OwnArray< T, M, P > >

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_setPtr

struct	has_setPtr< edm::OwnArray< T, M, P > >

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	HasAbilityToProduceInLumis

struct	HasAbilityToProduceInRuns

class	Hash

class	HcalNoiseStorage

class	HepMCProduct

class	HiMixingModule

class	HiMixingWorker

class	HiMixingWorkerBase

class	History

class	HistoryAppender

class	HLTGlobalStatus

class	HLTPathStatus

class	IDVectorMap

class	IfExistsDescription

class	IllegalParameters

class	IndexIntoFile

class	IndexSet

class	InputAnalyzer

class	InputFile

class	InputFileCatalog

class	InputProductResolver

class	InputSource

struct	InputSourceDescription

class	InputSourceFactory

class	InputTag

class	InputTagMatch

class	InternalContext

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	LogAbsolute

class	LogDebug_

class	LogError

class	LogErrorHarvester

class	LogImportant

class	LogInfo

class	LogPrint

class	LogProblem

class	LogSystem

class	LogTrace_

class	LogVerbatim

class	LogWarning

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

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	MallocOptionSetter

struct	MallocOpts

class	MapOfVectors

class	MCFileSource

class	MemberWithDict

struct	MergeableCounter

struct	MessageDrop

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	ModuleRegistry

class	ModuleTime

class	ModuloEventIDFilter

class	ModuloStreamIDFilter

class	MultiAssociation

class	MultiParticleInConeGunProducer

class	MultipleException

class	NavigateEventsLooper

struct	NewPolicy

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

class	OutputModule

class	OutputModuleCommunicator

class	OutputModuleCommunicatorT

struct	OutputModuleDescription

class	OwnArray

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

class	ParameterWildcard

class	ParameterWildcard< ParameterSetDescription >

class	ParameterWildcard< std::vector< ParameterSet > >

class	ParameterWildcardBase

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	PoissonPUGenerator

class	PoolOutputModule

class	PoolSource

class	PreallocationConfiguration

class	Prescaler

class	Presence

class	PresenceFactory

class	Principal

class	PrincipalCache

class	PrincipalGetAdapter

class	PrintEventSetupContent

class	PrintEventSetupDataRetrieval

class	ProblemTracker

class	ProcessConfiguration

class	ProcessContext

class	ProcessDesc

class	ProcessHistory

class	ProcessHistoryRegistry

class	ProcessingController

class	ProcessMatch

class	ProducedProductResolver

class	ProducerBase

class	ProducerSourceBase

class	ProducerSourceFromFiles

class	ProductData

class	ProductDeletedException

class	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

struct	ProductProvenanceEqual

struct	ProductProvenanceHasher

class	ProductProvenanceRetriever

class	ProductRegistry

class	ProductRegistryHelper

class	ProductResolverBase

class	ProductResolverIndexAndSkipBit

class	ProductResolverIndexHelper

class	ProductSelector

class	ProductSelectorRules

class	propagate_const

class	Provenance

class	ProvenanceAdaptor

class	ProvenanceCheckerOutputModule

class	ProvenanceReaderBase

class	Ptr

class	PtrHolder

class	PtrVector

class	PtrVectorBase

class	PtrVectorItr

class	PUGenerator

class	PuttableProductResolver

class	PuttableSourceBase

class	RandomEngineSentry

class	RandomEngineStates

class	RandomFilter

class	RandomMultiParticlePGunProducer

class	RandomNumberGenerator

class	RandomtXiGunProducer

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

struct	RunSummaryCache

class	Schedule

class	ScheduleInfo

struct	ScheduleItems

class	SecondaryEventIDAndFileInfo

class	SecondaryEventProvider

class	SecSourceAnalyzer

class	SendEvent

class	SendJobHeader

class	SerialTaskQueue

class	SerialTaskQueueChain

class	Service

class	ServiceRegistry

class	ServiceToken

class	SetRunForEachLumiHelper

class	SetRunHelper

class	SharedResourceNames

class	SharedResourcesAcquirer

class	SharedResourcesRegistry

class	SignallingProductRegistry

class	SimpleOutlet

class	SingleChoiceNoProcessProductResolver

class	SingleConsumerQ

class	SiteLocalConfig

class	SoATuple

class	SortedCollection

class	StableProvenance

class	StatsCount

struct	StoredProductProvenance

struct	StreamCache

class	StreamContext

class	StreamedProduct

class	StreamerFileReader

class	StreamerFileWriter

class	StreamerInputFile

class	StreamerInputModule

class	StreamerInputSource

class	StreamerOutputModule

class	StreamerOutputModuleBase

class	StreamID

class	StreamSchedule

class	StreamSerializer

struct	StrictWeakOrdering

class	SubProcess

class	SubProcessParentageHelper

class	Suppress_LogDebug_

class	SystemTimeKeeper

class	TerminationOrigin

class	TestHandle

class	TestMix

class	TestMixedSource

class	TestSource

class	ThinnedAssociation

class	ThinnedAssociationBranches

class	ThinnedAssociationsHelper

class	ThinningProducer

class	ThreadSafeAddOnlyContainer

class	ThreadSafeOutputFileStream

struct	TimeOfDay

class	TimeoutPoolOutputModule

class	Timestamp

class	TimingServiceBase

class	TRandomAdaptor

class	TransientDataFrame

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	TypeInBranchType

class	TypeToGet

class	TypeWithDict

class	UnknownModuleException
	Exception thrown when trying to instance a module which is not registered to the system. More...

class	UnscheduledAuxiliary

class	UnscheduledCallProducer

class	UnscheduledConfigurator

class	UnscheduledProductResolver

class	ValidityInterval

class	value_ptr

struct	value_ptr_traits

struct	value_ptr_traits< IndexIntoFile::IndexIntoFileItrImpl >

struct	value_ptr_traits< ParameterDescriptionNode >

class	ValueHolderECGetter

class	ValueMap

class	VecArray

class	VectorInputSource

struct	VectorInputSourceDescription

class	VectorInputSourceFactory

class	View

class	View< T >

class	ViewBase

class	ViewTypeChecker

class	VParameterSetEntry

class	WaitingTask

class	WaitingTaskHolder

class	WaitingTaskList

class	WaitingTaskWithArenaHolder

class	WallclockTimer

struct	WantsGlobalLuminosityBlockTransitions

struct	WantsGlobalRunTransitions

struct	WantsStreamLuminosityBlockTransitions

struct	WantsStreamRunTransitions

struct	WatchInputFiles

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	ZombieKillerService

Typedefs
template<typename T >
using	AlignedVec = Aligned< T, 16 >

typedef unsigned int	BranchDescriptionIndex

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 )

typedef std::vector< CTPPSFastRecHit >	CTPPSFastRecHitContainer

typedef std::vector< CTPPSFastTrack >	CTPPSFastTrackContainer

typedef DigiAccumulatorMixMod *(	DAFunc) (ParameterSet const &, ProducerBase &, ConsumesCollector &)

typedef uint32_t	det_id_type

typedef edmplugin::PluginFactory< DAFunc >	DigiAccumulatorMixModPluginFactory

typedef std::list< ELdestination * >	ELlist_dest

typedef std::list< ELstring >	ELlist_string

typedef std::map< ELstring const, ELseverityLevel::ELsev_ >	ELmap

typedef std::map< ELextendedID, CountAndLimit >	ELmap_counts

typedef std::map< ELstring, LimitAndTimespan >	ELmap_limits

typedef std::map< ELextendedID, StatsCount >	ELmap_stats

typedef ELseverityLevel const	ELslGen()

typedef std::string	ELstring

typedef Hash< EntryDescriptionType >	EntryDescriptionID

typedef std::map< EntryDescriptionID, EventEntryDescription >	EntryDescriptionMap

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

typedef RunLumiEntryInfo	LumiEntryInfo

typedef unsigned int	LuminosityBlockNumber_t

typedef edmplugin::PluginFactory< Maker *()>	MakerPluginFactory

typedef Hash< ModuleDescriptionType >	ModuleDescriptionID

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

typedef std::multimap< EventSetupRecordKey, FactoryInfo >	Record2Factories

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::map< std::string, char >	Type2Code

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 }

enum	BranchType { InEvent = 0, InLumi = 1, InRun = 2, NumBranchTypes }

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_string = 'S', k_vstring = 's', k_EventID = 'E', k_VEventID = 'e', k_LuminosityBlockID = 'M', k_VLuminosityBlockID = 'm', k_InputTag = 't', k_VInputTag = 'v', 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	TerminationOrigin { TerminationOrigin::ExceptionFromThisContext, TerminationOrigin::ExceptionFromAnotherContext, TerminationOrigin::ExternalSignal }

enum	Transition { Transition::Event, Transition::BeginLuminosityBlock, Transition::EndLuminosityBlock, Transition::BeginRun, Transition::EndRun }

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

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)

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

template<class FP >
bool	asm_isnan (FP x)

template<typename Traits , typename P , typename SC >
void	beginGlobalTransitionAsync (WaitingTaskHolder iWait, Schedule &iSchedule, P &iPrincipal, IOVSyncValue const &iTS, EventSetup const &iES, ServiceToken const &token, SC &iSubProcesses)

template<typename Traits , typename P , typename SC >
void	beginStreamsTransitionAsync (WaitingTask *iWait, Schedule &iSchedule, unsigned int iNStreams, P &iPrincipal, IOVSyncValue const &iTS, EventSetup const &iES, ServiceToken const &token, SC &iSubProcesses)

template<typename Traits , typename P , typename SC >
void	beginStreamTransitionAsync (WaitingTaskHolder iWait, Schedule &iSchedule, unsigned int iStreamIndex, P &iPrincipal, IOVSyncValue const &iTS, EventSetup const &iES, ServiceToken const &token, SC &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)

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 &	BranchTypeToMajorIndexName (BranchType const &branchType)

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

std::string const &	BranchTypeToMinorIndexName (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 const &	BranchTypeToString (BranchType const &branchType)

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

template<typename T >
static void	check (T const &p, std::string const &id, SelectedProducts const &iProducts)

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)

static void	cleanup (const Factory::MakerMap::value_type &v)

void	clearLoggedErrorsSummary (unsigned int iStreamID)

void	clearMessageLog ()

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

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

bool	contains (EventRange const &lh, EventID 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)

template<typename T >
void	convert_handle (BasicHandle &&bh, Handle< T > &result)

void	convert_handle (BasicHandle const &orig, Handle< FWGenericObject > &result)
	specialize this function forFWGenericHandle More...

void	convert_handle (BasicHandle &&orig, Handle< GenericObject > &result)
	specialize this function for GenericHandle More...

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

template<typename T1 , typename T2 , typename T3 , typename ToT >
void	copyFromTo (ESProducts< T1, T2, T3 > &iFrom, ToT &iTo)

std::string	createGlobalIdentifier ()

bool	decode (bool &, std::string const &)

bool	decode (std::vector< bool > &, std::string const &)

bool	decode (int &, std::string const &)

bool	decode (std::vector< int > &, std::string const &)

bool	decode (unsigned int &, std::string const &)

bool	decode (std::vector< unsigned int > &, std::string const &)

bool	decode (long long &, std::string const &)

bool	decode (std::vector< long long > &, std::string const &)

bool	decode (unsigned long long &, std::string const &)

bool	decode (std::vector< unsigned long long > &, std::string const &)

bool	decode (double &, std::string const &)

bool	decode (std::vector< double > &, std::string const &)

bool	decode (std::string &, std::string const &)

bool	decode (std::vector< std::string > &, std::string const &)

bool	decode (edm::FileInPath &, std::string const &)

bool	decode (edm::InputTag &, std::string const &)

bool	decode (std::vector< edm::InputTag > &, std::string const &)

bool	decode (edm::ESInputTag &, std::string const &)

bool	decode (std::vector< edm::ESInputTag > &, std::string const &)

bool	decode (edm::EventID &, std::string const &)

bool	decode (std::vector< edm::EventID > &, std::string const &)

bool	decode (edm::LuminosityBlockID &, std::string const &)

bool	decode (std::vector< edm::LuminosityBlockID > &, std::string const &)

bool	decode (edm::LuminosityBlockRange &, std::string const &)

bool	decode (std::vector< edm::LuminosityBlockRange > &, std::string const &)

bool	decode (edm::EventRange &, std::string const &)

bool	decode (std::vector< edm::EventRange > &, std::string const &)

bool	decode (ParameterSet &, std::string const &)

bool	decode (std::vector< ParameterSet > &, std::string const &)

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

void	doBuildRealData (const std::string &name)

const char *	edmModuleType (edm::ModuleDescription const &module)

EDMModuleType	edmModuleTypeEnum (edm::ModuleDescription const &module)

void	edmodule_mightGet_config (ConfigurationDescriptions &iDesc)

ELseverityLevel const	ELdebugGen ()

ELseverityLevel const	ELerrorGen ()

ELseverityLevel const	ELhighestSeverityGen ()

ELseverityLevel const	ELinfoGen ()

ELseverityLevel const	ELsevereGen ()

ELseverityLevel const	ELunspecifiedGen ()

ELseverityLevel const	ELwarningGen ()

ELseverityLevel const	ELzeroSeverityGen ()

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

template<typename Traits , typename P , typename SC >
void	endGlobalTransitionAsync (WaitingTaskHolder iWait, Schedule &iSchedule, P &iPrincipal, IOVSyncValue const &iTS, EventSetup const &iES, ServiceToken const &token, SC &iSubProcesses, bool cleaningUpAfterException)

template<typename Traits , typename P , typename SC >
void	endStreamsTransitionAsync (WaitingTaskHolder iWait, Schedule &iSchedule, unsigned int iNStreams, P &iPrincipal, IOVSyncValue const &iTS, EventSetup const &iES, ServiceToken const &iToken, SC &iSubProcesses, bool cleaningUpAfterException)

template<typename Traits , typename P , typename SC >
void	endStreamTransitionAsync (WaitingTaskHolder iWait, Schedule &iSchedule, unsigned int iStreamIndex, P &iPrincipal, IOVSyncValue const &iTS, EventSetup const &iES, ServiceToken const &token, SC &iSubProcesses, bool cleaningUpAfterException)

void	ep_sigusr2 (int, siginfo_t , void )

bool	eq (const ELstring &s1, const ELstring s2)

bool	eq_nocase (const ELstring &s1, const char s2[])

template<class FP >
bool	equal_isnan (FP x)

void	exceptionContext (std::ostream &, GlobalContext const &)

void	exceptionContext (std::ostream &, StreamContext const &)

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

std::shared_ptr< EDLooperBase >	fillLooper (eventsetup::EventSetupsController &esController, eventsetup::EventSetupProvider &cp, ParameterSet &params)

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 , unsigned int M, typename P >
void	fillPtrVector (OwnArray< T, M, P > 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 T >
void	fillView (PtrVector< T > const &obj, ProductID const &, std::vector< void const * > &pointers, 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 (RefToBaseVector< T > const &obj, ProductID const &, 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<typename T >
void	fillView (std::vector< edm::Ptr< T > > 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 , unsigned int M, typename P >
void	fillView (OwnArray< T, M, P > 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 , typename R = typename eventsetup::data_default_record_trait<typename T::value_type>::type>
T const &	get (EventSetup const &setup)

template<typename T , typename R = typename eventsetup::data_default_record_trait<typename T::value_type>::type, typename L >
T const &	get (EventSetup const &setup, L &&label)

template<typename T >
T const &	get (LuminosityBlock const &event, InputTag const &tag)

template<typename T >
T const &	get (LuminosityBlock const &event, EDGetToken const &token)

template<typename T >
T const &	get (Run const &event, InputTag const &tag)

template<typename T >
T const &	get (LuminosityBlock const &event, EDGetTokenT< T > const &token)

template<typename T >
T const &	get (Run const &event, EDGetToken const &token)

template<typename T >
T const &	get (Run const &event, EDGetTokenT< T > const &token)

template<typename T >
T const &	get (Event const &event, InputTag const &tag)

template<typename T >
T const &	get (Event const &event, EDGetToken const &token)

template<typename T >
T const &	get (Event const &event, EDGetTokenT< T > const &token)

template<typename T >
T &	get_underlying (propagate_const< T > &)

template<typename T >
T const &	get_underlying (propagate_const< T > const &)

template<typename T >
std::shared_ptr< T > &	get_underlying_safe (propagate_const< std::shared_ptr< T >> &iP)

template<typename T >
std::shared_ptr< T const >	get_underlying_safe (propagate_const< std::shared_ptr< T >> const &iP)

template<typename T >
T *&	get_underlying_safe (propagate_const< T * > &iP)

template<typename T >
T const *	get_underlying_safe (propagate_const< T * > const &iP)

template<typename T >
std::unique_ptr< T > &	get_underlying_safe (propagate_const< std::unique_ptr< T >> &iP)

template<typename T >
std::unique_ptr< T const >	get_underlying_safe (propagate_const< 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 ()

template<class T , std::size_t N>
std::array< T, N >	getFixedSizeArray (ParameterSet const &pset, std::string const &name)

MallocOptionSetter &	getGlobalOptionSetter ()

ParameterSet const &	getParameterSet (ParameterSetID const &id)

std::string	getPassID ()

ParameterSet const &	getProcessParameterSetContainingModule (ModuleDescription const &moduleDescription)

ParameterSet const *	getProducerParameterSet (Provenance const &provenance)

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)

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)

TClass *	getTClass (std::type_info const &ti)

template<typename T >
T const *	getThinnedProduct (RefCore const &ref, unsigned int &thinnedKey, 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 const &category)

void	HaltMessageLogging ()

bool	hasDictionary (std::type_info const &)

HRTimeType	hrRealTime ()

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 >
bool	isFinite (T x)

template<>
bool	isFinite (float x)

template<>
bool	isFinite (double x)

template<>
bool	isFinite (long double x)

bool	isInfoEnabled ()

bool	isMessageProcessingSetUp ()

bool	isnan (float f)

bool	isnan (double d)

bool	isnan (long double q)

template<typename T >
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	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")

static const std::string	kBaseType ("EDProducer")

static const std::string	kBaseType ("EDFilter")

static const std::string	kBaseType ("EDAnalyzer")

static const std::string	kBaseType ("OutputModule")

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 (std::string const &name, std::vector< std::string > &missingDictionaries)

bool	loadCap (const std::string &name, std::vector< std::string > &missingDictionaries)

void	loadExtraClasses ()

static ELmap const &	loadMap ()

std::vector< ErrorSummaryEntry >	LoggedErrorsOnlySummary (unsigned int iStreamID)

std::vector< 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)

std::unique_ptr< edm::EmptyWaitingTask, waitingtask::TaskDestroyer >	make_empty_waiting_task ()
	Create an EmptyWaitingTask which will properly be destroyed. More...

template<typename ALLOC , typename F >
FunctorTask< F > *	make_functor_task (ALLOC &&iAlloc, 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 ALLOC , typename F >
FunctorWaitingTask< F > *	make_waiting_task (ALLOC &&iAlloc, F f)

template<typename T >
std::shared_ptr< ESHandleExceptionFactory >	makeESHandleExceptionFactory (T &&iFunctor)

template<typename T >
std::shared_ptr< HandleExceptionFactory >	makeHandleExceptionFactory (T &&iFunctor)

std::unique_ptr< InputSource >	makeInput (ParameterSet &params, CommonParams const &common, std::shared_ptr< ProductRegistry > preg, std::shared_ptr< BranchIDListHelper > branchIDListHelper, std::shared_ptr< ThinnedAssociationsHelper > thinnedAssociationsHelper, std::shared_ptr< ActivityRegistry > areg, std::shared_ptr< ProcessConfiguration const > processConfiguration, PreallocationConfiguration const &allocations)

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::shared_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)

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 (Provenance const &provenance)

EDProductGetter const *	mustBeNonZero (EDProductGetter const *prodGetter, std::string refType, ProductID const &productID)

static Principal::CacheIdentifier_t	nextIdentifier ()

Long64_t	numEntries (TFile *hdl, const std::string &trname)

Long64_t	numEntries (TFile *hdl, std::string const &trname)

TFile *	openFileHdl (const std::string &fname)

TFile *	openFileHdl (std::string const &fname)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

bool	operator!= (TypeWithDict const &a, std::type_info 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 KEY >
bool	operator!= (RefVectorBase< KEY > const &lhs, RefVectorBase< KEY > const &rhs)
	Inequality operator. More...

template<typename T >
bool	operator!= (View< T > const &, View< T > const &)

bool	operator!= (std::type_info const &a, TypeWithDict const &b)

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

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)

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

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)

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

bool	operator!= (ELseverityLevel const &e1, ELseverityLevel const &e2)

template<typename T , typename U >
bool	operator!= (value_ptr< T > const &lhs, U const &rhs)

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)

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)

ParameterSet::Bool	operator&& (ParameterSet::Bool a, ParameterSet::Bool b)

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 C >
Association< C >	operator+ (const Association< C > &a1, const Association< C > &a2)

template<typename T >
ValueMap< T >	operator+ (const ValueMap< T > &a1, const ValueMap< T > &a2)

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

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

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

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

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

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

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

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

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

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)

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

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

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

template<typename T >
bool	operator< (View< T > const &, View< T > const &)

template<typename T >
bool	operator< (FwdPtr< T > const &lhs, FwdPtr< T > const &rhs)

template<typename T >
bool	operator< (RefToBaseProd< T > const &lhs, RefToBaseProd< T > const &rhs)

bool	operator< (ELseverityLevel const &e1, ELseverityLevel const &e2)

template<typename C >
bool	operator< (RefProd< C > const &lhs, RefProd< C > const &rhs)

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

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)

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 &os, BranchType const &branchType)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

std::ostream &	operator<< (std::ostream &oStream, LuminosityBlockRange const &iID)

std::ostream &	operator<< (std::ostream &oStream, EventRange const &iID)

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

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

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

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

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

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

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

std::ostream &	operator<< (std::ostream &t, OStreamColumn const &c)

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

template<typename E >
std::ostream &	operator<< (std::ostream &t, OStreamColumnEntry< E > const &ce)

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

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

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

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

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

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

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

std::ostream &	operator<< (std::ostream &os, ParameterSetEntry const &psetEntry)

std::ostream &	operator<< (std::ostream &ost, const HLTGlobalStatus &hlt)
	Formatted printout of trigger tbale. More...

std::ostream &	operator<< (std::ostream &os, JobReport::RunReport const &f)

template<class T >
ErrorObj &	operator<< (ErrorObj &e, const T &t)

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

ErrorObj &	operator<< (ErrorObj &e, const char s[])

std::ostream &	operator<< (std::ostream &oStream, LuminosityBlockID const &iID)

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

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

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

std::ostream &	operator<< (std::ostream &os, ProductResolverBase const &phb)

std::ostream &	operator<< (std::ostream &os, ProductRegistry const &pr)

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

std::ostream &	operator<< (std::ostream &os, const ELseverityLevel &sev)

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

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

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)

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

template<typename T >
bool	operator<= (View< T > const &, View< T > const &)

bool	operator<= (ELseverityLevel const &e1, ELseverityLevel const &e2)

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

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

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

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

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

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

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

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

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

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)

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

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

bool	operator== (edm::FileInPath const &a, edm::FileInPath 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)

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

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)

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

bool	operator== (ELseverityLevel const &e1, ELseverityLevel const &e2)

template<typename T , typename U >
bool	operator== (value_ptr< T > const &lhs, U const &rhs)

template<typename T , typename U >
bool	operator== (U const &lhs, value_ptr< T > const &rhs)

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

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<typename C , typename T , typename F >
bool	operator== (FwdRef< C, T, F > const &lhs, Ref< C, T, F > const &rhs)

template<typename T >
bool	operator== (Ptr< T > const &lhs, Ptr< T > const &rhs)

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)

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

template<typename T >
bool	operator> (View< T > const &, View< T > const &)

bool	operator> (ELseverityLevel const &e1, ELseverityLevel const &e2)

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

template<typename T >
bool	operator>= (View< T > const &, View< T > const &)

bool	operator>= (ELseverityLevel const &e1, ELseverityLevel const &e2)

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 (Provenance const &provenance)

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) 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 > > (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) 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 > > (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, std::vector< EventID > const &defaultValue) const

template<>
std::vector< EventID >	ParameterSet::getUntrackedParameter< std::vector< EventID > > (std::string const &name) 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, std::vector< long long > const &defaultValue) 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 > > (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, std::vector< LuminosityBlockID > 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 > > (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 > > (std::string 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 > > (std::string const &name, std::vector< PdtEntry > const &defaultValue) const

template<>
std::vector< PdtEntry >	ParameterSet::getUntrackedParameter< std::vector< PdtEntry > > (char const *name, std::vector< PdtEntry > 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 > > (std::string const &name, std::vector< std::string > const &defaultValue) 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, std::vector< unsigned int > const &defaultValue) 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 > > (char const *name) 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 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 > > (std::string const &name) 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< 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)

template<typename RecordT >
void	print_eventsetup_record_dependencies (std::ostream &oStream, std::string const &iIndent=std::string())

template<typename T >
void	print_eventsetup_record_dependencies (std::ostream &, std::string, T const , T const )

template<typename TFirst , typename TEnd >
void	print_eventsetup_record_dependencies (std::ostream &oStream, std::string iIndent, TFirst const , TEnd const iEnd)

template<typename RecordT >
void	print_eventsetup_record_dependencies_recursive (std::ostream &oStream, std::string const &iIndent, boost::mpl::true_)

template<typename RecordT >
void	print_eventsetup_record_dependencies_recursive (std::ostream &, std::string const &, boost::mpl::false_)

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)

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< TypeWithDict > &baseTypes)

std::string	pythonFileToConfigure (const std::string &iPythonFileName)

void	pythonToCppException (const std::string &iType)

void	read_from_cin (std::string &output)

std::string	read_whole_file (std::string const &filename)
	only does the yacc interpretation More...

std::shared_ptr< ParameterSet >	readConfig (std::string const &config)

std::shared_ptr< ParameterSet >	readConfig (std::string const &config, int argc, char *argv[])
	same, but with arguments More...

std::shared_ptr< 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__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 (":")

template<typename T >
void	SetCustomStreamer ()

template<typename T >
void	SetCustomStreamer (T const &)

void	setMaxLoggedErrorsSummaryIndicies (unsigned int iMax)

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 , unsigned int M, typename P >
void	setPtr (OwnArray< T, M, P > 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::ELseverityLevel const &severity)

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 const &string_to_split, char first, char sep, char last)

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	stripLeadingDirectoryTree (const std::string &file)

std::string	stripNamespace (std::string const &theName)

bool	stripTemplate (std::string &theName)

void	subProcessDoGlobalBeginTransitionAsync (WaitingTaskHolder iHolder, SubProcess &iSubProcess, LuminosityBlockPrincipal &iPrincipal, IOVSyncValue const &iTS)

void	subProcessDoGlobalBeginTransitionAsync (WaitingTaskHolder iHolder, SubProcess &iSubProcess, RunPrincipal &iPrincipal, IOVSyncValue const &iTS)

void	subProcessDoGlobalEndTransitionAsync (WaitingTaskHolder iHolder, SubProcess &iSubProcess, LuminosityBlockPrincipal &iPrincipal, IOVSyncValue const &iTS, bool cleaningUpAfterException)

void	subProcessDoGlobalEndTransitionAsync (WaitingTaskHolder iHolder, SubProcess &iSubProcess, RunPrincipal &iPrincipal, IOVSyncValue const &iTS, bool cleaningUpAfterException)

void	subProcessDoStreamBeginTransitionAsync (WaitingTaskHolder iHolder, SubProcess &iSubProcess, unsigned int i, LuminosityBlockPrincipal &iPrincipal, IOVSyncValue const &iTS)

void	subProcessDoStreamBeginTransitionAsync (WaitingTaskHolder iHolder, SubProcess &iSubProcess, unsigned int i, RunPrincipal &iPrincipal, IOVSyncValue const &iTS)

void	subProcessDoStreamEndTransitionAsync (WaitingTaskHolder iHolder, SubProcess &iSubProcess, unsigned int i, LuminosityBlockPrincipal &iPrincipal, IOVSyncValue const &iTS, bool cleaningUpAfterException)

void	subProcessDoStreamEndTransitionAsync (WaitingTaskHolder iHolder, SubProcess &iSubProcess, unsigned int i, RunPrincipal &iPrincipal, IOVSyncValue const &iTS, bool cleaningUpAfterException)

void	swap (ProductID &a, ProductID &b)

void	swap (Parentage &a, Parentage &b)

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

void	swap (OrphanHandleBase &a, OrphanHandleBase &b)

void	swap (ProductData &a, ProductData &b)

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

void	swap (ProcessHistory &a, ProcessHistory &b)

void	swap (TriggerResults &lhs, TriggerResults &rhs)

void	swap (ESHandleBase &a, ESHandleBase &b)

void	swap (HLTGlobalStatus &lhs, HLTGlobalStatus &rhs)
	Free swap function. More...

template<typename C >
void	swap (Association< C > &lhs, Association< C > &rhs)

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

void	swap (BasicHandle &a, BasicHandle &b)

void	swap (HandleBase &a, HandleBase &b)

void	swap (ErrorObj &a, ErrorObj &b)

void	swap (FileInPath &a, FileInPath &b)

template<typename KEY >
void	swap (RefVectorBase< KEY > &a, RefVectorBase< KEY > &b)
	swap two vectors More...

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

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

template<typename K , typename T >
void	swap (MapOfVectors< K, T > &lhs, MapOfVectors< K, T > &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)

template<typename T >
void	swap (edm::RefToBaseProd< T > const &lhs, edm::RefToBaseProd< T > const &rhs)

template<typename ID , typename C , typename P >
void	swap (IDVectorMap< ID, C, P > &a, IDVectorMap< ID, C, P > &b)

template<typename T >
void	swap (value_ptr< T > &vp1, value_ptr< T > &vp2)

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

template<typename C >
void	swap (RefProd< C > const &lhs, RefProd< C > const &rhs)

template<typename ID , typename C , typename P >
void	swap (RangeMap< ID, C, P > &a, RangeMap< ID, C, P > &b)

void	swap (DataFrameContainer &lhs, DataFrameContainer &rhs)

template<int I>
void	swap (Hash< I > &a, Hash< I > &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)

template<typename T , typename C >
void	swap (DetSetRefVector< T, C > &a, DetSetRefVector< T, C > &b)

template<typename C >
void	swap (MultiAssociation< C > &lhs, MultiAssociation< C > &rhs)

void	swap (ParameterSet &a, ParameterSet &b)

template<typename T >
void	swap (View< T > &lhs, View< T > &rhs)

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

template<typename T , typename SORT >
void	swap (SortedCollection< T, SORT > &a, SortedCollection< T, SORT > &b)

template<typename T , unsigned int M, typename P >
void	swap (OwnArray< T, M, P > &a, OwnArray< T, M, P > &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)

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

std::vector< std::string >	tokenize (const std::string &input, const std::string &separator)

template<typename T >
boost::python::list	toPythonList (const std::vector< T > &v)

template<typename T >
std::vector< T >	toVector (boost::python::list &l)

static std::string const	triggerResults ("TriggerResults")

static std::string const	triggerResultsInserter ("TriggerResultsInserter")

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	withoutQuotes (const std::string &from)

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

Variables
static int const	bufSize = 128

debugvalue	debugit

ELslProxy< ELdebugGen > const	ELdebug

ELslGen	ELdebugGen

ELslProxy< ELerrorGen > const	ELerror

ELslGen	ELerrorGen

ELslProxy< ELhighestSeverityGen > const	ELhighestSeverity

ELslGen	ELhighestSeverityGen

ELslProxy< ELinfoGen > const	ELinfo

ELslGen	ELinfoGen

ELslProxy< ELsevereGen > const	ELsevere

ELslGen	ELsevereGen

ELslProxy< ELunspecifiedGen > const	ELunspecified

ELslGen	ELunspecifiedGen

ELslProxy< ELwarningGen > const	ELwarning

ELslGen	ELwarningGen

ELslProxy< ELzeroSeverityGen > const	ELzeroSeverity

ELslGen	ELzeroSeverityGen

static char const *	fmt_Guid

MallocOptionSetter	global_malloc_options

EventNumber_t const	invalidEventNumber = 0U

LuminosityBlockNumber_t const	invalidLuminosityBlockNumber = 0U

RunNumber_t const	invalidRunNumber = 0U

static unsigned long long const	kAveEventPerSec = 200ULL

static unsigned long long const	kNanoSecPerSec = 1000000000ULL

static const unsigned char	MLSCRIBE_RUNNING_INDICATOR = 29

constexpr const char *	module_type_desc []

constexpr unsigned int	s_defaultNumberOfThreads = 1

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 = 0

static unsigned int const	shift = 8 * sizeof(unsigned int)

volatile std::atomic< bool >	shutdown_flag {false}

static pset::TypeTrans const	sTypeTranslations

Detailed Description

HLT enums.

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

Register the record.

classes declaration

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 should inherit from std::binary_function<const C&, typename IndexT, const T*> (or must provide the typedefs obtained from that inheritance directly).

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

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

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.

Helper functions for making stream modules

Description: [one line class summary]

Usage: <usage>

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.

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

streamTransitionAsync streamTransitionAsync.h "streamTransitionAsync.h"

Description: Helper functions for handling asynchronous stream transitions

Usage: <usage>

throwIfImproperDependencies throwIfImproperDependencies.h "throwIfImproperDependencies.h"

Description: Function which uses the graph of dependencies to determine if there are any cycles

Usage: <usage>

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

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

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

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.

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>

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

Usage: These are internal details of Table's implementation

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.

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.

jet parton energy corrections

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

Description: simple NxN ( 3x3 etc) clustering ,( for low energy photon reconstrution, currently used for pi0/eta HLT path)

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

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

Typedef Documentation

template<typename T >

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

Definition at line 104 of file SoATuple.h.

typedef unsigned int edm::BranchDescriptionIndex

Definition at line 28 of file BranchDescriptionIndex.h.

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

Definition at line 18 of file BranchIDList.h.

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

Definition at line 19 of file BranchIDList.h.

typedef unsigned short edm::BranchListIndex

Definition at line 17 of file BranchListIndex.h.

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

Definition at line 18 of file BranchListIndex.h.

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

Definition at line 20 of file UnixSignalHandlers.h.

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

Definition at line 13 of file CTPPSFastRecHitContainer.h.

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

Definition at line 11 of file CTPPSFastTrackContainer.h.

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

Definition at line 12 of file DigiAccumulatorMixModFactory.h.

typedef uint32_t edm::det_id_type

Definition at line 21 of file DetSet.h.

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

Definition at line 13 of file DigiAccumulatorMixModFactory.h.

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

Definition at line 39 of file ELlist.h.

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

Definition at line 42 of file ELlist.h.

typedef std::map< ELstring const, ELseverityLevel::ELsev_ > edm::ELmap

Definition at line 59 of file ELseverityLevel.cc.

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

Definition at line 101 of file ELmap.h.

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

Definition at line 99 of file ELmap.h.

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

Definition at line 103 of file ELmap.h.

typedef ELseverityLevel const edm::ELslGen()

Definition at line 61 of file ELseverityLevel.h.

typedef std::string edm::ELstring

Definition at line 26 of file ELstring.h.

typedef Hash<EntryDescriptionType> edm::EntryDescriptionID

Definition at line 9 of file EntryDescriptionID.h.

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

Definition at line 51 of file RootFile.h.

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

Definition at line 57 of file EventEntryInfo.h.

typedef unsigned long long edm::EventNumber_t

Definition at line 12 of file RunLumiEventNumber.h.

typedef ParameterSetID edm::EventSelectionID

Definition at line 16 of file EventSelectionID.h.

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

Definition at line 17 of file EventSelectionID.h.

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

Definition at line 30 of file FillViewHelperVector.h.

typedef Handle<FWGenericObject> edm::FWGenericHandle

Definition at line 140 of file FWGenericHandle.h.

typedef Handle<GenericObject> edm::GenericHandle

Definition at line 132 of file GenericHandle.h.

typedef long long int edm::HRTimeDiffType

Definition at line 97 of file HRRealTime.h.

typedef unsigned long long int edm::HRTimeType

Definition at line 98 of file HRRealTime.h.

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

Definition at line 14 of file InputSourceFactory.h.

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

Definition at line 12 of file InputSourceFactory.h.

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

Definition at line 14 of file VectorInputSourceFactory.h.

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

Definition at line 8 of file LHCTransportLinkContainer.h.

typedef RunLumiEntryInfo edm::LumiEntryInfo

Definition at line 49 of file RunLumiEntryInfo.h.

typedef unsigned int edm::LuminosityBlockNumber_t

Definition at line 13 of file RunLumiEventNumber.h.

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

Definition at line 16 of file Factory.h.

typedef Hash<ModuleDescriptionType> edm::ModuleDescriptionID

Definition at line 57 of file classes.h.

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

Definition at line 30 of file ParameterSetDescriptionFillerPluginFactory.h.

typedef Hash<ParameterSetType> edm::ParameterSetID

Definition at line 22 of file ParameterSetID.h.

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

Definition at line 40 of file ParameterSetConverter.h.

typedef Hash<ParentageType> edm::ParentageID

Definition at line 9 of file ParentageID.h.

typedef std::string edm::PassID

Definition at line 8 of file PassID.h.

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

Definition at line 60 of file PassiveHit.h.

using edm::PathStatus = typedef HLTPathStatus

Definition at line 7 of file PathStatus.h.

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

Definition at line 8 of file PCaloHitContainer.h.

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

Definition at line 13 of file ConfigurationHandshake.h.

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

Definition at line 10 of file ConfigurationHandshake.h.

typedef Presence*( edm::PresenceFunc) ()

Definition at line 13 of file PresenceFactory.h.

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

Definition at line 11 of file PresenceFactory.h.

typedef Hash<ProcessConfigurationType> edm::ProcessConfigurationID

Definition at line 9 of file ProcessConfigurationID.h.

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

Definition at line 64 of file ProcessConfiguration.h.

typedef Hash<ProcessHistoryType> edm::ProcessHistoryID

Definition at line 9 of file ProcessHistoryID.h.

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

Definition at line 15 of file ProcessHistoryRegistry.h.

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

Definition at line 16 of file ProcessHistoryRegistry.h.

typedef unsigned short edm::ProcessIndex

Definition at line 25 of file ProductID.h.

typedef std::string edm::ProcessingTask

Definition at line 8 of file ProcessingTask.h.

typedef unsigned short edm::ProductIndex

Definition at line 26 of file ProductID.h.

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

Definition at line 67 of file ProductProvenance.h.

typedef unsigned int edm::ProductResolverIndex

Definition at line 8 of file ProductResolverIndex.h.

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

Definition at line 11 of file PSimHitContainer.h.

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

Definition at line 30 of file ESProxyFactoryProducer.cc.

typedef std::string edm::ReleaseVersion

Definition at line 7 of file ReleaseVersion.h.

typedef RunLumiEntryInfo edm::RunEntryInfo

Definition at line 50 of file RunLumiEntryInfo.h.

typedef unsigned int edm::RunNumber_t

Definition at line 14 of file RunLumiEventNumber.h.

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

Definition at line 11 of file SelectedProducts.h.

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

Definition at line 13 of file SelectedProducts.h.

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

Definition at line 99 of file StreamedProducts.h.

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

Definition at line 67 of file StreamedProducts.h.

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

Definition at line 12 of file SimTrackContainer.h.

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

Definition at line 13 of file SimVertexContainer.h.

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

Definition at line 14 of file SimVertexContainer.h.

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

Definition at line 15 of file SimVertexContainer.h.

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

Definition at line 16 of file SimVertexContainer.h.

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

Definition at line 34 of file StoredProductProvenance.h.

using edm::Strings = typedef EventSelector::Strings

Definition at line 50 of file EventSelector.cc.

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

Definition at line 17 of file ParameterSetConverter.h.

typedef unsigned long long edm::TimeValue_t

Definition at line 28 of file Timestamp.h.

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

Definition at line 49 of file OutputModule.h.

typedef std::map<std::string, char> edm::Type2Code

Definition at line 79 of file Entry.cc.

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

Definition at line 17 of file ProductSelector.cc.

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

Definition at line 15 of file VectorInputSourceFactory.h.

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

Definition at line 33 of file ParameterSet.h.

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

Definition at line 430 of file Schedule.cc.

Enumeration Type Documentation

enum edm::BranchActionType

Enumerator
BranchActionGlobalBegin
BranchActionStreamBegin
BranchActionStreamEnd
BranchActionGlobalEnd

Definition at line 11 of file BranchActionType.h.

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

enum edm::BranchType

Enumerator
InEvent
InLumi
InRun
NumBranchTypes

Definition at line 11 of file BranchType.h.

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

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

enum edm::HashedTypes

Enumerator
ModuleDescriptionType
ParameterSetType
ProcessHistoryType
ProcessConfigurationType
EntryDescriptionType
ParentageType

Definition at line 10 of file HashedTypes.h.

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

enum edm::InputType

strong

Enumerator
Primary
SecondaryFile
SecondarySource

Definition at line 5 of file InputType.h.

                        {
     Primary,
     SecondaryFile,
     SecondarySource
   };

enum edm::JobMode

Enumerator
GridJobMode
ReleaseValidationJobMode
AnalysisJobMode
NilJobMode

Definition at line 15 of file JobMode.h.

                {
          GridJobMode
        , ReleaseValidationJobMode
        , AnalysisJobMode
        , NilJobMode
   };

enum edm::KindOfType

Enumerator
PRODUCT_TYPE
ELEMENT_TYPE

Definition at line 5 of file ProductKindOfType.h.

5 { PRODUCT_TYPE, ELEMENT_TYPE };

edm::PRODUCT_TYPE

Definition: ProductKindOfType.h:5

edm::ELEMENT_TYPE

Definition: ProductKindOfType.h:5

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_string
k_vstring
k_EventID
k_VEventID
k_LuminosityBlockID
k_VLuminosityBlockID
k_InputTag
k_VInputTag
k_FileInPath
k_LuminosityBlockRange
k_VLuminosityBlockRange
k_EventRange
k_VEventRange
k_PSet
k_VPSet

Definition at line 32 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_string = 'S',
     k_vstring = 's',
     k_EventID = 'E',
     k_VEventID = 'e',
     k_LuminosityBlockID = 'M',
     k_VLuminosityBlockID = 'm',
     k_InputTag = 't',
     k_VInputTag = 'v',
     k_FileInPath = 'F',
     k_LuminosityBlockRange = 'A',
     k_VLuminosityBlockRange = 'a',
     k_EventRange = 'R',
     k_VEventRange = 'r',
     k_PSet = 'Q',
     k_VPSet = 'q'
   };

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

enum edm::TerminationOrigin

strong

Enumerator
ExceptionFromThisContext
ExceptionFromAnotherContext
ExternalSignal

Definition at line 28 of file TerminationOrigin.h.

                                {
     ExceptionFromThisContext,
     ExceptionFromAnotherContext,
     ExternalSignal
   };

enum edm::Transition

strong

Enumerator
Event
BeginLuminosityBlock
EndLuminosityBlock
BeginRun
EndRun

Definition at line 12 of file Transition.h.

                         {
     Event,
     BeginLuminosityBlock,
     EndLuminosityBlock,
     BeginRun,
     EndRun
   };

enum edm::Verbosity

Enumerator
Silent
Concise
Normal
Detailed

Definition at line 5 of file Verbosity.h.

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

enum edm::WildcardValidationCriteria

Enumerator
RequireZeroOrMore
RequireAtLeastOne
RequireExactlyOne

Definition at line 18 of file ParameterWildcardBase.h.

                                   {
     RequireZeroOrMore,
     RequireAtLeastOne,
     RequireExactlyOne
   };

Function Documentation

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

Definition at line 12 of file ExceptionHelpers.cc.

References cms::Exception::addContext(), 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::WorkerManager::processOneOccurrence(), and edm::StreamSchedule::processOneStreamAsync().

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

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

Definition at line 177 of file DictionaryTools.cc.

References cms::Exception::addContext(), 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);
     }
   }

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

template<class FP >

bool edm::asm_isnan ( FP x )

inline

Definition at line 43 of file math.h.

References flags.

   {
     // I do not know of a preprocessor symbol used to identify the
     // presence of an x87 floating-point processor.
 #if defined(__i386__)||defined(__x86_64)
     u_int16_t flags;
     __asm__("fxam\n\t"
         "fstsw %%ax"
         : "=a" (flags) /* output */
         : "t"  (x)     /* input */
             :              /* clobbered */
             );
     return (flags & 0x4500)==0x0100;
 #else
     #error No asm_isnan for this architecture.
 #endif    
   }

template<typename Traits , typename P , typename SC >

void edm::beginGlobalTransitionAsync	(	WaitingTaskHolder	iWait,
		Schedule &	iSchedule,
		P &	iPrincipal,
		IOVSyncValue const &	iTS,
		EventSetup const &	iES,
		ServiceToken const &	token,
		SC &	iSubProcesses
	)

Definition at line 55 of file globalTransitionAsync.h.

References edm::WaitingTaskHolder::doneWaiting(), h, make_waiting_task(), eostools::move(), edm::Schedule::processOneGlobalAsync(), and subProcessDoGlobalBeginTransitionAsync().

                                                      {
 
     //When we are done processing the global for this process,
     // we need to run the global for all SubProcesses
     auto subs = make_waiting_task(tbb::task::allocate_root(), [&iSubProcesses, iWait,&iPrincipal,iTS](std::exception_ptr const* iPtr) mutable {
       if(iPtr) {
         auto excpt = *iPtr;
         auto delayError = make_waiting_task(tbb::task::allocate_root(), [iWait,excpt](std::exception_ptr const* ) mutable {
           iWait.doneWaiting(excpt);
         });
         WaitingTaskHolder h(delayError);
         for(auto& subProcess: iSubProcesses) {
           subProcessDoGlobalBeginTransitionAsync(h,subProcess,iPrincipal, iTS);
         }
       } else {
         for(auto& subProcess:iSubProcesses){
           subProcessDoGlobalBeginTransitionAsync(iWait,subProcess,iPrincipal, iTS);
         }
       }
     });
     
     WaitingTaskHolder h(subs);
     iSchedule.processOneGlobalAsync<Traits>(std::move(h),iPrincipal, iES,token);
   }

template<typename Traits , typename P , typename SC >

void edm::beginStreamsTransitionAsync	(	WaitingTask *	iWait,
		Schedule &	iSchedule,
		unsigned int	iNStreams,
		P &	iPrincipal,
		IOVSyncValue const &	iTS,
		EventSetup const &	iES,
		ServiceToken const &	token,
		SC &	iSubProcesses
	)

Definition at line 91 of file streamTransitionAsync.h.

References mps_fire::i.

   {
     WaitingTaskHolder holdUntilAllStreamsCalled(iWait);
     for(unsigned int i=0; i<iNStreams;++i) {
       beginStreamTransitionAsync<Traits>(WaitingTaskHolder(iWait), iSchedule,i,iPrincipal,iTS,iES,token, iSubProcesses);
     }
   }

template<typename Traits , typename P , typename SC >

void edm::beginStreamTransitionAsync	(	WaitingTaskHolder	iWait,
		Schedule &	iSchedule,
		unsigned int	iStreamIndex,
		P &	iPrincipal,
		IOVSyncValue const &	iTS,
		EventSetup const &	iES,
		ServiceToken const &	token,
		SC &	iSubProcesses
	)

Definition at line 56 of file streamTransitionAsync.h.

References edm::WaitingTaskHolder::doneWaiting(), h, make_waiting_task(), eostools::move(), edm::Schedule::processOneStreamAsync(), and subProcessDoStreamBeginTransitionAsync().

                                                      {
     //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
     auto subs = make_waiting_task(tbb::task::allocate_root(), [&iSubProcesses, iWait,iStreamIndex,&iPrincipal,iTS](std::exception_ptr const* iPtr) mutable {
       if(iPtr) {
         auto excpt = *iPtr;
         auto delayError = make_waiting_task(tbb::task::allocate_root(), [iWait,excpt](std::exception_ptr const* ) mutable {
           iWait.doneWaiting(excpt);
         });
         WaitingTaskHolder h(delayError);
         for(auto& subProcess: iSubProcesses){
           subProcessDoStreamBeginTransitionAsync(h,subProcess,iStreamIndex,iPrincipal, iTS);
           
         };
       } else {
         for(auto& subProcess: iSubProcesses){
           subProcessDoStreamBeginTransitionAsync(iWait,subProcess,iStreamIndex,iPrincipal, iTS);
         };
       }
     });
     
     WaitingTaskHolder h(subs);
     iSchedule.processOneStreamAsync<Traits>(std::move(h), iStreamIndex,iPrincipal, iES,token);
   }

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 76 of file Algorithms.h.

References edmIntegrityCheck::d.

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

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

template<typename ForwardSequence , typename Datum , typename Predicate >

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

inline

Definition at line 83 of file Algorithms.h.

References edmIntegrityCheck::d, and AlCaHLTBitMon_ParallelJobs::p.

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

std::string const & edm::BranchTypeToAuxBranchName ( BranchType const & branchType )

Definition at line 119 of file BranchType.cc.

References InEvent, and InRun.

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

                                                                            { // backward compatibility
     return ((branchType == InEvent) ? eventAux : ((branchType == InRun) ? runAux : lumiAux)); // backward compatibility
   } // backward compatibility

std::string const & edm::BranchTypeToAuxiliaryBranchName ( BranchType const & branchType )

Definition at line 115 of file BranchType.cc.

References InEvent, and InRun.

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(), and edm::RootTree::startTraining().

                                                                                  {
     return ((branchType == InEvent) ? eventAuxiliary : ((branchType == InRun) ? runAuxiliary : lumiAuxiliary));
   }

std::string const & edm::BranchTypeToBranchEntryInfoBranchName ( BranchType const & branchType )

Definition at line 127 of file BranchType.cc.

References InEvent, and InRun.

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

                                                                                        {
     return ((branchType == InEvent) ? eventEventEntryInfo : ((branchType == InRun) ? runEventEntryInfo : lumiEventEntryInfo));
   }

std::string const & edm::BranchTypeToInfoTreeName ( BranchType const & branchType )

Definition at line 111 of file BranchType.cc.

References dumpTauVariables_cfi::eventInfo, InEvent, InRun, and pileupCalc::lumiInfo.

                                                                           { // backward compatibility
     return ((branchType == InEvent) ? eventInfo : ((branchType == InRun) ? runInfo : lumiInfo)); // backward compatibility
   } // backward compatibility

std::string const & edm::BranchTypeToMajorIndexName ( BranchType const & branchType )

Definition at line 135 of file BranchType.cc.

References InEvent, and InRun.

                                                                             {
     return ((branchType == InEvent) ? eventMajorIndex : ((branchType == InRun) ? runMajorIndex : lumiMajorIndex));
   }

std::string const & edm::BranchTypeToMetaDataTreeName ( BranchType const & branchType )

Definition at line 107 of file BranchType.cc.

References InEvent, and InRun.

Referenced by ProvenanceDumper::work_().

                                                                               {
     return ((branchType == InEvent) ? eventMeta : ((branchType == InRun) ? runMeta : lumiMeta));
   }

std::string const & edm::BranchTypeToMinorIndexName ( BranchType const & branchType )

Definition at line 139 of file BranchType.cc.

References InEvent, and InRun.

                                                                             {
     return ((branchType == InEvent) ? eventMinorIndex : ((branchType == InRun) ? runMinorIndex : lumiMinorIndex));
   }

std::string const & edm::BranchTypeToProductProvenanceBranchName ( BranchType const & BranchType )

Definition at line 131 of file BranchType.cc.

References InEvent, and InRun.

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

                                                                                          {
     return ((branchType == InEvent) ? eventProductProvenance : ((branchType == InRun) ? runProductProvenance : lumiProductProvenance));
   }

std::string const & edm::BranchTypeToProductStatusBranchName ( BranchType const & branchType )

Definition at line 123 of file BranchType.cc.

References InEvent, and InRun.

                                                                                      { // backward compatibility
     return ((branchType == InEvent) ? eventProductStatus : ((branchType == InRun) ? runProductStatus : lumiProductStatus)); // backward compatibility
   } // backward compatibility

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

Definition at line 103 of file BranchType.cc.

References PatBasicFWLiteAnalyzer::events, InEvent, InRun, heppy_report::lumis, and gather_cfg::runs.

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

                                                                              {
     return ((branchType == InEvent) ? events : ((branchType == InRun) ? runs : lumis));
   }

std::string const & edm::BranchTypeToString ( BranchType const & branchType )

Definition at line 99 of file BranchType.cc.

References InEvent, InRun, and findQualityFiles::run.

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

                                                                     {
     return ((branchType == InEvent) ? event : ((branchType == InRun) ? run : lumi));
   }

template<typename TReturn >

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

Definition at line 51 of file ExceptionHelpers.h.

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

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

template<typename T >

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

static

Definition at line 83 of file GetProductCheckerOutputModule.cc.

References edm::Provenance::branchDescription(), edm::BranchDescription::branchID(), Exception, edm::BranchDescription::moduleLabel(), edm::BranchDescription::processName(), edm::BranchDescription::productInstanceName(), edm::BasicHandle::provenance(), and edm::BranchDescription::unwrappedTypeID().

Referenced by SegmentsTrackAssociator::associate(), L1TMenuHelper::getLUSOTrigger(), edm::StreamerInputFile::openStreamerFile(), fwlite::Handle< Collection >::operator*(), fwlite::Handle< Collection >::operator->(), fwlite::Handle< Collection >::product(), fwlite::Handle< Collection >::ptr(), edm::DataMixingMuonWorker::putMuon(), amc13::Header::raw(), amc13::Trailer::raw(), fwlite::Handle< Collection >::ref(), 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, bh);
        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";
        }
      }
    }

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

Definition at line 109 of file DictionaryTools.cc.

References edm::TypeWithDict::byName(), GetRecoTauVFromDQM_MC_cff::cl, edm::TypeID::className(), hasDictionary(), mps_fire::result, and edm::TypeIDBase::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;
   }

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

Definition at line 149 of file DictionaryTools.cc.

References GetRecoTauVFromDQM_MC_cff::cl, edm::TypeWithDict::getClass(), edm::TypeWithDict::invalidTypeInfo(), 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;
   }

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::TypeIDBase::typeInfo().

Referenced by edm::ProductRegistryHelper::addToRegistry(), edm::ProductRegistry::checkDictionariesOfConsumedTypes(), checkDictionaryOfWrappedType(), edm::ProductRegistry::initializeLookupTables(), edm::OutputModule::keepThisBranch(), edm::one::OutputModuleBase::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;
   }

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

Definition at line 98 of file DictionaryTools.cc.

References edm::TypeWithDict::invalidTypeInfo().

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

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

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

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

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

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

Definition at line 139 of file PathsAndConsumesOfModules.cc.

References edm::PathsAndConsumesOfModulesBase::allModules(), heppy_report::description, edm::PathsAndConsumesOfModulesBase::endPaths(), Exception, runEdmFileComparison::found, edm::graph::kDataDependencyIndex, edm::graph::kInvalidIndex, edm::errors::LogicError, edm::PathsAndConsumesOfModules::moduleIndex(), edm::PathsAndConsumesOfModulesBase::modulesOnEndPath(), edm::PathsAndConsumesOfModulesBase::modulesOnPath(), edm::PathsAndConsumesOfModulesBase::modulesWhoseProductsAreConsumedBy(), edm::PathsAndConsumesOfModulesBase::paths(), AlCaHLTBitMon_QueryRunRegistry::string, and edm::graph::throwIfImproperDependencies().

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

                                                                     {
     using namespace edm::graph;
     //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;
     unsigned int largestIndex = 0;
     unsigned int kPathToTriggerResultsDependencyLastIndex = kInvalidIndex;
     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 || description->moduleName() == kEndPathStatusInserter) {
         pathStatusInserterModuleLabelToModuleID[description->moduleLabel()] = description->id();
       }
     }
     kPathToTriggerResultsDependencyLastIndex = largestIndex ;
 
 
     /*
     {
       //We need to explicitly check that modules on Paths do not try to read data from
       // Modules which are only on EndPaths. The circular dependency finder has been
       // known to miss these.
       std::unordered_set<unsigned int> modulesOnlyOnEndPaths;
       auto const& endPaths = iPnC.endPaths();
       for( unsigned int pathIndex = 0; pathIndex != endPaths.size(); ++pathIndex) {
         auto const& moduleDescriptions = iPnC.modulesOnEndPath(pathIndex);
         for(auto const& description: moduleDescriptions) {
           modulesOnlyOnEndPaths.insert(description->id());
         }
       }
 
       std::unordered_set<unsigned int> modulesOnPaths;
       auto const& paths = iPnC.paths();
       for( unsigned int pathIndex = 0; pathIndex != paths.size(); ++pathIndex) {
         auto const& moduleDescriptions = iPnC.modulesOnPath(pathIndex);
         for(auto const& description: moduleDescriptions) {
           auto itFind =modulesOnlyOnEndPaths.find(description->id());
           if(modulesOnlyOnEndPaths.end() != itFind) {
             modulesOnlyOnEndPaths.erase(itFind);
           }
           modulesOnPaths.insert(description->id());
         }
       }
       
       for(auto moduleIndex : modulesOnPaths) {
         auto const& dependentModules = iPnC.modulesWhoseProductsAreConsumedBy(moduleIndex);
         for(auto const& depDescription: dependentModules) {
           auto itFind = modulesOnlyOnEndPaths.find(depDescription->id());
           if(itFind != modulesOnlyOnEndPaths.end()) {
             throw edm::Exception(edm::errors::ScheduleExecutionFailure, "Unrunnable schedule\n") 
               <<"The module "<<moduleIndexToNames[moduleIndex]<<" is on a Path and depends on data from module "
               <<moduleIndexToNames[depDescription->id()]<<" which is on an EndPath.";
           }
         }
       }
 
     }
      */
 
     //If a module to module dependency comes from a path, remember which path
     EdgeToPathMap edgeToPathMap;
 
     //Need to be able to quickly look up which paths a module appears on
     std::unordered_map<unsigned int, std::vector<unsigned int>> moduleIndexToPathIndex;
 
     //determine the path dependencies
     std::vector<std::string> pathNames = iPnC.paths();
     const unsigned int kFirstEndPathIndex = pathNames.size();
 
     const std::string kPathEnded("@PathEnded");
     const std::string kEndPathStart("@EndPathStart");
     
     //The finished processing depends on all paths and end paths
     const std::string kFinishedProcessing("@FinishedProcessing");
     const unsigned int kFinishedProcessingIndex{0};
     moduleIndexToNames.insert(std::make_pair(kFinishedProcessingIndex,
                                              kFinishedProcessing));
 
 
     pathNames.insert(pathNames.end(), iPnC.endPaths().begin(), iPnC.endPaths().end());
     std::vector<std::vector<unsigned int>> pathIndexToModuleIndexOrder(pathNames.size());
     {
       
       for(unsigned int pathIndex = 0; pathIndex != pathNames.size(); ++pathIndex) {
         std::set<unsigned int> alreadySeenIndex;
         
         std::vector<ModuleDescription const*> const* moduleDescriptions;
         if(pathIndex < kFirstEndPathIndex) {
           moduleDescriptions= &(iPnC.modulesOnPath(pathIndex));
         } else {
           moduleDescriptions= &(iPnC.modulesOnEndPath(pathIndex-kFirstEndPathIndex));
         }
         unsigned int lastModuleIndex = kInvalidIndex;
         auto& pathOrder =pathIndexToModuleIndexOrder[pathIndex];
         pathOrder.reserve(moduleDescriptions->size() + 1);
         for(auto const& description: *moduleDescriptions) {
           auto found = alreadySeenIndex.insert(description->id());
           if(found.second) {
             //first time for this path
             unsigned int const moduleIndex = description->id();
             pathOrder.push_back(moduleIndex);
             auto& paths =moduleIndexToPathIndex[moduleIndex];
             paths.push_back(pathIndex);
             if(lastModuleIndex  != kInvalidIndex ) {
               edgeToPathMap[std::make_pair(moduleIndex,lastModuleIndex)].push_back(pathIndex);
             }
             lastModuleIndex = moduleIndex;
           }
         }
         //Have TriggerResults depend on the end of all paths 
         // Have all EndPaths depend on TriggerResults
         auto labelToID = pathStatusInserterModuleLabelToModuleID.find(pathNames[pathIndex]);
         if(labelToID == pathStatusInserterModuleLabelToModuleID.end()) {
           // should never happen
           throw Exception(errors::LogicError)
             << "PathsAndConsumesOfModules::moduleDescription:checkForModuleDependencyCorrectness Could not find PathStatusInserter\n";
         }
         unsigned int pathStatusInserterModuleID = labelToID->second;
         if( pathIndex < kFirstEndPathIndex) {
           if( (lastModuleIndex  != kInvalidIndex) ) {
             edgeToPathMap[std::make_pair(pathStatusInserterModuleID, lastModuleIndex)].push_back(pathIndex);
             moduleIndexToNames.insert(std::make_pair(pathStatusInserterModuleID,
                                                      kPathEnded));
             if (kTriggerResultsIndex != kInvalidIndex) {
               edgeToPathMap[std::make_pair(kTriggerResultsIndex, pathStatusInserterModuleID)].push_back(kDataDependencyIndex);
             }
             //Need to make dependency for finished process
             edgeToPathMap[std::make_pair(kFinishedProcessingIndex, pathStatusInserterModuleID)].push_back(kDataDependencyIndex);
             pathOrder.push_back(pathStatusInserterModuleID);
           }
         } else {
           if( (not moduleDescriptions->empty()) ) {
             if (kTriggerResultsIndex != kInvalidIndex) {
               ++kPathToTriggerResultsDependencyLastIndex;
               edgeToPathMap[std::make_pair(moduleDescriptions->front()->id(),kPathToTriggerResultsDependencyLastIndex)].push_back(pathIndex);
               moduleIndexToNames.insert(std::make_pair(kPathToTriggerResultsDependencyLastIndex,
                                                        kEndPathStart));
               edgeToPathMap[std::make_pair(kPathToTriggerResultsDependencyLastIndex,kTriggerResultsIndex)].push_back(kDataDependencyIndex);
               pathOrder.insert(pathOrder.begin(),kPathToTriggerResultsDependencyLastIndex);
             }
             //Need to make dependency for finished process
             ++kPathToTriggerResultsDependencyLastIndex;
             edgeToPathMap[std::make_pair(pathStatusInserterModuleID, lastModuleIndex)].push_back(pathIndex);
             moduleIndexToNames.insert(std::make_pair(pathStatusInserterModuleID,
                                                      kPathEnded));
             edgeToPathMap[std::make_pair(kFinishedProcessingIndex, pathStatusInserterModuleID)].push_back(kDataDependencyIndex);
             pathOrder.push_back(pathStatusInserterModuleID);
           }
         }
       }
     }
     {
 
       //determine the data dependencies
       for(auto const& description: iPnC.allModules()) {
         unsigned int const moduleIndex = description->id();
         auto const& dependentModules = iPnC.modulesWhoseProductsAreConsumedBy(moduleIndex);
         for(auto const& depDescription: dependentModules) {
           if(iPrintDependencies) {
             edm::LogAbsolute("ModuleDependency") << "ModuleDependency '" << description->moduleLabel() <<
             "' depends on data products from module '" << depDescription->moduleLabel()<<"'";
           }
           //see if all paths containing this module also contain the dependent module earlier in the path
           // if it does, then treat this only as a path dependency and not a data dependency as this
           // simplifies the circular dependency checking logic
           auto depID =depDescription->id();
           auto itPathsFound = moduleIndexToPathIndex.find(moduleIndex);
           bool keepDataDependency = true;
           auto itDepsPathsFound =moduleIndexToPathIndex.find(depID);
           if(itPathsFound != moduleIndexToPathIndex.end() and itDepsPathsFound != moduleIndexToPathIndex.end()) {
             keepDataDependency = false;
             for(auto const pathIndex: itPathsFound->second) {
               for(auto idToCheck: pathIndexToModuleIndexOrder[pathIndex]) {
                 if(idToCheck == depID) {
                   //found dependent module first so check next path
                   break;
                 }
                 if(idToCheck == moduleIndex) {
                   //did not find dependent module earlier on path so
                   // must keep data dependency
                   keepDataDependency = true;
                   break;
                 }
               }
               if(keepDataDependency) {
                 break;
               }
             }
           }
           if(keepDataDependency) {
             edgeToPathMap[std::make_pair(moduleIndex, depID)].push_back(kDataDependencyIndex);
           }
         }
       }
     }
     graph::throwIfImproperDependencies(edgeToPathMap,pathIndexToModuleIndexOrder,pathNames,moduleIndexToNames);
   }

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

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

static void edm::cleanup ( const Factory::MakerMap::value_type & v )

static

Definition at line 12 of file Factory.cc.

References edm::Factory::singleInstance_.

Referenced by ESDataCertificationTask::endJob(), ESDaqInfoTask::endJob(), ESDcsInfoTask::endJob(), Herwig::HerwigUIProvider::quit(), PhysicsTools::MVATrainer::setCleanup(), edm::Factory::~Factory(), and Herwig::HerwigUIProvider::~HerwigUIProvider().

   {
     delete v.second.get();
   }

void edm::clearLoggedErrorsSummary ( unsigned int iStreamID )

Definition at line 193 of file MessageSender.cc.

References errorSummaryMaps.

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

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

void edm::clearMessageLog ( )

Definition at line 100 of file MessageLogger.cc.

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

Referenced by edm::Suppress_LogDebug_::operator<<().

                        {                    // 11/30/10 mf
   MessageDrop::instance()->clear();
 }

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

Definition at line 310 of file BranchDescription.cc.

References edm::BranchDescription::branchID(), edm::BranchDescription::branchType(), edm::BranchDescription::friendlyClassName(), edm::BranchDescription::fullClassName(), edm::BranchDescription::moduleLabel(), edm::BranchDescription::processName(), and edm::BranchDescription::productInstanceName().

Referenced by edm::ProductRegistry::copyProduct(), operator<<(), 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());
   }

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

Definition at line 52 of file LuminosityBlockRange.cc.

References edm::LuminosityBlockRange::endLumiID(), and edm::LuminosityBlockRange::startLumiID().

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

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

Definition at line 38 of file EventRange.cc.

References contains_(), edm::EventID::event(), edm::EventID::run(), edm::EventRange::startLumi(), and mitigatedMETSequence_cff::U.

Referenced by Vispa.Gui.PortConnection.PointToPointConnection::belongsToRoute(), contains(), Vispa.Views.LineDecayView.DecayNode::containsPoint(), Vispa.Views.LineDecayView.DecayLine::containsPoint(), CaloTowersCreationAlgo::convert(), MultipleScatteringGeometry::detLayers(), CTPPSDiamondDQMSource::dqmBeginRun(), Vispa.Gui.ConnectableWidget.ConnectableWidget::dropAreaPort(), pat::PATElectronProducer::fillElectron2(), pat::PATMuonProducer::fillMuon(), HeavyFlavorValidation::getFilterLevel(), CaloVNoiseSignalGenerator::getNoiseSignals(), Vispa.Main.StartupScreen.StartupScreen::mouseMoveEvent(), Vispa.Gui.MenuWidget.MenuWidget::mouseMoveEvent(), Vispa.Gui.MenuWidget.MenuWidget::mousePressEvent(), Vispa.Gui.PortWidget.PortWidget::mouseReleaseEvent(), Vispa.Gui.ConnectableWidgetOwner.ConnectableWidgetOwner::propagateEventUnderConnectionWidget(), CaloTowersCreationAlgo::rescaleTowers(), TotemDAQMappingESSourceXML::setIntervalFor(), and PhysicsTools::Calibration::MVAComputerContainer::~MVAComputerContainer().

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

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

Definition at line 59 of file LuminosityBlockRange.cc.

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

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

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

Definition at line 49 of file EventRange.cc.

References contains(), edm::EventRange::endEventID(), edm::EventRange::startEventID(), and edm::EventRange::startLumi().

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

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

Definition at line 45 of file EventRange.cc.

References edm::EventRange::endEventID(), and edm::EventRange::startEventID().

Referenced by contains().

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

template<class FwdIter >

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

Definition at line 48 of file split.h.

References b, MillePedeFileConverter_cfg::e, and CommonUtil::nested.

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

template<class FwdIter >

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

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

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

Definition at line 11 of file LuminosityBlockAux.cc.

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

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

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

Definition at line 11 of file RunAux.cc.

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

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

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

Definition at line 9 of file EventAux.cc.

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

Referenced by edm::RootFile::fillLumiAuxiliary(), edm::RootFile::fillRunAuxiliary(), edm::RootFile::fillThisEventAuxiliary(), ReducedEGProducer::linkConversionsByTrackRef(), 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_;
   }

template<typename T >

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

Definition at line 20 of file ConvertHandle.h.

References h, eostools::move(), edm::handleimpl::throwConvertTypeError(), edm::handleimpl::throwInvalidReference(), and wrapper.

Referenced by edm::EventBase::get(), edm::Event::get(), PileUpEventPrincipal::getByLabel(), edm::EventBase::getByLabel(), edm::RunBase::getByLabel(), edm::LuminosityBlockBase::getByLabel(), edm::LuminosityBlock::getByLabel(), edm::Run::getByLabel(), edm::Event::getByLabel(), edm::OccurrenceForOutput::getByToken(), edm::LuminosityBlock::getByToken(), edm::Run::getByToken(), edm::Event::getByToken(), and edm::PrincipalGetAdapter::getManyByType().

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

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

specialize this function forFWGenericHandle

Definition at line 20 of file FWGenericHandle.cc.

References MessageLogger_cfi::cerr, Exception, edm::BasicHandle::failedToGet(), edm::ObjectWithDict::get(), h, edm::BasicHandle::id(), edm::errors::InvalidReference, edm::errors::LogicError, edm::TypeWithDict::name(), edm::BasicHandle::provenance(), edm::Handle< FWGenericObject >::setWhyFailed(), edm::Handle< FWGenericObject >::type(), 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);
 }

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

specialize this function for GenericHandle

Definition at line 19 of file GenericHandle.cc.

References Exception, edm::ObjectWithDict::get(), h, edm::errors::InvalidReference, edm::errors::LogicError, edm::TypeWithDict::name(), edm::Handle< GenericObject >::setWhyFailedFactory(), edm::Handle< GenericObject >::type(), 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);
 }

constexpr BranchType edm::convertToBranchType ( Transition iValue )

Definition at line 21 of file Transition.h.

References constexpr, InEvent, InLumi, and InRun.

Referenced by edm::ProductRegistryHelper::addToRegistry(), and edm::ProducerBase::resolvePutIndicies().

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

constexpr Transition edm::convertToTransition ( BranchType iValue )

Definition at line 26 of file Transition.h.

References BeginLuminosityBlock, BeginRun, constexpr, and Event.

Referenced by edm::ProductRegistryHelper::produces().

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

template<typename ForwardSequence , typename Func >

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

inline

wrappers for copy

Definition at line 24 of file Algorithms.h.

References popcon2dropbox::copy(), and f.

Referenced by edm::service::ThreadSafeLogMessageLoggerScribe::configure_dest(), edm::service::MessageLoggerScribe::configure_dest(), 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);
   }

template<typename T1 , typename T2 , typename T3 , typename ToT >

void edm::copyFromTo	(	ESProducts< T1, T2, T3 > &	iFrom,
		ToT &	iTo
	)

Definition at line 202 of file ESProducts.h.

References edm::eventsetup::produce::ProductHolder< T1, T2, T3 >::assignTo().

                                {
        iFrom.assignTo(iTo);
      }

std::string edm::createGlobalIdentifier ( )

Definition at line 6 of file GlobalIdentifier.cc.

References edm::Guid::toString().

Referenced by NanoAODOutputModule::openFile(), DQMRootOutputModule::openFile(), edm::RootOutputFile::RootOutputFile(), and edm::RootFile::validateFile().

                            {
     Guid guid;
     return guid.toString();
   }

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

Definition at line 62 of file types.cc.

Referenced by BeautifulSoup.NavigableString::__unicode__(), decode(), 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(), edm::Entry::getPSet(), edm::Entry::getString(), 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(), HGCal64BitRandomCodecImpl::HGCal64BitRandomCodecImpl(), uploadConditions::re_upload(), and edm::Entry::validate().

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

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

Definition at line 82 of file types.cc.

References b, decode(), MillePedeFileConverter_cfg::e, split(), groupFilesInBlocks::temp, and heppy_batch::val.

                                                         {
     std::vector<std::string> temp;
     if(!split(std::back_inserter(temp), from, '{', ',', '}')) {
       return false;
     }
 
     to.clear();
     for(std::vector<std::string>::const_iterator b = temp.begin()
                                                , e = temp.end()
         ; b != e; ++b) {
       bool val = false;
       if(!decode(val, *b)) {
         return false;
       }
       to.push_back(val);
     }
     return true;
   } // decode to vector<bool>

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

Definition at line 129 of file types.cc.

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

                                             {
     std::string::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

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

Definition at line 218 of file types.cc.

References b, decode(), MillePedeFileConverter_cfg::e, split(), groupFilesInBlocks::temp, and heppy_batch::val.

                                                        {
     std::vector<std::string> temp;
     if(!split(std::back_inserter(temp), from, '{', ',', '}')) {
       return false;
     }
 
     to.clear();
     for(std::vector<std::string>::const_iterator b = temp.begin()
                                                , e = temp.end()
         ; b != e; ++b) {
       int val = 0;
       if(!decode(val, *b)) {
         return false;
       }
       to.push_back(val);
     }
 
     return true;
   } // decode to vector<int>

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

Definition at line 314 of file types.cc.

References b, and MillePedeFileConverter_cfg::e.

                                                      {
     std::string::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

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

Definition at line 383 of file types.cc.

References b, decode(), MillePedeFileConverter_cfg::e, split(), groupFilesInBlocks::temp, and heppy_batch::val.

                                                                 {
     std::vector<std::string> temp;
     if(!split(std::back_inserter(temp), from, '{', ',', '}')) {
       return false;
     }
     to.clear();
     for(std::vector<std::string>::const_iterator b = temp.begin()
                                                , e = temp.end()
         ; b != e; ++b) {
       unsigned int val = 0;
       if(!decode(val, *b)) {
         return false;
       }
       to.push_back(val);
     }
 
     return true;
   } // decode to vector<unsigned int>

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

Definition at line 173 of file types.cc.

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

                                                   {
     std::string::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

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

Definition at line 267 of file types.cc.

References b, decode(), MillePedeFileConverter_cfg::e, split(), groupFilesInBlocks::temp, and heppy_batch::val.

                                                              {
     std::vector<std::string> temp;
     if(!split(std::back_inserter(temp), from, '{', ',', '}')) {
       return false;
     }
 
     to.clear();
     for(std::vector<std::string>::const_iterator b = temp.begin()
                                                , e = temp.end()
         ; b != e; ++b) {
       long long val = 0LL;
       if(!decode(val, *b)) {
         return false;
       }
       to.push_back(val);
     }
 
     return true;
   } // decode to vector<int>

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

Definition at line 349 of file types.cc.

References b, and MillePedeFileConverter_cfg::e.

                                                            {
     std::string::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

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

Definition at line 430 of file types.cc.

References b, decode(), MillePedeFileConverter_cfg::e, split(), groupFilesInBlocks::temp, and heppy_batch::val.

                                                                       {
     std::vector<std::string> temp;
     if(!split(std::back_inserter(temp), from, '{', ',', '}')) {
       return false;
     }
     to.clear();
     for(std::vector<std::string>::const_iterator b = temp.begin()
                                                ,  e = temp.end()
         ; b != e; ++b) {
       unsigned long long val = 0ULL;
       if(!decode(val, *b)) {
         return false;
       }
       to.push_back(val);
     }
 
     return true;
   } // decode to vector<unsigned int>

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

Definition at line 479 of file types.cc.

References infinity, and SiStripPI::max.

                                                {
     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 = boost::lexical_cast<double>(from);
         // std::cerr << "to:" << to << std::endl;
       }
       catch(boost::bad_lexical_cast&)  {
         return false;
       }
     }
     return true;
   }

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

Definition at line 523 of file types.cc.

References b, decode(), MillePedeFileConverter_cfg::e, split(), groupFilesInBlocks::temp, and heppy_batch::val.

                                                           {
     std::vector<std::string> temp;
     if(!split(std::back_inserter(temp), from, '{', ',', '}'))
       return false;
 
     to.clear();
     for(std::vector<std::string>::const_iterator b = temp.begin()
                                                , e = temp.end()
         ; b != e; ++b) {
       double  val;
       if(!decode(val, *b))
         return false;
       to.push_back(val);
     }
 
     return true;
   } // decode to vector<double>

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

Definition at line 569 of file types.cc.

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

                                                   {
     /*std::cerr << "Decoding: " << from << '\n'; //DEBUG*/
     std::string::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

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

Definition at line 1092 of file types.cc.

References b, decode(), MillePedeFileConverter_cfg::e, split(), AlCaHLTBitMon_QueryRunRegistry::string, groupFilesInBlocks::temp, and heppy_batch::val.

                                                              {
     std::vector<std::string> temp;
     if(!split(std::back_inserter(temp), from, '{', ',', '}'))
       return false;
 
     to.clear();
     for(std::vector<std::string>::const_iterator b = temp.begin()
                                                , e = temp.end()
         ; b != e; ++b) {
       std::string val;
       // treat blank string specially
       if(*b == "XXX") {
          val = "";
       } else if(!decode(val, *b)) {
         return false;
       }
       to.push_back(val);
     }
 
     return true;
   } // decode to vector<string>

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

Definition at line 614 of file types.cc.

References edm::FileInPath::readFromParameterSetBlob(), and groupFilesInBlocks::temp.

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

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

Definition at line 640 of file types.cc.

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

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

Definition at line 659 of file types.cc.

References decode(), and nano_cff::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

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

Definition at line 690 of file types.cc.

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

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

Definition at line 709 of file types.cc.

References decode(), and nano_cff::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

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

Definition at line 739 of file types.cc.

References findQualityFiles::run, and tokenize().

                                                    {
     std::vector<std::string> tokens = edm::tokenize(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

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

Definition at line 770 of file types.cc.

References decode(), and nano_cff::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

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

Definition at line 803 of file types.cc.

References findQualityFiles::run, and tokenize().

                                                              {
       std::vector<std::string> tokens = edm::tokenize(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

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

Definition at line 828 of file types.cc.

References decode(), and nano_cff::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

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

Definition at line 862 of file types.cc.

References begin, decode(), end, edm::LuminosityBlockID::luminosityBlock(), edm::LuminosityBlockID::run(), and tokenize().

                                                                 {
     std::vector<std::string> tokens = edm::tokenize(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

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

Definition at line 888 of file types.cc.

References decode(), and nano_cff::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

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

Definition at line 919 of file types.cc.

References begin, decode(), end, edm::EventID::event(), edm::EventID::luminosityBlock(), edm::EventID::run(), and tokenize().

                                                       {
     std::vector<std::string> tokens = edm::tokenize(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

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

Definition at line 953 of file types.cc.

References decode(), and nano_cff::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;
   }

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

Definition at line 1146 of file types.cc.

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

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

Definition at line 1165 of file types.cc.

References b, decode(), MillePedeFileConverter_cfg::e, split(), groupFilesInBlocks::temp, and heppy_batch::val.

                                                                 {
     std::vector<std::string> temp;
     if(!split(std::back_inserter(temp), from, '{', ',', '}'))
       return false;
 
     to.clear();
     for(std::vector<std::string>::const_iterator b = temp.begin()
                                                , e = temp.end()
         ; b != e; ++b) {
       ParameterSet val;
       if(!decode(val, *b)) {
         return false;
       }
       to.push_back(val);
     }
 
     return true;
   } // decode to vector<ParameterSet>

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",
                                               "CondorStatusService",
                                               "XrdAdaptor::XrdStatisticsService"};
 
       return returnValue;
    }

std::string edm::defaultModuleLabel ( std::string label )

Definition at line 8 of file defaultModuleLabel.h.

References EnergyCorrector::c, mps_fire::i, diffTwoXMLs::label, and MatrixUtil::remove().

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

                                                 { // take by value because we'll copy it anyway
     // remove all colons (module type may contain namespace)
     label.erase(std::remove(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;
   }

void edm::disableAllSigs ( sigset_t * oldset )

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

bool edm::DisableLoggedErrorsSummary ( )

Definition at line 166 of file MessageSender.cc.

References errorSummaryIsBeingKept.

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

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

void edm::disableRTSigs ( )

Definition at line 46 of file UnixSignalHandlers.cc.

References MUST_BE_ZERO, and pileupDistInMC::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
     }

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

Definition at line 89 of file UnixSignalHandlers.cc.

References MUST_BE_ZERO.

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

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

Definition at line 74 of file LuminosityBlockRange.cc.

References lessThan().

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

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

Definition at line 72 of file EventRange.cc.

References begin, end, edm::EventRange::endEventID(), edm::EventRange::EventRange(), lessThan(), mathSSE::lh, max(), min(), overlaps(), edm::EventRange::startEventID(), 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); 
   }

void edm::doBuildRealData ( std::string const & name )

Definition at line 22 of file ClassFiller.cc.

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

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

void edm::doBuildRealData ( const std::string & name )

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

const char * edm::edmModuleType ( edm::ModuleDescription const & module )

Definition at line 35 of file EDMModuleType.cc.

References edmModuleTypeEnum(), and module_type_desc.

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

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, edm::ModuleDescription::parameterSetID(), muonDTDigis_cfi::pset, PhysicsTools::registry, AlCaHLTBitMon_QueryRunRegistry::string, lumiQTWidget::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;
 }

void edm::edmodule_mightGet_config ( ConfigurationDescriptions & iDesc )

Definition at line 37 of file edmodule_mightGet_config.cc.

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

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

ELseverityLevel const edm::ELdebugGen ( )

Definition at line 251 of file ELseverityLevel.cc.

References MillePedeFileConverter_cfg::e, and edm::ELseverityLevel::ELsev_success.

                                      {
   static ELseverityLevel const  e( ELseverityLevel::ELsev_success );
   return e;
 }

ELseverityLevel const edm::ELerrorGen ( )

Definition at line 269 of file ELseverityLevel.cc.

References MillePedeFileConverter_cfg::e, and edm::ELseverityLevel::ELsev_error.

                                      {
   static ELseverityLevel const  e( ELseverityLevel::ELsev_error );
   return e;
 }

ELseverityLevel const edm::ELhighestSeverityGen ( )

Definition at line 287 of file ELseverityLevel.cc.

References MillePedeFileConverter_cfg::e, and edm::ELseverityLevel::ELsev_highestSeverity.

                                                {
   static ELseverityLevel const  e( ELseverityLevel::ELsev_highestSeverity );
   return e;
 }

ELseverityLevel const edm::ELinfoGen ( )

Definition at line 257 of file ELseverityLevel.cc.

References MillePedeFileConverter_cfg::e, and edm::ELseverityLevel::ELsev_info.

                                     {
   static ELseverityLevel const  e( ELseverityLevel::ELsev_info );
   return e;
 }

ELseverityLevel const edm::ELsevereGen ( )

Definition at line 281 of file ELseverityLevel.cc.

References MillePedeFileConverter_cfg::e, and edm::ELseverityLevel::ELsev_severe.

                                       {
   static ELseverityLevel const  e( ELseverityLevel::ELsev_severe );
   return e;
 }

ELseverityLevel const edm::ELunspecifiedGen ( )

Definition at line 275 of file ELseverityLevel.cc.

References MillePedeFileConverter_cfg::e, and edm::ELseverityLevel::ELsev_unspecified.

                                            {
   static ELseverityLevel const  e( ELseverityLevel::ELsev_unspecified );
   return e;
 }

ELseverityLevel const edm::ELwarningGen ( )

Definition at line 263 of file ELseverityLevel.cc.

References MillePedeFileConverter_cfg::e, and edm::ELseverityLevel::ELsev_warning.

                                        {
   static ELseverityLevel const  e( ELseverityLevel::ELsev_warning );
   return e;
 }

ELseverityLevel const edm::ELzeroSeverityGen ( )

Definition at line 245 of file ELseverityLevel.cc.

References MillePedeFileConverter_cfg::e, and edm::ELseverityLevel::ELsev_zeroSeverity.

                                             {
   static ELseverityLevel const  e( ELseverityLevel::ELsev_zeroSeverity );
   return e;
 }

bool edm::EnableLoggedErrorsSummary ( )

Definition at line 161 of file MessageSender.cc.

References errorSummaryIsBeingKept.

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

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

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

Definition at line 80 of file UnixSignalHandlers.cc.

References MUST_BE_ZERO.

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

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

Definition at line 71 of file types.cc.

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

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

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

Definition at line 104 of file types.cc.

References b, 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>

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

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

Definition at line 241 of file types.cc.

References b, 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>

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

Definition at line 334 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

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

Definition at line 405 of file types.cc.

References b, 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>

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

Definition at line 197 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

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

Definition at line 290 of file types.cc.

References b, 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>

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

Definition at line 368 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

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

Definition at line 452 of file types.cc.

References b, 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>

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

Definition at line 508 of file types.cc.

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

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

Definition at line 544 of file types.cc.

References b, 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>

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

Definition at line 982 of file types.cc.

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

                                                   {
     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

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

Definition at line 1117 of file types.cc.

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

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

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

Definition at line 626 of file types.cc.

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

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

Definition at line 648 of file types.cc.

References edm::InputTag::encode().

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

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

Definition at line 673 of file types.cc.

References encode(), and nano_cff::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;
   }

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

Definition at line 698 of file types.cc.

References edm::ESInputTag::encode().

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

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

Definition at line 723 of file types.cc.

References encode(), and nano_cff::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;
   }

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

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

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

Definition at line 786 of file types.cc.

References encode(), AlCaHLTBitMon_QueryRunRegistry::string, and nano_cff::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;
     }

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

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

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

Definition at line 844 of file types.cc.

References encode(), AlCaHLTBitMon_QueryRunRegistry::string, and nano_cff::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;
   }

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

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

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

Definition at line 902 of file types.cc.

References encode(), AlCaHLTBitMon_QueryRunRegistry::string, and nano_cff::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;
   }

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

Definition at line 933 of file types.cc.

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

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

Definition at line 967 of file types.cc.

References encode(), AlCaHLTBitMon_QueryRunRegistry::string, and nano_cff::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;
   }

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

Definition at line 1154 of file types.cc.

References edm::ParameterSet::toString().

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

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

Definition at line 1187 of file types.cc.

References b, 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>

template<typename Traits , typename P , typename SC >

void edm::endGlobalTransitionAsync	(	WaitingTaskHolder	iWait,
		Schedule &	iSchedule,
		P &	iPrincipal,
		IOVSyncValue const &	iTS,
		EventSetup const &	iES,
		ServiceToken const &	token,
		SC &	iSubProcesses,
		bool	cleaningUpAfterException
	)

Definition at line 88 of file globalTransitionAsync.h.

References edm::WaitingTaskHolder::doneWaiting(), h, make_waiting_task(), eostools::move(), edm::Schedule::processOneGlobalAsync(), and subProcessDoGlobalEndTransitionAsync().

   {
     //When we are done processing the global for this process,
     // we need to run the global for all SubProcesses
     auto subs = make_waiting_task(tbb::task::allocate_root(), [&iSubProcesses, iWait,&iPrincipal,iTS,cleaningUpAfterException](std::exception_ptr const* iPtr) mutable {
       if(iPtr) {
         auto excpt = *iPtr;
         auto delayError = make_waiting_task(tbb::task::allocate_root(), [iWait,excpt](std::exception_ptr const* ) mutable {
           iWait.doneWaiting(excpt);
         });
         WaitingTaskHolder h(delayError);
         for(auto& subProcess: iSubProcesses){
           subProcessDoGlobalEndTransitionAsync(h,subProcess,iPrincipal, iTS,cleaningUpAfterException);
         }
       } else {
         for(auto& subProcess: iSubProcesses){
           subProcessDoGlobalEndTransitionAsync(iWait,subProcess,iPrincipal, iTS,cleaningUpAfterException);
         }
       }
     });
     
     WaitingTaskHolder h(subs);
     iSchedule.processOneGlobalAsync<Traits>(std::move(h),iPrincipal, iES,token,cleaningUpAfterException);
   }

template<typename Traits , typename P , typename SC >

void edm::endStreamsTransitionAsync	(	WaitingTaskHolder	iWait,
		Schedule &	iSchedule,
		unsigned int	iNStreams,
		P &	iPrincipal,
		IOVSyncValue const &	iTS,
		EventSetup const &	iES,
		ServiceToken const &	iToken,
		SC &	iSubProcesses,
		bool	cleaningUpAfterException
	)

Definition at line 142 of file streamTransitionAsync.h.

References mps_fire::i.

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

template<typename Traits , typename P , typename SC >

void edm::endStreamTransitionAsync	(	WaitingTaskHolder	iWait,
		Schedule &	iSchedule,
		unsigned int	iStreamIndex,
		P &	iPrincipal,
		IOVSyncValue const &	iTS,
		EventSetup const &	iES,
		ServiceToken const &	token,
		SC &	iSubProcesses,
		bool	cleaningUpAfterException
	)

Definition at line 107 of file streamTransitionAsync.h.

References edm::WaitingTaskHolder::doneWaiting(), h, make_waiting_task(), edm::Schedule::processOneStreamAsync(), and subProcessDoStreamEndTransitionAsync().

   {
     //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
 
     auto subs = make_waiting_task(tbb::task::allocate_root(), [&iSubProcesses, iWait,iStreamIndex,&iPrincipal,iTS,cleaningUpAfterException](std::exception_ptr const* iPtr) mutable {
       if(iPtr) {
         auto excpt = *iPtr;
         auto delayError = make_waiting_task(tbb::task::allocate_root(), [iWait,excpt](std::exception_ptr const* ) mutable {
           iWait.doneWaiting(excpt);
         });
         WaitingTaskHolder h(delayError);
         for(auto& subProcess: iSubProcesses) {
           subProcessDoStreamEndTransitionAsync(h,subProcess,iStreamIndex,iPrincipal, iTS,cleaningUpAfterException);
         }
       } else {
         for(auto& subProcess: iSubProcesses) {
           subProcessDoStreamEndTransitionAsync(iWait,subProcess,iStreamIndex,iPrincipal, iTS,cleaningUpAfterException);
         }
       }
     });
     
     iSchedule.processOneStreamAsync<Traits>(WaitingTaskHolder(subs), iStreamIndex,iPrincipal, iES, token, cleaningUpAfterException);
   }

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

bool edm::eq	(	const ELstring &	s1,
		const ELstring	s2
	)

Definition at line 42 of file ELstring.cc.

References indexGen::s2.

                                                     {
 
   return  s1 == s2;
 
 }  // eq()

bool edm::eq_nocase	(	const ELstring &	s1,
		const char	s2[]
	)

Definition at line 24 of file ELstring.cc.

References p1, p2, and indexGen::s2.

Referenced by edm::ErrorObj::emitToken().

                                                          {
   using std::toupper;
 
   if (s1.length() != strlen(s2) ) return false;
 
   ELstring::const_iterator  p1;
   const char             *  p2;
 
   for ( p1 = s1.begin(), p2 = s2;  *p2 != '\0';  ++p1, ++p2 )  {
     if ( toupper(*p1) != toupper(*p2) )  {
       return false;
     }
   }
   return true;
 
 }  // eq_nocase()

template<class FP >

bool edm::equal_isnan ( FP x )

inline

Definition at line 61 of file math.h.

Referenced by isnan().

     {
       return x !=x;
     }

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

Definition at line 61 of file GlobalContext.cc.

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

Referenced by edm::Worker::activityRegistry(), edm::Worker::exceptionContext(), and edm::Worker::runModule().

                                                                  {
     os << "Processing ";
     switch (gc.transition()) {
       case GlobalContext::Transition::kBeginJob:
         os << "begin Job";
         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::kEndJob:
         os << "endJob";
         break;
       case GlobalContext::Transition::kWriteRun:
         os << "write Run "<<RunID(gc.luminosityBlockID().run());
         break;
       case GlobalContext::Transition::kWriteLuminosityBlock:
         os << "write LuminosityBlock "<<gc.luminosityBlockID();
         break;
     }
   }

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

Definition at line 76 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, findQualityFiles::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();
   }

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

Definition at line 88 of file FillDescriptionFromPSet.cc.

References edm::ParameterSetDescription::add(), edm::ParameterSetDescription::addNode(), edm::ParameterSetDescription::addUntracked(), mps_splice::entry, edm::ParameterSet::getParameterSet(), edm::ParameterSet::getParameterSetVector(), edm::ParameterSet::getUntrackedParameterSet(), edm::ParameterSet::getUntrackedParameterSetVector(), eostools::move(), edm::ParameterSet::psetTable(), edm::ParameterSet::tbl(), and edm::ParameterSet::vpsetTable().

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

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

Definition at line 191 of file EventProcessor.cc.

References reco::get(), edm::ParameterSet::getParameter(), edm::ParameterSet::getPSetForUpdate(), and edm::ParameterSet::registerIt().

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

                                    {
     std::shared_ptr<EDLooperBase> vLooper;
 
     std::vector<std::string> loopers = params.getParameter<std::vector<std::string> >("@all_loopers");
 
     if(loopers.empty()) {
       return vLooper;
     }
 
     assert(1 == loopers.size());
 
     for(std::vector<std::string>::iterator itName = loopers.begin(), itNameEnd = loopers.end();
         itName != itNameEnd;
         ++itName) {
 
       ParameterSet* providerPSet = params.getPSetForUpdate(*itName);
       providerPSet->registerIt();
       vLooper = eventsetup::LooperFactory::get()->addTo(esController,
                                                         cp,
                                                         *providerPSet);
     }
     return vLooper;
   }

void edm::fillMaxEventsDescription ( ParameterSetDescription & description )

Definition at line 57 of file validateTopLevelParameterSets.cc.

References edm::ParameterSetDescription::addOptionalNode(), edm::ParameterSetDescription::addUntracked(), and edm::ParameterSetDescription::addWildcardUntracked().

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

void edm::fillMaxLuminosityBlocksDescription ( ParameterSetDescription & description )

Definition at line 67 of file validateTopLevelParameterSets.cc.

References edm::ParameterSetDescription::addUntracked().

Referenced by validateTopLevelParameterSets().

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

void edm::fillMaxSecondsUntilRampdownDescription ( ParameterSetDescription & description )

Definition at line 72 of file validateTopLevelParameterSets.cc.

References edm::ParameterSetDescription::addUntracked().

Referenced by validateTopLevelParameterSets().

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

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

static

Definition at line 821 of file StreamSchedule.cc.

References edm::Worker::description(), edm::Path::getWorker(), edm::ModuleInPathSummary::moduleLabel, edm::ModuleDescription::moduleLabel(), edm::ModuleInPathSummary::timesExcept, edm::Path::timesExcept(), edm::ModuleInPathSummary::timesFailed, edm::Path::timesFailed(), edm::ModuleInPathSummary::timesPassed, edm::Path::timesPassed(), edm::ModuleInPathSummary::timesVisited, and edm::Path::timesVisited().

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

void edm::fillOptionsDescription ( ParameterSetDescription & description )

Definition at line 14 of file validateTopLevelParameterSets.cc.

References edm::ParameterSetDescription::addOptionalUntracked(), edm::ParameterSetDescription::addUntracked(), 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");
   description.addUntracked<unsigned int>("numberOfConcurrentRuns", 1);
   description.addUntracked<unsigned int>("numberOfConcurrentLuminosityBlocks", 1)->
     setComment("If zero, then set the same as the number of runs");
   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");
 
 
   // 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>>("SkipEvent", emptyVector);
   description.addUntracked<std::vector<std::string>>("FailPath", emptyVector);
   description.addUntracked<std::vector<std::string>>("IgnoreCompletely", emptyVector);
 
   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");
 
   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.");
 }

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

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

static

Definition at line 832 of file StreamSchedule.cc.

References edm::PathSummary::bitPosition, edm::Path::bitPosition(), fillModuleInPathSummary(), mps_fire::i, edm::PathSummary::moduleInPathSummaries, edm::PathSummary::name, edm::Path::name(), edm::Path::size(), groupFilesInBlocks::temp, edm::PathSummary::timesExcept, edm::Path::timesExcept(), edm::PathSummary::timesFailed, edm::Path::timesFailed(), edm::PathSummary::timesPassed, edm::Path::timesPassed(), edm::PathSummary::timesRun, and edm::Path::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]);
       }
     }
   }

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

Definition at line 32 of file CommonProvenanceFiller.cc.

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

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 85 of file fillPtrVector.h.

References edm::detail::reallyfillPtrVector().

Referenced by edm::WrapperBase::isPresent(), and edm::SortedCollection< EcalRecHit >::pop_back().

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

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 94 of file fillPtrVector.h.

References edm::detail::reallyfillPtrVector().

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

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 103 of file fillPtrVector.h.

References edm::detail::reallyfillPtrVector().

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

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 112 of file fillPtrVector.h.

References edm::detail::reallyfillPtrVector().

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

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 473 of file SortedCollection.h.

References edm::SortedCollection< T, SORT >::fillPtrVector().

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

template<typename T , unsigned int M, typename P >

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

inline

Definition at line 489 of file OwnArray.h.

References edm::OwnArray< T, MAX_SIZE, P >::fillPtrVector().

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

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 564 of file OwnVector.h.

References edm::OwnVector< T, P >::fillPtrVector().

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

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 49 of file FillView.h.

References edm::detail::reallyFillView().

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

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 59 of file FillView.h.

References edm::detail::reallyFillView().

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

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 69 of file FillView.h.

References edm::detail::reallyFillView().

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

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 79 of file FillView.h.

References edm::detail::reallyFillView().

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

template<typename T >

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

inline

Definition at line 197 of file PtrVector.h.

References edm::PtrVector< T >::fillView().

                                                       {
     obj.fillView(pointers,helpers);
   }

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 210 of file RefVector.h.

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

template<typename T >

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

inline

Definition at line 251 of file RefToBaseVector.h.

References edm::RefToBaseVector< T >::fillView().

                                                       {
     obj.fillView(pointers,helpers);
   }

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 281 of file AssociationVector.h.

References edm::AssociationVector< KeyRefProd, CVal, KeyRef, SizeType, KeyReferenceHelper >::fillView().

Referenced by edm::RefToBaseVector< reco::GsfElectronCore >::isInvalid(), edm::WrapperBase::isPresent(), edm::PtrVector< reco::FFTJPTJet >::operator=(), edm::SortedCollection< EcalRecHit >::pop_back(), edm::RefToBaseProd< T >::RefToBaseProd(), edm::DetSetVector< TotemRPLocalTrack::FittedRecHit >::reserve(), and edm::AssociationVector< PFTauRefProd, std::vector< int > >::value().

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

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 296 of file Ptr.h.

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

template<class T >

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

inline

Definition at line 422 of file DetSetVector.h.

References edm::DetSetVector< T >::fillView().

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

template<typename T , unsigned int M, typename P >

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

inline

Definition at line 441 of file OwnArray.h.

References edm::OwnArray< T, MAX_SIZE, P >::fillView().

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

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 452 of file SortedCollection.h.

References edm::SortedCollection< T, SORT >::fillView().

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

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 516 of file OwnVector.h.

References edm::OwnVector< T, P >::fillView().

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

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

static

Definition at line 866 of file StreamSchedule.cc.

References fillWorkerSummaryAux().

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

                                                           {
     fillWorkerSummaryAux(*pw, sum);
   }

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

static

Definition at line 856 of file StreamSchedule.cc.

References edm::Worker::description(), edm::ModuleDescription::moduleLabel(), edm::WorkerSummary::moduleLabel, edm::WorkerSummary::timesExcept, edm::Worker::timesExcept(), edm::WorkerSummary::timesFailed, edm::Worker::timesFailed(), edm::WorkerSummary::timesPassed, edm::Worker::timesPassed(), edm::WorkerSummary::timesRun, edm::Worker::timesRun(), edm::WorkerSummary::timesVisited, and edm::Worker::timesVisited().

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

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

References AlCaHLTBitMon_ParallelJobs::p.

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

template<typename ForwardSequence , typename Predicate >

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

inline

Definition at line 61 of file Algorithms.h.

References AlCaHLTBitMon_ParallelJobs::p.

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

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 32 of file Algorithms.h.

References edmIntegrityCheck::d, and spr::find().

Referenced by edm::RootFile::fillIndexIntoFile(), edm::ProvenanceAdaptor::fixProcessHistory(), edm::ParameterSet::fromString(), and edm::BranchIDListHelper::updateFromInput().

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

template<typename ForwardSequence , typename Datum >

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

inline

Definition at line 39 of file Algorithms.h.

References edmIntegrityCheck::d, and spr::find().

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

template<typename Key , typename Value >

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

inline

Definition at line 58 of file Map.h.

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

template<typename Key , typename Value >

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

inline

Definition at line 67 of file Map.h.

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

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 28 of file Map.h.

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

template<typename Key , typename Value >

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

inline

Definition at line 36 of file Map.h.

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

template<typename Key , typename Value >

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

inline

Definition at line 47 of file Map.h.

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

template<typename Key , typename Value >

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

inline

Definition at line 18 of file Map.h.

References gen::k.

                                                     {
     return m[k];
   }

template<typename T , typename U >

T edm::first ( std::pair< T, U > const & p )

Definition at line 246 of file ParameterSet.cc.

Referenced by edm::TrieNode< T >::_sequentialSearch(), L1TGlobalSummary::analyze(), l1t::GtRecordDump::analyze(), edm::TypeWithDict::byName(), edm::OwnArray< T, MAX_SIZE, P >::capacity(), DynamicTruncation::compatibleDets(), edm::service::ELoutput::emitToken(), TtEvent::eventHypo(), JME::getDefinitionLine(), edm::ParameterSet::getParameterNames(), UCTCTP7RawData::print(), PF_PU_FirstVertexTracks::produce(), PFCand_NoPU_WithAM::produce(), edm::OwnVector< reco::reco::PFBlockElement >::shrink_to_fit(), stripTemplate(), edm::TrieNode< T >::subNodeByLabel(), and L1TOccupancyClientHistogramService::updateHistogramEndLS().

                                                                    {
     return p.first;
   }

void edm::FlushMessageLog ( )

Definition at line 94 of file MessageLogger.cc.

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

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

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

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 16 of file Algorithms.h.

References f.

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

template<typename S , typename T >

S& edm::formatFile	(	T const &	f,
		S &	os
	)

Definition at line 39 of file JobReport.cc.

References MicroEventContent_cff::branch.

Referenced by print().

                                    {
 
     if(f.fileHasBeenClosed) {
       os << "\n<State  Value=\"closed\"/>";
     } else {
       os << "\n<State  Value=\"open\"/>";
     }
 
     os << "\n<LFN>" << TiXmlText(f.logicalFileName) << "</LFN>";
     os << "\n<PFN>" << TiXmlText(f.physicalFileName) << "</PFN>";
     os << "\n<Catalog>" << TiXmlText(f.catalog) << "</Catalog>";
     os << "\n<ModuleLabel>" << TiXmlText(f.moduleLabel) << "</ModuleLabel>";
     os << "\n<GUID>" << f.guid << "</GUID>";
     os << "\n<Branches>";
     for(auto const& branch : f.branchNames) {
       os << "\n  <Branch>" << TiXmlText(branch) << "</Branch>";
     }
     os << "\n</Branches>";
     return os;
   }

bool edm::FreshErrorsExist ( unsigned int iStreamID )

Definition at line 171 of file MessageSender.cc.

References errorSummaryMaps.

Referenced by HLTLogMonitorFilter::filter(), and edm::LogErrorHarvester::produce().

                                                 {
     assert(iStreamID<errorSummaryMaps.size());
     return  !errorSummaryMaps[iStreamID].empty();
   }

template<typename T , typename R = typename eventsetup::data_default_record_trait<typename T::value_type>::type>

T const& edm::get ( EventSetup const & setup )

Definition at line 157 of file EventSetup.h.

References cmsBatch::handle, dttmaxenums::L, edm::ESHandle< T >::product(), dttmaxenums::R, and GeneralSetup::setup().

                                         {
     ESHandle<T> handle;
     // throw if the record is not available
     setup.get<R>().get(handle);
     // throw if the handle is not valid
     return * handle.product();
   }

template<typename T , typename R = typename eventsetup::data_default_record_trait<typename T::value_type>::type, typename L >

T const& edm::get	(	EventSetup const &	setup,
		L &&	label
	)

Definition at line 166 of file EventSetup.h.

References cmsBatch::handle, diffTwoXMLs::label, edm::ESHandle< T >::product(), and dttmaxenums::R.

                                                     {
     ESHandle<T> handle;
     // throw if the record is not available
     setup.get<R>().get(std::forward(label), handle);
     // throw if the handle is not valid
     return * handle.product();
   }

template<typename T >

T const& edm::get	(	LuminosityBlock const &	event,
		InputTag const &	tag
	)

Definition at line 318 of file LuminosityBlock.h.

References cmsBatch::handle, edm::Handle< T >::product(), and GlobalPosition_Frontier_DevDB_cff::tag.

                                                                   {
     Handle<T> handle;
     event.getByLabel(tag, handle);
     // throw if the handle is not valid
     return * handle.product();
   }

template<typename T >

T const& edm::get	(	LuminosityBlock const &	event,
		EDGetToken const &	token
	)

Definition at line 326 of file LuminosityBlock.h.

References cmsBatch::handle, and edm::Handle< T >::product().

                                                                       {
     Handle<T> handle;
     event.getByToken(token, handle);
     // throw if the handle is not valid
     return * handle.product();
   }

template<typename T >

T const& edm::get	(	Run const &	event,
		InputTag const &	tag
	)

Definition at line 328 of file Run.h.

References cmsBatch::handle, edm::Handle< T >::product(), and GlobalPosition_Frontier_DevDB_cff::tag.

                                                       {
     Handle<T> handle;
     event.getByLabel(tag, handle);
     // throw if the handle is not valid
     return * handle.product();
   }

template<typename T >

T const& edm::get	(	LuminosityBlock const &	event,
		EDGetTokenT< T > const &	token
	)

Definition at line 334 of file LuminosityBlock.h.

References cmsBatch::handle, and edm::Handle< T >::product().

                                                                           {
     Handle<T> handle;
     event.getByToken(token, handle);
     // throw if the handle is not valid
     return * handle.product();
   }

template<typename T >

T const& edm::get	(	Run const &	event,
		EDGetToken const &	token
	)

Definition at line 336 of file Run.h.

References cmsBatch::handle, and edm::Handle< T >::product().

                                                           {
     Handle<T> handle;
     event.getByToken(token, handle);
     // throw if the handle is not valid
     return * handle.product();
   }

template<typename T >

T const& edm::get	(	Run const &	event,
		EDGetTokenT< T > const &	token
	)

Definition at line 344 of file Run.h.

References cmsBatch::handle, and edm::Handle< T >::product().

                                                               {
     Handle<T> handle;
     event.getByToken(token, handle);
     // throw if the handle is not valid
     return * handle.product();
   }

template<typename T >

T const& edm::get	(	Event const &	event,
		InputTag const &	tag
	)

Definition at line 630 of file Event.h.

References cmsBatch::handle, edm::Handle< T >::product(), and GlobalPosition_Frontier_DevDB_cff::tag.

Referenced by TriggerBxMonitor::dqmAnalyze(), TriggerRatesMonitor::dqmAnalyze(), and triggerExpression::Data::setEvent().

                                                         {
     Handle<T> handle;
     event.getByLabel(tag, handle);
     // throw if the handle is not valid
     return * handle.product();
   }

template<typename T >

T const& edm::get	(	Event const &	event,
		EDGetToken const &	token
	)

Definition at line 638 of file Event.h.

References cmsBatch::handle, and edm::Handle< T >::product().

                                                             {
     Handle<T> handle;
     event.getByToken(token, handle);
     // throw if the handle is not valid
     return * handle.product();
   }

template<typename T >

T const& edm::get	(	Event const &	event,
		EDGetTokenT< T > const &	token
	)

Definition at line 646 of file Event.h.

References cmsBatch::handle, and edm::Handle< T >::product().

                                                                 {
     Handle<T> handle;
     event.getByToken(token, handle);
     // throw if the handle is not valid
     return * handle.product();
   }

template<typename T >

T & edm::get_underlying ( propagate_const< T > & iP )

Definition at line 87 of file propagate_const.h.

References edm::propagate_const< T >::m_value.

Referenced by edm::SharedResourcesRegistry::createAcquirerForSourceDelayedReader(), get_underlying_safe(), edm::GlobalSchedule::GlobalSchedule(), and edm::StreamSchedule::makePathStatusInserters().

87 { return iP.m_value;}

template<typename T >

T const & edm::get_underlying ( propagate_const< T > const & iP )

Definition at line 88 of file propagate_const.h.

References edm::propagate_const< T >::m_value.

88 {return iP.m_value;}

template<typename T >

std::shared_ptr<T>& edm::get_underlying_safe ( propagate_const< std::shared_ptr< T >> & iP )

Definition at line 39 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::RootFile::branchIDListHelper(), edm::SubProcess::branchIDListHelper(), edm::EventProcessor::branchIDListHelper(), SerializeDataBuffer::bufferPointer(), edm::LuminosityBlock::commit_(), edm::Run::commit_(), edm::Event::commit_aux(), XrdAdaptor::XrdStatisticsService::condorUpdate(), edm::RootPrimaryFileSequence::duplicateChecker(), edm::service::RandomNumberGeneratorService::LabelAndEngine::engine(), edm::ProductRegistry::Transients::eventProductLookup(), edm::RootFile::eventProductProvenanceRetriever(), edm::StreamerFileReader::eventSkipperByID(), edm::RootPrimaryFileSequence::eventSkipperByID(), XrdAdaptor::Source::fh(), edm::RootOutputFile::filePtr(), edm::eventsetup::EventSetupRecordProvider::finder(), XrdAdaptor::ClientRequest::getCurrentSource(), edm::ModuleRegistry::getModule(), edm::ProcessDesc::getProcessPSet(), XrdAdaptor::XrdSiteStatisticsInformation::getStatisticsForSite(), edm::RootFile::indexIntoFileSharedPtr(), HepMCFileReader::input(), edm::service::RandomNumberGeneratorService::ModuleIDToEngine::labelAndEngine(), edm::EventProcessor::looper(), edm::ProductRegistry::Transients::lumiProductLookup(), edm::Schedule::moduleRegistry(), edm::value_ptr< edm::service::MessageLoggerDefaults >::operator->(), edm::JobReport::JobReportImpl::ost(), edm::RootOutputFile::pEventEntryInfoVector(), edm::ScheduleItems::preg(), edm::EventProcessor::preg(), edm::ScheduleItems::processConfiguration(), edm::VectorInputSource::productRegistry(), edm::InputSource::productRegistry(), edm::EventPrincipal::provRetrieverPtr(), edm::eventsetup::EventSetupRecordProvider::proxyProvider(), edm::service::MessageServicePresence::queue(), edm::RandomEngineSentry< T >::randomEngine(), edm::Principal::recombine(), edm::root::TFWLiteSelectorMembers::reg(), StorageAccountProxy::releaseStorage(), TStorageFactoryFile::releaseStorage(), edm::StreamSchedule::results(), edm::Schedule::resultsInserter(), edm::RootInputFileSequence::rootFile(), edm::ProductRegistry::Transients::runProductLookup(), edm::RootFile::savedRunAuxiliary(), XrdAdaptor::ClientRequest::self_reference(), edm::service::SimpleMemoryCheck::smapsLineBuffer(), XrdAdaptor::Source::stats(), edm::ScheduleItems::subProcessParentageHelper(), edm::ScheduleItems::thinnedAssociationsHelper(), edm::root::TFWLiteSelectorMembers::thinnedAssociationsHelper(), edm::InputSource::thinnedAssociationsHelper(), edm::SubProcess::thinnedAssociationsHelper(), edm::EventProcessor::thinnedAssociationsHelper(), and edm::root::TFWLiteSelectorMembers::tree().

39 {return get_underlying(iP);}

edm::get_underlying

T & get_underlying(propagate_const< T > &)

Definition: propagate_const.h:87

template<typename T >

std::shared_ptr<T const> edm::get_underlying_safe ( propagate_const< std::shared_ptr< T >> const & iP )

Definition at line 40 of file get_underlying_safe.h.

References popcon2dropbox::copy(), and get_underlying().

40 {std::shared_ptr<T const> copy = get_underlying(iP); return copy;}

popcon2dropbox.copy

def copy(args, dbName)

Definition: popcon2dropbox.py:121

edm::get_underlying

T & get_underlying(propagate_const< T > &)

Definition: propagate_const.h:87

template<typename T >

T*& edm::get_underlying_safe ( propagate_const< T * > & iP )

Definition at line 43 of file get_underlying_safe.h.

References get_underlying().

43 {return get_underlying(iP);}

edm::get_underlying

T & get_underlying(propagate_const< T > &)

Definition: propagate_const.h:87

template<typename T >

T const* edm::get_underlying_safe ( propagate_const< T * > const & iP )

Definition at line 44 of file get_underlying_safe.h.

References popcon2dropbox::copy(), and get_underlying().

44 {T const* copy = get_underlying(iP); return copy;}

popcon2dropbox.copy

def copy(args, dbName)

Definition: popcon2dropbox.py:121

edm::get_underlying

T & get_underlying(propagate_const< T > &)

Definition: propagate_const.h:87

T

long double T

Definition: Basic3DVectorLD.h:66

template<typename T >

std::unique_ptr<T>& edm::get_underlying_safe ( propagate_const< std::unique_ptr< T >> & iP )

Definition at line 47 of file get_underlying_safe.h.

References get_underlying().

47 {return get_underlying(iP);}

edm::get_underlying

T & get_underlying(propagate_const< T > &)

Definition: propagate_const.h:87

template<typename T >

std::unique_ptr<T const> edm::get_underlying_safe ( propagate_const< std::unique_ptr< T >> const & iP )

Definition at line 49 of file get_underlying_safe.h.

References popcon2dropbox::copy(), and get_underlying().

49 {std::unique_ptr<T const> copy = get_underlying(iP); return copy;}

popcon2dropbox.copy

def copy(args, dbName)

Definition: popcon2dropbox.py:121

edm::get_underlying

T & get_underlying(propagate_const< T > &)

Definition: propagate_const.h:87

std::vector< std::string > const & edm::getAllTriggerNames ( )

Definition at line 23 of file getAllTriggerNames.cc.

References edm::service::TriggerNamesService::getTrigPaths().

Referenced by edm::OutputModule::doPreallocate(), edm::global::OutputModuleBase::doPreallocate(), edm::limited::OutputModuleBase::doPreallocate(), edm::one::OutputModuleBase::doPreallocate(), edm::OutputModule::OutputModule(), edm::global::OutputModuleBase::OutputModuleBase(), edm::limited::OutputModuleBase::OutputModuleBase(), edm::one::OutputModuleBase::OutputModuleBase(), edm::StreamerOutputModuleBase::serializeRegistry(), and edm::SubProcess::SubProcess().

                                                    {
     Service<service::TriggerNamesService> tns;
     return tns->getTrigPaths();
   }

template<typename T >

std::unique_ptr<T> edm::getAnyPtr	(	void *	p,
		int	offset
	)

inline

Definition at line 10 of file getAnyPtr.h.

References eostools::move(), PFRecoTauDiscriminationByIsolation_cfi::offset, and AlCaHLTBitMon_ParallelJobs::p.

                                                   {
     // A union is used to avoid possible copies during the triple cast that would otherwise be needed.   
     // std::unique_ptr<T> edp(static_cast<T*>(static_cast<void *>(static_cast<unsigned char *>(p) + offset)));   
     union {      
       void* vp;      
       unsigned char* ucp;    
       T* tp;     
     } pointerUnion;      
     assert(p != nullptr);
     pointerUnion.vp = p;     
     pointerUnion.ucp += offset;      
     std::unique_ptr<T> tp(pointerUnion.tp);
     return(std::move(tp));
   }

std::string edm::getEnvironmentVariable	(	std::string const &	name,
		std::string const &	defaultValue = `std::string()`
	)

inline

Definition at line 9 of file GetEnvironmentVariable.h.

References AlCaHLTBitMon_ParallelJobs::p, and AlCaHLTBitMon_QueryRunRegistry::string.

Referenced by reco::ExpressionEvaluator::ExpressionEvaluator().

                                                                                                         {
     char *p = ::getenv(name.c_str());
     return (p ? std::string(p) : defaultValue); 
   }

int edm::getFileFormatVersion ( )

Definition at line 4 of file GetFileFormatVersion.cc.

Referenced by edm::RootOutputFile::writeFileFormatVersion().

4 { return 20; }

template<class T , std::size_t N>

std::array<T, N> edm::getFixedSizeArray	(	ParameterSet const &	pset,
		std::string const &	name
	)

Definition at line 17 of file getFixedSizeArray.h.

References a, edm::errors::Configuration, Exception, edm::ParameterSet::getParameter(), N, and dataset::name.

                                                                      {
     std::vector<T> vec = pset.getParameter<std::vector<T>>(name);
     if (vec.size() != N) {
       throw Exception(errors::Configuration)
         << "The parameter '" << name
         << "' should have " << N << " elements, but has " << vec.size()
         << " elements in the configuration.\n";
     }
     std::array<T, N> a {};
     std::copy_n(vec.begin(), N, a.begin());
     return a;
   }

MallocOptionSetter & edm::getGlobalOptionSetter ( )

Definition at line 221 of file MallocOpts.cc.

References global_malloc_options.

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

   {
     return global_malloc_options;
   }

ParameterSet const & edm::getParameterSet ( ParameterSetID const & id )

Definition at line 955 of file ParameterSet.cc.

References Exception, edm::pset::Registry::instance(), edm::errors::LogicError, and mps_fire::result.

Referenced by edm::service::CondorStatusService::beginPost(), evf::EvFDaqDirector::checkMergeTypePSet(), evf::EvFDaqDirector::checkTransferSystemPSet(), edm::ParameterSetEntry::fillPSet(), edm::VParameterSetEntry::fillVPSet(), findBinOfMaximum(), operator!=(), edm::service::PrescaleService::postBeginJob(), edm::OutputModule::setEventSelectionInfo(), edm::one::OutputModuleBase::setEventSelectionInfo(), edm::global::OutputModuleBase::setEventSelectionInfo(), edm::limited::OutputModuleBase::setEventSelectionInfo(), and edm::ParameterSet::trackedID().

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

std::string edm::getPassID ( )

inline

Definition at line 8 of file GetPassID.h.

References AlCaHLTBitMon_QueryRunRegistry::string.

Referenced by edm::DaqProvenanceHelper::daqInit(), edm::ScheduleItems::initMisc(), and edm::LHEProvenanceHelper::lheInit().

                          {
     static std::string const passID;
     // return empty string for now.
     return passID; 
   }

ParameterSet const & edm::getProcessParameterSetContainingModule ( ModuleDescription const & moduleDescription )

Definition at line 965 of file ParameterSet.cc.

References edm::ParameterSet::getParameterSet(), and edm::ModuleDescription::mainParameterSetID().

Referenced by DQMDcsInfoClient::beginRun(), HLTPrescaleRecorder::beginRun(), DQMDcsInfo::bookHistograms(), DQMEventInfo::bookHistograms(), ProbeTreeProducer::endJob(), TagProbeFitTreeProducer::endJob(), and operator!=().

                                                                                      {
     return getParameterSet(moduleDescription.mainParameterSetID());
   }

ParameterSet const * edm::getProducerParameterSet ( Provenance const & provenance )

Definition at line 17 of file getProducerParameterSet.cc.

References edm::Provenance::constBranchDescriptionPtr(), Exception, edm::pset::Registry::getMapped(), edm::ParameterSet::getParameterSet(), edm::pset::Registry::instance(), diffTwoXMLs::label, LaserDQM_cfg::process, edm::Provenance::processHistoryPtr(), and AlCaHLTBitMon_QueryRunRegistry::string.

                                                         {
 
     const std::shared_ptr<BranchDescription const>& branchDescription =
       provenance.constBranchDescriptionPtr();
 
     if (branchDescription) {
       std::string const& process = branchDescription->processName();
       std::string const& label = branchDescription->moduleLabel();
       ProcessHistory const* processHistory = provenance.processHistoryPtr();
 
       if (processHistory) {
         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;
   }

template<typename T >

T const* edm::getProduct ( RefCore const & ref )

inline

Definition at line 41 of file RefCoreGet.h.

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

template<typename PROD >

std::shared_ptr<Wrapper<PROD> const> edm::getProductByTag	(	Principal const &	ep,
		InputTag const &	tag,
		ModuleCallingContext const *	mcc
	)

inline

Definition at line 290 of file Principal.h.

References edm::WrapperBase::dynamicTypeInfo(), edm::Principal::findProductByTag(), PROD, mps_fire::result, edm::ProductData::sharedConstWrapper(), edm::handleimpl::throwConvertTypeError(), and edm::ProductData::wrapper().

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

template<typename T >

T const* edm::getProductWithCoreFromRef	(	RefCore const &	ref,
		EDProductGetter const *	prodGetter
	)

inline

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

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 edm::helper::MatcherGetRef< C >::getRef().

Referenced by TrackingTruthAccumulator::fillSimHits(), reco::modules::MatcherBase< C1, C2, M >::produce(), HLTScoutingEgammaProducer::produce(), HLTScoutingMuonProducer::produce(), and AssociatedVariableCollectionSelector< InputCollection, VarCollection, Selector, OutputCollection, StoreContainer, RefAdder >::select().

                                                                                   { 
     return helper::MatcherGetRef<C>::getRef( c, k ); 
   }

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

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(), HcalLaserEventFilter::HcalLaserEventFilter(), edm::ScheduleItems::initMisc(), edm::LHEProvenanceHelper::lheInit(), DQMFileSaver::saveForOffline(), edm::StreamerOutputModuleBase::serializeRegistry(), HLXMonitor::SetupEventInfo(), TauTagValidation::TauTagValidation(), and TrackParameterAnalyzer::TrackParameterAnalyzer().

                                 {
     static std::string const releaseVersion(STRINGIFY(PROJECT_VERSION));
     return releaseVersion; 
   }

TClass* edm::getTClass ( const std::type_info & ti )

Referenced by edm::StreamerInputSource::deserializeRegistry(), dumpInitVerbose(), and edm::StreamSerializer::serializeRegistry().

TClass* edm::getTClass ( std::type_info const & ti )

Definition at line 66 of file ClassFiller.cc.

References edm::TypeID::className().

                                             {
     TypeID const type(ti);
     return getRootClass(type.className());
   }

template<typename T >

T const* edm::getThinnedProduct	(	RefCore const &	ref,
		unsigned int &	thinnedKey,
		EDProductGetter const *	prodGetter
	)

inline

Definition at line 129 of file RefCoreGet.h.

References edm::RefCore::isTransient(), and edm::RefCore::nullPointerForTransientException().

Referenced by edm::Principal::applyToResolvers(), fwlite::ChainEvent::event(), fwlite::Event::getTFile(), and fwlite::MultiChainEvent::secondary().

                                                                                                      {
     // 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, thinnedKey, prodGetter);
   }

std::string edm::getUuid ( TTree * uuidTree )

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

std::unique_ptr<WrapperBase> edm::getWrapperBasePtr	(	void *	p,
		int	offset
	)

inline

Definition at line 9 of file getWrapperBasePtr.h.

References PFRecoTauDiscriminationByIsolation_cfi::offset, and AlCaHLTBitMon_ParallelJobs::p.

Referenced by edm::RootFile::dropOnInput(), edm::RootOutputFile::fillBranches(), and edm::RootDelayedReader::getProduct_().

                                                                     {
     return getAnyPtr<WrapperBase>(p, offset);
   }

std::string edm::glob2reg ( std::string const & pattern )

Definition at line 22 of file RegexMatch.cc.

References listBenchmarks::pattern, fetchall_from_DQM_v2::regexp, and AlCaHLTBitMon_QueryRunRegistry::string.

Referenced by triggerExpression::L1uGTReader::init(), HLTConfigProvider::matched(), and regexMatch().

                                                {
     std::string regexp = pattern;
     boost::replace_all(regexp, "*", ".*");
     boost::replace_all(regexp, "?", ".");
     return regexp;
   }

void edm::GroupLogStatistics ( std::string const & category )

Definition at line 112 of file MessageLogger.cc.

References edm::MessageLoggerQ::MLqGRP(), and AlCaHLTBitMon_QueryRunRegistry::string.

Referenced by edm::Suppress_LogDebug_::operator<<().

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

void edm::HaltMessageLogging ( )

Definition at line 90 of file MessageLogger.cc.

References edm::MessageLoggerQ::MLqSHT().

Referenced by edm::Suppress_LogDebug_::operator<<().

                           {
   edm::MessageLoggerQ::MLqSHT ( ); // Shut the logger up
 }

bool edm::hasDictionary ( std::type_info const & ti )

Definition at line 900 of file TypeWithDict.cc.

Referenced by checkClassDictionaries(), pat::UserData::checkDictionaries(), checkDictionary(), fwlite::Record::get(), edm::service::InitRootHandlers::InitRootHandlers(), and edm::TypeWithDict::unvalidatedTypeInfo().

                                         {
     if (ti.name()[1] == '\0') {
       // returns true for built in types (single character mangled names)
       return true;
     }
     return (TClassTable::GetDict(ti) != nullptr);
   }

HRTimeType edm::hrRealTime ( )

inline

Definition at line 101 of file HRRealTime.h.

                                  {
     return details::rdtsc();
   }

void edm::installCustomHandler	(	int	signum,
		CFUNC	func
	)

Definition at line 97 of file UnixSignalHandlers.cc.

References disableAllSigs(), disableRTSigs(), 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);
     }

void edm::installSig	(	int	signum,
		CFUNC	func
	)

Definition at line 110 of file UnixSignalHandlers.cc.

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

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

Definition at line 18 of file RegexMatch.cc.

Referenced by triggerExpression::L1uGTReader::init(), triggerExpression::PathReader::init(), HLTHighLevel::init(), ZCounting::initHLT(), edm::EventSelector::initPathNames(), and hltdqm::passTrig().

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

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

Definition at line 61 of file ProcessHistory.cc.

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

Referenced by isDescendant(), and operator!=().

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

bool edm::isDebugEnabled ( )

Definition at line 71 of file MessageLogger.cc.

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

                       {
   return ((!edm::MessageDrop::debugAlwaysSuppressed)        // 9/27/10 mf
          && edm::MessageDrop::instance()->debugEnabled );
 }

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

inline

Definition at line 117 of file ProcessHistory.h.

References isAncestor(), and operator<<().

                                                                  {
     return isAncestor(b, a);
   }

constexpr bool edm::isEndTransition ( Transition iValue )

Definition at line 31 of file Transition.h.

References EndLuminosityBlock, EndRun, and or.

Referenced by edm::ProductRegistryHelper::addToRegistry(), edm::LuminosityBlock::commit_(), and edm::Run::commit_().

                                                     {
     return iValue==Transition::EndLuminosityBlock or iValue==Transition::EndRun;
   }

bool edm::isErrorEnabled ( )

Definition at line 86 of file MessageLogger.cc.

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

                       {
   return edm::MessageDrop::instance()->errorEnabled;                        // 7/6/11 fwyzard
 }

template<typename T >

bool edm::isFinite ( T x )

Referenced by JetTagPlotter::analyzeTag(), ECAL2DPositionCalcWithDepthCorr::calculateAndSetPositionActual(), btagbtvdeep::SortingClass< T >::compare(), SuperClusterHelper::computeLocalCovariances(), GEDPhotonProducer::fillPhotonCollection(), TrackingTruthAccumulator::fillSimHits(), PuppiContainer::getRawAlphas(), PuppiContainer::getRMSAvg(), EGammaMvaEleEstimator::IDIsoCombinedMvaValue(), PuppiContainer::initialize(), isFinite(), isNotFinite(), EGammaMvaEleEstimatorCSA14::mvaValue(), EGammaMvaEleEstimator::mvaValue(), TracksClusteringFromDisplacedSeed::nearTracks(), reco::tau::PFRecoTauEnergyAlgorithmPlugin::operator()(), TemplatedInclusiveVertexFinder< InputContainer, VTX >::produce(), PuppiContainer::puppiWeights(), ElectronMVAEstimatorRun2Fall17::setClips(), TrackVertexArbitration< VTX >::trackVertexArbitrator(), and svhelper::updateVertexTime().

template<>

bool edm::isFinite ( float x )

inline

Definition at line 16 of file isFinite.h.

References edmIntegrityCheck::d, checklumidiff::l, RecoTauDiscriminantConfiguration::mask, and findQualityFiles::v.

                          {
     const unsigned int mask =  0x7f800000;
     union { unsigned int l; float d;} v;
     v.d =x;
     return (v.l&mask)!=mask;
   }

template<>

bool edm::isFinite ( double x )

inline

Definition at line 25 of file isFinite.h.

References edmIntegrityCheck::d, checklumidiff::l, RecoTauDiscriminantConfiguration::mask, and findQualityFiles::v.

                           {
     const unsigned long long mask = 0x7FF0000000000000LL;
     union { unsigned long long l; double d;} v;
     v.d =x;
     return (v.l&mask)!=mask;
   }

template<>

bool edm::isFinite ( long double x )

inline

Definition at line 34 of file isFinite.h.

References isFinite(), and geometryCSVtoXML::xx.

                                {
     double xx=x;
     return isFinite(xx);
   }

bool edm::isInfoEnabled ( )

Definition at line 76 of file MessageLogger.cc.

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

Referenced by edm::InputSource::issueReports(), and edm::Suppress_LogDebug_::operator<<().

                      {
   return ((!edm::MessageDrop::infoAlwaysSuppressed)     // 9/27/10 mf
          && edm::MessageDrop::instance()->infoEnabled );
 }

bool edm::isMessageProcessingSetUp ( )

Definition at line 104 of file MessageLogger.cc.

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

Referenced by edm::Suppress_LogDebug_::operator<<().

                                 {               // 6/20/08 mf
 //  std::cerr << "isMessageProcessingSetUp: \n";
 //  std::cerr << "messageLoggerScribeIsRunning = "
 //            << (int)MessageDrop::instance()->messageLoggerScribeIsRunning << "\n";
   return (MessageDrop::instance()->messageLoggerScribeIsRunning ==
             MLSCRIBE_RUNNING_INDICATOR);
 }

bool edm::isnan ( float f )

inline

Definition at line 69 of file math.h.

References edm::detail::isnan().

69 { return detail::isnan(f); }

edm::isnan

bool isnan(long double q)

Definition: math.h:73

f

double f[11][100]

Definition: MuScleFitUtils.cc:78

bool edm::isnan ( double d )

inline

Definition at line 71 of file math.h.

References equal_isnan().

71 { return equal_isnan(d); }

edmIntegrityCheck.d

d

Definition: edmIntegrityCheck.py:65

edm::equal_isnan

bool equal_isnan(FP x)

Definition: math.h:61

bool edm::isnan ( long double q )

inline

Definition at line 73 of file math.h.

References edm::detail::isnan().

73 { return detail::isnan(q); }

edm::isnan

bool isnan(long double q)

Definition: math.h:73

lumiQueryAPI.q

q

Definition: lumiQueryAPI.py:1839

template<typename T >

bool edm::isNotFinite ( T x )

inline

Definition at line 10 of file isFinite.h.

References isFinite().

Referenced by EBHitResponse::add(), HcalSiPMHitResponse::add(), CaloHitResponse::add(), EcalHitResponse::add(), EcalTimeMapDigitizer::add(), ElectronCalibration::analyze(), Vx3DHLTAnalyzer::analyze(), ElectronCalibrationUniv::analyze(), JetTagPlotter::analyzeTag(), TrackDetectorAssociator::associate(), EGammaMvaEleEstimatorCSA14::bindVariables(), EGammaMvaEleEstimator::bindVariables(), TransientTrackBuilder::build(), DetIdAssociator::buildMap(), TwoTrackMinimumDistanceHelixHelix::calculate(), GsfVertexWeightCalculator::calculate(), Cluster3DPCACalculator::calculateAndSetPositionActual(), Basic2DGenericPFlowPositionCalc::calculateAndSetPositionActual(), GsfElectronAlgo::calculateShowerShape(), GsfElectronFull5x5Filler::calculateShowerShape_full5x5(), GsfElectronAlgo::calculateShowerShape_full5x5(), PrimaryVertexAssignment::chargedHadronVertex(), TwoBodyDecayEstimator::checkValues(), Qjets::d_ij(), HLTScalersClient::endLuminosityBlock(), FitterFuncs::PulseShapeFunctor::EvalPulse(), MagGeometry::fieldInTesla(), EcalRegressionData::fill(), DAClusterizerInZ_vect::fill(), DAClusterizerInZT_vect::fill(), AlignmentExtendedCorrelationsStore::fillCovariance(), AlignmentExtendedCorrelationsStore::fillCovarianceT(), MatrixFillMap::fillEBMap(), MatrixFillMap::fillEEMap(), ClusterFillMap::fillMap(), ElectronSeedProducer::filterClusters(), DivisiveVertexFinder::findVertexes(), DivisiveVertexFinder::findVertexesAlt(), BSFitter::Fit(), KFTrajectoryFitter::fitOne(), FitterFuncs::PulseShapeFunctor::funcShape(), SCEnergyCorrectorSemiParm::getCorrections(), SequentialVertexFitter< 5 >::hasNan(), ConversionFastHelix::helixStateAtVertex(), CAHitTripletGenerator::hitNtuplets(), CAHitQuadrupletGenerator::hitNtuplets(), MultiHitGeneratorFromChi2::hitSets(), cms::SubEventGenJetProducer::inputTowers(), VirtualJetProducer::inputTowers(), PhotonConversionTrajectorySeedProducerFromSingleLegAlgo::inspectTrack(), GlobalTrackQualityProducer::kink(), fftjetcms::FFTJetInterface::loadInputCollection(), OptOCOPS::makeMeasurement(), Vx3DHLTAnalyzer::MyFit(), SensitiveDetector::NaNTrap(), reco::InverseCrosstalkMatrix::operator()(), TtHadLRSignalSelObservables::operator()(), TtSemiLRSignalSelObservables::operator()(), EcalUncalibRecHitFixedAlphaBetaAlgo< C >::PerformAnalyticFit(), pat::PATPhotonSlimmer::produce(), ShiftedParticleProducer::produce(), ShiftedParticleProducerT< T >::produce(), cms::CkfTrackCandidateMakerBase::produceBase(), IMACalibBlock::riempiMtr(), IMACalibBlock::riempiVtr(), EBHitResponse::run(), EcalHitResponse::run(), PVFitter::runFitter(), PrimaryVertexSorting::score(), SimpleCosmicBONSeeder::seeds(), HelixArbitraryPlaneCrossing2Order::solutionByDirection(), ConversionFastHelix::straightLineStateAtVertex(), TrackWithVertexSelector::testVertices(), TrackingNtuple::tpHitIndexListLessSort(), KinematicConstrainedVertexUpdator::update(), DAClusterizerInZ_vect::update(), DAClusterizerInZT_vect::update(), PrimaryVertexMonitor::vertexPlots(), DAClusterizerInZ_vect::vertices(), DAClusterizerInZT_vect::vertices(), GeometricAnnealing::weight(), DeterministicAnnealing::weight(), and VirtualJetProducer::writeJets().

                         {
     return !isFinite(x);
   }

bool edm::isSameEvent	(	EventAuxiliary const &	a,
		EventAuxiliary const &	b
	)

Definition at line 17 of file EventAuxiliary.cc.

References edm::EventAuxiliary::bunchCrossing(), edm::EventAuxiliary::experimentType(), edm::EventAuxiliary::id(), edm::EventAuxiliary::isRealData(), edm::EventAuxiliary::luminosityBlock(), edm::EventAuxiliary::processGUID(), edm::EventAuxiliary::storeNumber(), and edm::EventAuxiliary::time().

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

bool edm::isSameEvent	(	EventPrincipal const &	a,
		EventPrincipal const &	b
	)

inline

Definition at line 215 of file EventPrincipal.h.

References edm::EventPrincipal::aux(), and isSameEvent().

                                                                 {
     return isSameEvent(a.aux(), b.aux());
   }

template<typename C , typename KEY >

bool edm::isThinnedAvailable	(	RefCore const &	product,
		KEY const &	iKey
	)

inline

Definition at line 119 of file RefItemGet.h.

References edm::refitem::IsThinnedAvailableImpl< C, KEY >::isThinnedAvailable_().

                                                                    {
     return refitem::IsThinnedAvailableImpl<C, KEY>::isThinnedAvailable_(product, iKey);
   }

bool edm::isTransientEqual	(	ParameterSet const &	a,
		ParameterSet const &	b
	)

Definition at line 868 of file ParameterSet.cc.

References MillePedeFileConverter_cfg::e, f, mps_fire::i, gen::k, Pi, edm::ParameterSet::psetTable(), edm::ParameterSet::tbl(), and edm::ParameterSet::vpsetTable().

Referenced by edm::eventsetup::EventSetupsController::getESProducerAndRegisterProcess(), edm::eventsetup::EventSetupsController::getESSourceAndRegisterProcess(), operator==(), and swap().

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

bool edm::isWarningEnabled ( )

Definition at line 81 of file MessageLogger.cc.

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

Referenced by edm::Suppress_LogDebug_::operator<<(), L1GlobalTriggerPSB::receiveGctObjectData(), and L1GlobalTriggerPSB::receiveTechnicalTriggers().

                         {
   return ((!edm::MessageDrop::warningAlwaysSuppressed)      // 9/27/10 mf
          && edm::MessageDrop::instance()->warningEnabled );
 }

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 297 of file Trie.h.

References MillePedeFileConverter_cfg::e, diffTwoXMLs::label, 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;
   }

static std::string const edm::kBaseType ( "Source" )

static

static const std::string edm::kBaseType ( "EDProducer" )

static

static const std::string edm::kBaseType ( "EDFilter" )

static

static const std::string edm::kBaseType ( "EDAnalyzer" )

static

Referenced by edm::EDAnalyzer::baseType(), edm::EDProducer::baseType(), edm::stream::EDAnalyzerBase::baseType(), edm::EDFilter::baseType(), edm::stream::EDProducerBase::baseType(), edm::stream::EDFilterBase::baseType(), edm::OutputModule::baseType(), edm::InputSource::baseType(), edm::EDProducer::prevalidate(), edm::stream::EDAnalyzerBase::prevalidate(), edm::EDFilter::prevalidate(), edm::stream::EDProducerBase::prevalidate(), edm::stream::EDFilterBase::prevalidate(), edm::OutputModule::prevalidate(), edm::InputSource::prevalidate(), and edm::EDAnalyzer::registerProductsAndCallbacks().

static const std::string edm::kBaseType ( "OutputModule" )

static

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

Definition at line 70 of file LuminosityBlockRange.cc.

References edm::LuminosityBlockRange::endLumiID(), and edm::LuminosityBlockRange::startLumiID().

                                                                                 {
     return lh.endLumiID() < rh.startLumiID();
   }

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

Definition at line 67 of file EventRange.cc.

References edm::EventRange::endEventID(), edm::EventRange::startEventID(), and edm::EventRange::startLumi().

Referenced by distinct(), edm::EventSkipperByID::skipIt(), and DQMRootSource::skipIt().

                                                             {
     assert((lh.startLumi() == 0) == (rh.startLumi() == 0));
     return lh.endEventID() < rh.startEventID();
   }

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

Definition at line 59 of file EventRange.cc.

References edm::EventRange::endEventID(), 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();
   }

bool edm::loadCap	(	std::string const &	name,
		std::vector< std::string > &	missingDictionaries
	)

Definition at line 16 of file ClassFiller.cc.

References edm::TypeWithDict::byName(), checkClassDictionaries(), and FDEBUG.

                                                                                  {
     FDEBUG(1) << "Loading dictionary for " << name << "\n";
     TypeWithDict typeWithDict = TypeWithDict::byName(name);
     return checkClassDictionaries(missingDictionaries, name, typeWithDict);
   }

bool edm::loadCap	(	const std::string &	name,
		std::vector< std::string > &	missingDictionaries
	)

Referenced by edm::StreamerInputSource::declareStreamers(), and loadExtraClasses().

void edm::loadExtraClasses ( )

Definition at line 34 of file ClassFiller.cc.

References edm::errors::Configuration, Exception, loadCap(), dataset::name, 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;
   }

static ELmap const& edm::loadMap ( )

static

Definition at line 62 of file ELseverityLevel.cc.

References ELdebug, ELerror, ELhighestSeverity, ELinfo, edm::ELseverityLevel::ELsev_error, edm::ELseverityLevel::ELsev_highestSeverity, edm::ELseverityLevel::ELsev_info, edm::ELseverityLevel::ELsev_severe, edm::ELseverityLevel::ELsev_success, edm::ELseverityLevel::ELsev_unspecified, edm::ELseverityLevel::ELsev_warning, edm::ELseverityLevel::ELsev_zeroSeverity, ELsevere, ELunspecified, ELwarning, ELzeroSeverity, and funct::m.

Referenced by edm::ELseverityLevel::ELseverityLevel().

                             {
     
     static const ELmap  m = {
       { ELzeroSeverity.getSymbol(), ELseverityLevel::ELsev_zeroSeverity }
     , { ELzeroSeverity.getName()     , ELseverityLevel::ELsev_zeroSeverity }
     , { ELzeroSeverity.getInputStr() , ELseverityLevel::ELsev_zeroSeverity }
     , { ELzeroSeverity.getVarName()  , ELseverityLevel::ELsev_zeroSeverity }
       ,
       { ELdebug.getSymbol()   , ELseverityLevel::ELsev_success }
     , { ELdebug.getName()     , ELseverityLevel::ELsev_success }
     , { ELdebug.getInputStr() , ELseverityLevel::ELsev_success }
     , { ELdebug.getVarName()  , ELseverityLevel::ELsev_success }
       ,
       { ELinfo.getSymbol()   , ELseverityLevel::ELsev_info }
     , { ELinfo.getName()     , ELseverityLevel::ELsev_info }
     , { ELinfo.getInputStr() , ELseverityLevel::ELsev_info }
     , { ELinfo.getVarName()  , ELseverityLevel::ELsev_info }
     ,
       { ELwarning.getSymbol()   , ELseverityLevel::ELsev_warning }
     , { ELwarning.getName()     , ELseverityLevel::ELsev_warning }
     , { ELwarning.getInputStr() , ELseverityLevel::ELsev_warning }
     , { ELwarning.getVarName()  , ELseverityLevel::ELsev_warning }
     ,
       { ELerror.getSymbol()   , ELseverityLevel::ELsev_error }
     , { ELerror.getName()     , ELseverityLevel::ELsev_error }
     , { ELerror.getInputStr() , ELseverityLevel::ELsev_error }
     , { ELerror.getVarName()  , ELseverityLevel::ELsev_error }
     ,
       { ELunspecified.getSymbol()   , ELseverityLevel::ELsev_unspecified }
     , { ELunspecified.getName()     , ELseverityLevel::ELsev_unspecified }
     , { ELunspecified.getInputStr() , ELseverityLevel::ELsev_unspecified }
     , { ELunspecified.getVarName()  , ELseverityLevel::ELsev_unspecified }
     ,
       { ELsevere.getSymbol()   , ELseverityLevel::ELsev_severe }
     , { ELsevere.getName()     , ELseverityLevel::ELsev_severe }
     , { ELsevere.getInputStr() , ELseverityLevel::ELsev_severe }
     , { ELsevere.getVarName()  , ELseverityLevel::ELsev_severe }
     ,
       { ELhighestSeverity.getSymbol()   , ELseverityLevel::ELsev_highestSeverity }
     , { ELhighestSeverity.getName()     , ELseverityLevel::ELsev_highestSeverity }
     , { ELhighestSeverity.getInputStr() , ELseverityLevel::ELsev_highestSeverity }
     , { ELhighestSeverity.getVarName()  , ELseverityLevel::ELsev_highestSeverity }
     } ;
 
     return m;
     
   }

std::vector< ErrorSummaryEntry > edm::LoggedErrorsOnlySummary ( unsigned int iStreamID )

Definition at line 203 of file MessageSender.cc.

References MillePedeFileConverter_cfg::e, ELerror, end, errorSummaryMaps, mps_fire::i, crabWrapper::key, 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;
   }

std::vector< ErrorSummaryEntry > edm::LoggedErrorsSummary ( unsigned int iStreamID )

Definition at line 176 of file MessageSender.cc.

References MillePedeFileConverter_cfg::e, end, errorSummaryMaps, mps_fire::i, crabWrapper::key, 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;
   }

void edm::LogStatistics ( )

Definition at line 67 of file MessageLogger.cc.

References edm::MessageLoggerQ::MLqSUM().

                      {
   edm::MessageLoggerQ::MLqSUM ( ); // trigger summary info
 }

void edm::longBranchPrint ( TTree * tr )

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

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 91 of file Algorithms.h.

References edmIntegrityCheck::d.

Referenced by edm::RootFile::fillEventHistory(), edm::FileIndex::findEventEntryPosition(), and edm::FileIndex::findPosition().

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

template<typename ForwardSequence , typename Datum >

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

inline

Definition at line 98 of file Algorithms.h.

References edmIntegrityCheck::d.

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

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 105 of file Algorithms.h.

References edmIntegrityCheck::d, and AlCaHLTBitMon_ParallelJobs::p.

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

template<typename ForwardSequence , typename Datum , typename Predicate >

ForwardSequence::iterator edm::lower_bound_all	(	ForwardSequence &	s,
		Datum const &	d,
		Predicate	p
	)

inline

Definition at line 112 of file Algorithms.h.

References edmIntegrityCheck::d, and AlCaHLTBitMon_ParallelJobs::p.

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

std::unique_ptr<edm::EmptyWaitingTask, waitingtask::TaskDestroyer> edm::make_empty_waiting_task ( )

inline

Create an EmptyWaitingTask which will properly be destroyed.

Definition at line 98 of file WaitingTaskList.h.

Referenced by edm::EventProcessor::beginRun(), edm::Worker::doWork(), edm::EventProcessor::endRun(), edm::EventProcessor::endUnfinishedLumi(), edm::EventProcessor::endUnfinishedRun(), edm::EventProcessor::processLumis(), and edm::WorkerManager::processOneOccurrence().

                                                                                                  {
       return std::unique_ptr<edm::EmptyWaitingTask, waitingtask::TaskDestroyer>( new (tbb::task::allocate_root()) edm::EmptyWaitingTask{});
    }

template<typename ALLOC , typename F >

FunctorTask<F>* edm::make_functor_task	(	ALLOC &&	iAlloc,
		F	f
	)

Definition at line 47 of file FunctorTask.h.

Referenced by edm::EventProcessor::continueLumiAsync(), edm::Worker::doWorkNoPrefetchingAsync(), edm::InputProductResolver::prefetchAsync_(), edm::EventProcessor::processEventAsync(), and edm::StreamSchedule::processOneStreamAsync().

                                                           {
     return new (iAlloc) FunctorTask<F>(f);
   }

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 29 of file make_sentry.h.

Referenced by edm::InputProductResolver::resolveProduct_(), edm::UnscheduledProductResolver::resolveProduct_(), edm::OutputModuleCommunicatorT< T >::writeLumiAsync(), and edm::OutputModuleCommunicatorT< T >::writeRunAsync().

                                                                                         {
     return std::unique_ptr<T, F>(iObject, iFunc);
   }

template<typename ALLOC , typename F >

FunctorWaitingTask<F>* edm::make_waiting_task	(	ALLOC &&	iAlloc,
		F	f
	)

Definition at line 92 of file WaitingTask.h.

Referenced by beginGlobalTransitionAsync(), edm::EventProcessor::beginLumiAsync(), beginStreamTransitionAsync(), edm::Worker::doWorkAsync(), endGlobalTransitionAsync(), endStreamTransitionAsync(), edm::EventProcessor::globalEndLumiAsync(), edm::EventProcessor::handleNextEventForStreamAsync(), edm::PuttableProductResolver::prefetchAsync_(), edm::UnscheduledProductResolver::prefetchAsync_(), edm::Worker::prePrefetchSelectionAsync(), edm::SubProcess::processAsync(), edm::EventProcessor::processEventAsyncImpl(), edm::StreamSchedule::processOneEventAsync(), edm::GlobalSchedule::processOneGlobalAsync(), edm::StreamSchedule::processOneStreamAsync(), edm::Path::runNextWorkerAsync(), edm::EventProcessor::streamEndLumiAsync(), edm::SubProcess::writeLumiAsync(), edm::EventProcessor::writeLumiAsync(), edm::SubProcess::writeRunAsync(), and edm::EventProcessor::writeRunAsync().

                                                                  {
     return new (iAlloc) FunctorWaitingTask<F>(f);
   }

template<typename T >

std::shared_ptr<ESHandleExceptionFactory> edm::makeESHandleExceptionFactory ( T && iFunctor )

Definition at line 43 of file FunctorESHandleExceptionFactory.h.

References eostools::move().

Referenced by edm::eventsetup::EventSetupRecord::getImplementation().

                                                                                      {
     return std::make_shared<FunctorESHandleExceptionFactory<T>>(std::move(iFunctor));
   }

template<typename T >

std::shared_ptr<HandleExceptionFactory> edm::makeHandleExceptionFactory ( T && iFunctor )

Definition at line 48 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(), and edm::PrincipalGetAdapter::makeFailToGetException().

                                                                                  {
     return std::make_shared<FunctorHandleExceptionFactory<T>>(std::move(iFunctor));
   }

std::unique_ptr<InputSource> edm::makeInput	(	ParameterSet &	params,
		CommonParams const &	common,
		std::shared_ptr< ProductRegistry >	preg,
		std::shared_ptr< BranchIDListHelper >	branchIDListHelper,
		std::shared_ptr< ThinnedAssociationsHelper >	thinnedAssociationsHelper,
		std::shared_ptr< ActivityRegistry >	areg,
		std::shared_ptr< ProcessConfiguration const >	processConfiguration,
		PreallocationConfiguration const &	allocations
	)

Definition at line 117 of file EventProcessor.cc.

References cms::Exception::addContext(), edm::errors::Configuration, beamerCreator::create(), Exception, objects.autophobj::filler, reco::get(), edm::ParameterSet::getParameter(), edm::ParameterSet::getPSetForUpdate(), edm::ParameterSet::id(), input, edm::CommonParams::maxEventsInput_, edm::CommonParams::maxLumisInput_, edm::CommonParams::maxSecondsUntilRampdown_, 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(),
                          ModuleDescription::getUniqueID());
 
     InputSourceDescription isdesc(md, preg, branchIDListHelper, 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;
   }

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 56 of file Principal.cc.

References cppFunctionSkipper::exception, 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;
   }

void edm::makeParameterSets	(	std::string const &	configtext,
		std::shared_ptr< ParameterSet > &	main
	)

essentially the same as the previous method

Definition at line 54 of file MakeParameterSets.cc.

References PythonProcessDesc::parameterSet().

Referenced by edm::ServiceRegistry::createServicesFromConfig().

                                                      {
     PythonProcessDesc pythonProcessDesc(configtext);
     main = pythonProcessDesc.parameterSet();
   }

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 473 of file DetSetVector.h.

References edm::errors::InvalidReference, and edm::Exception::throwThis().

Referenced by makeRefToDetSetVector(), 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));
   }

template<typename T >

RefToBaseProd<T> edm::makeRefToBaseProdFrom	(	RefToBase< T > const &	iRef,
		Event const &	iEvent
	)

Definition at line 34 of file makeRefToBaseProdFrom.h.

References edm::Event::get(), and edm::RefToBase< T >::id().

Referenced by BTagPerformanceAnalyzerMC::getJetWithFlavour(), helper::MasterCollection< edm::View< T > >::MasterCollection(), reco::modulesNew::MCTruthCompositeMatcher::produce(), JetTagProducer::produce(), ConeIsolation::produce(), ImpactParameter::produce(), GenJetBCEnergyRatio::produce(), PixelJetPuId::produce(), DeepFlavourTFJetTagsProducer::produce(), DeepFlavourJetTagsProducer::produce(), and reco::modules::JetFlavourIdentifier::produce().

                                                                                           {
     Handle<View<T>> view;
     iEvent.get(iRef.id(),view);
 
     return RefToBaseProd<T>(view);
   }

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

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 319 of file DetSetRefVector.h.

References makeRefToDetSetRefVector().

                                                                     {
       typedef typename HandleT::element_type Vec;
       typename Vec::detset::const_iterator itIter2 = itIter;
       return makeRefToDetSetRefVector(iHandle,iDetID,itIter2);
    }

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 496 of file DetSetVector.h.

References makeRefTo().

                                                                     {
     typedef typename HandleT::element_type Vec;
     typename Vec::detset::const_iterator itIter2 = itIter;
     return makeRefTo(iHandle,iDetID,itIter2);
   }

std::unique_ptr< RunHelperBase > edm::makeRunHelper ( ParameterSet const & pset )

Definition at line 13 of file RunHelper.cc.

References edm::ParameterSet::exists(), edm::ParameterSet::getUntrackedParameter(), muonDTDigis_cfi::pset, findQualityFiles::run, gather_cfg::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);
       }
     }
     return std::make_unique<DefaultRunHelper>();
   }

std::string edm::match	(	BranchDescription const &	a,
		BranchDescription const &	b,
		std::string const &	fileName
	)

Definition at line 329 of file BranchDescription.cc.

References edm::BranchDescription::branchID(), edm::BranchDescription::branchName(), edm::BranchDescription::branchType(), edm::BranchDescription::dropped(), and edm::BranchDescription::fullClassName().

Referenced by edm::RootOutputFile::beginInputFile(), edm::EventSelector::identical(), ConversionTools::matchedConversion(), ConversionTools::matchedPromptElectron(), edm::ProductRegistry::merge(), reco::modules::MCMatchCandRefSelector::newEvent(), edm::InputTagMatch::operator()(), edm::IDVectorMap< ID, C, P >::match_iterator< M >::operator++(), operator<<(), edm::IDVectorMap< ID, C, P >::match_iterator< M >::operator=(), HLTTauRefCombiner::produce(), GlobalCosmicMuonTrajectoryBuilder::propagator(), CosmicMuonLinksProducer::sharedHits(), edm::ThinnedAssociationsHelper::shouldKeepAssociation(), SiStripRecHitConverterAlgorithm::products::shrink_to_fit(), edm::PoolOutputModule::SpecialSplitLevelForBranch::SpecialSplitLevelForBranch(), and edm::detail::TriggerResultsBasedEventSelector::wantEvent().

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

LuminosityBlockID const& edm::max	(	LuminosityBlockID const &	lh,
		LuminosityBlockID const &	rh
	)

inline

Definition at line 135 of file LuminosityBlockID.h.

                                                                                          {
     return (rh < lh ? lh : rh);
   }

EventID const& edm::max	(	EventID const &	lh,
		EventID const &	rh
	)

inline

Definition at line 142 of file EventID.h.

Referenced by edm::helper::Filler< Association< C > >::add(), DTLocalTriggerSynchTest::bookChambHistos(), DTTriggerEfficiencyTest::bookChambHistos(), TIBLayerBuilder::constructRings(), distinct(), DTRunConditionVarClient::dqmEndJob(), DTDigitizer::driftTimeFromParametrization(), MuonPFAnalyzer::fillInRange(), edm::ProvenanceAdaptor::fixProcessHistory(), merge(), DTLocalTriggerBaseTest::phiRange(), DTTriggerLutTest::runClientDiagnostic(), CSCHaloAlgo::SetMinMaxInnerRadius(), CSCHaloAlgo::SetMinMaxOuterMomentumTheta(), and CSCHaloAlgo::SetMinMaxOuterRadius().

                                                            {
     return (rh < lh ? lh : rh);
   }

const unsigned int edm::maxIDlength ( 200 )

Referenced by edm::ErrorObj::setID().

bool edm::merge	(	LuminosityBlockRange &	lh,
		LuminosityBlockRange &	rh
	)

Definition at line 78 of file LuminosityBlockRange.cc.

References begin, end, edm::LuminosityBlockRange::endLumiID(), mathSSE::lh, edm::LuminosityBlockRange::LuminosityBlockRange(), max(), min(), overlaps(), edm::LuminosityBlockRange::startLumi(), 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;
   }

LuminosityBlockID const& edm::min	(	LuminosityBlockID const &	lh,
		LuminosityBlockID const &	rh
	)

inline

Definition at line 130 of file LuminosityBlockID.h.

                                                                                          {
     return (rh < lh ? rh : lh);
   }

EventID const& edm::min	(	EventID const &	lh,
		EventID const &	rh
	)

inline

Definition at line 137 of file EventID.h.

Referenced by DTLocalTriggerSynchTest::bookChambHistos(), DTTriggerEfficiencyTest::bookChambHistos(), distinct(), DTRunConditionVarClient::dqmEndJob(), DTLocalTriggerTest::fillGlobalSummary(), MuonPFAnalyzer::fillInRange(), merge(), DTLocalTriggerBaseTest::phiRange(), CSCHaloAlgo::SetMinMaxInnerRadius(), CSCHaloAlgo::SetMinMaxOuterMomentumTheta(), CSCHaloAlgo::SetMinMaxOuterRadius(), and edm::Lumi3DReWeighting::weight3D().

                                                            {
     return (rh < lh ? rh : lh);
   }

std::string edm::moduleName ( Provenance const & provenance )

Definition at line 27 of file Provenance.cc.

References edm::ParameterSet::getParameter(), edm::Provenance::moduleLabel(), parameterSet(), AlCaHLTBitMon_QueryRunRegistry::string, triggerResults(), and triggerResultsInserter().

Referenced by HLTObjectsMonitor::analyze(), TopDecaySubset::checkShowerModel(), edm::DaqProvenanceHelper::DaqProvenanceHelper(), HeavyFlavorValidation::dqmBeginRun(), edm::LHEProvenanceHelper::fillCommonProcessParameterSet(), pos::PixelDelay25Calib::getCommands(), egHLT::trigTools::getL1SeedFilterOfPath(), pos::PixelPortcardMap::getName(), HLTObjectMonitor::HLTObjectMonitor(), HLTObjectMonitorProtonLead::HLTObjectMonitorProtonLead(), HeavyFlavorValidation::myBook1D(), pos::PixelPortcardMap::numChannels(), AlignableTrackerBuilder::objectIdProvider(), OniaVtxReProducer::OniaVtxReProducer(), PixelToFEDAssociateFromAscii::operator()(), pos::PixelDetectorConfig::PixelDetectorConfig(), HadronAndPartonSelector::produce(), edm::RootFile::reportOpened(), edm::RootOutputFile::RootOutputFile(), and edm::Maker::throwValidationException().

                                                      {
     // Trigger results ia a special case
     if(provenance.moduleLabel() == triggerResults) {
       return triggerResultsInserter; 
     }
     return parameterSet(provenance).getParameter<std::string>("@module_type");
   }

EDProductGetter const * edm::mustBeNonZero	(	EDProductGetter const *	prodGetter,
		std::string	refType,
		ProductID const &	productID
	)

Definition at line 70 of file EDProductGetter.cc.

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

Referenced by edm::EDProductGetter::transitionIndex().

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

static Principal::CacheIdentifier_t edm::nextIdentifier ( )

inlinestatic

Definition at line 109 of file Principal.cc.

References s_nextIdentifier.

Referenced by edm::Principal::fillPrincipal().

                                                             {
     return s_nextIdentifier.fetch_add(1,std::memory_order_acq_rel);
   }

Long64_t edm::numEntries	(	TFile *	hdl,
		const std::string &	trname
	)

Long64_t edm::numEntries	(	TFile *	hdl,
		std::string const &	trname
	)

Definition at line 50 of file CollUtil.cc.

References MicroEventContent_cff::branch, gather_cfg::cout, mps_fire::i, and findQualityFiles::size.

Referenced by format_vstring(), edm::RootFile::readEntryDescriptionTree(), edm::RootFile::readParentageTree(), ProvenanceDumper::work_(), and RecoTauCleanerImpl< Prod >::~RecoTauCleanerImpl().

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

TFile* edm::openFileHdl ( const std::string & fname )

TFile* edm::openFileHdl ( std::string const & fname )

Definition at line 24 of file CollUtil.cc.

References gather_cfg::cout, and cmsRelvalreport::exit.

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

bool edm::operator!=	(	FileID const &	lh,
		FileID const &	rh
	)

inline

Definition at line 28 of file FileID.h.

References operator<<().

28 {return !(lh == rh);}

mathSSE::lh

bool int lh

Definition: SIMDVec.h:21

bool edm::operator!=	(	RunLumiEntryInfo const &	a,
		RunLumiEntryInfo const &	b
	)

inline

Definition at line 47 of file RunLumiEntryInfo.h.

References b.

47 { return !(a==b); }

b

double b

Definition: hdecay.h:120

a

double a

Definition: hdecay.h:121

bool edm::operator!=	(	EventEntryInfo const &	a,
		EventEntryInfo const &	b
	)

inline

Definition at line 56 of file EventEntryInfo.h.

References b.

56 { return !(a==b); }

b

double b

Definition: hdecay.h:120

a

double a

Definition: hdecay.h:121

bool edm::operator!=	(	ProductID const &	lh,
		ProductID const &	rh
	)

inline

Definition at line 58 of file ProductID.h.

References mathSSE::lh, operator<(), and operator<<().

                                                             {
     return !(lh == rh);
   }

bool edm::operator!=	(	EventEntryDescription const &	a,
		EventEntryDescription const &	b
	)

inline

Definition at line 60 of file EventEntryDescription.h.

References b.

60 { return !(a==b); }

b

double b

Definition: hdecay.h:120

a

double a

Definition: hdecay.h:121

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

inline

Definition at line 61 of file TypeID.h.

References b, and operator<<().

                                                            {
     return !(a == b);
   }

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

inline

Definition at line 66 of file BranchKey.h.

References b, and operator<<().

                                                      {
     return !(a == b);
   }

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

inline

Definition at line 66 of file ProductProvenance.h.

References b.

66 { return !(a == b); }

b

double b

Definition: hdecay.h:120

a

double a

Definition: hdecay.h:121

bool edm::operator!=	(	const TypeIDBase &	a,
		const TypeIDBase &	b
	)

inline

Definition at line 74 of file TypeIDBase.h.

References b.

75 { return !(a==b); }

b

double b

Definition: hdecay.h:120

template<class X , class Y >

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

noexcept

Definition at line 75 of file debugging_allocator.h.

Referenced by SimpleL1MuGMTCand::getMomentum(), edm::IndexIntoFile::SortedRunOrLumiItr::runOrLumi(), and HcalDcsMap::const_iterator::~const_iterator().

75 { return false; }

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

inline

Definition at line 76 of file Parentage.h.

References b.

76 { return !(a == b); }

b

double b

Definition: hdecay.h:120

a

double a

Definition: hdecay.h:121

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

inline

Definition at line 80 of file ProcessConfiguration.h.

References b, and operator<<().

                                                                            {
     return !(a == b);
   }

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

inline

Definition at line 108 of file ProcessHistory.h.

References a, b, and isAncestor().

                                                                {
     return !(a==b);
   }

bool edm::operator!=	(	TypeWithDict const &	a,
		TypeWithDict const &	b
	)

inline

Definition at line 139 of file TypeWithDict.h.

References b, and edm::TypeWithDict::operator==.

                                                                      {
   return !(a == b);
 }

bool edm::operator!=	(	TypeWithDict const &	a,
		std::type_info const &	b
	)

inline

Definition at line 145 of file TypeWithDict.h.

References b.

                                                                      {
   return !(a == b);
 }

template<typename T >

bool edm::operator!=	(	FwdPtr< T > const &	lhs,
		FwdPtr< T > const &	rhs
	)

inline

Definition at line 145 of file FwdPtr.h.

                                                          {
     return !(lhs == rhs);
   }

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

inline

Definition at line 145 of file RefCore.h.

                                                      {
     return !(lhs == rhs);
   }

template<typename KEY >

bool edm::operator!=	(	RefVectorBase< KEY > const &	lhs,
		RefVectorBase< KEY > const &	rhs
	)

Inequality operator.

Definition at line 146 of file RefVectorBase.h.

                                                                            {
     return !(lhs == rhs);
   }

template<typename T >

bool edm::operator!=	(	View< T > const &	lhs,
		View< T > const &	rhs
	)

inline

Definition at line 361 of file View.h.

                                                      {
     return !(lhs == rhs);
   }

bool edm::operator!=	(	std::type_info const &	a,
		TypeWithDict const &	b
	)

inline

Definition at line 153 of file TypeWithDict.h.

References a, and operator<<().

                                                                      {
   return !(b == a);
 }

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

inline

Definition at line 153 of file FileIndex.h.

References mathSSE::lh.

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

mathSSE::lh

bool int lh

Definition: SIMDVec.h:21

template<typename T >

bool edm::operator!=	(	RefToBaseProd< T > const &	lhs,
		RefToBaseProd< T > const &	rhs
	)

inline

Definition at line 179 of file RefToBaseProd.h.

                                                                         {
     return !(lhs == rhs);
   }

template<typename T , typename U >

bool edm::operator!=	(	atomic_value_ptr< T > const &	lhs,
		U const &	rhs
	)

inline

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

bool edm::operator!=	(	ProductRegistry const &	a,
		ProductRegistry const &	b
	)

inline

Definition at line 195 of file ProductRegistry.h.

References b.

                                                                  {
     return !(a == b);
   }

template<typename T , typename U >

bool edm::operator!=	(	U const &	lhs,
		atomic_value_ptr< T > const &	rhs
	)

inline

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

template<typename C >

bool edm::operator!=	(	RefProd< C > const &	lhs,
		RefProd< C > const &	rhs
	)

inline

Definition at line 204 of file RefProd.h.

                                                            {
     return !(lhs == rhs);
   }

bool edm::operator!=	(	Entry const &	a,
		Entry const &	b
	)

inline

Definition at line 205 of file Entry.h.

References b.

                                              {
     return !(a == b);
   }

bool edm::operator!=	(	ELseverityLevel const &	e1,
		ELseverityLevel const &	e2
	)

template<typename T , typename U >

bool edm::operator!=	(	value_ptr< T > const &	lhs,
		U const &	rhs
	)

inline

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

template<typename T , typename U >

bool edm::operator!=	(	U const &	lhs,
		value_ptr< T > const &	rhs
	)

inline

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

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 232 of file RefVector.h.

                                                                            {
     return !(lhs == rhs);
   }

template<typename T >

bool edm::operator!=	(	Ptr< T > const &	lhs,
		Ptr< T > const &	rhs
	)

inline

Definition at line 273 of file Ptr.h.

                                                    {
     return !(lhs == rhs);
   }

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 277 of file FwdRef.h.

                                                                      {
     return !(lhs == rhs);
   }

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 284 of file FwdRef.h.

                                                                   {
     return !(lhs == rhs);
   }

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 291 of file FwdRef.h.

                                                                   {
     return !(lhs == rhs);
   }

bool edm::operator!=	(	ParameterSet const &	a,
		ParameterSet const &	b
	)

inline

Definition at line 331 of file ParameterSet.h.

References b, getParameterSet(), getProcessParameterSetContainingModule(), dataset::name, operator&&(), AlCaHLTBitMon_QueryRunRegistry::string, and relativeConstraints::value.

                                                            {
     return !(a == b);
   }

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 632 of file Ref.h.

                                                                {
     return !(lhs == rhs);
   }

std::unique_ptr< ParameterDescriptionNode > edm::operator&&	(	ParameterDescriptionNode const &	node_left,
		ParameterDescriptionNode const &	node_right
	)

Definition at line 197 of file ParameterDescriptionNode.cc.

Referenced by edm::value_ptr_traits< ParameterDescriptionNode >::clone().

                                                          {
     return std::make_unique<ANDGroupDescription>(node_left, node_right);
   }

std::unique_ptr< ParameterDescriptionNode > edm::operator&&	(	std::unique_ptr< ParameterDescriptionNode >	node_left,
		ParameterDescriptionNode const &	node_right
	)

Definition at line 203 of file ParameterDescriptionNode.cc.

References eostools::move().

                                                          {
     return std::make_unique<ANDGroupDescription>(std::move(node_left), node_right);
   }

std::unique_ptr< ParameterDescriptionNode > edm::operator&&	(	ParameterDescriptionNode const &	node_left,
		std::unique_ptr< ParameterDescriptionNode >	node_right
	)

Definition at line 209 of file ParameterDescriptionNode.cc.

References eostools::move().

                                                                  {
     return std::make_unique<ANDGroupDescription>(node_left, std::move(node_right));
   }

std::unique_ptr< ParameterDescriptionNode > edm::operator&&	(	std::unique_ptr< ParameterDescriptionNode >	node_left,
		std::unique_ptr< ParameterDescriptionNode >	node_right
	)

Definition at line 215 of file ParameterDescriptionNode.cc.

References eostools::move().

                                                                  {
     return std::make_unique<ANDGroupDescription>(std::move(node_left), std::move(node_right));
   }

ParameterSet::Bool edm::operator&&	(	ParameterSet::Bool	a,
		ParameterSet::Bool	b
	)

Definition at line 2438 of file ParameterSet.cc.

References edm::ParameterSet::False, edm::ParameterSet::True, and edm::ParameterSet::Unknown.

Referenced by operator!=().

                                                      {
     if(a == ParameterSet::False || b == ParameterSet::False) {
       return ParameterSet::False;
     } else if(a == ParameterSet::Unknown || b == ParameterSet::Unknown) {
       return ParameterSet::Unknown;
     }
     return ParameterSet::True;
   }

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 97 of file RefVectorIterator.h.

References gen::n.

                                                                                                                                 {
     return iter + n;
   } 

template<typename C >

Association<C> edm::operator+	(	const Association< C > &	a1,
		const Association< C > &	a2
	)

inline

Definition at line 121 of file Association.h.

References a.

                                                    {
     Association<C> a = a1;
     a += a2;
     return a;
   }

template<typename T >

ValueMap<T> edm::operator+	(	const ValueMap< T > &	a1,
		const ValueMap< T > &	a2
	)

inline

Definition at line 253 of file ValueMap.h.

References a.

                                              {
     ValueMap<T> a = a1;
     a += a2;
     return a;
   }

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

inline

Definition at line 22 of file EventProcessHistoryID.h.

References edm::EventProcessHistoryID::eventID().

                                                                                    {
       return lh.eventID() < rh.eventID();
   }

bool edm::operator<	(	RunLumiEntryInfo const &	a,
		RunLumiEntryInfo const &	b
	)

inline

Definition at line 34 of file RunLumiEntryInfo.h.

References edm::RunLumiEntryInfo::branchID().

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

bool edm::operator<	(	StoredProductProvenance const &	a,
		StoredProductProvenance const &	b
	)

inline

Definition at line 38 of file StoredProductProvenance.h.

References edm::StoredProductProvenance::branchID_.

                                                                                 {
     return a.branchID_ < b.branchID_;
   }

bool edm::operator<	(	EventEntryInfo const &	a,
		EventEntryInfo const &	b
	)

inline

Definition at line 43 of file EventEntryInfo.h.

References edm::EventEntryInfo::branchID().

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

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

inline

Definition at line 46 of file BranchKey.h.

References edm::BranchKey::friendlyClassName(), edm::BranchKey::moduleLabel(), edm::BranchKey::processName(), and edm::BranchKey::productInstanceName().

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

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

inline

Definition at line 53 of file ProductProvenance.h.

References edm::ProductProvenance::branchID().

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

bool edm::operator<	(	WorkerTimingSummary const &	a,
		WorkerTimingSummary const &	b
	)

inline

Definition at line 54 of file TriggerTimingReport.h.

References edm::WorkerTimingSummary::moduleLabel.

                                                                              {
     return a.moduleLabel < b.moduleLabel;
   }

bool edm::operator<	(	WorkerSummary const &	a,
		WorkerSummary const &	b
	)

inline

Definition at line 60 of file TriggerReport.h.

References edm::WorkerSummary::moduleLabel.

                                                                  {
     return a.moduleLabel < b.moduleLabel;
   }

bool edm::operator<	(	ProductID const &	lh,
		ProductID const &	rh
	)

Definition at line 12 of file ProductID.cc.

References edm::ProductID::processIndex(), and edm::ProductID::productIndex().

                                                            {
     return lh.processIndex() < rh.processIndex() ||
       (lh.processIndex() == rh.processIndex() && lh.productIndex() < rh.productIndex());
   }

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

Definition at line 96 of file ProcessConfiguration.cc.

References edm::ProcessConfiguration::parameterSetID(), edm::ProcessConfiguration::passID(), edm::ProcessConfiguration::processName(), and edm::ProcessConfiguration::releaseVersion().

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

template<class T >

bool edm::operator<	(	DetSet< T > const &	x,
		DetSet< T > const &	y
	)

inline

Definition at line 90 of file DetSet.h.

Referenced by sistrip::SpyEventMatcher::EventKey::apvAddress(), operator!=(), operator<<(), and edm::ProductResolverIndexHelper::Item::setIndex().

                                                      {
     return x.detId() < y.detId();
   }

template<class T >

bool edm::operator<	(	DetSet< T > const &	x,
		det_id_type	y
	)

inline

Definition at line 97 of file DetSet.h.

                                                 {
     return x.detId() < y;
   }

template<class T >

bool edm::operator<	(	det_id_type	x,
		DetSet< T > const &	y
	)

inline

Definition at line 104 of file DetSet.h.

                                                 {
     return x < y.detId();
   }

bool edm::operator<	(	TypeWithDict const &	a,
		TypeWithDict const &	b
	)

inline

Definition at line 133 of file TypeWithDict.h.

References a, b, edm::TypeWithDict::name(), and edm::TypeWithDict::operator==.

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

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

Definition at line 182 of file FileIndex.cc.

References edm::FileIndex::Element::event_, 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_;
   }

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

inline

Definition at line 151 of file RefCore.h.

References edm::RefCore::id(), edm::RefCore::isTransient(), and edm::RefCore::productPtr().

                                                     {
     return lhs.isTransient() ? (rhs.isTransient() ? lhs.productPtr() < rhs.productPtr() : false) : (rhs.isTransient() ? true : lhs.id() < rhs.id());
   }

template<typename T >

bool edm::operator<	(	View< T > const &	lhs,
		View< T > const &	rhs
	)

inline

Definition at line 368 of file View.h.

                                                     {
     return std::lexicographical_compare(lhs.begin(), lhs.end(),
                                         rhs.begin(), rhs.end());
   }

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 152 of file FwdPtr.h.

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

template<typename T >

bool edm::operator<	(	RefToBaseProd< T > const &	lhs,
		RefToBaseProd< T > const &	rhs
	)

inline

Definition at line 186 of file RefToBaseProd.h.

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

bool edm::operator<	(	ELseverityLevel const &	e1,
		ELseverityLevel const &	e2
	)

template<typename C >

bool edm::operator<	(	RefProd< C > const &	lhs,
		RefProd< C > const &	rhs
	)

inline

Definition at line 211 of file RefProd.h.

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

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

Definition at line 287 of file BranchDescription.cc.

References edm::BranchDescription::branchAliases(), edm::BranchDescription::branchID(), edm::BranchDescription::branchType(), edm::BranchDescription::friendlyClassName(), edm::BranchDescription::fullClassName(), edm::BranchDescription::moduleLabel(), edm::BranchDescription::present(), edm::BranchDescription::processName(), and edm::BranchDescription::productInstanceName().

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

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 280 of file Ptr.h.

                                                   {
     return (lhs.refCore() == rhs.refCore() ? lhs.key() < rhs.key() : lhs.refCore() < rhs.refCore());
   }

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 300 of file FwdRef.h.

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

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 307 of file FwdRef.h.

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

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 314 of file FwdRef.h.

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

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 639 of file Ref.h.

                                                               {
       return (lhs.refCore() == rhs.refCore() ? compare_key<C>(lhs.key(), rhs.key()) : lhs.refCore() < rhs.refCore());
   }

std::ostream & edm::operator<<	(	std::ostream &	os,
		TimeOfDay const &	tod
	)

Definition at line 27 of file TimeOfDay.cc.

References begin, min(), listBenchmarks::pattern, common_cff::precision, and edm::TimeOfDay::tv_.

                                                    {
     std::ios::fmtflags oldflags = os.flags(); // Save stream formats so they can be left unchanged.
     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);
     return os;
   }

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

Definition at line 6 of file ParameterSetBlob.cc.

References edm::ParameterSetBlob::pset().

                                                            {
     os << blob.pset();
     return os;
   }

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

Definition at line 6 of file FileID.cc.

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

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

Definition at line 6 of file BranchType.cc.

References printConversionInfo::aux, BranchTypeToString(), dumpTauVariables_cfi::eventInfo, PatBasicFWLiteAnalyzer::events, pileupCalc::lumiInfo, heppy_report::lumis, findQualityFiles::run, gather_cfg::runs, and AlCaHLTBitMon_QueryRunRegistry::string.

                                                            {
     os << BranchTypeToString(branchType);
     return os;
   }

std::ostream & edm::operator<<	(	std::ostream &	os,
		PlaceInPathContext const &	ppc
	)

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

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

Definition at line 14 of file BranchID.cc.

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

std::ostream & edm::operator<<	(	std::ostream &	os,
		InternalContext const &	ic
	)

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

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

inline

Definition at line 40 of file RunLumiEntryInfo.h.

References a, b, operator==(), and edm::RunLumiEntryInfo::write().

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

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

Definition at line 111 of file FileFormatVersion.cc.

References edm::FileFormatVersion::value().

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

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

inline

Definition at line 49 of file EventEntryInfo.h.

References a, b, operator==(), and edm::EventEntryInfo::write().

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

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

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

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

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

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

inline

Definition at line 53 of file EventEntryDescription.h.

References a, b, operator==(), and edm::EventEntryDescription::write().

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

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

inline

Definition at line 59 of file ProductProvenance.h.

References a, b, operator==(), and edm::ProductProvenance::write().

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

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

Definition at line 26 of file MallocOpts.cc.

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

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

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

Definition at line 122 of file ProductSelector.cc.

References edm::ProductSelector::print().

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

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

Definition at line 7 of file ProductID.cc.

                                                   {
     os << id.processIndex() << ":" << id.productIndex();
     return os;
   }

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

Definition at line 131 of file TypeID.cc.

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

std::ostream & edm::operator<<	(	std::ostream &	oStream,
		LuminosityBlockRange const &	iID
	)

Definition at line 46 of file LuminosityBlockRange.cc.

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

                                                                              {
     oStream << "'" << r.startRun() << ":" << r.startLumi() << "-"
                    << r.endRun()   << ":" << r.endLumi()   << "'" ;
     return oStream;
   }

std::ostream & edm::operator<<	(	std::ostream &	oStream,
		EventRange const &	iID
	)

Definition at line 27 of file EventRange.cc.

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

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

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

inline

Definition at line 68 of file RunAuxiliary.h.

References edm::RunAuxiliary::write().

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

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

inline

Definition at line 69 of file Parentage.h.

References a, b, operator==(), and edm::Parentage::write().

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

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

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

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

Definition at line 19 of file BranchKey.cc.

References edm::BranchKey::friendlyClassName(), edm::BranchKey::moduleLabel(), edm::BranchKey::processName(), and edm::BranchKey::productInstanceName().

                                                   {
     os << "BranchKey("
        << bk.friendlyClassName() << ", "
        << bk.moduleLabel() << ", "
        << bk.productInstanceName() << ", "
        << bk.processName() << ')';
     return os;
   }

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

Definition at line 221 of file InputTag.cc.

References edm::InputTag::instance(), edm::InputTag::label(), edm::InputTag::process(), and AlCaHLTBitMon_QueryRunRegistry::string.

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

std::ostream & edm::operator<<	(	std::ostream &	os,
		GlobalContext const &	gc
	)

Definition at line 22 of file GlobalContext.cc.

                                                                   {
     os << "GlobalContext: transition = ";
     switch (gc.transition()) {
     case GlobalContext::Transition::kBeginJob:
       os << "BeginJob";
       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::kEndJob:
       os << "EndJob";
       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;
   }

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

inline

Definition at line 74 of file LuminosityBlockAuxiliary.h.

References edm::LuminosityBlockAuxiliary::write().

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

std::ostream & edm::operator<<	(	std::ostream &	t,
		OStreamColumn const &	c
	)

Definition at line 17 of file OStreamColumn.cc.

References lumiQTWidget::t, edm::OStreamColumn::title_, and edm::OStreamColumn::width_.

   {
     t << std::setw(c.width_) << c.title_;
     return t;
   }

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

inline

Definition at line 78 of file StableProvenance.h.

References a, b, operator==(), and edm::StableProvenance::write().

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

template<typename E >

std::ostream& edm::operator<<	(	std::ostream &	t,
		OStreamColumnEntry< E > const &	ce
	)

Definition at line 79 of file OStreamColumn.h.

References edm::OStreamColumnEntry< T >::t.

   {
     t << std::setw(ce.col.width_) << ce.t;
     return t;
   }

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

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

std::ostream & edm::operator<<	(	std::ostream &	os,
		StreamContext const &	sc
	)

Definition at line 36 of file StreamContext.cc.

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

std::ostream & edm::operator<<	(	std::ostream &	os,
		ModuleCallingContext const &	mcc
	)

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

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

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

inline

Definition at line 95 of file Provenance.h.

References a, b, operator==(), and edm::Provenance::write().

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

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

inline

Definition at line 97 of file ModuleDescription.h.

References edm::ModuleDescription::write().

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

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

inline

Definition at line 102 of file EventAuxiliary.h.

References edm::EventAuxiliary::write().

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

std::ostream& edm::operator<<	(	std::ostream &	os,
		ParameterSetEntry const &	psetEntry
	)

Definition at line 115 of file ParameterSetEntry.cc.

References edm::ParameterSetEntry::dump().

                                                                                {
     os << psetEntry.dump();
     return os;
   }

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

inline

Formatted printout of trigger tbale.

Definition at line 115 of file HLTGlobalStatus.h.

References mps_fire::i, gen::n, edm::HLTGlobalStatus::size(), edm::HLTGlobalStatus::state(), and RecoTauValidation_cfi::text.

Referenced by fastsim::SimplifiedGeometry::getInteractionModels(), fastsim::Geometry::getMaxZ(), OMTFConfiguration::getMeasurements4Dref(), fastsim::InteractionModel::getName(), L1GlobalTriggerReadoutRecord::gtPsbVector(), L1GtTechnicalTrigger::gtTechnicalTriggerResult(), isDescendant(), edm::MallocOpts::operator!=(), operator!=(), and L1GlobalTriggerRecord::setGtPrescaleFactorIndexAlgo().

                                                                               {
     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.at(hlt.state(i));
     return ost;
   }

std::ostream& edm::operator<<	(	std::ostream &	os,
		JobReport::RunReport const &	f
	)

Definition at line 119 of file JobReport.cc.

References print().

                                                                        {
     return print(os,f);
   }

template<class T >

ErrorObj& edm::operator<<	(	ErrorObj &	e,
		const T &	t
	)

inline

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

Definition at line 72 of file ProcessHistory.cc.

References copy_all().

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

ErrorObj & edm::operator<<	(	ErrorObj &	e,
		const char	s[]
	)

Definition at line 289 of file ErrorObj.cc.

References edm::ErrorObj::opltlt().

                                                       {
   return e.opltlt(s);
 }

std::ostream & edm::operator<<	(	std::ostream &	oStream,
		LuminosityBlockID const &	iID
	)

Definition at line 25 of file LuminosityBlockID.cc.

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

                                                                             {
     oStream<< "run: " << iID.run() << " luminosityBlock: " << iID.luminosityBlock();
     return oStream;
   }

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

std::ostream& edm::operator<<	(	std::ostream &	os,
		const edm::FileInPath &	fip
	)

inline

Definition at line 146 of file FileInPath.h.

References edm::FileInPath::write().

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

std::ostream& edm::operator<<	(	std::ostream &	os,
		VParameterSetEntry const &	vpsetEntry
	)

Definition at line 147 of file VParameterSetEntry.cc.

References edm::VParameterSetEntry::dump().

                                                                                {
     os << vpsetEntry.dump();
     return os;
   }

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

Definition at line 923 of file TypeWithDict.cc.

References edm::TypeWithDict::print().

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

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

Definition at line 211 of file FileIndex.cc.

References edm::FileIndex::begin(), edm::FileIndex::end(), 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;
   }

std::ostream& edm::operator<<	(	std::ostream &	os,
		ProductResolverBase const &	phb
	)

inline

Definition at line 201 of file ProductResolverBase.h.

References edm::ProductResolverBase::write().

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

std::ostream& edm::operator<<	(	std::ostream &	os,
		ProductRegistry const &	pr
	)

inline

Definition at line 201 of file ProductRegistry.h.

References edm::ProductRegistry::print().

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

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

inline

Definition at line 213 of file BranchDescription.h.

References a, b, combinable(), MillePedeFileConverter_cfg::fileName, match(), operator<(), operator==(), AlCaHLTBitMon_QueryRunRegistry::string, and edm::BranchDescription::write().

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

std::ostream& edm::operator<<	(	std::ostream &	os,
		const ELseverityLevel &	sev
	)

Definition at line 235 of file ELseverityLevel.cc.

References edm::ELseverityLevel::getName().

                                                                          {
   return os << " -" << sev.getName() << "- ";
 }

template<int I>

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

inline

Definition at line 249 of file Hash.h.

                                                {
     return h.print(os);
   }

template<typename PROD >

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

inline

Definition at line 276 of file PrincipalGetAdapter.h.

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

template<typename C , typename T , typename F >

std::ostream& edm::operator<<	(	std::ostream &	os,
		RefVector< C, T, F > const &	r
	)

Definition at line 283 of file RefVector.h.

References MillePedeFileConverter_cfg::e, mps_fire::i, and alignCSCRings::r.

                                                         {
     for(typename RefVector<C,T,F>::const_iterator
            i = r.begin(),
            e = r.end();
            i != e;
            ++i) {
         os << *i << '\n';
       }
     return os;
   }

std::ostream & edm::operator<<	(	std::ostream &	os,
		JobReport::InputFile const &	f
	)

Definition at line 113 of file JobReport.cc.

References print().

                                                                        {
     return print(os,f);
   }

std::ostream & edm::operator<<	(	std::ostream &	os,
		JobReport::OutputFile const &	f
	)

Definition at line 116 of file JobReport.cc.

References print().

                                                                         {
     return print(os,f);
   }

std::ostream& edm::operator<<	(	std::ostream &	os,
		ParameterSet const &	pset
	)

Definition at line 948 of file ParameterSet.cc.

References edm::ParameterSet::dump().

                                                                    {
     os << pset.dump();
     return os;
   }

std::ostream& edm::operator<<	(	std::ostream &	os,
		Entry const &	entry
	)

Definition at line 954 of file Entry.cc.

References MillePedeFileConverter_cfg::e, edm::Entry::getInt32(), edm::Entry::getPSet(), edm::Entry::getString(), edm::Entry::getUInt32(), edm::Entry::getVESInputTag(), edm::Entry::getVInputTag(), edm::Entry::getVPSet(), edm::Entry::getVString(), mps_fire::i, edm::Entry::isTracked(), kTVESInputTag, edm::Entry::rep, AlCaHLTBitMon_QueryRunRegistry::string, nano_cff::strings, edm::pset::TypeTrans::table_, and edm::Entry::typeCode().

                                                   {
     os << sTypeTranslations.table_[entry.typeCode()] << " "
        << (entry.isTracked() ? "tracked " : "untracked ") <<" = ";
 
     // now handle the difficult cases
     switch(entry.typeCode()) {
       case 'P': // 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 'S':
       {
         os << "'" << entry.getString() << "'";
         break;
       }
       case 's':
       {
 
         os << "{";
         std::string start ="'";
         std::string const between(",'");
         std::vector<std::string> strings = entry.getVString();
         for(std::vector<std::string>::const_iterator it = strings.begin(), itEnd = strings.end();
             it != itEnd;
             ++it) {
           os << start << *it << "'";
           start = between;
         }
         os << "}";
         break;
       }
       case 'I':
       {
         os << entry.getInt32();
         break;
       }
       case 'U':
       {
         os << entry.getUInt32();
         break;
       }
       case 'v':
       {
         //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;
   }

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

inline

Definition at line 147 of file FileIndex.h.

References mathSSE::lh.

147 {return !(rh < lh);}

mathSSE::lh

bool int lh

Definition: SIMDVec.h:21

template<typename T >

bool edm::operator<=	(	View< T > const &	lhs,
		View< T > const &	rhs
	)

inline

Definition at line 376 of file View.h.

                                                      {
     return !(rhs<lhs);
   }

bool edm::operator<=	(	ELseverityLevel const &	e1,
		ELseverityLevel const &	e2
	)

bool edm::operator==	(	FileID const &	lh,
		FileID const &	rh
	)

inline

Definition at line 25 of file FileID.h.

References edm::FileID::fid().

25 {return lh.fid() == rh.fid();}

mathSSE::lh

bool int lh

Definition: SIMDVec.h:21

bool edm::operator==	(	RunLumiEntryInfo const &	a,
		RunLumiEntryInfo const &	b
	)

Definition at line 21 of file RunLumiEntryInfo.cc.

References edm::RunLumiEntryInfo::branchID().

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

bool edm::operator==	(	ProductID const &	lh,
		ProductID const &	rh
	)

inline

Definition at line 54 of file ProductID.h.

References edm::ProductID::processIndex(), and edm::ProductID::productIndex().

                                                             {
     return lh.processIndex() == rh.processIndex() && lh.productIndex() == rh.productIndex();
   }

bool edm::operator==	(	EventEntryInfo const &	a,
		EventEntryInfo const &	b
	)

Definition at line 25 of file EventEntryInfo.cc.

References edm::EventEntryInfo::branchID(), edm::EventEntryInfo::entryDescriptionID(), and edm::EventEntryInfo::productID().

                                                                {
     return
       a.branchID() == b.branchID()
       && a.productID() == b.productID()
       && a.entryDescriptionID() == b.entryDescriptionID();
   }

bool edm::operator==	(	EventEntryDescription const &	a,
		EventEntryDescription const &	b
	)

Definition at line 43 of file EventEntryDescription.cc.

References edm::EventEntryDescription::parents().

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

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

inline

Definition at line 60 of file BranchKey.h.

References a.

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

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

Definition at line 72 of file ProductProvenance.cc.

References edm::ProductProvenance::branchID(), and edm::ProductProvenance::parentageID().

                                                                      {
     return
       a.branchID() == b.branchID() && a.parentageID() == b.parentageID();
   }

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

inline

Definition at line 71 of file ProcessConfiguration.h.

References edm::ProcessConfiguration::parameterSetID(), edm::ProcessConfiguration::passID(), edm::ProcessConfiguration::processName(), and edm::ProcessConfiguration::releaseVersion().

                                                                            {
     return a.processName() == b.processName() &&
     a.parameterSetID() == b.parameterSetID() &&
     a.releaseVersion() == b.releaseVersion() &&
     a.passID() == b.passID();
   }

template<class X , class Y >

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

noexcept

Definition at line 72 of file debugging_allocator.h.

Referenced by edm::IndexIntoFile::IndexIntoFileItrImpl::getEntryType(), operator<<(), and edm::IndexIntoFile::SortedRunOrLumiItr::runOrLumi().

72 { return true; }

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

Definition at line 42 of file Parentage.cc.

References edm::Parentage::parents().

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

bool edm::operator==	(	StableProvenance const &	a,
		StableProvenance const &	b
	)

Definition at line 41 of file StableProvenance.cc.

References edm::StableProvenance::branchDescription().

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

template<class T >

bool edm::operator==	(	RefToBaseVector< T > const &	a,
		RefToBaseVector< T > const &	b
	)

inline

Definition at line 97 of file RefToBaseVector.h.

References edm::RefToBaseVector< T >::begin(), edm::RefToBaseVector< T >::end(), cond::serialization::equal(), edm::RefToBaseVector< T >::isInvalid(), and edm::RefToBaseVector< T >::size().

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

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

Definition at line 49 of file Provenance.cc.

References edm::Provenance::stable().

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

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

inline

Definition at line 102 of file ProcessHistory.h.

References edm::ProcessHistory::data().

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

template<typename T >

bool edm::operator==	(	FwdPtr< T > const &	lhs,
		FwdPtr< T > const &	rhs
	)

inline

Definition at line 135 of file FwdPtr.h.

                                                          {
     return (lhs.ptr() == rhs.ptr() ||
          lhs.backPtr() == rhs.ptr() ||
          lhs.ptr() == rhs.backPtr() ||
          lhs.backPtr() == rhs.backPtr());
   }

bool edm::operator==	(	TypeWithDict const &	a,
		TypeWithDict const &	b
	)

Definition at line 909 of file TypeWithDict.cc.

References edm::TypeWithDict::name().

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

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

inline

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

template<typename KEY >

bool edm::operator==	(	RefVectorBase< KEY > const &	lhs,
		RefVectorBase< KEY > const &	rhs
	)

Equality operator.

Definition at line 139 of file RefVectorBase.h.

References edm::RefVectorBase< KEY >::keys(), and edm::RefVectorBase< KEY >::refCore().

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

bool edm::operator==	(	TypeWithDict const &	a,
		std::type_info const &	b
	)

Definition at line 914 of file TypeWithDict.cc.

References b, edm::TypeID::className(), edm::TypeWithDict::isArray(), edm::TypeWithDict::isPointer(), edm::TypeWithDict::name(), and edm::TypeWithDict::ti_.

                                                            {
     if(*a.ti_ == typeid(TypeWithDict::dummyType) || a.isPointer() || a.isArray()) {
       // No accurate type_info
       return a.name() == TypeID(b).className();
     }
     return *a.ti_ == b;
   }

template<typename T >

bool edm::operator==	(	View< T > const &	lhs,
		View< T > const &	rhs
	)

inline

Definition at line 352 of file View.h.

References cond::serialization::equal().

                                                      {
     return
       lhs.size() == rhs.size() &&
       std::equal(lhs.begin(), lhs.end(), rhs.begin());
   }

bool edm::operator==	(	std::type_info const &	a,
		TypeWithDict const &	b
	)

inline

Definition at line 149 of file TypeWithDict.h.

References a.

                                                                      {
   return b == a;
 }

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

inline

Definition at line 150 of file FileIndex.h.

References mathSSE::lh.

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

mathSSE::lh

bool int lh

Definition: SIMDVec.h:21

bool edm::operator==	(	edm::FileInPath const &	a,
		edm::FileInPath const &	b
	)

inline

Definition at line 160 of file FileInPath.h.

References edm::FileInPath::location(), and edm::FileInPath::relativePath().

   {
     return a.location() == b.location() && a.relativePath() == b.relativePath();      
   }

template<typename T >

bool edm::operator==	(	RefToBaseProd< T > const &	lhs,
		RefToBaseProd< T > const &	rhs
	)

inline

Definition at line 172 of file RefToBaseProd.h.

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

template<typename T , typename U >

bool edm::operator==	(	atomic_value_ptr< T > const &	lhs,
		U const &	rhs
	)

inline

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

bool edm::operator==	(	ProductRegistry const &	a,
		ProductRegistry const &	b
	)

inline

Definition at line 189 of file ProductRegistry.h.

References edm::ProductRegistry::productList().

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

template<typename T , typename U >

bool edm::operator==	(	U const &	lhs,
		atomic_value_ptr< T > const &	rhs
	)

inline

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

template<typename C >

bool edm::operator==	(	RefProd< C > const &	lhs,
		RefProd< C > const &	rhs
	)

inline

Definition at line 197 of file RefProd.h.

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

bool edm::operator==	(	Entry const &	a,
		Entry const &	b
	)

inline

Definition at line 200 of file Entry.h.

References edm::Entry::toString().

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

bool edm::operator==	(	ELseverityLevel const &	e1,
		ELseverityLevel const &	e2
	)

template<typename T , typename U >

bool edm::operator==	(	value_ptr< T > const &	lhs,
		U const &	rhs
	)

inline

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

template<typename T , typename U >

bool edm::operator==	(	U const &	lhs,
		value_ptr< T > const &	rhs
	)

inline

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

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

Definition at line 322 of file BranchDescription.cc.

References edm::BranchDescription::branchAliases(), combinable(), edm::BranchDescription::dropped(), and AlCaHLTBitMon_QueryRunRegistry::string.

                                                                      {
     return combinable(a, b) &&
        (a.dropped() == b.dropped()) &&
        (a.branchAliases() == b.branchAliases());
   }

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 225 of file RefVector.h.

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

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

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

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

template<typename T >

bool edm::operator==	(	Ptr< T > const &	lhs,
		Ptr< T > const &	rhs
	)

inline

Definition at line 266 of file Ptr.h.

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

bool edm::operator==	(	ParameterSet const &	a,
		ParameterSet const &	b
	)

Definition at line 861 of file ParameterSet.cc.

References edm::ParameterSet::id(), edm::ParameterSet::isRegistered(), isTransientEqual(), and edm::ParameterSet::trackedPart().

                                                                 {
     if(a.isRegistered() && b.isRegistered()) {
       return (a.id() == b.id());
     }
     return isTransientEqual(a.trackedPart(), b.trackedPart());
   }

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 428 of file SortedCollection.h.

References edm::SortedCollection< T, SORT >::begin(), cond::serialization::equal(), and edm::SortedCollection< T, SORT >::size().

                                                {
     return c.size() == v.size() && std::equal(v.begin(), v.end(), c.begin());
   }

template<typename T , typename SORT >

bool edm::operator==	(	SortedCollection< T, SORT > const &	a,
		SortedCollection< T, SORT > const &	b
	)

inline

Definition at line 440 of file SortedCollection.h.

References edm::SortedCollection< T, SORT >::begin(), edm::SortedCollection< T, SORT >::end(), cond::serialization::equal(), and edm::SortedCollection< T, SORT >::size().

                                                  {
     return a.size() == b.size() && std::equal(a.begin(), a.end(), b.begin());
   }

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 625 of file Ref.h.

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

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

inline

Definition at line 57 of file TypeID.h.

References a.

                                                           {
     return b < a;
   }

bool edm::operator>	(	const TypeIDBase &	a,
		const TypeIDBase &	b
	)

inline

Definition at line 71 of file TypeIDBase.h.

References a.

72 { return b<a; }

a

double a

Definition: hdecay.h:121

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

inline

Definition at line 141 of file FileIndex.h.

References mathSSE::lh.

141 {return rh < lh;}

mathSSE::lh

bool int lh

Definition: SIMDVec.h:21

template<typename T >

bool edm::operator>	(	View< T > const &	lhs,
		View< T > const &	rhs
	)

inline

Definition at line 382 of file View.h.

                                                           {
     return rhs<lhs;
   }

bool edm::operator>	(	ELseverityLevel const &	e1,
		ELseverityLevel const &	e2
	)

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

inline

Definition at line 144 of file FileIndex.h.

144 {return !(lh < rh);}

mathSSE::lh

bool int lh

Definition: SIMDVec.h:21

template<typename T >

bool edm::operator>=	(	View< T > const &	lhs,
		View< T > const &	rhs
	)

inline

Definition at line 388 of file View.h.

                                                           {
     return !(lhs<rhs);
   }

bool edm::operator>=	(	ELseverityLevel const &	e1,
		ELseverityLevel const &	e2
	)

std::istream& edm::operator>>	(	std::istream &	is,
		FileInPath &	fip
	)

inline

Definition at line 153 of file FileInPath.h.

References edm::FileInPath::read().

Referenced by edm::value_ptr_traits< ParameterDescriptionNode >::clone().

   {
     fip.read(is);
     return is;
   }

std::unique_ptr< ParameterDescriptionCases< bool > > edm::operator>>	(	bool	caseValue,
		ParameterDescriptionNode const &	node
	)

Definition at line 138 of file ParameterDescriptionNode.cc.

References edm::ParameterDescriptionNode::clone(), and eostools::move().

                                                    {
     std::unique_ptr<ParameterDescriptionNode> clonedNode(node.clone());
     return caseValue >> std::move(clonedNode);
   }

std::unique_ptr< ParameterDescriptionCases< int > > edm::operator>>	(	int	caseValue,
		ParameterDescriptionNode const &	node
	)

Definition at line 145 of file ParameterDescriptionNode.cc.

References edm::ParameterDescriptionNode::clone(), and eostools::move().

                                                    {
     std::unique_ptr<ParameterDescriptionNode> clonedNode(node.clone());
     return caseValue >> std::move(clonedNode);
   }

std::unique_ptr< ParameterDescriptionCases< std::string > > edm::operator>>	(	std::string 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);
   }

std::unique_ptr< ParameterDescriptionCases< std::string > > edm::operator>>	(	char const *	caseValue,
		ParameterDescriptionNode const &	node
	)

Definition at line 159 of file ParameterDescriptionNode.cc.

References edm::ParameterDescriptionNode::clone(), and eostools::move().

                                                    {
     std::unique_ptr<ParameterDescriptionNode> clonedNode(node.clone());
     return caseValue >> std::move(clonedNode);
   }

std::unique_ptr< ParameterDescriptionCases< bool > > edm::operator>>	(	bool	caseValue,
		std::unique_ptr< ParameterDescriptionNode >	node
	)

Definition at line 166 of file ParameterDescriptionNode.cc.

References eostools::move().

                                                            {
     return std::unique_ptr<ParameterDescriptionCases<bool>>(
       new ParameterDescriptionCases<bool>(caseValue, std::move(node)));
   }

std::unique_ptr< ParameterDescriptionCases< int > > edm::operator>>	(	int	caseValue,
		std::unique_ptr< ParameterDescriptionNode >	node
	)

Definition at line 173 of file ParameterDescriptionNode.cc.

References eostools::move().

                                                            {
     return std::unique_ptr<ParameterDescriptionCases<int>>(
       new ParameterDescriptionCases<int>(caseValue, std::move(node)));
   }

std::unique_ptr< ParameterDescriptionCases< std::string > > edm::operator>>	(	std::string const &	caseValue,
		std::unique_ptr< ParameterDescriptionNode >	node
	)

Definition at line 180 of file ParameterDescriptionNode.cc.

References eostools::move().

                                                            {
     return std::unique_ptr<ParameterDescriptionCases<std::string>>(
       new ParameterDescriptionCases<std::string>(caseValue, std::move(node)));
   }

std::unique_ptr< ParameterDescriptionCases< std::string > > edm::operator>>	(	char const *	caseValue,
		std::unique_ptr< ParameterDescriptionNode >	node
	)

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

std::unique_ptr< ParameterDescriptionNode > edm::operator^	(	ParameterDescriptionNode const &	node_left,
		ParameterDescriptionNode const &	node_right
	)

Definition at line 249 of file ParameterDescriptionNode.cc.

Referenced by edm::value_ptr_traits< ParameterDescriptionNode >::clone().

                                                         {
     return std::make_unique<XORGroupDescription>(node_left, node_right);
   }

std::unique_ptr< ParameterDescriptionNode > edm::operator^	(	std::unique_ptr< ParameterDescriptionNode >	node_left,
		ParameterDescriptionNode const &	node_right
	)

Definition at line 255 of file ParameterDescriptionNode.cc.

References eostools::move().

                                                         {
     return std::make_unique<XORGroupDescription>(std::move(node_left), node_right);
   }

std::unique_ptr< ParameterDescriptionNode > edm::operator^	(	ParameterDescriptionNode const &	node_left,
		std::unique_ptr< ParameterDescriptionNode >	node_right
	)

Definition at line 261 of file ParameterDescriptionNode.cc.

References eostools::move().

                                                                 {
     return std::make_unique<XORGroupDescription>(node_left, std::move(node_right));
   }

std::unique_ptr< ParameterDescriptionNode > edm::operator^	(	std::unique_ptr< ParameterDescriptionNode >	node_left,
		std::unique_ptr< ParameterDescriptionNode >	node_right
	)

Definition at line 267 of file ParameterDescriptionNode.cc.

References eostools::move().

                                                                 {
     return std::make_unique<XORGroupDescription>(std::move(node_left), std::move(node_right));
   }

std::unique_ptr< ParameterDescriptionCases< bool > > edm::operator\|\|	(	std::unique_ptr< ParameterDescriptionCases< bool > >	left,
		std::unique_ptr< ParameterDescriptionCases< bool > >	right
	)

Definition at line 8 of file ParameterDescriptionCases.cc.

References genParticles_cff::map, and eostools::move().

Referenced by edm::value_ptr_traits< ParameterDescriptionNode >::clone().

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

std::unique_ptr< ParameterDescriptionCases< int > > edm::operator\|\|	(	std::unique_ptr< ParameterDescriptionCases< int > >	left,
		std::unique_ptr< ParameterDescriptionCases< int > >	right
	)

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

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

std::unique_ptr< ParameterDescriptionNode > edm::operator\|\|	(	ParameterDescriptionNode const &	node_left,
		ParameterDescriptionNode const &	node_right
	)

Definition at line 223 of file ParameterDescriptionNode.cc.

                                                          {
     return std::make_unique<ORGroupDescription>(node_left, node_right);
   }

std::unique_ptr< ParameterDescriptionNode > edm::operator\|\|	(	std::unique_ptr< ParameterDescriptionNode >	node_left,
		ParameterDescriptionNode const &	node_right
	)

Definition at line 229 of file ParameterDescriptionNode.cc.

References eostools::move().

                                                          {
     return std::make_unique<ORGroupDescription>(std::move(node_left), node_right);
   }

std::unique_ptr< ParameterDescriptionNode > edm::operator\|\|	(	ParameterDescriptionNode const &	node_left,
		std::unique_ptr< ParameterDescriptionNode >	node_right
	)

Definition at line 235 of file ParameterDescriptionNode.cc.

References eostools::move().

                                                                  {
     return std::make_unique<ORGroupDescription>(node_left, std::move(node_right));
   }

std::unique_ptr< ParameterDescriptionNode > edm::operator\|\|	(	std::unique_ptr< ParameterDescriptionNode >	node_left,
		std::unique_ptr< ParameterDescriptionNode >	node_right
	)

Definition at line 241 of file ParameterDescriptionNode.cc.

References eostools::move().

                                                                  {
     return std::make_unique<ORGroupDescription>(std::move(node_left), std::move(node_right));
   }

static std::atomic<int> edm::ourSerial ( 0 )

static

Referenced by edm::ErrorObj::set().

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

Definition at line 66 of file LuminosityBlockRange.cc.

References distinct().

                                                                                 {
     return !distinct(lh, rh);
   }

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

Definition at line 54 of file EventRange.cc.

References distinct(), and edm::EventRange::startLumi().

Referenced by distinct(), and merge().

                                                             {
     assert((lh.startLumi() == 0) == (rh.startLumi() == 0));
     return !distinct(lh, rh);
   }

ParameterSet const & edm::parameterSet ( Provenance const & provenance )

Definition at line 11 of file Provenance.cc.

References edm::ParameterSet::existsAs(), edm::pset::Registry::getMapped(), edm::ParameterSet::getParameterSet(), edm::Provenance::getProcessConfiguration(), edm::pset::Registry::instance(), diffTwoXMLs::label, edm::Provenance::moduleLabel(), edm::ProcessConfiguration::parameterSetID(), source(), AlCaHLTBitMon_QueryRunRegistry::string, and triggerResults().

Referenced by edm::ScheduleItems::addCPRandTNS(), GsfElectronProducer::beginEvent(), GsfElectronBaseProducer::beginEvent(), fwlite::ChainEvent::event(), edm::EventProcessor::EventProcessor(), EcalSelectiveReadoutProducer::getBinOfMax(), edm::Event::getRefBeforePut(), fwlite::Event::getTFile(), edm::EventProcessor::init(), edm::ScheduleItems::initSchedule(), moduleName(), OniaVtxReProducer::OniaVtxReProducer(), PFCandidateDQMAnalyzer::PFCandidateDQMAnalyzer(), PFJetDQMAnalyzer::PFJetDQMAnalyzer(), PFMETDQMAnalyzer::PFMETDQMAnalyzer(), PFMuonDQMAnalyzer::PFMuonDQMAnalyzer(), PythonProcessDesc::pset(), and fwlite::MultiChainEvent::secondaryFileIndex().

                                                                  {
     ProcessConfiguration pc;
     provenance.getProcessConfiguration(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);
   }

template<>

std::string edm::ParameterSet::getParameter< std::string > ( std::string const & name ) const

Definition at line 1068 of file ParameterSet.cc.

References edm::Entry::getString(), dataset::name, and edm::ParameterSet::retrieve().

                                                                    {
     return retrieve(name).getString();
   }

template<>

std::string edm::ParameterSet::getParameter< std::string > ( char const * name ) const

Definition at line 1698 of file ParameterSet.cc.

References edm::Entry::getString(), and edm::ParameterSet::retrieve().

                                                               {
     return retrieve(name).getString();
   }

template<>

std::vector<double> edm::ParameterSet::getParameter< std::vector< double > > ( std::string const & name ) const

Definition at line 1059 of file ParameterSet.cc.

References edm::Entry::getVDouble(), dataset::name, edm::ParameterSet::retrieve(), and AlCaHLTBitMon_QueryRunRegistry::string.

                                                                             {
     return retrieve(name).getVDouble();
   }

template<>

std::vector<double> edm::ParameterSet::getParameter< std::vector< double > > ( char const * name ) const

Definition at line 1689 of file ParameterSet.cc.

References edm::Entry::getVDouble(), edm::ParameterSet::retrieve(), and AlCaHLTBitMon_QueryRunRegistry::string.

                                                                        {
     return retrieve(name).getVDouble();
   }

template<>

std::vector<ESInputTag> edm::ParameterSet::getParameter< std::vector< ESInputTag > > ( std::string const & name ) const

Definition at line 1130 of file ParameterSet.cc.

References edm::Entry::getVESInputTag(), dataset::name, and edm::ParameterSet::retrieve().

                                                                                  {
       return retrieve(name).getVESInputTag();
    }

template<>

std::vector<ESInputTag> edm::ParameterSet::getParameter< std::vector< ESInputTag > > ( char const * name ) const

Definition at line 1759 of file ParameterSet.cc.

References edm::Entry::getVESInputTag(), and edm::ParameterSet::retrieve().

                                                                             {
       return retrieve(name).getVESInputTag();
    }

template<>

std::vector<EventID> edm::ParameterSet::getParameter< std::vector< EventID > > ( std::string const & name ) const

Definition at line 1148 of file ParameterSet.cc.

References edm::Entry::getVEventID(), dataset::name, and edm::ParameterSet::retrieve().

                                                                              {
     return retrieve(name).getVEventID();
   }

template<>

std::vector<EventID> edm::ParameterSet::getParameter< std::vector< EventID > > ( char const * name ) const

Definition at line 1778 of file ParameterSet.cc.

References edm::Entry::getVEventID(), and edm::ParameterSet::retrieve().

                                                                         {
     return retrieve(name).getVEventID();
   }

template<>

std::vector<EventRange> edm::ParameterSet::getParameter< std::vector< EventRange > > ( std::string const & name ) const

Definition at line 1184 of file ParameterSet.cc.

References edm::Entry::getVEventRange(), dataset::name, and edm::ParameterSet::retrieve().

                                                                                 {
     return retrieve(name).getVEventRange();
   }

template<>

std::vector<EventRange> edm::ParameterSet::getParameter< std::vector< EventRange > > ( char const * name ) const

Definition at line 1814 of file ParameterSet.cc.

References edm::Entry::getVEventRange(), and edm::ParameterSet::retrieve().

                                                                            {
     return retrieve(name).getVEventRange();
   }

template<>

std::vector<InputTag> edm::ParameterSet::getParameter< std::vector< InputTag > > ( std::string const & name ) const

Definition at line 1112 of file ParameterSet.cc.

References edm::Entry::getVInputTag(), dataset::name, and edm::ParameterSet::retrieve().

                                                                               {
     return retrieve(name).getVInputTag();
   }

template<>

std::vector<InputTag> edm::ParameterSet::getParameter< std::vector< InputTag > > ( char const * name ) const

Definition at line 1741 of file ParameterSet.cc.

References edm::Entry::getVInputTag(), and edm::ParameterSet::retrieve().

                                                                          {
     return retrieve(name).getVInputTag();
   }

template<>

std::vector<int> edm::ParameterSet::getParameter< std::vector< int > > ( std::string const & name ) const

Definition at line 999 of file ParameterSet.cc.

References edm::Entry::getVInt32(), dataset::name, and edm::ParameterSet::retrieve().

                                                                          {
     return retrieve(name).getVInt32();
   }

template<>

std::vector<int> edm::ParameterSet::getParameter< std::vector< int > > ( char const * name ) const

Definition at line 1629 of file ParameterSet.cc.

References edm::Entry::getVInt32(), and edm::ParameterSet::retrieve().

                                                                     {
     return retrieve(name).getVInt32();
   }

template<>

std::vector<long long> edm::ParameterSet::getParameter< std::vector< long long > > ( std::string const & name ) const

Definition at line 1014 of file ParameterSet.cc.

References edm::Entry::getVInt64(), dataset::name, and edm::ParameterSet::retrieve().

                                                                                {
     return retrieve(name).getVInt64();
   }

template<>

std::vector<long long> edm::ParameterSet::getParameter< std::vector< long long > > ( char const * name ) const

Definition at line 1644 of file ParameterSet.cc.

References edm::Entry::getVInt64(), and edm::ParameterSet::retrieve().

                                                                           {
     return retrieve(name).getVInt64();
   }

template<>

std::vector<LuminosityBlockID> edm::ParameterSet::getParameter< std::vector< LuminosityBlockID > > ( std::string const & name ) const

Definition at line 1166 of file ParameterSet.cc.

References edm::Entry::getVLuminosityBlockID(), dataset::name, and edm::ParameterSet::retrieve().

                                                                                        {
     return retrieve(name).getVLuminosityBlockID();
   }

template<>

std::vector<LuminosityBlockID> edm::ParameterSet::getParameter< std::vector< LuminosityBlockID > > ( char const * name ) const

Definition at line 1796 of file ParameterSet.cc.

References edm::Entry::getVLuminosityBlockID(), and edm::ParameterSet::retrieve().

                                                                                   {
     return retrieve(name).getVLuminosityBlockID();
   }

template<>

std::vector<LuminosityBlockRange> edm::ParameterSet::getParameter< std::vector< LuminosityBlockRange > > ( std::string const & name ) const

Definition at line 1202 of file ParameterSet.cc.

References edm::Entry::getVLuminosityBlockRange(), dataset::name, and edm::ParameterSet::retrieve().

                                                                                           {
     return retrieve(name).getVLuminosityBlockRange();
   }

template<>

std::vector<LuminosityBlockRange> edm::ParameterSet::getParameter< std::vector< LuminosityBlockRange > > ( char const * name ) const

Definition at line 1832 of file ParameterSet.cc.

References edm::Entry::getVLuminosityBlockRange(), and edm::ParameterSet::retrieve().

                                                                                      {
     return retrieve(name).getVLuminosityBlockRange();
   }

template<>

std::vector<PdtEntry> edm::ParameterSet::getParameter< std::vector< PdtEntry > > ( char const * name ) const

inline

Definition at line 110 of file PdtEntry.h.

References MillePedeFileConverter_cfg::e, and edm::pdtentry::getPdtEntryVector().

                                                                                                     {
     Entry const& e = retrieve(name);
     return pdtentry::getPdtEntryVector(e, name);
   }

template<>

std::vector<PdtEntry> edm::ParameterSet::getParameter< std::vector< PdtEntry > > ( std::string const & name ) const

inline

Definition at line 90 of file PdtEntry.h.

References MillePedeFileConverter_cfg::e, and edm::pdtentry::getPdtEntryVector().

                                                                                                          {
     Entry const& e = retrieve(name);
     return pdtentry::getPdtEntryVector(e, name.c_str());
   }

template<>

std::vector<std::string> edm::ParameterSet::getParameter< std::vector< std::string > > ( std::string const & name ) const

Definition at line 1074 of file ParameterSet.cc.

References edm::Entry::getVString(), dataset::name, and edm::ParameterSet::retrieve().

                                                                                {
     return retrieve(name).getVString();
   }

template<>

std::vector<std::string> edm::ParameterSet::getParameter< std::vector< std::string > > ( char const * name ) const

Definition at line 1704 of file ParameterSet.cc.

References edm::Entry::getVString(), and edm::ParameterSet::retrieve().

                                                                           {
     return retrieve(name).getVString();
   }

template<>

std::vector<unsigned int> edm::ParameterSet::getParameter< std::vector< unsigned int > > ( std::string const & name ) const

Definition at line 1029 of file ParameterSet.cc.

References edm::Entry::getVUInt32(), dataset::name, and edm::ParameterSet::retrieve().

                                                                                   {
     return retrieve(name).getVUInt32();
   }

template<>

std::vector<unsigned int> edm::ParameterSet::getParameter< std::vector< unsigned int > > ( char const * name ) const

Definition at line 1659 of file ParameterSet.cc.

References edm::Entry::getVUInt32(), and edm::ParameterSet::retrieve().

                                                                              {
     return retrieve(name).getVUInt32();
   }

template<>

std::vector<unsigned long long> edm::ParameterSet::getParameter< std::vector< unsigned long long > > ( std::string const & name ) const

Definition at line 1044 of file ParameterSet.cc.

References edm::Entry::getVUInt64(), dataset::name, and edm::ParameterSet::retrieve().

                                                                                         {
     return retrieve(name).getVUInt64();
   }

template<>

std::vector<unsigned long long> edm::ParameterSet::getParameter< std::vector< unsigned long long > > ( char const * name ) const

Definition at line 1674 of file ParameterSet.cc.

References edm::Entry::getVUInt64(), and edm::ParameterSet::retrieve().

                                                                                    {
     return retrieve(name).getVUInt64();
   }

template<>

std::vector<std::string> edm::ParameterSet::getParameterNamesForType< std::vector< PdtEntry > > ( bool trackiness ) const

inline

Definition at line 138 of file PdtEntry.h.

References popcon2dropbox::copy(), and nano_cff::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;
   }

template<>

std::string edm::ParameterSet::getUntrackedParameter< std::string >	(	std::string const &	name,
		std::string const &	defaultValue
	)		const

Definition at line 1388 of file ParameterSet.cc.

References edm::Entry::getString(), edm::ParameterSet::retrieveUntracked(), and AlCaHLTBitMon_QueryRunRegistry::string.

                                                                                                            {
     Entry const* entryPtr = retrieveUntracked(name);
     return entryPtr == nullptr ? defaultValue : entryPtr->getString();
   }

template<>

std::string edm::ParameterSet::getUntrackedParameter< std::string > ( std::string const & name ) const

Definition at line 1395 of file ParameterSet.cc.

References edm::ParameterSet::getEntryPointerOrThrow_(), and edm::Entry::getString().

                                                                             {
     return getEntryPointerOrThrow_(name)->getString();
   }

template<>

std::string edm::ParameterSet::getUntrackedParameter< std::string >	(	char const *	name,
		std::string const &	defaultValue
	)		const

Definition at line 2018 of file ParameterSet.cc.

References edm::Entry::getString(), edm::ParameterSet::retrieveUntracked(), and AlCaHLTBitMon_QueryRunRegistry::string.

                                                                                                       {
     Entry const* entryPtr = retrieveUntracked(name);
     return entryPtr == nullptr ? defaultValue : entryPtr->getString();
   }

template<>

std::string edm::ParameterSet::getUntrackedParameter< std::string > ( char const * name ) const

Definition at line 2025 of file ParameterSet.cc.

References edm::ParameterSet::getEntryPointerOrThrow_(), and edm::Entry::getString().

                                                                        {
     return getEntryPointerOrThrow_(name)->getString();
   }

template<>

std::vector<double> edm::ParameterSet::getUntrackedParameter< std::vector< double > > ( std::string const & name ) const

Definition at line 1379 of file ParameterSet.cc.

References edm::ParameterSet::getEntryPointerOrThrow_(), edm::Entry::getVDouble(), and AlCaHLTBitMon_QueryRunRegistry::string.

                                                                                      {
     return getEntryPointerOrThrow_(name)->getVDouble();
   }

template<>

std::vector<double> edm::ParameterSet::getUntrackedParameter< std::vector< double > >	(	std::string const &	name,
		std::vector< double > const &	defaultValue
	)		const

Definition at line 1373 of file ParameterSet.cc.

References edm::Entry::getVDouble(), and edm::ParameterSet::retrieveUntracked().

                                                                                                                             {
     Entry const* entryPtr = retrieveUntracked(name); return entryPtr == nullptr ? defaultValue : entryPtr->getVDouble();
   }

template<>

std::vector<double> edm::ParameterSet::getUntrackedParameter< std::vector< double > > ( char const * name ) const

Definition at line 2009 of file ParameterSet.cc.

References edm::ParameterSet::getEntryPointerOrThrow_(), edm::Entry::getVDouble(), and AlCaHLTBitMon_QueryRunRegistry::string.

                                                                                 {
     return getEntryPointerOrThrow_(name)->getVDouble();
   }

template<>

std::vector<double> edm::ParameterSet::getUntrackedParameter< std::vector< double > >	(	char const *	name,
		std::vector< double > const &	defaultValue
	)		const

Definition at line 2003 of file ParameterSet.cc.

References edm::Entry::getVDouble(), and edm::ParameterSet::retrieveUntracked().

                                                                                                                        {
     Entry const* entryPtr = retrieveUntracked(name); return entryPtr == nullptr ? defaultValue : entryPtr->getVDouble();
   }

template<>

std::vector<ESInputTag> edm::ParameterSet::getUntrackedParameter< std::vector< ESInputTag > > ( std::string const & name ) const

Definition at line 1484 of file ParameterSet.cc.

References edm::ParameterSet::getEntryPointerOrThrow_(), and edm::Entry::getVESInputTag().

                                                                                           {
       return getEntryPointerOrThrow_(name)->getVESInputTag();
    }

template<>

std::vector<ESInputTag> edm::ParameterSet::getUntrackedParameter< std::vector< ESInputTag > >	(	std::string const &	name,
		std::vector< ESInputTag > const &	defaultValue
	)		const

Definition at line 1476 of file ParameterSet.cc.

References edm::Entry::getVESInputTag(), and edm::ParameterSet::retrieveUntracked().

                                                                                                                 {
       Entry const* entryPtr = retrieveUntracked(name);
       return entryPtr == nullptr ? defaultValue : entryPtr->getVESInputTag();
    }

template<>

std::vector<ESInputTag> edm::ParameterSet::getUntrackedParameter< std::vector< ESInputTag > >	(	char const *	name,
		std::vector< ESInputTag > const &	defaultValue
	)		const

Definition at line 2106 of file ParameterSet.cc.

References edm::Entry::getVESInputTag(), and edm::ParameterSet::retrieveUntracked().

                                                                                                                 {
       Entry const* entryPtr = retrieveUntracked(name);
       return entryPtr == nullptr ? defaultValue : entryPtr->getVESInputTag();
    }

template<>

std::vector<ESInputTag> edm::ParameterSet::getUntrackedParameter< std::vector< ESInputTag > > ( char const * name ) const

Definition at line 2114 of file ParameterSet.cc.

References edm::ParameterSet::getEntryPointerOrThrow_(), and edm::Entry::getVESInputTag().

                                                                                      {
       return getEntryPointerOrThrow_(name)->getVESInputTag();
    }

template<>

std::vector<EventID> edm::ParameterSet::getUntrackedParameter< std::vector< EventID > >	(	std::string const &	name,
		std::vector< EventID > const &	defaultValue
	)		const

Definition at line 1506 of file ParameterSet.cc.

References edm::Entry::getVEventID(), and edm::ParameterSet::retrieveUntracked().

                                                                                     {
     Entry const* entryPtr = retrieveUntracked(name);
     return entryPtr == nullptr ? defaultValue : entryPtr->getVEventID();
   }

template<>

std::vector<EventID> edm::ParameterSet::getUntrackedParameter< std::vector< EventID > > ( std::string const & name ) const

Definition at line 1514 of file ParameterSet.cc.

References edm::ParameterSet::getEntryPointerOrThrow_(), and edm::Entry::getVEventID().

                                                                                       {
     return getEntryPointerOrThrow_(name)->getVEventID();
   }

template<>

std::vector<EventID> edm::ParameterSet::getUntrackedParameter< std::vector< EventID > >	(	char const *	name,
		std::vector< EventID > const &	defaultValue
	)		const

Definition at line 2136 of file ParameterSet.cc.

References edm::Entry::getVEventID(), and edm::ParameterSet::retrieveUntracked().

                                                                                     {
     Entry const* entryPtr = retrieveUntracked(name);
     return entryPtr == nullptr ? defaultValue : entryPtr->getVEventID();
   }

template<>

std::vector<EventID> edm::ParameterSet::getUntrackedParameter< std::vector< EventID > > ( char const * name ) const

Definition at line 2144 of file ParameterSet.cc.

References edm::ParameterSet::getEntryPointerOrThrow_(), and edm::Entry::getVEventID().

                                                                                  {
     return getEntryPointerOrThrow_(name)->getVEventID();
   }

template<>

std::vector<EventRange> edm::ParameterSet::getUntrackedParameter< std::vector< EventRange > >	(	std::string const &	name,
		std::vector< EventRange > const &	defaultValue
	)		const

Definition at line 1566 of file ParameterSet.cc.

References edm::Entry::getVEventRange(), and edm::ParameterSet::retrieveUntracked().

                                                                                        {
     Entry const* entryPtr = retrieveUntracked(name);
     return entryPtr == nullptr ? defaultValue : entryPtr->getVEventRange();
   }

template<>

std::vector<EventRange> edm::ParameterSet::getUntrackedParameter< std::vector< EventRange > > ( std::string const & name ) const

Definition at line 1574 of file ParameterSet.cc.

References edm::ParameterSet::getEntryPointerOrThrow_(), and edm::Entry::getVEventRange().

                                                                                          {
     return getEntryPointerOrThrow_(name)->getVEventRange();
   }

template<>

std::vector<EventRange> edm::ParameterSet::getUntrackedParameter< std::vector< EventRange > >	(	char const *	name,
		std::vector< EventRange > const &	defaultValue
	)		const

Definition at line 2196 of file ParameterSet.cc.

References edm::Entry::getVEventRange(), and edm::ParameterSet::retrieveUntracked().

                                                                                        {
     Entry const* entryPtr = retrieveUntracked(name);
     return entryPtr == nullptr ? defaultValue : entryPtr->getVEventRange();
   }

template<>

std::vector<EventRange> edm::ParameterSet::getUntrackedParameter< std::vector< EventRange > > ( char const * name ) const

Definition at line 2204 of file ParameterSet.cc.

References edm::ParameterSet::getEntryPointerOrThrow_(), and edm::Entry::getVEventRange().

                                                                                     {
     return getEntryPointerOrThrow_(name)->getVEventRange();
   }

template<>

std::vector<InputTag> edm::ParameterSet::getUntrackedParameter< std::vector< InputTag > > ( std::string const & name ) const

Definition at line 1454 of file ParameterSet.cc.

References edm::ParameterSet::getEntryPointerOrThrow_(), and edm::Entry::getVInputTag().

                                                                                        {
     return getEntryPointerOrThrow_(name)->getVInputTag();
   }

template<>

std::vector<InputTag> edm::ParameterSet::getUntrackedParameter< std::vector< InputTag > >	(	std::string const &	name,
		std::vector< InputTag > const &	defaultValue
	)		const

Definition at line 1446 of file ParameterSet.cc.

References edm::Entry::getVInputTag(), and edm::ParameterSet::retrieveUntracked().

                                                                                      {
     Entry const* entryPtr = retrieveUntracked(name);
     return entryPtr == nullptr ? defaultValue : entryPtr->getVInputTag();
   }

template<>

std::vector<InputTag> edm::ParameterSet::getUntrackedParameter< std::vector< InputTag > > ( char const * name ) const

Definition at line 2084 of file ParameterSet.cc.

References edm::ParameterSet::getEntryPointerOrThrow_(), and edm::Entry::getVInputTag().

                                                                                   {
     return getEntryPointerOrThrow_(name)->getVInputTag();
   }

template<>

std::vector<InputTag> edm::ParameterSet::getUntrackedParameter< std::vector< InputTag > >	(	char const *	name,
		std::vector< InputTag > const &	defaultValue
	)		const

Definition at line 2076 of file ParameterSet.cc.

References edm::Entry::getVInputTag(), and edm::ParameterSet::retrieveUntracked().

                                                                                      {
     Entry const* entryPtr = retrieveUntracked(name);
     return entryPtr == nullptr ? defaultValue : entryPtr->getVInputTag();
   }

template<>

std::vector<int> edm::ParameterSet::getUntrackedParameter< std::vector< int > >	(	std::string const &	name,
		std::vector< int > const &	defaultValue
	)		const

Definition at line 1257 of file ParameterSet.cc.

References edm::Entry::getVInt32(), and edm::ParameterSet::retrieveUntracked().

                                                                                                                       {
     Entry const* entryPtr = retrieveUntracked(name);
     return entryPtr == nullptr ? defaultValue : entryPtr->getVInt32();
   }

template<>

std::vector<int> edm::ParameterSet::getUntrackedParameter< std::vector< int > > ( std::string const & name ) const

Definition at line 1264 of file ParameterSet.cc.

References edm::ParameterSet::getEntryPointerOrThrow_(), and edm::Entry::getVInt32().

                                                                                   {
     return getEntryPointerOrThrow_(name)->getVInt32();
   }

template<>

std::vector<int> edm::ParameterSet::getUntrackedParameter< std::vector< int > >	(	char const *	name,
		std::vector< int > const &	defaultValue
	)		const

Definition at line 1887 of file ParameterSet.cc.

References edm::Entry::getVInt32(), and edm::ParameterSet::retrieveUntracked().

                                                                                                                  {
     Entry const* entryPtr = retrieveUntracked(name);
     return entryPtr == nullptr ? defaultValue : entryPtr->getVInt32();
   }

template<>

std::vector<int> edm::ParameterSet::getUntrackedParameter< std::vector< int > > ( char const * name ) const

Definition at line 1894 of file ParameterSet.cc.

References edm::ParameterSet::getEntryPointerOrThrow_(), and edm::Entry::getVInt32().

                                                                              {
     return getEntryPointerOrThrow_(name)->getVInt32();
   }

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 1344 of file ParameterSet.cc.

References edm::Entry::getVInt64(), and edm::ParameterSet::retrieveUntracked().

                                                                                                                                   {
     Entry const* entryPtr = retrieveUntracked(name);
     return entryPtr == nullptr ? defaultValue : entryPtr->getVInt64();
   }

template<>

std::vector<long long> edm::ParameterSet::getUntrackedParameter< std::vector< long long > > ( std::string const & name ) const

Definition at line 1351 of file ParameterSet.cc.

References edm::ParameterSet::getEntryPointerOrThrow_(), and edm::Entry::getVInt64().

                                                                                         {
     return getEntryPointerOrThrow_(name)->getVInt64();
   }

template<>

std::vector<long long> edm::ParameterSet::getUntrackedParameter< std::vector< long long > > ( char const * name ) const

Definition at line 1981 of file ParameterSet.cc.

References edm::ParameterSet::getEntryPointerOrThrow_(), and edm::Entry::getVInt64().

                                                                                    {
     return getEntryPointerOrThrow_(name)->getVInt64();
   }

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 1974 of file ParameterSet.cc.

References edm::Entry::getVInt64(), and edm::ParameterSet::retrieveUntracked().

                                                                                                                              {
     Entry const* entryPtr = retrieveUntracked(name);
     return entryPtr == nullptr ? defaultValue : entryPtr->getVInt64();
   }

template<>

std::vector<LuminosityBlockID> edm::ParameterSet::getUntrackedParameter< std::vector< LuminosityBlockID > >	(	std::string const &	name,
		std::vector< LuminosityBlockID > const &	defaultValue
	)		const

Definition at line 1536 of file ParameterSet.cc.

References edm::Entry::getVLuminosityBlockID(), and edm::ParameterSet::retrieveUntracked().

                                                                                               {
     Entry const* entryPtr = retrieveUntracked(name);
     return entryPtr == nullptr ? defaultValue : entryPtr->getVLuminosityBlockID();
   }

template<>

std::vector<LuminosityBlockID> edm::ParameterSet::getUntrackedParameter< std::vector< LuminosityBlockID > > ( std::string const & name ) const

Definition at line 1544 of file ParameterSet.cc.

References edm::ParameterSet::getEntryPointerOrThrow_(), and edm::Entry::getVLuminosityBlockID().

                                                                                                 {
     return getEntryPointerOrThrow_(name)->getVLuminosityBlockID();
   }

template<>

std::vector<LuminosityBlockID> edm::ParameterSet::getUntrackedParameter< std::vector< LuminosityBlockID > > ( char const * name ) const

Definition at line 2174 of file ParameterSet.cc.

References edm::ParameterSet::getEntryPointerOrThrow_(), and edm::Entry::getVLuminosityBlockID().

                                                                                            {
     return getEntryPointerOrThrow_(name)->getVLuminosityBlockID();
   }

template<>

std::vector<LuminosityBlockID> edm::ParameterSet::getUntrackedParameter< std::vector< LuminosityBlockID > >	(	char const *	name,
		std::vector< LuminosityBlockID > const &	defaultValue
	)		const

Definition at line 2166 of file ParameterSet.cc.

References edm::Entry::getVLuminosityBlockID(), and edm::ParameterSet::retrieveUntracked().

                                                                                               {
     Entry const* entryPtr = retrieveUntracked(name);
     return entryPtr == nullptr ? defaultValue : entryPtr->getVLuminosityBlockID();
   }

template<>

std::vector<LuminosityBlockRange> edm::ParameterSet::getUntrackedParameter< std::vector< LuminosityBlockRange > >	(	std::string const &	name,
		std::vector< LuminosityBlockRange > const &	defaultValue
	)		const

Definition at line 1596 of file ParameterSet.cc.

References edm::Entry::getVLuminosityBlockRange(), and edm::ParameterSet::retrieveUntracked().

                                                                                                  {
     Entry const* entryPtr = retrieveUntracked(name);
     return entryPtr == nullptr ? defaultValue : entryPtr->getVLuminosityBlockRange();
   }

template<>

std::vector<LuminosityBlockRange> edm::ParameterSet::getUntrackedParameter< std::vector< LuminosityBlockRange > > ( std::string const & name ) const

Definition at line 1604 of file ParameterSet.cc.

References edm::ParameterSet::getEntryPointerOrThrow_(), and edm::Entry::getVLuminosityBlockRange().

                                                                                                    {
     return getEntryPointerOrThrow_(name)->getVLuminosityBlockRange();
   }

template<>

std::vector<LuminosityBlockRange> edm::ParameterSet::getUntrackedParameter< std::vector< LuminosityBlockRange > >	(	char const *	name,
		std::vector< LuminosityBlockRange > const &	defaultValue
	)		const

Definition at line 2226 of file ParameterSet.cc.

References edm::Entry::getVLuminosityBlockRange(), and edm::ParameterSet::retrieveUntracked().

                                                                                                  {
     Entry const* entryPtr = retrieveUntracked(name);
     return entryPtr == nullptr ? defaultValue : entryPtr->getVLuminosityBlockRange();
   }

template<>

std::vector<LuminosityBlockRange> edm::ParameterSet::getUntrackedParameter< std::vector< LuminosityBlockRange > > ( char const * name ) const

Definition at line 2234 of file ParameterSet.cc.

References edm::ParameterSet::getEntryPointerOrThrow_(), and edm::Entry::getVLuminosityBlockRange().

                                                                                               {
     return getEntryPointerOrThrow_(name)->getVLuminosityBlockRange();
   }

template<>

std::vector<PdtEntry> edm::ParameterSet::getUntrackedParameter< std::vector< PdtEntry > > ( std::string const & name ) const

inline

Definition at line 96 of file PdtEntry.h.

References MillePedeFileConverter_cfg::e, and edm::pdtentry::getPdtEntryVector().

                                                                                                                   {
     Entry const* e = getEntryPointerOrThrow_(name);
     return pdtentry::getPdtEntryVector(*e, name.c_str());
   }

template<>

std::vector<PdtEntry> edm::ParameterSet::getUntrackedParameter< std::vector< PdtEntry > > ( char const * name ) const

inline

Definition at line 116 of file PdtEntry.h.

References MillePedeFileConverter_cfg::e, and edm::pdtentry::getPdtEntryVector().

                                                                                                              {
     Entry const* e = getEntryPointerOrThrow_(name);
     return pdtentry::getPdtEntryVector(*e, name);
   }

template<>

std::vector<PdtEntry> edm::ParameterSet::getUntrackedParameter< std::vector< PdtEntry > >	(	std::string const &	name,
		std::vector< PdtEntry > const &	defaultValue
	)		const

inline

Definition at line 102 of file PdtEntry.h.

References MillePedeFileConverter_cfg::e, and edm::pdtentry::getPdtEntryVector().

                                                                                   {
     Entry const* e = retrieveUntracked(name);
     if (e == nullptr) return defaultValue;
     return pdtentry::getPdtEntryVector(*e, name.c_str());
   }

template<>

std::vector<PdtEntry> edm::ParameterSet::getUntrackedParameter< std::vector< PdtEntry > >	(	char const *	name,
		std::vector< PdtEntry > const &	defaultValue
	)		const

inline

Definition at line 122 of file PdtEntry.h.

References MillePedeFileConverter_cfg::e, and edm::pdtentry::getPdtEntryVector().

                                                                                   {
     Entry const* e = retrieveUntracked(name);
     if (e == nullptr) return defaultValue;
     return pdtentry::getPdtEntryVector(*e, name);
   }

template<>

std::vector<std::string> edm::ParameterSet::getUntrackedParameter< std::vector< std::string > > ( std::string const & name ) const

Definition at line 1408 of file ParameterSet.cc.

References edm::ParameterSet::getEntryPointerOrThrow_(), and edm::Entry::getVString().

                                                                                         {
     return getEntryPointerOrThrow_(name)->getVString();
   }

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 1401 of file ParameterSet.cc.

References edm::Entry::getVString(), and edm::ParameterSet::retrieveUntracked().

                                                                                                                                   {
     Entry const* entryPtr = retrieveUntracked(name);
     return entryPtr == nullptr ? defaultValue : entryPtr->getVString();
   }

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 2031 of file ParameterSet.cc.

References edm::Entry::getVString(), and edm::ParameterSet::retrieveUntracked().

                                                                                                                              {
     Entry const* entryPtr = retrieveUntracked(name);
     return entryPtr == nullptr ? defaultValue : entryPtr->getVString();
   }

template<>

std::vector<std::string> edm::ParameterSet::getUntrackedParameter< std::vector< std::string > > ( char const * name ) const

Definition at line 2038 of file ParameterSet.cc.

References edm::ParameterSet::getEntryPointerOrThrow_(), and edm::Entry::getVString().

                                                                                    {
     return getEntryPointerOrThrow_(name)->getVString();
   }

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 1286 of file ParameterSet.cc.

References edm::Entry::getVUInt32(), and edm::ParameterSet::retrieveUntracked().

                                                                                                                                         {
     Entry const* entryPtr = retrieveUntracked(name);
     return entryPtr == nullptr ? defaultValue : entryPtr->getVUInt32();
   }

template<>

std::vector<unsigned int> edm::ParameterSet::getUntrackedParameter< std::vector< unsigned int > > ( std::string const & name ) const

Definition at line 1293 of file ParameterSet.cc.

References edm::ParameterSet::getEntryPointerOrThrow_(), and edm::Entry::getVUInt32().

                                                                                            {
     return getEntryPointerOrThrow_(name)->getVUInt32();
   }

template<>

std::vector<unsigned int> edm::ParameterSet::getUntrackedParameter< std::vector< unsigned int > > ( char const * name ) const

Definition at line 1923 of file ParameterSet.cc.

References edm::ParameterSet::getEntryPointerOrThrow_(), and edm::Entry::getVUInt32().

                                                                                       {
     return getEntryPointerOrThrow_(name)->getVUInt32();
   }

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 1916 of file ParameterSet.cc.

References edm::Entry::getVUInt32(), and edm::ParameterSet::retrieveUntracked().

                                                                                                                                    {
     Entry const* entryPtr = retrieveUntracked(name);
     return entryPtr == nullptr ? defaultValue : entryPtr->getVUInt32();
   }

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 1315 of file ParameterSet.cc.

References edm::Entry::getVUInt64(), and edm::ParameterSet::retrieveUntracked().

                                                                                                                                                     {
     Entry const* entryPtr = retrieveUntracked(name);
     return entryPtr == nullptr ? defaultValue : entryPtr->getVUInt64();
   }

template<>

std::vector<unsigned long long> edm::ParameterSet::getUntrackedParameter< std::vector< unsigned long long > > ( std::string const & name ) const

Definition at line 1322 of file ParameterSet.cc.

References edm::ParameterSet::getEntryPointerOrThrow_(), and edm::Entry::getVUInt64().

                                                                                                  {
     return getEntryPointerOrThrow_(name)->getVUInt64();
   }

template<>

std::vector<unsigned long long> edm::ParameterSet::getUntrackedParameter< std::vector< unsigned long long > > ( char const * name ) const

Definition at line 1952 of file ParameterSet.cc.

References edm::ParameterSet::getEntryPointerOrThrow_(), and edm::Entry::getVUInt64().

                                                                                             {
     return getEntryPointerOrThrow_(name)->getVUInt64();
   }

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 1945 of file ParameterSet.cc.

References edm::Entry::getVUInt64(), and edm::ParameterSet::retrieveUntracked().

                                                                                                                                                {
     Entry const* entryPtr = retrieveUntracked(name);
     return entryPtr == nullptr ? defaultValue : entryPtr->getVUInt64();
   }

std::string edm::parameterTypeEnumToString ( ParameterTypes iType )

Definition at line 55 of file ParameterDescriptionNode.cc.

References TYPE_TO_NAME, and HistogramManager_cfi::VPSet().

Referenced by edm::ParameterSwitchBase::insertAndCheckTypes(), edm::ParameterWildcardBase::print_(), edm::ParameterDescriptionBase::print_(), edm::ParameterSwitch< T >::print_(), edm::AllowedLabelsDescriptionBase::printNestedContentBase_(), edm::IfExistsDescription::throwIfDuplicateTypes(), edm::ORGroupDescription::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_NAME(string);
       TYPE_TO_NAME(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(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 "";
   }

template<>

ParameterTypes edm::ParameterTypeToEnum::toEnum< std::string > ( )

Definition at line 36 of file ParameterDescriptionNode.cc.

template<>

ParameterTypes edm::ParameterTypeToEnum::toEnum< std::vector< double > > ( )

Definition at line 34 of file ParameterDescriptionNode.cc.

template<>

ParameterTypes edm::ParameterTypeToEnum::toEnum< std::vector< EventID > > ( )

Definition at line 39 of file ParameterDescriptionNode.cc.

template<>

ParameterTypes edm::ParameterTypeToEnum::toEnum< std::vector< EventRange > > ( )

Definition at line 48 of file ParameterDescriptionNode.cc.

template<>

ParameterTypes edm::ParameterTypeToEnum::toEnum< std::vector< InputTag > > ( )

Definition at line 43 of file ParameterDescriptionNode.cc.

template<>

ParameterTypes edm::ParameterTypeToEnum::toEnum< std::vector< int > > ( )

Definition at line 26 of file ParameterDescriptionNode.cc.

template<>

ParameterTypes edm::ParameterTypeToEnum::toEnum< std::vector< long long > > ( )

Definition at line 30 of file ParameterDescriptionNode.cc.

template<>

ParameterTypes edm::ParameterTypeToEnum::toEnum< std::vector< LuminosityBlockID > > ( )

Definition at line 41 of file ParameterDescriptionNode.cc.

template<>

ParameterTypes edm::ParameterTypeToEnum::toEnum< std::vector< LuminosityBlockRange > > ( )

Definition at line 46 of file ParameterDescriptionNode.cc.

template<>

ParameterTypes edm::ParameterTypeToEnum::toEnum< std::vector< std::string > > ( )

Definition at line 37 of file ParameterDescriptionNode.cc.

template<>

ParameterTypes edm::ParameterTypeToEnum::toEnum< std::vector< unsigned > > ( )

Definition at line 28 of file ParameterDescriptionNode.cc.

template<>

ParameterTypes edm::ParameterTypeToEnum::toEnum< std::vector< unsigned long long > > ( )

Definition at line 32 of file ParameterDescriptionNode.cc.

template<typename T >

void const* edm::pointerToBase	(	std::type_info const &	baseTypeInfo,
		T const *	address
	)

Definition at line 50 of file OffsetToBase.h.

References PFRecoTauDiscriminationByIsolation_cfi::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;
   }

std::vector< ParameterSet > edm::popSubProcessVParameterSet ( ParameterSet & parameterSet )

Definition at line 684 of file SubProcess.cc.

References edm::ParameterSet::getUntrackedParameter(), 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 {};
   }

static void edm::postIndexIntoFilePrintEventLists	(	TFile *	tfl,
		FileFormatVersion const &	fileFormatVersion,
		TTree *	metaDataTree
	)

static

Definition at line 150 of file CollUtil.cc.

References edm::IndexIntoFile::begin(), gather_cfg::cout, edm::IndexIntoFile::end(), edm::EventID::event(), edm::poolNames::eventTreeName(), edm::IndexIntoFile::firstAppearanceOrder, edm::EventAuxiliary::id(), edm::poolNames::indexIntoFileBranchName(), edm::IndexIntoFile::iterationWillBeInEntryOrder(), edm::IndexIntoFile::kEvent, edm::IndexIntoFile::kLumi, edm::IndexIntoFile::kRun, AlCaHLTBitMon_QueryRunRegistry::string, and lumiQTWidget::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";
   }

static void edm::postIndexIntoFilePrintEventsInLumis	(	TFile *	tfl,
		FileFormatVersion const &	fileFormatVersion,
		TTree *	metaDataTree
	)

static

Definition at line 296 of file CollUtil.cc.

References edm::IndexIntoFile::begin(), gather_cfg::cout, edm::IndexIntoFile::end(), edm::IndexIntoFile::firstAppearanceOrder, edm::poolNames::indexIntoFileBranchName(), edm::IndexIntoFile::kEvent, edm::IndexIntoFile::kLumi, edm::IndexIntoFile::kRun, nEvents, and lumiQTWidget::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";
   }

static void edm::preIndexIntoFilePrintEventLists	(	TFile *	,
		FileFormatVersion const &	fileFormatVersion,
		TTree *	metaDataTree
	)

static

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

static void edm::preIndexIntoFilePrintEventsInLumis	(	TFile *	,
		FileFormatVersion const &	fileFormatVersion,
		TTree *	metaDataTree
	)

static

Definition at line 247 of file CollUtil.cc.

References edm::FileIndex::begin(), gather_cfg::cout, edm::FileIndex::end(), edm::poolNames::fileIndexBranchName(), edm::FileIndex::kEvent, edm::FileIndex::kLumi, and 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";
   }

template<typename S >

S& edm::print	(	S &	os,
		JobReport::InputFile const &	f
	)

Definition at line 65 of file JobReport.cc.

References formatFile(), edm::JobReport::InputFile::inputSourceClassName, edm::JobReport::InputFile::inputType, and edm::JobReport::InputFile::numEventsRead.

Referenced by TH2PolyOfflineMaps.TH2PolyOfflineMaps::__del__(), OrderedSet.OrderedSet::__eq__(), PhaseITreeProducer.ModuleLvlValuesReader::__TraverseDirTree(), TH2PolyOfflineMaps.TH2PolyOfflineMaps::__TraverseDirTree(), FilterSelection::acceptMap(), reco::IsoDeposit::addCandEnergy(), data_sources.json_list::as_dicts(), data_sources.json_list::as_table(), PixelTrackBuilder::build(), shell::close_connections(), helper::ConfigSectionMap(), command_line::copy_tag(), PhaseITreeProducer.ModuleLvlValuesReader::CreateTree(), PhaseITreeProducer.ModuleLvlValuesReader::CreateTree2(), AlCaHLTBitMon_ParallelJobs::defineOptions(), AlCaHLTBitMon_QueryRunRegistry::defineOptions(), SRBlockFormatter::DigiToRaw(), TCCBlockFormatter::DigiToRaw(), TowerBlockFormatter::DigiToRaw(), PhaseITreeProducer.ModuleLvlValuesReader::DumpData(), TH2PolyOfflineMaps.TH2PolyOfflineMaps::DumpData(), dqmd_manager::exec_func(), uploads.uploader::exit_upload(), sistrip::FEDDAQHeader::FEDDAQHeader(), NuclearInteractionEDProducer::findAdditionalSecondaryTracks(), models::generate(), uploadConditions::get_local_commit_hash(), PixelMapPlotter::GetAffectedRocs(), edmPickEvents::getFileNames_dasgoclient(), SimpleL1MuGMTCand::getMomentum(), SiStripSummary::getRunNr(), querying_tests::global_tag_tests(), grid1d_t(), L1GlobalTriggerReadoutRecord::gtPsbVector(), L1GtTechnicalTrigger::gtTechnicalTriggerResult(), dqmd_manager::info(), command_line::list_object(), python.rootplot.tree2hists::main(), edm::ProductResolverIndexHelper::nextIndexValue(), helper::ScannerBase::numberOfExtraCuts(), L1GtAlgorithmEvaluation::operandTokenVector(), l1t::AlgorithmEvaluation::operandTokenVector(), operator<<(), uploadConditions::parse_arguments(), command_line::parse_command_line(), PixelMapPlotter.HistogramManager::prettifyCanvas(), PFCheckHitPattern::print(), createFEDtable::printHtmlTable(), studyJets::printJetProperties(), TH2PolyOfflineMaps.TH2PolyOfflineMaps::PrintTrackerMaps(), createFEDtable::printTwikiTable(), RPCUnpackingModule::produce(), EcalTrigPrimProducer::produce(), L1TGlobalProducer::produce(), __class__< T >::produce(), EcalDigiToRaw::produce(), NuclearInteractionEDProducer::produce(), uploadConditions::pull_code_from_git(), edm::RandomNumberGenerator::RandomNumberGenerator(), PhaseITreeProducer.ModuleLvlValuesReader::ReadHistograms(), TH2PolyOfflineMaps.TH2PolyOfflineMaps::ReadHistograms(), InefficientDoubleROC.InefficientDeadROCs::ReadHistograms(), python.rootplot.core::report_progress(), querying.connection::rollback(), L1GlobalTriggerGTL::run(), l1t::GlobalBoard::runGTL(), url_query.url_query::send(), uploads.uploader::send_metadata(), hcaldqm::Container1D::setBinContent(), L1GlobalTriggerRecord::setGtPrescaleFactorIndexAlgo(), optutl::CommandLineParser::setPrintOptoins(), edm::pathStatusExpression::BinaryOperator< T >::setRight(), TtFullLeptonicEvent::setWrongCharge(), TtSemiLeptonicEvent::singleNeutrino(), muonisolation::Cuts::size(), MSLayersAtAngle::size(), sistrip::FEDDAQTrailer::slinkCRCError(), sqr(), RPCLinkSynchroStat::SynchroCounts::sum(), data_formats_tests.data_formats_tests::test_dicts_to_orm_objects(), FBaseSimEvent::theTable(), TopGenEvent::topBar(), PixelMapPlotter::TranslatePartString(), PixelMapPlotter::TranslateReasonStringBPix(), PixelMapPlotter::TranslateReasonStringFPix(), dqmd_manager::usage(), TtFullHadronicEvent::wMinus(), uploads.output::write(), uploads.uploader::write_server_side_log(), edm::ParameterDescriptionNode::writeCfi(), hitfit::Base_Constrainer::~Base_Constrainer(), hitfit::Chisq_Constrainer::~Chisq_Constrainer(), hcaldqm::ContainerXXX< int >::~ContainerXXX(), hcaldqm::filter::HashFilter::~HashFilter(), lumi::LumiSectionData::~LumiSectionData(), RecoTauCleanerImpl< Prod >::~RecoTauCleanerImpl(), and RPCRawDataCounts::~RPCRawDataCounts().

                                                {
 
     os << "\n<InputFile>";
     formatFile(f, os);
     os << "\n<InputType>" << f.inputType << "</InputType>";
     os << "\n<InputSourceClass>" << TiXmlText(f.inputSourceClassName)
        << "</InputSourceClass>";
     os << "\n<EventsRead>" << f.numEventsRead << "</EventsRead>";
     return os;
   }

template<typename S >

S& edm::print	(	S &	os,
		JobReport::OutputFile const &	f
	)

Definition at line 77 of file JobReport.cc.

References edm::JobReport::OutputFile::branchHash, edm::JobReport::OutputFile::dataType, formatFile(), edm::JobReport::OutputFile::numEventsWritten, and edm::JobReport::OutputFile::outputModuleClassName.

                                                 {
     formatFile(f, os);
     os << "\n<OutputModuleClass>"
        << TiXmlText(f.outputModuleClassName)
        << "</OutputModuleClass>";
     os << "\n<TotalEvents>"
        << f.numEventsWritten
        << "</TotalEvents>\n";
     os << "\n<DataType>"
        << TiXmlText(f.dataType)
        << "</DataType>\n";
     os << "\n<BranchHash>"
        << TiXmlText(f.branchHash)
        << "</BranchHash>\n";
     return os;
   }

template<typename S >

S& edm::print	(	S &	os,
		JobReport::RunReport const &	rep
	)

Definition at line 95 of file JobReport.cc.

References edm::JobReport::RunReport::lumiSectionsToNEvents, SiStripPI::max, and edm::JobReport::RunReport::runNumber.

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

template<typename RecordT >

void edm::print_eventsetup_record_dependencies	(	std::ostream &	oStream,
		std::string const &	iIndent = `std::string()`
	)

Definition at line 77 of file print_eventsetup_record_dependencies.h.

References edm::rec_dep::inherits_from_DependentRecordTag(), and dataset::name.

Referenced by print_eventsetup_record_dependencies(), and print_eventsetup_record_dependencies_recursive().

                                                                                             {
       oStream<<iIndent<<edm::eventsetup::EventSetupRecordKey::makeKey<RecordT>().name()<<std::endl;
       
       print_eventsetup_record_dependencies_recursive<RecordT>(oStream, iIndent, rec_dep::inherits_from_DependentRecordTag(static_cast<RecordT const*>(nullptr)));
    }

template<typename T >

void edm::print_eventsetup_record_dependencies	(	std::ostream &	,
		std::string	,
		T const *	,
		T const *
	)

Definition at line 42 of file print_eventsetup_record_dependencies.h.

45 { }

template<typename TFirst , typename TEnd >

void edm::print_eventsetup_record_dependencies	(	std::ostream &	oStream,
		std::string	iIndent,
		TFirst const *	,
		TEnd const *	iEnd
	)

Definition at line 48 of file print_eventsetup_record_dependencies.h.

References GetRecoTauVFromDQM_MC_cff::next, and print_eventsetup_record_dependencies().

                                                                               {
       iIndent +=" ";
       print_eventsetup_record_dependencies<typename boost::mpl::deref<TFirst>::type>(oStream,iIndent);
       typename boost::mpl::next< TFirst >::type const* next(nullptr);
       print_eventsetup_record_dependencies(oStream, iIndent, next, iEnd);
    }

template<typename RecordT >

void edm::print_eventsetup_record_dependencies_recursive	(	std::ostream &	oStream,
		std::string const &	iIndent,
		boost::mpl::true_
	)

Definition at line 63 of file print_eventsetup_record_dependencies.h.

References begin, end, and print_eventsetup_record_dependencies().

                                                                                                                      {
       typedef typename  RecordT::list_type list_type;
       
       typename boost::mpl::begin<list_type>::type const* begin(nullptr);
       typename boost::mpl::end<list_type>::type const* end(nullptr);
       print_eventsetup_record_dependencies(oStream, iIndent, begin, end);
    }

template<typename RecordT >

void edm::print_eventsetup_record_dependencies_recursive	(	std::ostream &	,
		std::string const &	,
		boost::mpl::false_
	)

Definition at line 72 of file print_eventsetup_record_dependencies.h.

                                                                                                       {
       return;
    }

void edm::printBranchNames ( TTree * tree )

Definition at line 73 of file CollUtil.cc.

References gather_cfg::cout, mps_fire::i, and findQualityFiles::size.

                                      {
     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 << std::endl;
       }
     } else {
       std::cout << "Missing Events tree?\n";
     }
   }

void edm::printCmsException	(	cms::Exception &	e,
		edm::JobReport *	jobRep = `nullptr`,
		int	rc = `-1`
	)

Definition at line 13 of file ExceptionMessages.cc.

References cms::Exception::explainSelf(), 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(...) {
   }

void edm::printCmsExceptionWarning	(	char const *	behavior,
		cms::Exception const &	e
	)

Definition at line 28 of file ExceptionMessages.cc.

References cms::Exception::explainSelf(), 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(...) {
   }

void edm::printEventLists ( TFile * tfl )

Definition at line 229 of file CollUtil.cc.

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

void edm::printEventsInLumis ( TFile * tfl )

Definition at line 354 of file CollUtil.cc.

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

void edm::printTrees ( TFile * hdl )

Definition at line 35 of file CollUtil.cc.

References fftjetcommon_cfi::Class, crabWrapper::key, and GetRecoTauVFromDQM_MC_cff::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;
   }

void edm::printUuids ( TTree * uuidTree )

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

BranchID edm::productIDToBranchID	(	ProductID const &	pid,
		BranchIDLists const &	lists,
		BranchListIndexes const &	indexes
	)

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

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

Definition at line 340 of file DictionaryTools.cc.

References runEdmFileComparison::base, checkDictionary(), edm::BaseWithDict::isPublic(), edm::TypeWithDict::name(), search_all(), edm::TypeIDBase::typeInfo(), edm::TypeWithDict::typeInfo(), and edm::BaseWithDict::typeOf().

Referenced by edm::ProductRegistry::checkDictionariesOfConsumedTypes(), edm::ProductRegistry::initializeLookupTables(), and edm::ProductResolverIndexHelper::insert().

                                                           {
 
     if (!checkDictionary(missingDictionaries, typeID)) {
       return false;
     }
     TypeWithDict typeWithDict(typeID.typeInfo());
 
     if (!typeWithDict.isClass()) {
       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;
       }
       TypeWithDict 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, TypeID(baseType.typeInfo()), 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;
   }

std::string edm::pythonFileToConfigure ( const std::string & iPythonFileName )

Definition at line 14 of file pythonFileToConfigure.cc.

References mps_check::command, pythonToCppException(), mps_fire::result, and AlCaHLTBitMon_QueryRunRegistry::string.

 {
   std::string returnValue;
   std::string initCommand("import FWCore.ParameterSet.Config as cms\n"
                           "fileDict = dict()\n"
                           "execfile('");
   initCommand += iPythonFileName+"',fileDict)";
   
   Py_InitializeEx(0);
   using namespace boost::python;
   
   object main_module((
                       boost::python::handle<PyObject>(borrowed(PyImport_AddModule(const_cast<char *>("__main__"))))));
   object main_namespace = main_module.attr("__dict__");
   try {
     try {
       object result((boost::python::handle<>(PyRun_String(initCommand.c_str(),
                                                           Py_file_input,
                                                           main_namespace.ptr(),
                                                           main_namespace.ptr()))));
     } catch(error_already_set) {
       edm::pythonToCppException("Configuration");
     }
     try {
       std::string command("cms.findProcess(fileDict).dumpConfig()");
       object result((handle<>(PyRun_String(command.c_str(),
                                            Py_eval_input,
                                            main_namespace.ptr(),
                                            main_namespace.ptr()))));
       returnValue= extract<std::string>(result);
       
     }catch( error_already_set ) {
       edm::pythonToCppException("Configuration");
     }
   }catch(...) {
     Py_Finalize();
     throw;
   }
   Py_Finalize();
   return returnValue;
 }

void edm::pythonToCppException ( const std::string & iType )

Definition at line 6 of file PythonWrapper.cc.

References Exception, GsfMatrixTools::trace(), and heppy_batch::val.

Referenced by pythonFileToConfigure(), PythonProcessDesc::read(), readPSetsFrom(), and FWPathsPopup::scheduleReloadEvent().

  {
   using namespace boost::python;
   PyObject *exc=nullptr, *val=nullptr, *trace=nullptr;
   PyErr_Fetch(&exc,&val,&trace);
   PyErr_NormalizeException(&exc,&val,&trace);
   handle<> hExc(allow_null(exc));
   handle<> hVal(allow_null(val));
   handle<> hTrace(allow_null(trace));
  
   if(hTrace) {
     object oTrace(hTrace);
     handle<> hStringTr(PyObject_Str(oTrace.ptr()));
     object stringTr(hStringTr);
 //std::cout << "PR TR " << stringTr <<  " DONE "<<  std::endl;
   }
 
   if(hVal && hExc) {
     object oExc(hExc);
     object oVal(hVal);
     handle<> hStringVal(PyObject_Str(oVal.ptr()));
     object stringVal( hStringVal );
 
     handle<> hStringExc(PyObject_Str(oExc.ptr()));
     object stringExc( hStringExc);
 
     //PyErr_Print();
     throw cms::Exception(iType)
       << "python encountered the error: "
       // include python exception type
       << PyString_AsString(stringExc.ptr()) << "\n"
       // message in the python exception
       << PyString_AsString(stringVal.ptr()) << "\n"; 
   } else {
     throw cms::Exception(iType)<<" unknown python problem occurred.\n";
   }
 }

void edm::read_from_cin ( std::string & output )

Definition at line 27 of file Parse.cc.

References geometryCSVtoXML::line, and AlCaHLTBitMon_QueryRunRegistry::string.

                                            {
       std::string line;
       while (getline(std::cin, line)) {
         output += line;
         output += '\n';
       }
     }

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

std::shared_ptr< ParameterSet > edm::readConfig ( std::string const & config )

Definition at line 42 of file MakeParameterSets.cc.

References PythonProcessDesc::parameterSet().

Referenced by XMLConfigReader::setEventsFile().

                                       {
     PythonProcessDesc pythonProcessDesc(config);
     return pythonProcessDesc.parameterSet();
   }

std::shared_ptr< ParameterSet > edm::readConfig	(	std::string const &	config,
		int	argc,
		char *	argv[]
	)

same, but with arguments

Definition at line 48 of file MakeParameterSets.cc.

References PythonProcessDesc::parameterSet().

                                                               {
     PythonProcessDesc pythonProcessDesc(config, argc, argv);
     return pythonProcessDesc.parameterSet();
   }

std::shared_ptr< 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 61 of file MakeParameterSets.cc.

References edm::python::initializeModule(), makePSetsFromFile(), makePSetsFromString(), resolutioncreator_cfi::object, PythonParameterSet::pset(), pythonToCppException(), and edm::ParameterSet::swap().

Referenced by main(), and MakeVersionedSelector< reco::Muon >::operator()().

                                          {
     python::initializeModule();
 
     boost::python::object mainModule = object(handle<>(borrowed(PyImport_AddModule(const_cast<char*>("__main__")))));
 
     boost::python::object mainNamespace = mainModule.attr("__dict__");
     PythonParameterSet theProcessPSet;
     mainNamespace["topPSet"] = ptr(&theProcessPSet);
 
     try {
       // if it ends with py, it's a file
       if(module.substr(module.size()-3) == ".py") {
         makePSetsFromFile(module,mainNamespace);
       } else {
         makePSetsFromString(module,mainNamespace);
       }
     }
     catch( error_already_set ) {
       pythonToCppException("Configuration");
       Py_Finalize();
     }
     auto returnValue = std::make_shared<ParameterSet>();
     theProcessPSet.pset().swap(*returnValue);
     return returnValue;
   }

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

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()(), reco::operator<<(), ParticleLevelProducer::produce(), pat::PATTauSlimmer::produce(), pat::PackedPFCandidateRefMixer::produce(), pat::PATSecondaryVertexSlimmer::produce(), IsolatedTrackCleaner::produce(), GEDPhotonCoreProducer::produce(), pat::PATGenJetSlimmer::produce(), pat::PATJetSlimmer::produce(), pat::PATMuonSlimmer::produce(), TauGenJetProducer::produce(), JetSubstructurePacker::produce(), and reco::PFTau::sourceCandidatePtr().

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

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

Definition at line 30 of file RegexMatch.cc.

References mps_fire::i, and patRefSel_triggerMatching_cfi::matches.

Referenced by triggerExpression::PathReader::init(), HLTHighLevel::init(), ZCounting::initHLT(), edm::EventSelector::initPathNames(), dqmservices::DQMStreamerReader::matchTriggerSel(), hltdqm::passTrig(), regexMatch(), 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;
   }

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

Definition at line 41 of file RegexMatch.cc.

References glob2reg(), regexMatch(), and fetchall_from_DQM_v2::regexp.

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

void edm::replaceString	(	std::string &	demangledName,
		std::string const &	from,
		std::string const &	to
	)

Definition at line 88 of file TypeDemangler.cc.

References AlCaHLTBitMon_QueryRunRegistry::string.

Referenced by edm::TypeWithDict::cppName(), L1GtVhdlTemplateFile::findAndReplaceString(), 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); 
     }
   }

void edm::resolveSymbolicLinks ( std::string & fullPath )

Definition at line 48 of file resolveSymbolicLinks.cc.

References runEdmFileComparison::found.

                                                  {
     bool found = resolveOneSymbolicLink(fullPath);
     if(found) {
       resolveSymbolicLinks(fullPath);
     }
   }

static const edm::ParameterSetDescriptionFillerPluginFactory::PMaker<edm::ParameterSetDescriptionFiller< HiMixingModule > > edm::s_filler__LINE__ ( "HiMixingModule" )

static

static const edm::MakerPluginFactory ::PMaker< edm::WorkerMaker< HiMixingModule > > edm::s_maker__LINE__ ( "HiMixingModule" )

static

template<typename ForwardSequence , typename Datum >

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

inline

Definition at line 46 of file Algorithms.h.

References edmIntegrityCheck::d, and spr::find().

Referenced by edm::eventsetup::EventSetupRecordProvider::add(), edm::WorkerManager::addToAllWorkers(), edm::service::ThreadSafeLogMessageLoggerScribe::configure_statistics(), edm::service::MessageLoggerScribe::configure_statistics(), edm::StreamSchedule::fillWorkers(), edm::service::TriggerNamesService::getTrigPaths(), edm::Schedule::limitOutput(), edm::MainParameterSet::MainParameterSet(), public_base_classes(), and DQMRootSource::skipIt().

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

template<typename ForwardSequence , typename Predicate >

bool edm::search_if_in_all	(	ForwardSequence const &	s,
		Predicate const &	p
	)

inline

Definition at line 68 of file Algorithms.h.

References AlCaHLTBitMon_ParallelJobs::p.

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

template<typename T , typename U >

U edm::second ( std::pair< T, U > const & p )

Definition at line 250 of file ParameterSet.cc.

                                                                     {
     return p.second;
   }

static std::string const edm::separator ( ":" )

static

Referenced by edm::InputTag::encode(), edm::ESInputTag::encode(), and edm::InputTag::InputTag().

template<typename T >

void edm::SetCustomStreamer ( )

Definition at line 41 of file CustomStreamer.h.

References GetRecoTauVFromDQM_MC_cff::cl.

                       {
     TClass *cl = TClass::GetClass(typeid(T));
     if (cl->GetStreamer() == 0) {
       cl->AdoptStreamer(new CustomStreamer<T>());
     }
   }

template<typename T >

void edm::SetCustomStreamer ( T const & )

Definition at line 50 of file CustomStreamer.h.

References GetRecoTauVFromDQM_MC_cff::cl.

                               {
     TClass *cl = TClass::GetClass(typeid(T));
     if (cl->GetStreamer() == 0) {
       cl->AdoptStreamer(new CustomStreamer<T>());
     }
   }

void edm::setMaxLoggedErrorsSummaryIndicies ( unsigned int iMax )

Definition at line 198 of file MessageSender.cc.

References errorSummaryMaps.

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

                                                             {
     errorSummaryMaps.resize(iMax);
   }

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 72 of file setPtr.h.

References edm::detail::reallySetPtr().

Referenced by edm::WrapperBase::isPresent(), and edm::SortedCollection< EcalRecHit >::pop_back().

                             {
     detail::reallySetPtr(obj, iToType, iIndex, oPtr);
   }

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 81 of file setPtr.h.

References edm::detail::reallySetPtr().

                             {
     detail::reallySetPtr(obj, iToType, iIndex, oPtr);
   }

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 90 of file setPtr.h.

References edm::detail::reallySetPtr().

                             {
     detail::reallySetPtr(obj, iToType, iIndex, oPtr);
   }

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 99 of file setPtr.h.

References edm::detail::reallySetPtr().

                             {
     detail::reallySetPtr(obj, iToType, iIndex, oPtr);
   }

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 463 of file SortedCollection.h.

References edm::SortedCollection< T, SORT >::setPtr().

                            {
     obj.setPtr(toType, index, ptr);
   }

template<typename T , unsigned int M, typename P >

void edm::setPtr	(	OwnArray< T, M, P > const &	obj,
		std::type_info const &	toType,
		unsigned long	index,
		void const *&	ptr
	)

inline

Definition at line 469 of file OwnArray.h.

References edm::OwnArray< T, MAX_SIZE, P >::setPtr().

                            {
     obj.setPtr(toType, index, ptr);
   }

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 544 of file OwnVector.h.

References edm::OwnVector< T, P >::setPtr().

                            {
     obj.setPtr(toType, index, ptr);
   }

void edm::setRefCoreStreamer ( bool resetAll = false )

Definition at line 93 of file RefCoreStreamer.cc.

References edm::EDProductGetter::switchProductGetter().

Referenced by edm::StreamerInputSource::deserializeEvent(), edm::RootDelayedReader::getProduct_(), TFWLiteSelectorBasic::Notify(), and edm::RootOutputTree::writeTTree().

                                 {
     EDProductGetter::switchProductGetter(nullptr);
   }

EDProductGetter const * edm::setRefCoreStreamer ( EDProductGetter const * ep )

Definition at line 97 of file RefCoreStreamer.cc.

References edm::EDProductGetter::switchProductGetter().

                                                                        {
     EDProductGetter const* returnValue=nullptr;
     if (ep != nullptr) {
       returnValue = edm::EDProductGetter::switchProductGetter(ep);
     }
     return returnValue;
   }

void edm::setRefCoreStreamerInTClass ( )

Definition at line 77 of file RefCoreStreamer.cc.

References GetRecoTauVFromDQM_MC_cff::cl, and edm::RefCoreStreamer::RefCoreStreamer().

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

                                     {
 
     TClass *cl = TClass::GetClass("edm::RefCore");
     TClassStreamer *st = cl->GetStreamer();
     if (st == nullptr) {
       cl->AdoptStreamer(new RefCoreStreamer());
     }
     {
       TClass *cl = TClass::GetClass("edm::RefCoreWithIndex");
       TClassStreamer *st = cl->GetStreamer();
       if (st == nullptr) {
         cl->AdoptStreamer(new RefCoreWithIndexStreamer());
       }
     }
   }

void edm::setStandAloneMessageThreshold ( edm::ELseverityLevel const & severity )

Definition at line 139 of file MessageLogger.cc.

References edm::MessageLoggerQ::standAloneThreshold().

Referenced by edm::Suppress_LogDebug_::operator<<().

                                                                        {
   edm::MessageLoggerQ::standAloneThreshold(severity);
 }

void edm::sigInventory ( )

Definition at line 141 of file UnixSignalHandlers.cc.

References MessageLogger_cfi::cerr, gen::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));
     }

template<typename RandomAccessSequence >

void edm::sort_all ( RandomAccessSequence & s )

inline

wrappers for std::sort

Definition at line 120 of file Algorithms.h.

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

template<typename RandomAccessSequence , typename Predicate >

void edm::sort_all	(	RandomAccessSequence &	s,
		Predicate	p
	)

inline

Definition at line 127 of file Algorithms.h.

References AlCaHLTBitMon_ParallelJobs::p.

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

std::vector< LuminosityBlockRange > & edm::sortAndRemoveOverlaps ( std::vector< LuminosityBlockRange > & lumiRange )

Definition at line 96 of file LuminosityBlockRange.cc.

References MillePedeFileConverter_cfg::e, mps_fire::i, 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;
   }

std::vector< EventRange > & edm::sortAndRemoveOverlaps ( std::vector< EventRange > & eventRange )

Definition at line 102 of file EventRange.cc.

References MillePedeFileConverter_cfg::e, mps_fire::i, sort_all(), and mitigatedMETSequence_cff::U.

Referenced by edm::service::CondorStatusService::beginPost(), DQMRootSource::DQMRootSource(), 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;
   }

static std::string const edm::source ( "source" )

static

Referenced by edm::DataMixingModule::doPileUp(), edm::MixingModule::doPileUp(), parameterSet(), edm::Principal::Principal(), edm::RootFile::RootFile(), and lumi::DataPipe::~DataPipe().

template<class OutIter >

bool edm::split	(	OutIter	result,
		std::string const &	string_to_split,
		char	first,
		char	sep,
		char	last
	)

Definition at line 88 of file split.h.

References b, contextual_find(), contextual_find_not(), MillePedeFileConverter_cfg::e, and AlCaHLTBitMon_QueryRunRegistry::string.

Referenced by edm::ParameterSetConverter::convertParameterSets(), decode(), edm::ParameterSet::fromString(), and edm::VParameterSetEntry::VParameterSetEntry().

 {
   typedef  std::string::const_iterator  str_c_iter;
   str_c_iter  b = s.begin()
            ,  e = s.end();
 
   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(boi, eoi);
   }  // for
 
   return true;
 }  // split< >()

void edm::squelchStandAloneMessageCategory ( std::string const & category )

Definition at line 142 of file MessageLogger.cc.

References edm::MessageLoggerQ::squelch().

Referenced by edm::Suppress_LogDebug_::operator<<().

                                                                  {
   edm::MessageLoggerQ::squelch(category);
 }

template<typename RandomAccessSequence >

void edm::stable_sort_all ( RandomAccessSequence & s )

inline

wrappers for std::stable_sort

Definition at line 135 of file Algorithms.h.

Referenced by edm::RootFile::fillIndexIntoFile(), edm::IndexIntoFile::fillRunOrLumiIndexes(), edm::ProvenanceAdaptor::fixProcessHistory(), 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());
   }

template<typename RandomAccessSequence , typename Predicate >

void edm::stable_sort_all	(	RandomAccessSequence &	s,
		Predicate	p
	)

inline

Definition at line 142 of file Algorithms.h.

References AlCaHLTBitMon_ParallelJobs::p.

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

std::string edm::stripLeadingDirectoryTree ( const std::string & file )

std::string edm::stripNamespace ( std::string const & theName )

Definition at line 97 of file TypeID.cc.

References EnergyCorrector::c, and egammaForCoreTracking_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;
   }

bool edm::stripTemplate ( std::string & theName )

Definition at line 72 of file TypeID.cc.

References first(), training_settings::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;
   }

void edm::subProcessDoGlobalBeginTransitionAsync	(	WaitingTaskHolder	iHolder,
		SubProcess &	iSubProcess,
		LuminosityBlockPrincipal &	iPrincipal,
		IOVSyncValue const &	iTS
	)

inline

Definition at line 38 of file globalTransitionAsync.h.

References edm::SubProcess::doBeginLuminosityBlockAsync(), and eostools::move().

Referenced by beginGlobalTransitionAsync().

                                                                                                                                                                        {
     iSubProcess.doBeginLuminosityBlockAsync(std::move(iHolder),iPrincipal, iTS);
   }

void edm::subProcessDoGlobalBeginTransitionAsync	(	WaitingTaskHolder	iHolder,
		SubProcess &	iSubProcess,
		RunPrincipal &	iPrincipal,
		IOVSyncValue const &	iTS
	)

inline

Definition at line 42 of file globalTransitionAsync.h.

References edm::SubProcess::doBeginRunAsync(), and eostools::move().

                                                                                                                                                             {
     iSubProcess.doBeginRunAsync(std::move(iHolder),iPrincipal, iTS);
   }

void edm::subProcessDoGlobalEndTransitionAsync	(	WaitingTaskHolder	iHolder,
		SubProcess &	iSubProcess,
		LuminosityBlockPrincipal &	iPrincipal,
		IOVSyncValue const &	iTS,
		bool	cleaningUpAfterException
	)

inline

Definition at line 46 of file globalTransitionAsync.h.

References edm::SubProcess::doEndLuminosityBlockAsync(), and eostools::move().

Referenced by endGlobalTransitionAsync().

                                                                                                                                                                                                      {
     iSubProcess.doEndLuminosityBlockAsync(std::move(iHolder),iPrincipal, iTS,cleaningUpAfterException);
   }

void edm::subProcessDoGlobalEndTransitionAsync	(	WaitingTaskHolder	iHolder,
		SubProcess &	iSubProcess,
		RunPrincipal &	iPrincipal,
		IOVSyncValue const &	iTS,
		bool	cleaningUpAfterException
	)

inline

Definition at line 50 of file globalTransitionAsync.h.

References edm::SubProcess::doEndRunAsync(), and eostools::move().

                                                                                                                                                                                          {
     iSubProcess.doEndRunAsync(std::move(iHolder), iPrincipal, iTS, cleaningUpAfterException);
   }

void edm::subProcessDoStreamBeginTransitionAsync	(	WaitingTaskHolder	iHolder,
		SubProcess &	iSubProcess,
		unsigned int	i,
		LuminosityBlockPrincipal &	iPrincipal,
		IOVSyncValue const &	iTS
	)

inline

Definition at line 38 of file streamTransitionAsync.h.

References edm::SubProcess::doStreamBeginLuminosityBlockAsync(), and eostools::move().

Referenced by beginStreamTransitionAsync().

                                                                                                                                                                                        {
     iSubProcess.doStreamBeginLuminosityBlockAsync(std::move(iHolder),i,iPrincipal, iTS);
   }

void edm::subProcessDoStreamBeginTransitionAsync	(	WaitingTaskHolder	iHolder,
		SubProcess &	iSubProcess,
		unsigned int	i,
		RunPrincipal &	iPrincipal,
		IOVSyncValue const &	iTS
	)

inline

Definition at line 42 of file streamTransitionAsync.h.

References edm::SubProcess::doStreamBeginRunAsync(), and eostools::move().

                                                                                                                                                                             {
     iSubProcess.doStreamBeginRunAsync(std::move(iHolder),i,iPrincipal, iTS);
   }

void edm::subProcessDoStreamEndTransitionAsync	(	WaitingTaskHolder	iHolder,
		SubProcess &	iSubProcess,
		unsigned int	i,
		LuminosityBlockPrincipal &	iPrincipal,
		IOVSyncValue const &	iTS,
		bool	cleaningUpAfterException
	)

inline

Definition at line 46 of file streamTransitionAsync.h.

References edm::SubProcess::doStreamEndLuminosityBlockAsync(), and eostools::move().

Referenced by endStreamTransitionAsync().

                                                                                                                                                                                                                      {
     iSubProcess.doStreamEndLuminosityBlockAsync(std::move(iHolder),i,iPrincipal, iTS,cleaningUpAfterException);
   }

void edm::subProcessDoStreamEndTransitionAsync	(	WaitingTaskHolder	iHolder,
		SubProcess &	iSubProcess,
		unsigned int	i,
		RunPrincipal &	iPrincipal,
		IOVSyncValue const &	iTS,
		bool	cleaningUpAfterException
	)

inline

Definition at line 50 of file streamTransitionAsync.h.

References edm::SubProcess::doStreamEndRunAsync(), and eostools::move().

                                                                                                                                                                                                          {
     iSubProcess.doStreamEndRunAsync(std::move(iHolder), i ,iPrincipal, iTS, cleaningUpAfterException);
   }

void edm::swap	(	ProductID &	a,
		ProductID &	b
	)

inline

Definition at line 49 of file ProductID.h.

References edm::ProductID::swap().

                                         {
     a.swap(b);
   }

void edm::swap	(	Parentage &	a,
		Parentage &	b
	)

inline

Definition at line 63 of file Parentage.h.

References edm::Parentage::swap().

                                    {
     a.swap(b);
   }

template<class T , class P >

void edm::swap	(	CloningPtr< T, P > &	a,
		CloningPtr< T, P > &	b
	)

inline

Definition at line 65 of file CloningPtr.h.

References edm::CloningPtr< T, P >::swap().

   {
     a.swap(b);
   }

void edm::swap	(	OrphanHandleBase &	a,
		OrphanHandleBase &	b
	)

inline

Definition at line 75 of file OrphanHandleBase.h.

References edm::OrphanHandleBase::swap().

                                                  {
     a.swap(b);
   }

void edm::swap	(	ProductData &	a,
		ProductData &	b
	)

inline

Definition at line 80 of file ProductData.h.

References edm::ProductData::swap().

                                                    {
     a.swap(b);
   }

template<class T >

void edm::swap	(	RefToBaseVector< T > &	a,
		RefToBaseVector< T > &	b
	)

inline

Definition at line 90 of file RefToBaseVector.h.

References edm::RefToBaseVector< T >::swap().

                                                      {
     a.swap(b);
   }

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

inline

Definition at line 96 of file ProcessHistory.h.

References edm::ProcessHistory::swap().

                                              {
     a.swap(b);
   }

void edm::swap	(	TriggerResults &	lhs,
		TriggerResults &	rhs
	)

inline

Definition at line 99 of file TriggerResults.h.

References edm::TriggerResults::swap().

                                                  {
     lhs.swap(rhs);
   }

void edm::swap	(	ESHandleBase &	a,
		ESHandleBase &	b
	)

inline

Definition at line 105 of file ESHandle.h.

References edm::ESHandleBase::swap().

   {
     a.swap(b);
   }

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

inline

Free swap function.

Definition at line 110 of file HLTGlobalStatus.h.

References edm::HLTGlobalStatus::swap().

                                                    {
     lhs.swap(rhs);
   }

template<typename C >

void edm::swap	(	Association< C > &	lhs,
		Association< C > &	rhs
	)

inline

Definition at line 116 of file Association.h.

References edm::Association< C >::swap().

Referenced by L1TStage2CaloLayer1::analyze(), ftl_digitizer::FTLDigitizer< SensorPhysics, ElectronicsSim >::beginRun(), CaloSD::cleanHitCollection(), SimTrackManager::cleanTkCaloStateInfoMap(), CaloSD::clearHits(), SimCluster::clearHitsAndFractions(), edm::DetSetRefVector< Phase2ITPixelCluster >::DetSetRefVector(), edm::IndexIntoFile::doneFileInitialization(), HGCDigitizer::endRun(), LA_Filler_Fitter::fill(), CaloTruthAccumulator::finalizeEvent(), EgHLTOfflineSummaryClient::getEgHLTFiltersToMon_(), EgHLTOfflineSource::getHLTFilterNamesUsed(), hitfit::Constraint_Intermed_Labels::has_labels(), HcalDcsMap::HcalDcsMap(), HcalElectronicsMap::HcalElectronicsMap(), HcalFrontEndMap::HcalFrontEndMap(), HcalSiPMCharacteristics::HcalSiPMCharacteristics(), HGCDigitizer::HGCDigitizer(), HGCDigitizerBase< DFr >::HGCDigitizerBase(), PixelTripletNoTipGenerator::hitTriplets(), PixelTripletHLTGenerator::hitTriplets(), edm::IndexIntoFile::IndexIntoFileItr::IndexIntoFileItr(), edm::IndexIntoFile::inputFileClosed(), FastCandMatcher< C >::operator()(), CandMatcherBase< C1, C2 >::operator()(), edm::RefVectorBase< key_type >::operator=(), fwlite::Handle< Collection >::operator=(), edm::value_ptr< edm::service::MessageLoggerDefaults >::operator=(), TempTrajectory::operator=(), edm::Handle< GenericObject >::operator=(), edm::Handle< FWGenericObject >::operator=(), Trajectory::operator=(), TrajectoryMeasurement::operator=(), edm::PtrVector< reco::FFTJPTJet >::operator=(), edm::DetSetRefVector< T, C >::operator=(), edm::SortedCollection< EcalRecHit >::pop_back(), FWRecoGeometryESProducer::produce(), StripCompactDigiSimLinksProducer::produce(), PFElecTkProducer::produce(), FastjetJetProducer::produceTrackJets(), MultiHitGeneratorFromChi2::refit2Hits(), HGCal3DClustering::reset(), SimTrackManager::reset(), HGCalImagingAlgo::reset(), SubjetFilterAlgorithm::run(), SiStripBaseCondObjDQM::selectModules(), hitfit::Top_Decaykin::solve_nu(), hitfit::Top_Decaykin::solve_nu_tmass(), DynamicTruncation::sort(), SimTrackManager::storeTracks(), FWGUIManager::subviewSwapped(), HcalDataFrameContainer< QIE10DataFrame >::swap(), edm::Handle< GenericObject >::swap(), edm::RefToBaseProd< T >::swap(), edm::Handle< FWGenericObject >::swap(), edm::RefProd< C >::swap(), and edmNew::DetSetVector< edm::Ref< edmNew::DetSetVector< SiStripCluster >, SiStripCluster, edmNew::DetSetVector< SiStripCluster >::FindForDetSetVector > >::swap().

                                                              {
     lhs.swap(rhs);
   }

template<class T >

void edm::swap	(	DetSet< T > &	a,
		DetSet< T > &	b
	)

inline

Definition at line 119 of file DetSet.h.

References edm::DetSet< T >::swap().

                                      {
     a.swap(b);
   }

void edm::swap	(	BasicHandle &	a,
		BasicHandle &	b
	)

inline

Definition at line 129 of file BasicHandle.h.

References edm::BasicHandle::swap().

Referenced by edm::BasicHandle::operator=(), and edm::BasicHandle::swap().

                                        {
     a.swap(b);
   }

void edm::swap	(	HandleBase &	a,
		HandleBase &	b
	)

inline

Definition at line 129 of file HandleBase.h.

References edm::HandleBase::swap().

Referenced by edm::HandleBase::operator=(), and edm::HandleBase::swap().

                                      {
     a.swap(b);
   }

void edm::swap	(	ErrorObj &	a,
		ErrorObj &	b
	)

inline

Definition at line 134 of file ErrorObj.h.

References edm::ErrorObj::swap().

                                     {
   a.swap(b);
 }

void edm::swap	(	FileInPath &	a,
		FileInPath &	b
	)

inline

Definition at line 140 of file FileInPath.h.

References edm::FileInPath::swap().

   {
     a.swap(b);
   }

template<typename KEY >

void edm::swap	(	RefVectorBase< KEY > &	a,
		RefVectorBase< KEY > &	b
	)

inline

swap two vectors

Definition at line 154 of file RefVectorBase.h.

References edm::RefVectorBase< KEY >::swap().

                                                        {
     a.swap(b);
   }

template<class T >

void edm::swap	(	EDCollection< T > &	a,
		EDCollection< T > &	b
	)

inline

Definition at line 161 of file EDCollection.h.

References edm::EDCollection< T >::swap().

   {
     a.swap(b);
   }

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

inline

Definition at line 163 of file RefCore.h.

References edm::RefCore::swap().

                                                        {
     lhs.swap(rhs);
   }

template<typename K , typename T >

void edm::swap	(	MapOfVectors< K, T > &	lhs,
		MapOfVectors< K, T > &	rhs
	)

inline

Definition at line 165 of file MapOfVectors.h.

References edm::MapOfVectors< K, T >::swap().

                                                          {
     lhs.swap(rhs);
   }

void edm::swap	(	edm::RefCoreWithIndex &	lhs,
		edm::RefCoreWithIndex &	rhs
	)

inline

Definition at line 169 of file RefCoreWithIndex.h.

References edm::RefCoreWithIndex::swap().

                                                                          {
     lhs.swap(rhs);
   }

template<typename C , typename T , typename F >

void edm::swap	(	RefVector< C, T, F > &	a,
		RefVector< C, T, F > &	b
	)

inline

Definition at line 186 of file RefVector.h.

References a, and b.

                                                                  {
     a.swap(b);
   }

template<typename T >

void edm::swap	(	edm::RefToBaseProd< T > const &	lhs,
		edm::RefToBaseProd< T > const &	rhs
	)

inline

Definition at line 191 of file RefToBaseProd.h.

References edm::RefToBaseProd< T >::swap().

                                                                                    {
     lhs.swap(rhs);
   }

template<typename ID , typename C , typename P >

void edm::swap	(	IDVectorMap< ID, C, P > &	a,
		IDVectorMap< ID, C, P > &	b
	)

inline

Definition at line 192 of file IDVectorMap.h.

References edm::IDVectorMap< ID, C, P >::swap().

                                                              {
     a.swap(b);
   }

template<typename T >

void edm::swap	(	value_ptr< T > &	vp1,
		value_ptr< T > &	vp2
	)

inline

Definition at line 198 of file value_ptr.h.

References edm::value_ptr< T >::swap().

198 { vp1.swap(vp2); }

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

template<typename C >

void edm::swap	(	RefProd< C > const &	lhs,
		RefProd< C > const &	rhs
	)

inline

Definition at line 217 of file RefProd.h.

                                                           {
     lhs.swap(rhs);
   }

template<typename ID , typename C , typename P >

void edm::swap	(	RangeMap< ID, C, P > &	a,
		RangeMap< ID, C, P > &	b
	)

inline

Definition at line 221 of file RangeMap.h.

References edm::RangeMap< ID, C, P >::swap().

                                                        {
     a.swap(b);
   }

void edm::swap	(	DataFrameContainer &	lhs,
		DataFrameContainer &	rhs
	)

inline

Definition at line 226 of file DataFrameContainer.h.

References edm::DataFrameContainer::swap().

                                                          {
     lhs.swap(rhs);
   }

template<int I>

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

inline

Definition at line 242 of file Hash.h.

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

                                {
     a.swap(b);
   }

template<typename T >

void edm::swap	(	ValueMap< T > &	lhs,
		ValueMap< T > &	rhs
	)

inline

Definition at line 263 of file ValueMap.h.

References edm::ValueMap< T >::swap().

                                                 {
     lhs.swap(rhs);
   }

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 269 of file AssociationVector.h.

References edm::AssociationVector< KeyRefProd, CVal, KeyRef, SizeType, KeyReferenceHelper >::swap().

                                                                                          {
     a.swap(b);
   }

template<typename T , typename C >

void edm::swap	(	DetSetRefVector< T, C > &	a,
		DetSetRefVector< T, C > &	b
	)

inline

Definition at line 282 of file DetSetRefVector.h.

References edm::DetSetRefVector< T, C >::swap().

                                                            {
     a.swap(b);
   }

template<typename C >

void edm::swap	(	MultiAssociation< C > &	lhs,
		MultiAssociation< C > &	rhs
	)

inline

Definition at line 292 of file MultiAssociation.h.

292 { lhs.swap(rhs); }

void edm::swap	(	ParameterSet &	a,
		ParameterSet &	b
	)

inline

Definition at line 321 of file ParameterSet.h.

References a, b, isTransientEqual(), cms::operator==(), and edm::ParameterSet::swap().

                                                {
     a.swap(b);
   }

template<typename T >

void edm::swap	(	View< T > &	lhs,
		View< T > &	rhs
	)

inline

Definition at line 395 of file View.h.

                                         {
     lhs.swap(rhs);
   }

template<class T >

void edm::swap	(	RefToBase< T > &	a,
		RefToBase< T > &	b
	)

inline

Definition at line 400 of file RefToBase.h.

References edm::RefToBase< T >::swap().

   {
     a.swap(b);
   }

template<typename T , typename SORT >

void edm::swap	(	SortedCollection< T, SORT > &	a,
		SortedCollection< T, SORT > &	b
	)

inline

Definition at line 403 of file SortedCollection.h.

References edm::SortedCollection< T, SORT >::swap().

                                                                    {
     a.swap(b);
   }

template<typename T , unsigned int M, typename P >

void edm::swap	(	OwnArray< T, M, P > &	a,
		OwnArray< T, M, P > &	b
	)

inline

Definition at line 430 of file OwnArray.h.

References edm::OwnArray< T, MAX_SIZE, P >::swap().

                                                                {
     a.swap(b);
   }

template<class T >

void edm::swap	(	DetSetVector< T > &	a,
		DetSetVector< T > &	b
	)

inline

Definition at line 441 of file DetSetVector.h.

References edm::DetSetVector< T >::swap().

   {
     a.swap(b);
   }

template<typename T , typename P >

void edm::swap	(	OwnVector< T, P > &	a,
		OwnVector< T, P > &	b
	)

inline

Definition at line 505 of file OwnVector.h.

References a, and b.

                                                                     {
     a.swap(b);
   }

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 73 of file Principal.cc.

References cppFunctionSkipper::exception, modifiedElectrons_cfi::processName, PRODUCT_TYPE, and AlCaHLTBitMon_QueryRunRegistry::string.

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

void edm::throwExceptionWithText ( char const * txt )

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

void edm::throwMissingDictionariesException	(	std::vector< std::string > &	missingDictionaries,
		std::string const &	context
	)

Definition at line 203 of file DictionaryTools.cc.

References relativeConstraints::empty.

Referenced by edm::ProductRegistryHelper::addToRegistry(), edm::ProductRegistry::checkDictionariesOfConsumedTypes(), edm::StreamerInputSource::declareStreamers(), edm::ProductRegistry::initializeLookupTables(), edm::OutputModule::keepThisBranch(), edm::one::OutputModuleBase::keepThisBranch(), and loadExtraClasses().

                                                                    {
     std::vector<std::string> empty;
     throwMissingDictionariesException(missingDictionaries, context, empty);
   }

void edm::throwMissingDictionariesException	(	std::vector< std::string > &	missingDictionaries,
		std::string const &	context,
		std::vector< std::string > &	producedTypes
	)

Definition at line 209 of file DictionaryTools.cc.

References addToMissingDictionariesException(), edm::errors::DictionaryNotFound, cppFunctionSkipper::exception, 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;
   }

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 237 of file DictionaryTools.cc.

References addToMissingDictionariesException(), edm::errors::DictionaryNotFound, cppFunctionSkipper::exception, 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;
   }

void edm::throwMissingDictionariesException	(	std::vector< std::string > &	missingDictionaries,
		std::string const &	context,
		std::set< std::string > &	producedTypes,
		bool	consumedWithView
	)

Definition at line 298 of file DictionaryTools.cc.

References addToMissingDictionariesException(), edm::errors::DictionaryNotFound, and cppFunctionSkipper::exception.

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

static void edm::throwProductDeletedException	(	ProductID const &	pid,
		edm::EventPrincipal::ConstProductResolverPtr const	phb
	)

static

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

static void edm::throwProductNotFoundException	(	char const *	where,
		errors::ErrorCodes	error,
		BranchID const &	bid
	)

static

Definition at line 49 of file Principal.cc.

References Exception.

Referenced by fwlite::ChainEvent::event(), fwlite::Run::getBranchDescriptions(), fwlite::LuminosityBlock::getBranchDescriptions(), edm::Principal::getProvenance(), fwlite::Event::processHistory(), and fwlite::MultiChainEvent::secondaryFileIndex().

                                                                                                 {
     throw Exception(error, "InvalidID")
       << "Principal::" << where << ": no product with given branch id: "<< bid << "\n";
   }

static void edm::throwTypeException	(	std::string const &	function,
		std::string const &	typeName
	)

static

Definition at line 41 of file TypeWithDict.cc.

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

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.";
 
    }

std::vector<std::string> edm::tokenize	(	std::string const &	input,
		std::string const &	separator
	)

breaks the input string into tokens, delimited by the separator

Referenced by MomentumDependentPedeLabeler::buildMomentumDependencyMap(), RunRangeDependentPedeLabeler::buildRunRangeDependencyMap(), decode(), editESInputTag(), editInputTag(), editVInputTag(), edm::ESInputTag::ESInputTag(), edm::FileInPath::initialize_(), edm::InputTag::InputTag(), align::makeNonOverlappingRunRanges(), MultiEventFilter::MultiEventFilter(), and PasswordReader::readPassword().

std::vector<std::string> edm::tokenize	(	const std::string &	input,
		const std::string &	separator
	)

Definition at line 57 of file Parse.cc.

References copy_all(), and mps_fire::result.

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

template<typename T >

boost::python::list edm::toPythonList ( const std::vector< T > & v )

Definition at line 16 of file PythonWrapper.h.

References mps_fire::i, list(), and mps_fire::result.

Referenced by PythonParameterSet::getParameters().

                                                        {
     boost::python::list result;
     for(unsigned i = 0; i < v.size(); ++i) {
        result.append(v[i]);
     }
     return result;
   }

template<typename T >

std::vector<T> edm::toVector ( boost::python::list & l )

Definition at line 28 of file PythonWrapper.h.

References mps_fire::i, gen::n, GetRecoTauVFromDQM_MC_cff::obj, resolutioncreator_cfi::object, and mps_fire::result.

   {
     std::vector<T> result;
     unsigned n = PyList_Size(l.ptr());
     boost::python::object iter_obj(boost::python::handle<>(PyObject_GetIter(l.ptr())));
     for(unsigned i = 0; i < n; ++i)
     {
       boost::python::object obj = boost::python::extract<boost::python::object>(iter_obj.attr("next")());
       result.push_back(boost::python::extract<T>(obj)); 
     }
     return result;
   }

static std::string const edm::triggerResults ( "TriggerResults" )

static

Referenced by HLTVertexPerformanceAnalyzer::analyze(), HLTBTagPerformanceAnalyzer::analyze(), AnalysisRootpleProducer::analyze(), JetAnalyzer::analyze(), METAnalyzer::analyze(), FSQ::BaseHandler::BaseHandler(), fwlite::ChainEvent::event(), HSCPHLTFilter::filter(), edm::service::TriggerNamesService::findTrigPath(), edm::Event::getRefBeforePut(), fwlite::Event::getTFile(), HLTTauDQMPath::isValid(), HLTPrescaleProvider::l1tGlobalUtil(), moduleName(), edm::EventBase::orbitNumber(), parameterSet(), fwlite::MultiChainEvent::secondaryFileIndex(), and HLTTauDQMPathSummaryPlotter::setPathObjects().

static std::string const edm::triggerResultsInserter ( "TriggerResultsInserter" )

static

Referenced by moduleName().

template<typename T >

T const* edm::tryToGetProductWithCoreFromRef	(	RefCore const &	ref,
		EDProductGetter const *	prodGetter
	)

inline

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

std::string edm::typeDemangle ( char const * mangledName )

Definition at line 98 of file TypeDemangler.cc.

References symbols::demangled, Exception, replaceString(), mps_update::status, and AlCaHLTBitMon_QueryRunRegistry::string.

Referenced by PhysicsTools::VarProcessor::deriv(), PhysicsTools::MVAComputer::evalInternal(), edm::TypeID::print(), 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;
   }

std::string edm::uniqueSharedResourceName ( )

Definition at line 18 of file SharedResourceNames.cc.

Referenced by edm::GeneratorFilter< HAD, DEC >::GeneratorFilter(), and edm::HadronizerFilter< HAD, DEC >::HadronizerFilter().

                                         {
   std::stringstream ss;
   ss << "uniqueSharedResourceName" << counter.fetch_add(1);
   return ss.str();
 }

bool edm::untaintString	(	char const *	pattern,
		char const *	regexp
	)

Definition at line 13 of file RegexMatch.cc.

Referenced by do_work().

                                                          {
     std::regex rexp(regexp);
     return std::regex_match(pattern, rexp);
   }

void edm::validateTopLevelParameterSets ( ParameterSet * processParameterSet )

Definition at line 77 of file validateTopLevelParameterSets.cc.

References cms::Exception::addContext(), edm::ParameterSet::addUntrackedParameter(), edm::errors::Configuration, heppy_report::description, Exception, fillMaxEventsDescription(), fillMaxLuminosityBlocksDescription(), fillMaxSecondsUntilRampdownDescription(), fillOptionsDescription(), edm::ParameterSet::getParameter(), edm::ParameterSet::getPSetForUpdate(), modifiedElectrons_cfi::processName, muonDTDigis_cfi::pset, AlCaHLTBitMon_QueryRunRegistry::string, and edm::ParameterSetDescription::validate().

Referenced by edm::EventProcessor::init(), and edm::SubProcess::SubProcess().

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

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 CaloTauSelectorDefinition::CaloTauSelectorDefinition(), reco::modules::CandCombinerBase::CandCombinerBase(), EGammaCutBasedEleIdAnalyzer::EGammaCutBasedEleIdAnalyzer(), HLTBTagPerformanceAnalyzer::HLTBTagPerformanceAnalyzer(), HLTVertexPerformanceAnalyzer::HLTVertexPerformanceAnalyzer(), pf2pat::IsolatedPFCandidateSelectorDefinition::IsolatedPFCandidateSelectorDefinition(), JetSubstructurePacker::JetSubstructurePacker(), MultiTrackValidator::MultiTrackValidator(), reco::modules::NamedCandCombinerBase::NamedCandCombinerBase(), OccupancyPlots::OccupancyPlots(), pat::PATElectronProducer::PATElectronProducer(), pat::PATGenericParticleProducer::PATGenericParticleProducer(), pat::PATJetProducer::PATJetProducer(), pat::PATJetUpdater::PATJetUpdater(), pat::PATMuonProducer::PATMuonProducer(), pat::PATPFParticleProducer::PATPFParticleProducer(), pat::PATPhotonProducer::PATPhotonProducer(), pat::PATSingleVertexSelector::PATSingleVertexSelector(), PATTauIDEmbedder::PATTauIDEmbedder(), pat::PATTauProducer::PATTauProducer(), pat::PATTriggerEventProducer::PATTriggerEventProducer(), PixelInactiveAreaFinder::PixelInactiveAreaFinder(), pat::PATMuonProducer::readIsolationLabels(), pat::PATPhotonProducer::readIsolationLabels(), pat::PATElectronProducer::readIsolationLabels(), ReducedESRecHitCollectionProducer::ReducedESRecHitCollectionProducer(), ReducedRecHitCollectionProducer::ReducedRecHitCollectionProducer(), SeedCombiner::SeedCombiner(), SiStripClusterizer::SiStripClusterizer(), SiStripProcessedRawDigiProducer::SiStripProcessedRawDigiProducer(), SiStripZeroSuppression::SiStripZeroSuppression(), TrackerDpgAnalysis::TrackerDpgAnalysis(), TrackingMonitor::TrackingMonitor(), TrackingNtuple::TrackingNtuple(), and TtEvtBuilder< C >::TtEvtBuilder().

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

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 284 of file Trie.h.

References MillePedeFileConverter_cfg::e, diffTwoXMLs::label, 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());
     }
   }

std::string edm::withoutQuotes ( std::string const & from )

std::string edm::withoutQuotes ( const std::string & from )

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

std::string edm::wrappedClassName ( std::string const & iFullName )

Definition at line 5 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

int const edm::bufSize = 128

static

Definition at line 24 of file Guid.cc.

Referenced by edm::RootOutputTree::addAuxiliary(), evf::compute_crc(), doBZ2Compression(), parse_int(), and edm::Guid::toString().

debugvalue edm::debugit

Definition at line 13 of file DebugMacros.cc.

Referenced by edm::ExceptionToActionTable::addDefaults(), edm::RootDebug::RootDebug(), and edm::RootDebug::~RootDebug().

ELslProxy< ELdebugGen > const edm::ELdebug

Definition at line 255 of file ELseverityLevel.cc.

Referenced by loadMap(), edm::service::ELoutput::log(), and edm::ErrorObj::setSeverity().

ELslGen edm::ELdebugGen

ELslProxy< ELerrorGen > const edm::ELerror

Definition at line 273 of file ELseverityLevel.cc.

Referenced by loadMap(), and LoggedErrorsOnlySummary().

ELslGen edm::ELerrorGen

ELslProxy< ELhighestSeverityGen > const edm::ELhighestSeverity

Definition at line 291 of file ELseverityLevel.cc.

Referenced by edm::service::ThreadSafeLogMessageLoggerScribe::configure_ordinary_destinations(), edm::service::MessageLoggerScribe::configure_ordinary_destinations(), loadMap(), edm::service::ELadministrator::resetSeverityCount(), and edm::ErrorObj::setSeverity().

ELslGen edm::ELhighestSeverityGen

ELslProxy< ELinfoGen > const edm::ELinfo

Definition at line 261 of file ELseverityLevel.cc.

Referenced by loadMap().

ELslGen edm::ELinfoGen

ELslProxy< ELsevereGen > const edm::ELsevere

Definition at line 285 of file ELseverityLevel.cc.

Referenced by loadMap(), edm::service::ELoutput::log(), and edm::ErrorObj::setSeverity().

ELslGen edm::ELsevereGen

ELslProxy< ELunspecifiedGen > const edm::ELunspecified

Definition at line 279 of file ELseverityLevel.cc.

Referenced by edm::ELextendedID::clear(), and loadMap().

ELslGen edm::ELunspecifiedGen

ELslProxy< ELwarningGen > const edm::ELwarning

Definition at line 267 of file ELseverityLevel.cc.

Referenced by edm::service::ELdestination::changeFile(), edm::service::ELdestination::flush(), loadMap(), and edm::MessageSender::ErrorObjDeleter::operator()().

ELslGen edm::ELwarningGen

ELslProxy< ELzeroSeverityGen > const edm::ELzeroSeverity

Definition at line 249 of file ELseverityLevel.cc.

Referenced by edm::service::ELadministrator::checkSeverity(), edm::service::ThreadSafeLogMessageLoggerScribe::configure_ordinary_destinations(), edm::service::MessageLoggerScribe::configure_ordinary_destinations(), loadMap(), edm::service::ELadministrator::resetSeverityCount(), and edm::ErrorObj::setSeverity().

ELslGen edm::ELzeroSeverityGen

char const* edm::fmt_Guid

static

Initial value:

=

"%08lX-%04hX-%04hX-%02hhX%02hhX-%02hhX%02hhX%02hhX%02hhX%02hhX%02hhX"

Definition at line 21 of file Guid.cc.

MallocOptionSetter edm::global_malloc_options

Definition at line 219 of file MallocOpts.cc.

Referenced by getGlobalOptionSetter().

EventNumber_t const edm::invalidEventNumber = 0U

Definition at line 16 of file RunLumiEventNumber.h.

Referenced by FWGUIManager::eventIdChanged(), and edm::EventPrincipal::fillEventPrincipal().

LuminosityBlockNumber_t const edm::invalidLuminosityBlockNumber = 0U

Definition at line 17 of file RunLumiEventNumber.h.

Referenced by FWGUIManager::lumiIdChanged().

RunNumber_t const edm::invalidRunNumber = 0U

Definition at line 18 of file RunLumiEventNumber.h.

Referenced by FWGUIManager::runIdChanged().

unsigned long long const edm::kAveEventPerSec = 200ULL

static

Definition at line 22 of file ProducerSourceBase.cc.

Referenced by edm::ProducerSourceBase::fillDescription().

unsigned long long const edm::kNanoSecPerSec = 1000000000ULL

static

Definition at line 21 of file ProducerSourceBase.cc.

const unsigned char edm::MLSCRIBE_RUNNING_INDICATOR = 29

static

Definition at line 122 of file MessageDrop.h.

Referenced by FlushMessageLog(), isMessageProcessingSetUp(), edm::service::MessageLoggerScribe::run(), run_app(), and edm::service::SingleThreadMSPresence::SingleThreadMSPresence().

constexpr const char* edm::module_type_desc[]

Initial value:

{
  "Unknown",
  "Source",
  "ESSource",
  "ESProducer",
  "EDAnalyzer",
  "EDProducer",
  "EDFilter",
  "OutputModule"
}

Definition at line 20 of file EDMModuleType.h.

Referenced by edmModuleType(), DependencyGraph::edmModuleType(), edmModuleTypeEnum(), and DependencyGraph::edmModuleTypeEnum().

constexpr unsigned int edm::s_defaultNumberOfThreads = 1

Definition at line 9 of file validateTopLevelParameterSets.h.

Referenced by fillOptionsDescription().

const std::vector<void const*> edm::s_emptyCache {}

static

Definition at line 196 of file PtrVectorBase.cc.

Referenced by edm::PtrVectorBase::emptyCache().

ProcessHistory const edm::s_emptyProcessHistory

static

Definition at line 33 of file Principal.cc.

Referenced by edm::Principal::fillPrincipal().

std::atomic<Principal::CacheIdentifier_t> edm::s_nextIdentifier {1}

static

Definition at line 108 of file Principal.cc.

Referenced by nextIdentifier().

thread_local EDProductGetter const* edm::s_productGetter = 0

Definition at line 79 of file EDProductGetter.cc.

Referenced by edm::EDProductGetter::assignEDProductGetter(), and edm::EDProductGetter::switchProductGetter().

unsigned int const edm::shift = 8 * sizeof(unsigned int)

static

Definition at line 9 of file LuminosityBlockID.cc.

Referenced by EcalTPGParamBuilder::analyze(), L1TCSCTF::analyze(), HcalTriggerPrimitiveAlgo::analyze(), HcalTriggerPrimitiveAlgo::analyze2017(), HcalTriggerPrimitiveAlgo::analyzeHF(), HcalTriggerPrimitiveAlgo::analyzeHF2017(), BeamSpotAlignmentParameters::apply(), RigidBodyAlignmentParameters::apply(), TwoBowedSurfacesAlignmentParameters::apply(), MuScleFitUtils::applyScale(), CSCTFTrackBuilder::buildTracks(), barrelUtil::calculatePhiWindow(), HcalPulseShapes::computeSiPMShapeHE206(), DEutils< T >::DEDigi(), InitialState::Evolve(), DDCutTubsFromPoints::execute(), PFPhotonClusters::FillClusterShape(), Py8toJetInput::fillJetAlgoInput(), MiniFloatConverter::float32to16round(), l1t::GtRecordDump::formatHMB(), RPCTBMuon::PACOut::fromBits(), RPCTBMuon::TBOut::fromBits(), RPCTBMuon::TCOut::fromBits(), RPCTBMuon::HSBOut::fromBits(), RPCTBMuon::FSBOut::fromBits(), PtAssignmentEngineAux2016::getEtaFromEtaInt(), PtAssignmentEngineAux2016::getEtaInt(), UCTCTP7RawData::getHFFeatureBits(), popcon::EcalLaser_weekly_Linearization_Check::getNewObjects(), popcon::EcalLaser_weekly_Linearization::getNewObjects(), popcon::EcalTPGLinPed::getNewObjects(), popcon::EcalTPGPedfromFile::getNewObjects(), OptOModifiedRhomboidPrism::getRotatedPlate(), HcalDDDSimConstants::getShift(), HIPplots::GetSubDet(), RigidBodyAlignmentParameters::globalParameters(), BeamSpotAlignmentParameters::globalParameters(), HcalDDDSimConstants::HcalCellTypes(), PixelTripletNoTipGenerator::hitTriplets(), FFTJetPFPileupCleaner::isRemovable(), L1TTwinMuxRawToDigi::L1TTwinMuxRawToDigi(), npstat::ArrayND< Numeric, StackLen, StackDim >::linearFill(), npstat::ArrayND< Numeric, StackLen, StackDim >::linearFillLoop(), fftjetcms::LinInterpolatedTable1D::LinInterpolatedTable1D(), L1MuDTPtaLut::load(), L1TMuonBarrelParamsHelper::load_pt(), pat::MET::Vector2::phi(), HcalTTPDigiProducer::produce(), DistortedMuonProducerFromDB::produce(), ShiftedMETcorrInputProducer::produce(), ShiftedJetProducerByMatchedObjectT< T >::produce(), ShiftedPFCandidateProducerByMatchedObject::produce(), ShiftedPFCandidateProducerForPFMVAMEt::produce(), ShiftedParticleProducer::produce(), ShiftedPFCandidateProducerForPFNoPUMEt::produce(), ShiftedPFCandidateProducerForNoPileUpPFMEt::produce(), ShiftedParticleProducerT< T >::produce(), ShiftedJetProducerT< T, Textractor >::produce(), HFPreRecAlgo::reconstruct(), CSCTFSectorProcessor::run(), CSCTFSPCoreLogic::run(), HFRecHitAuxSetter::setAux(), reco::PFCandidate::setHcalDepthEnergyFractions(), UCTCTP7RawData::setHFFeatureBits(), HcalTriggerPrimitiveAlgo::setNCTScaleShift(), BackgroundHandler::setParameters(), HcalTriggerPrimitiveAlgo::setRCTScaleShift(), FFTJetPFPileupCleaner::setRemovalBit(), pat::MET::setUncShift(), pat::MET::shiftedP2_74x(), pat::MET::shiftedP4_74x(), pat::MET::shiftedSumEt_74x(), DTTracoChip::storeCorr(), DTTracoChip::storeUncorr(), SiStripTemplate::sxtemp(), RPCTBMuon::PACOut::toBits(), RPCTBMuon::TBOut::toBits(), RPCTBMuon::TCOut::toBits(), RPCTBMuon::HSBOut::toBits(), RPCTBMuon::FSBOut::toBits(), BeamSpotAlignmentParameters::translation(), RigidBodyAlignmentParameters::translation(), DCCEEEventBlock::unpack(), DCCEBEventBlock::unpack(), CSCTFEvent::unpack(), pat::PackedGenParticle::unpack(), pat::PackedCandidate::unpack(), LatencyHistosUsingDb::update(), Alignable::update(), edm::LuminosityBlockID::value(), CastorCORData::wasMarkAndPassZS(), and HcalPulseShapes::Y11206().

volatile std::atomic< bool > edm::shutdown_flag {false}

Definition at line 22 of file UnixSignalHandlers.cc.

Referenced by edm::EventProcessor::checkForAsyncStopRequest(), evf::EvFBuildingThrottle::dowork(), ep_sigusr2(), dqmservices::DQMProtobufReader::getNextItemType(), FedRawDataInputSource::nextEvent(), evf::FastMonitoringService::preGlobalEndLumi(), dqmservices::DQMStreamerReader::prepareNextFile(), and FedRawDataInputSource::readSupervisor().

pset::TypeTrans const edm::sTypeTranslations

static

Definition at line 78 of file Entry.cc.

Namespaces

Classes

Typedefs

Enumerations

Functions

Variables

Detailed Description

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

Typedef Documentation

Enumeration Type Documentation

Function Documentation

Variable Documentation