edm Namespace Reference

A PluginFactory for concrete instances of class KalmanAlignmentMetricsUpdator. More...

Namespaces
	clonehelper
	convertException
	detail
	details
	detailsTrie
	dqh
	dslv
	dslvdetail
	dsrvdetail
	edmmltest
	errors
	es
	eventsetup
	evtSel
	exception_actions
	extensioncord
	fillDetails
	friendlyname
	global
	handleimpl
	hash_detail
	helper
	helpers
	hlt
	impl
	lazydetail
	maker
	math_private
	messagedrop
	module
	multicore
	one
	pdtentry
	poolNames
	principal_get_adapter_detail
	pset
	python
	rec_dep
	refcore
	refcoreimpl
	refhelper
	refitem
	reftobase
	releaseversion
	root
	roottree
	service
	serviceregistry
	signalslot
	soahelper
	storage
	stream
	test
	typelookup
	workerhelper
	workerimpl
	writeParameterValue

Classes
class	ActivityRegistry
class	Adjuster
class	AdjusterBase
class	AliasProductHolder
class	AllowedLabelsDescription
class	AllowedLabelsDescription< ParameterSetDescription >
class	AllowedLabelsDescription< std::vector< ParameterSet > >
class	AllowedLabelsDescriptionBase
class	AnalyzerWrapper
class	ANDGroupDescription
class	AsciiOutputModule
class	AssertHandler
struct	Association
class	AssociationMap
class	AssociationVector
class	AssociativeIterator
class	atomic_value_ptr
struct	atomic_value_ptr_traits
class	AtomicPtrCache
class	BaseFlatGunProducer
class	BaseWithDict
class	BasicAnalyzer
class	BasicFilter
class	BasicHandle
class	BeamHaloProducer
struct	BeginLuminosityBlockProducer
struct	BeginRunProducer
class	BMixingModule
class	BoolCache
class	BranchChildren
class	BranchDescription
class	BranchID
class	BranchIDListHelper
class	BranchKey
class	CallNTimesNoWait
class	CallOnceNoWait
class	CFWriter
struct	CheckAbility
struct	CheckAbility< ABILITY >
struct	CheckAbility< ABILITY, T, VArgs...>
struct	ClonePolicy
class	CloningPtr
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	ContainerMask
class	ContainerMaskTraits
class	ContainerMaskTraits< edm::LazyGetter< T > >
class	ContainerMaskTraits< edmNew::DetSetVector< T > >
struct	CopyPolicy
class	CosMuoGenProducer
class	CountAndLimit
class	CPUTimer
class	CurrentModuleOnThread
class	CustomStreamer
struct	DaqProvenanceHelper
class	DataFrame
class	DataFrameContainer
class	DataMixingEcalDigiWorkerProd
class	DataMixingEMDigiWorker
class	DataMixingEMWorker
class	DataMixingGeneralTrackWorker
class	DataMixingHcalDigiWorker
class	DataMixingHcalDigiWorkerProd
class	DataMixingHcalWorker
class	DataMixingModule
class	DataMixingMuonWorker
class	DataMixingPileupCopy
class	DataMixingSiPixelWorker
class	DataMixingSiStripMCDigiWorker
class	DataMixingSiStripRawWorker
class	DataMixingSiStripWorker
class	debugging_allocator
struct	debugvalue
class	DelayedReader
class	DescriptionFillerForESProducers
class	DescriptionFillerForESSources
class	DescriptionFillerForServices
class	DetSet
class	DetSetLazyVector
class	DetSetRefVector
class	DetSetVector
class	DigiAccumulatorMixModFactory
struct	do_nothing_deleter
struct	DoAssign
class	DocFormatHelper
struct	DoFillView
struct	DoHasIsProductEqual
struct	DoIsProductEqual
struct	DoMergeProduct
struct	DoNotFillView
struct	DoNotHasIsProductEqual
struct	DoNotIsProductEqual
struct	DoNotMergeProduct
struct	DoNotPostInsert
struct	DoNotRecordParents
struct	DoNotSetPtr
struct	DoNotSortUponInsertion
struct	DoPostInsert
struct	DoSetPtr
struct	DoSwap
class	DummyProvenanceReader
class	DuplicateChecker
class	EarlyDeleteHelper
class	EcalNoiseStorage
class	EDAnalyzer
class	EDCollection
class	EDConsumerBase
class	EDFilter
class	EDGetToken
class	EDGetTokenT
class	EDInputSource
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	ELextendedID
class	ELseverityLevel
struct	ELslProxy
class	EmptyESSource
class	EmptyGroupDescription
class	EmptySource
struct	EndLuminosityBlockProducer
struct	EndRunProducer
class	Entry
class	ErrorObj
struct	ErrorSummaryEntry
class	ESHandle
class	ESHandleBase
class	ESInputTag
class	ESOutlet
class	ESProducer
class	ESProducerLooper
struct	ESProducts
class	ESProxyFactoryProducer
class	ESRecordAuxiliary
class	ESTransientHandle
class	ESWatcher
class	Event
class	EventAux
class	EventAuxiliary
class	EventAuxiliaryHistoryProducer
class	EventBase
class	EventBuffer
class	EventContentAnalyzer
class	EventEntryDescription
class	EventEntryInfo
class	EventID
class	EventMsg
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
class	Factory
class	FileBlock
class	FileCatalogItem
class	FileFormatVersion
class	FileID
class	FileIndex
class	FileInPath
class	FileLocator
class	FileRandomKEThetaGunProducer
struct	FilledProductPtr
class	FilterObjectWrapper
class	FilterWrapper
struct	FindRegion
struct	FindValue
class	FixedPUGenerator
class	FlatBaseThetaGunProducer
class	FlatEGunASCIIWriter
class	FlatRandomEGunProducer
class	FlatRandomEThetaGunProducer
class	FlatRandomOneOverPtGunProducer
class	FlatRandomPtGunProducer
class	FlatRandomPtThetaGunProducer
class	FromFiles
class	FullProvenanceReader
class	FunctionWithDict
class	FunctorHandleExceptionFactory
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	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 > >
class	Hash
class	HcalNoiseStorage
class	HepMCProduct
class	HiMixingModule
class	HiMixingWorker
class	HiMixingWorkerBase
class	History
class	HistoryAppender
class	HLTGlobalStatus
class	HLTPathStatus
class	IDVectorMap
class	IEventProcessor
class	IfExistsDescription
class	IllegalParameters
class	IndexIntoFile
class	InitMsg
class	InputAnalyzer
class	InputFile
class	InputFileCatalog
class	InputProductHolder
class	InputSource
struct	InputSourceDescription
class	InputSourceFactory
class	InputTag
class	InputTagMatch
class	InputTagSelector
class	InternalContext
class	IOVSyncValue
struct	IsMergeable
struct	IsNotMergeable
class	IterateNTimesLooper
class	IterWithDict
class	IterWithDictBase
class	JobReport
struct	key_traits
struct	key_traits< std::pair< U, V > >
struct	key_traits< std::string >
class	LazyAdapter
class	LazyGetter
class	LazyUnpacker
struct	LHEProvenanceHelper
class	LimitAndTimespan
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	LuminosityBlockID
class	LuminosityBlockIndex
class	LuminosityBlockPrincipal
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	MsgCode
class	MultiAssociation
class	MultiParticleInConeGunProducer
class	NavigateEventsLooper
struct	NewPolicy
class	NoProcessProductHolder
class	ObjectWithDict
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	OldProvenanceReader
class	OneToMany
class	OneToManyWithQuality
class	OneToManyWithQualityGeneric
class	OneToOne
class	OneToOneGeneric
class	OneToValue
class	ORGroupDescription
class	OrphanHandle
class	OrphanHandleBase
struct	Other
class	OutletBase
class	OutputHandle
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	Path
class	PathContext
struct	PathSummary
struct	PathTimingSummary
class	PileUp
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	ProducedProductHolder
class	ProducerBase
class	ProducerSourceBase
class	ProducerSourceFromFiles
struct	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	ProductHolderBase
class	ProductHolderIndexAndSkipBit
class	ProductHolderIndexHelper
class	ProductID
class	ProductProvenance
class	ProductProvenanceRetriever
class	ProductRegistry
class	ProductRegistryHelper
class	ProductSelector
class	ProductSelectorRules
class	Provenance
class	ProvenanceAdaptor
class	ProvenanceCheckerOutputModule
class	ProvenanceReaderBase
class	Ptr
class	PtrHolder
class	PtrVector
class	PtrVectorBase
class	PtrVectorItr
class	PUGenerator
class	RandomEngineSentry
class	RandomEngineStates
class	RandomFilter
class	RandomNumberGenerator
class	RangeMap
class	RawInputSource
class	RawInputSourceFromFiles
class	RecordEventID
struct	RecordInParentfull
struct	RecordInParentless
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	RefGetter
class	RefProd
class	RefToBase
class	RefToBaseProd
class	RefToBaseVector
class	RefVector
class	RefVectorBase
class	RefVectorIterator
class	RegionIndex
class	RootAutoLibraryLoader
class	RootDebug
class	RootDelayedReader
class	RootFile
class	RootFileEventFinder
class	RootHandlers
class	RootInputFileSequence
class	RootOutputFile
class	RootOutputTree
class	RootServiceChecker
class	RootTree
class	Run
class	RunAux
class	RunAuxiliary
class	RunBase
struct	RunCache
class	RunDualStopwatches
class	RunID
class	RunIndex
class	RunLumiEntryInfo
class	RunPrincipal
class	RunStopwatch
struct	RunSummaryCache
class	Schedule
class	ScheduledProductHolder
class	ScheduleInfo
struct	ScheduleItems
class	SecondaryEventProvider
class	SecSourceAnalyzer
class	SendEvent
class	SendJobHeader
class	SerialTaskQueue
class	Service
class	ServiceRegistry
class	ServiceToken
class	SharedResourceNames
class	SharedResourcesAcquirer
class	SharedResourcesRegistry
class	SignallingProductRegistry
class	SimpleOutlet
class	SingleConsumerQ
class	SiteLocalConfig
class	SoATuple
class	SortedCollection
class	SourceProductHolder
class	StatsCount
struct	StoredProductProvenance
struct	StreamCache
class	StreamContext
class	StreamDQMDeserializer
class	StreamDQMSerializer
class	StreamedProduct
class	StreamedProductStreamer
class	StreamerFileReader
class	StreamerFileWriter
struct	StreamerFileWriterEventParams
struct	StreamerFileWriterHeaderParams
class	StreamerInputFile
class	StreamerInputModule
class	StreamerInputSource
class	StreamerOutputModule
class	StreamerOutputModuleBase
class	StreamID
class	StreamProcessingTask
class	StreamSchedule
class	StreamSerializer
struct	StrictWeakOrdering
class	SubProcess
class	Suppress_LogDebug_
class	TestHandle
class	TestMix
class	TestMixedSource
struct	TimeOfDay
class	TimeoutPoolOutputModule
class	Timestamp
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	UnscheduledCallProducer
class	UnscheduledHandler
class	UnscheduledProductHolder
class	UpdateGetterAdapter
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
class	VectorInputSourceFactory
class	View
class	View< T >
class	ViewBase
class	VParameterSetEntry
class	WaitingTaskList
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	WrapperHolder
class	WrapperInterface
class	WrapperInterfaceBase
class	WrapperOwningHolder
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 DigiAccumulatorMixMod *(	DAFunc )(ParameterSet const &, one::EDProducerBase &, 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 int	EventNumber_t
typedef ParameterSetID	EventSelectionID
typedef std::vector < EventSelectionID >	EventSelectionIDVector
typedef Handle< FWGenericObject >	FWGenericHandle
typedef Handle< GenericObject >	GenericHandle
typedef boost::shared_ptr < reftobase::RefHolderBase >	helper_ptr
typedef reftobase::RefVectorHolderBase	helper_vector
typedef boost::shared_ptr < reftobase::RefVectorHolderBase >	helper_vector_ptr
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 &, InputSourceDescription const &)
typedef std::vector < LHCTransportLink >	LHCTransportLinkContainer
typedef RunLumiEntryInfo	LumiEntryInfo
typedef unsigned int	LuminosityBlockNumber_t
typedef unsigned int	LumiNumber_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< PCaloHit >	PCaloHitContainer
typedef boost::shared_ptr < Pointer_to_new_exception_on_heap >	Place_for_passing_exception_ptr
typedef boost::shared_ptr < edm::Exception >	Pointer_to_new_exception_on_heap
typedef PoolSource	PoolRASource
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 int	ProductHolderIndex
typedef unsigned short	ProductIndex
typedef std::vector < ProductProvenance >	ProductProvenanceVector
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 < BranchDescription const * >	SelectedProducts
typedef boost::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
typedef std::set< std::string >	StringSet
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	{ kChildSucceed, kChildExitBadly, kChildSegv, kMaxChildAction }
enum	BranchActionType { BranchActionGlobalBegin = 0, BranchActionStreamBegin = 1, BranchActionStreamEnd = 2, BranchActionGlobalEnd = 3 }
enum	BranchType { InEvent = 0, InLumi = 1, InRun = 2, NumBranchTypes }
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	ProductHolderIndexValues { ProductHolderIndexValuesBit = 1U << 30, ProductHolderIndexInvalid = std::numeric_limits<unsigned int>::max(), ProductHolderIndexInitializing = std::numeric_limits<unsigned int>::max() - 1, ProductHolderIndexAmbiguous = std::numeric_limits<unsigned int>::max() - 2 }
enum	TypeMemberQuery { InheritedDefault = Reflex::INHERITEDMEMBERS_DEFAULT, InheritedNo = Reflex::INHERITEDMEMBERS_NO, InheritedAlso = Reflex::INHERITEDMEMBERS_ALSO }
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)
	all_output_communicators_ ()
template<class FP >
bool	asm_isnan (FP x)
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)
static void	check (Principal const &p, std::string const &id, edm::ModuleCallingContext const *mcc)
void	checkDictionaries (std::string const &name, bool noComponents=false)
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 (LuminosityBlockRange const &lh, LuminosityBlockRange const &rh)
bool	contains (EventRange const &lh, EventID 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...
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 &)
unsigned int	decodeInt (unsigned char *v)
std::string const &	dictionaryPlugInPrefix ()
void	disableAllSigs (sigset_t *oldset)
bool	DisableLoggedErrorsSummary ()
void	disableRTSigs ()
void	disableSignal (sigset_t *newset, int signum)
bool	distinct (LuminosityBlockRange const &lh, LuminosityBlockRange const &rh)
bool	distinct (EventRange const &lh, EventRange const &rh)
void	doBuildRealData (const std::string &name)
void	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 &)
void	encodeInt (unsigned int i, unsigned char *v)
	endpathsAreActive_ (true)
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	fillDescriptionFromPSet (ParameterSet const &pset, ParameterSetDescription &desc)
boost::shared_ptr< EDLooperBase >	fillLooper (eventsetup::EventSetupsController &esController, eventsetup::EventSetupProvider &cp, ParameterSet &params)
static void	fillModuleInPathSummary (Path const &path, size_t which, ModuleInPathSummary &sum)
static void	fillModuleInPathTimingSummary (Path const &path, size_t which, ModuleInPathTimingSummary &sum)
static void	fillPathSummary (Path const &path, PathSummary &sum)
static void	fillPathTimingSummary (Path const &path, PathTimingSummary &sum)
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, helper_vector &helpers)
template<class T , class A >
void	fillView (std::list< T, A > const &obj, ProductID const &id, std::vector< void const * > &ptrs, helper_vector &helpers)
template<class T , class A >
void	fillView (std::deque< T, A > const &obj, ProductID const &id, std::vector< void const * > &ptrs, helper_vector &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, helper_vector &helpers)
template<typename T >
void	fillView (PtrVector< T > const &obj, std::vector< void const * > &pointers)
template<typename C , typename T , typename F >
void	fillView (RefVector< C, T, F > const &obj, ProductID const &id, std::vector< void const * > &pointers, helper_vector &helpers)
template<typename T >
void	fillView (RefToBaseVector< T > const &obj, std::vector< void const * > &pointers)
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, helper_vector &helpers)
template<class T >
void	fillView (DetSetVector< T > const &obj, ProductID const &id, std::vector< void const * > &pointers, helper_vector &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, helper_vector &helpers)
template<typename T , typename P >
void	fillView (OwnVector< T, P > const &obj, ProductID const &id, std::vector< void const * > &pointers, helper_vector &helpers)
template<typename T , typename SORT >
void	fillView (SortedCollection< T, SORT > const &obj, ProductID const &id, std::vector< void const * > &pointers, helper_vector &helpers)
static void	fillWorkerSummary (Worker const *pw, WorkerSummary &sum)
static void	fillWorkerSummaryAux (Worker const &w, WorkerSummary &sum)
static void	fillWorkerTimingSummary (Worker const *pw, WorkerTimingSummary &sum)
static void	fillWorkerTimingSummaryAux (Worker const &w, WorkerTimingSummary &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)
bool	find_nested_type_named (std::string const &nested_type, TypeWithDict const &type_to_search, TypeWithDict &found_type)
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)
StringSet &	foundTypes ()
bool	FreshErrorsExist (unsigned int iStreamID)
std::vector< std::string > const &	getAllTriggerNames ()
void	getCodeTable (Exception::CodeMap *&setme)
std::string	getEnvironmentVariable (std::string const &name, std::string const &defaultValue=std::string())
EventBuffer *	getEventBuffer (int event_size_max, int queue_depth_max)
int	getFileFormatVersion ()
MallocOptionSetter &	getGlobalOptionSetter ()
ParameterSet const &	getParameterSet (ParameterSetID const &id)
std::string	getPassID ()
ParameterSet const &	getProcessParameterSet ()
template<typename T >
T const *	getProduct (RefCore const &ref)
template<typename PROD >
boost::shared_ptr< Wrapper < PROD > const >	getProductByTag (Principal const &ep, InputTag const &tag, ModuleCallingContext const *mcc)
template<typename C , typename T , typename F , typename KEY >
T const *	getPtr (RefCore const &product, KEY const &iKey)
template<typename C , typename T , typename F , typename KEY >
T const *	getPtr_ (RefCore const &product, KEY const &key)
template<typename C >
helper::MatcherGetRef< C > ::ref_type	getRef (const Handle< C > &c, size_t k)
std::string	getReleaseVersion ()
TClass *	getTClass (const std::type_info &ti)
UnscheduledHandler *	getUnscheduledHandler (EventPrincipal const &ep)
std::string	getUuid (TTree *uuidTree)
std::string	glob2reg (std::string const &pattern)
void	GroupLogStatistics (std::string const &category)
void	HaltMessageLogging ()
HRTimeType	hrRealTime ()
void	installCustomHandler (int signum, CFUNC func)
void	installSig (int signum, CFUNC func)
bool	is_glob (std::string const &pattern)
bool	is_PtrVector (TypeWithDict const &possible_ref_vector, TypeWithDict &value_type)
bool	is_RefToBaseVector (TypeWithDict const &possible_ref_vector, TypeWithDict &value_type)
bool	is_RefVector (TypeWithDict const &possible_ref_vector, TypeWithDict &value_type)
bool	isAncestor (ProcessHistory const &a, ProcessHistory const &b)
bool	isDebugEnabled ()
bool	isDescendant (ProcessHistory const &a, ProcessHistory const &b)
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)
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)
void	loadCap (const std::string &name)
void	loadExtraClasses ()
static ELmap const &	loadMap ()
void	loadMissingDictionaries ()
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)
template<typename T >
std::shared_ptr < HandleExceptionFactory >	makeHandleExceptionFactory (T &&iFunctor)
std::unique_ptr< InputSource >	makeInput (ParameterSet &params, CommonParams const &common, ProductRegistry &preg, boost::shared_ptr< BranchIDListHelper > branchIDListHelper, boost::shared_ptr< ActivityRegistry > areg, boost::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, boost::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<class HandleT >
Ref< typename HandleT::element_type, typename HandleT::element_type::value_type::value_type >	makeRefToDetSetLazyVector (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 >	makeRefToDetSetLazyVector (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 >	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)
template<typename T >
Ref< LazyGetter< T >, T, FindValue< T > >	makeRefToLazyGetter (const Handle< LazyGetter< T > > &handle, const uint32_t index)
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)
static void	maybeThrowMissingDictionaryException (TypeID const &productType, bool isElement, std::vector< std::string > const &missingDictionaries)
bool	merge (LuminosityBlockRange &lh, LuminosityBlockRange &rh)
LuminosityBlockID const &	min (LuminosityBlockID const &lh, LuminosityBlockID const &rh)
EventID const &	min (EventID const &lh, EventID const &rh)
StringSet &	missingTypes ()
std::string	moduleName (Provenance const &provenance)
	moduleRegistry_ (new ModuleRegistry())
EDProductGetter const *	mustBeNonZero (EDProductGetter const *prodGetter, std::string refType, ProductID const &productID)
static Principal::CacheIdentifier_t	nextIdentifier ()
Long64_t	numEntries (TFile *hdl, std::string const &trname)
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!= (Parentage const &a, Parentage 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 &) throw ()
bool	operator!= (ProcessConfiguration const &a, ProcessConfiguration const &b)
bool	operator!= (ProductProvenance const &a, ProductProvenance const &b)
bool	operator!= (RefCore const &lhs, RefCore const &rhs)
bool	operator!= (ProcessHistory const &a, ProcessHistory const &b)
template<typename KEY >
bool	operator!= (RefVectorBase< KEY > const &lhs, RefVectorBase< KEY > const &rhs)
	Inequality operator. More...
template<typename T >
bool	operator!= (FwdPtr< T > const &lhs, FwdPtr< T > const &rhs)
template<typename T >
bool	operator!= (View< T > const &, View< T > const &)
bool	operator!= (FileIndex::Element const &lh, FileIndex::Element const &rh)
bool	operator!= (ProductRegistry const &a, ProductRegistry const &b)
bool	operator!= (TypeWithDict const &a, TypeWithDict const &b)
bool	operator!= (ELseverityLevel const &e1, ELseverityLevel const &e2)
bool	operator!= (Entry const &a, Entry const &b)
template<typename T >
bool	operator!= (RefToBaseProd< T > const &lhs, RefToBaseProd< T > const &rhs)
template<typename T , typename U >
bool	operator!= (atomic_value_ptr< T > const &lhs, U const &rhs)
template<typename C >
bool	operator!= (RefProd< C > const &lhs, RefProd< C > 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 , typename U >
bool	operator!= (U const &lhs, atomic_value_ptr< T > const &rhs)
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 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::auto_ptr < ParameterDescriptionNode >	operator&& (ParameterDescriptionNode const &node_left, ParameterDescriptionNode const &node_right)
std::auto_ptr < ParameterDescriptionNode >	operator&& (std::auto_ptr< ParameterDescriptionNode > node_left, ParameterDescriptionNode const &node_right)
std::auto_ptr < ParameterDescriptionNode >	operator&& (ParameterDescriptionNode const &node_left, std::auto_ptr< ParameterDescriptionNode > node_right)
std::auto_ptr < ParameterDescriptionNode >	operator&& (std::auto_ptr< ParameterDescriptionNode > node_left, std::auto_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< (ProductID const &lh, ProductID const &rh)
bool	operator< (ProcessConfiguration const &a, ProcessConfiguration const &b)
bool	operator< (ProductProvenance const &a, ProductProvenance 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< (RefCore const &lhs, RefCore const &rhs)
bool	operator< (FileIndex::Element const &lh, FileIndex::Element const &rh)
template<typename T >
bool	operator< (FwdPtr< T > const &lhs, FwdPtr< T > const &rhs)
template<typename T >
bool	operator< (View< T > const &, View< T > const &)
bool	operator< (TypeWithDict const &a, TypeWithDict const &b)
bool	operator< (ELseverityLevel const &e1, ELseverityLevel const &e2)
template<typename T >
bool	operator< (RefToBaseProd< T > const &lhs, RefToBaseProd< T > const &rhs)
bool	operator< (BranchDescription const &a, BranchDescription const &b)
template<typename C >
bool	operator< (RefProd< C > const &lhs, RefProd< C > const &rhs)
template<typename T >
bool	operator< (Ptr< T > const &lhs, Ptr< T > const &rhs)
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, FileFormatVersion const &ff)
std::ostream &	operator<< (std::ostream &os, RunLumiEntryInfo const &p)
std::ostream &	operator<< (std::ostream &os, EventEntryInfo const &p)
std::ostream &	operator<< (std::ostream &os, const ProductSelector &gs)
std::ostream &	operator<< (std::ostream &, PathContext const &)
std::ostream &	operator<< (std::ostream &, ProcessContext const &)
std::ostream &	operator<< (std::ostream &os, EventEntryDescription const &p)
std::ostream &	operator<< (std::ostream &ost, const MallocOpts &)
std::ostream &	operator<< (std::ostream &os, Parentage const &p)
std::ostream &	operator<< (std::ostream &os, ProductID const &id)
std::ostream &	operator<< (std::ostream &oStream, LuminosityBlockRange const &iID)
std::ostream &	operator<< (std::ostream &, ParentContext const &)
std::ostream &	operator<< (std::ostream &, GlobalContext const &)
std::ostream &	operator<< (std::ostream &os, const RunAuxiliary &p)
std::ostream &	operator<< (std::ostream &os, TypeID const &id)
std::ostream &	operator<< (std::ostream &oStream, EventRange const &iID)
std::ostream &	operator<< (std::ostream &os, const LuminosityBlockAuxiliary &p)
std::ostream &	operator<< (std::ostream &os, BranchKey const &bk)
std::ostream &	operator<< (std::ostream &os, ProductProvenance const &p)
std::ostream &	operator<< (std::ostream &ost, InputTag const &tag)
std::ostream &	operator<< (std::ostream &, StreamContext const &)
std::ostream &	operator<< (std::ostream &os, ProcessConfiguration const &pc)
std::ostream &	operator<< (std::ostream &, ModuleCallingContext const &)
std::ostream &	operator<< (std::ostream &oStream, RunID const &iID)
std::ostream &	operator<< (std::ostream &os, const EventAuxiliary &p)
std::ostream &	operator<< (std::ostream &os, ModuleDescription const &p)
std::ostream &	operator<< (std::ostream &os, Provenance const &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)
ErrorObj &	operator<< (ErrorObj &e, const char s[])
std::ostream &	operator<< (std::ostream &ost, ProcessHistory const &ph)
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, FileIndex const &fileIndex)
std::ostream &	operator<< (std::ostream &os, ProductRegistry const &pr)
std::ostream &	operator<< (std::ostream &os, TypeWithDict const &id)
std::ostream &	operator<< (std::ostream &os, ProductHolderBase const &phb)
std::ostream &	operator<< (std::ostream &os, BranchDescription const &p)
template<typename PROD >
std::ostream &	operator<< (std::ostream &os, Handle< PROD > const &h)
std::ostream &	operator<< (std::ostream &os, const ELseverityLevel &sev)
template<int I>
std::ostream &	operator<< (std::ostream &os, Hash< I > 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== (Parentage const &a, Parentage 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 &) throw ()
bool	operator== (ProductProvenance const &a, ProductProvenance const &b)
template<class T >
bool	operator== (RefToBaseVector< T > const &a, RefToBaseVector< T > const &b)
bool	operator== (RefCore const &lhs, RefCore const &rhs)
bool	operator== (ProcessHistory const &a, ProcessHistory const &b)
template<typename KEY >
bool	operator== (RefVectorBase< KEY > const &lhs, RefVectorBase< KEY > const &rhs)
	Equality operator. More...
bool	operator== (Provenance const &a, Provenance const &b)
template<typename T >
bool	operator== (FwdPtr< T > const &lhs, FwdPtr< T > const &rhs)
bool	operator== (FileIndex::Element const &lh, FileIndex::Element const &rh)
template<typename T >
bool	operator== (View< T > const &, View< T > const &)
bool	operator== (edm::FileInPath const &a, edm::FileInPath const &b)
bool	operator== (ProductRegistry const &a, ProductRegistry const &b)
bool	operator== (TypeWithDict const &a, TypeWithDict const &b)
bool	operator== (ELseverityLevel const &e1, ELseverityLevel const &e2)
bool	operator== (Entry const &a, Entry const &b)
template<typename T >
bool	operator== (RefToBaseProd< T > const &lhs, RefToBaseProd< T > const &rhs)
template<typename T , typename U >
bool	operator== (atomic_value_ptr< T > const &lhs, U const &rhs)
template<typename C >
bool	operator== (RefProd< C > const &lhs, RefProd< C > const &rhs)
template<typename C , typename T , typename F >
bool	operator== (RefVector< C, T, F > const &lhs, RefVector< C, T, F > const &rhs)
bool	operator== (BranchDescription const &a, BranchDescription const &b)
template<typename T , typename U >
bool	operator== (U const &lhs, atomic_value_ptr< T > const &rhs)
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 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 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::auto_ptr < ParameterDescriptionCases < bool > >	operator>> (bool caseValue, ParameterDescriptionNode const &node)
std::auto_ptr < ParameterDescriptionCases < int > >	operator>> (int caseValue, ParameterDescriptionNode const &node)
std::auto_ptr < ParameterDescriptionCases < std::string > >	operator>> (std::string const &caseValue, ParameterDescriptionNode const &node)
std::auto_ptr < ParameterDescriptionCases < std::string > >	operator>> (char const *caseValue, ParameterDescriptionNode const &node)
std::auto_ptr < ParameterDescriptionCases < bool > >	operator>> (bool caseValue, std::auto_ptr< ParameterDescriptionNode > node)
std::auto_ptr < ParameterDescriptionCases < int > >	operator>> (int caseValue, std::auto_ptr< ParameterDescriptionNode > node)
std::auto_ptr < ParameterDescriptionCases < std::string > >	operator>> (std::string const &caseValue, std::auto_ptr< ParameterDescriptionNode > node)
std::auto_ptr < ParameterDescriptionCases < std::string > >	operator>> (char const *caseValue, std::auto_ptr< ParameterDescriptionNode > node)
std::auto_ptr < ParameterDescriptionNode >	operator^ (ParameterDescriptionNode const &node_left, ParameterDescriptionNode const &node_right)
std::auto_ptr < ParameterDescriptionNode >	operator^ (std::auto_ptr< ParameterDescriptionNode > node_left, ParameterDescriptionNode const &node_right)
std::auto_ptr < ParameterDescriptionNode >	operator^ (ParameterDescriptionNode const &node_left, std::auto_ptr< ParameterDescriptionNode > node_right)
std::auto_ptr < ParameterDescriptionNode >	operator^ (std::auto_ptr< ParameterDescriptionNode > node_left, std::auto_ptr< ParameterDescriptionNode > node_right)
std::auto_ptr < ParameterDescriptionCases < bool > >	operator|| (std::auto_ptr< ParameterDescriptionCases< bool > >, std::auto_ptr< ParameterDescriptionCases< bool > >)
std::auto_ptr < ParameterDescriptionCases < int > >	operator|| (std::auto_ptr< ParameterDescriptionCases< int > >, std::auto_ptr< ParameterDescriptionCases< int > >)
std::auto_ptr < ParameterDescriptionCases < std::string > >	operator|| (std::auto_ptr< ParameterDescriptionCases< std::string > >, std::auto_ptr< ParameterDescriptionCases< std::string > >)
std::auto_ptr < ParameterDescriptionNode >	operator|| (ParameterDescriptionNode const &node_left, ParameterDescriptionNode const &node_right)
std::auto_ptr < ParameterDescriptionNode >	operator|| (std::auto_ptr< ParameterDescriptionNode > node_left, ParameterDescriptionNode const &node_right)
std::auto_ptr < ParameterDescriptionNode >	operator|| (ParameterDescriptionNode const &node_left, std::auto_ptr< ParameterDescriptionNode > node_right)
std::auto_ptr < ParameterDescriptionNode >	operator|| (std::auto_ptr< ParameterDescriptionNode > node_left, std::auto_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 > > (std::string const &name) const
template<>
std::vector< PdtEntry >	ParameterSet::getParameter< std::vector< PdtEntry > > (char 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, std::vector< ESInputTag > const &defaultValue) const
template<>
std::vector< ESInputTag >	ParameterSet::getUntrackedParameter< std::vector< ESInputTag > > (std::string const &name) const
template<>
std::vector< ESInputTag >	ParameterSet::getUntrackedParameter< std::vector< ESInputTag > > (char const *name, std::vector< ESInputTag > const &defaultValue) const
template<>
std::vector< ESInputTag >	ParameterSet::getUntrackedParameter< std::vector< ESInputTag > > (char const *name) const
template<>
std::vector< EventID >	ParameterSet::getUntrackedParameter< std::vector< EventID > > (std::string const &name, 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) const
template<>
std::vector< EventID >	ParameterSet::getUntrackedParameter< std::vector< EventID > > (char const *name, std::vector< EventID > 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 > > (std::string const &name, std::vector< EventRange > const &defaultValue) const
template<>
std::vector< EventRange >	ParameterSet::getUntrackedParameter< std::vector< EventRange > > (char const *name) const
template<>
std::vector< EventRange >	ParameterSet::getUntrackedParameter< std::vector< EventRange > > (char const *name, std::vector< EventRange > const &defaultValue) 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) 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 > > (char const *name, std::vector< int > const &defaultValue) const
template<>
std::vector< int >	ParameterSet::getUntrackedParameter< std::vector< int > > (char const *name) const
template<>
std::vector< long long >	ParameterSet::getUntrackedParameter< std::vector< long long > > (std::string const &name) const
template<>
std::vector< long long >	ParameterSet::getUntrackedParameter< std::vector< long long > > (std::string const &name, std::vector< long long > const &defaultValue) const
template<>
std::vector< long long >	ParameterSet::getUntrackedParameter< std::vector< long long > > (char const *name) const
template<>
std::vector< long long >	ParameterSet::getUntrackedParameter< std::vector< long long > > (char const *name, std::vector< long long > const &defaultValue) const
template<>
std::vector< LuminosityBlockID >	ParameterSet::getUntrackedParameter< std::vector< LuminosityBlockID > > (std::string const &name) const
template<>
std::vector< LuminosityBlockID >	ParameterSet::getUntrackedParameter< std::vector< LuminosityBlockID > > (std::string const &name, std::vector< LuminosityBlockID > const &defaultValue) const
template<>
std::vector< LuminosityBlockID >	ParameterSet::getUntrackedParameter< std::vector< LuminosityBlockID > > (char const *name) const
template<>
std::vector< LuminosityBlockID >	ParameterSet::getUntrackedParameter< std::vector< LuminosityBlockID > > (char const *name, std::vector< LuminosityBlockID > const &defaultValue) const
template<>
std::vector< LuminosityBlockRange >	ParameterSet::getUntrackedParameter< std::vector< LuminosityBlockRange > > (std::string const &name, std::vector< LuminosityBlockRange > const &defaultValue) const
template<>
std::vector< LuminosityBlockRange >	ParameterSet::getUntrackedParameter< std::vector< LuminosityBlockRange > > (std::string const &name) const
template<>
std::vector< LuminosityBlockRange >	ParameterSet::getUntrackedParameter< std::vector< LuminosityBlockRange > > (char const *name) const
template<>
std::vector< LuminosityBlockRange >	ParameterSet::getUntrackedParameter< std::vector< LuminosityBlockRange > > (char const *name, std::vector< LuminosityBlockRange > const &defaultValue) 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, std::vector< PdtEntry > const &defaultValue) const
template<>
std::vector< PdtEntry >	ParameterSet::getUntrackedParameter< std::vector< PdtEntry > > (std::string const &name, std::vector< PdtEntry > const &defaultValue) const
template<>
std::vector< PdtEntry >	ParameterSet::getUntrackedParameter< std::vector< PdtEntry > > (char const *name) 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) 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< 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, std::vector< unsigned int > const &defaultValue) const
template<>
std::vector< unsigned int >	ParameterSet::getUntrackedParameter< std::vector< unsigned int > > (char const *name) const
template<>
std::vector< unsigned long long >	ParameterSet::getUntrackedParameter< std::vector< unsigned long long > > (std::string const &name, 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 > > ()
std::auto_ptr< ParameterSet >	popSubProcessParameterSet (ParameterSet &parameterSet)
static void	postIndexIntoFilePrintEventLists (TFile *tfl, FileFormatVersion const &fileFormatVersion, TTree *metaDataTree)
static void	postIndexIntoFilePrintEventsInLumis (TFile *tfl, FileFormatVersion const &fileFormatVersion, TTree *metaDataTree)
	preallocConfig_ (prealloc)
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=0, int rc=-1)
void	printCmsExceptionWarning (char const *behavior, cms::Exception const &e, edm::JobReport *jobRep=0, int rc=-1)
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)
void	public_base_classes (TypeWithDict const &type, 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...
boost::shared_ptr< ParameterSet >	readConfig (std::string const &config)
boost::shared_ptr< ParameterSet >	readConfig (std::string const &config, int argc, char *argv[])
	same, but with arguments More...
boost::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, boost::regex const &regexp)
std::vector< std::vector < std::string > ::const_iterator >	regexMatch (std::vector< std::string > const &strings, std::string const &pattern)
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)
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	setStandAloneMessageThreshold (edm::ELseverityLevel const &severity)
void	setStreamedProductStreamer ()
void	sigInventory ()
	size_ (0)
	size_ (n)
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	stemFromPath (const std::string &path)
std::string	stripLeadingDirectoryTree (const std::string &file)
std::string	stripNamespace (std::string const &theName)
bool	stripTemplate (std::string &theName)
void	swap (ProductID &a, ProductID &b)
void	swap (ProductData &a, ProductData &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 (ESHandleBase &a, ESHandleBase &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 (HLTGlobalStatus &lhs, HLTGlobalStatus &rhs)
	Free swap function. More...
template<typename C >
void	swap (Association< C > &lhs, Association< C > &rhs)
void	swap (OutputHandle &a, OutputHandle &b)
template<class T >
void	swap (DetSet< T > &a, DetSet< T > &b)
template<typename KEY >
void	swap (RefVectorBase< KEY > &a, RefVectorBase< KEY > &b)
	swap two vectors More...
void	swap (edm::RefCore &lhs, edm::RefCore &rhs)
void	swap (edm::RefCoreWithIndex &lhs, edm::RefCoreWithIndex &rhs)
void	swap (ErrorObj &a, ErrorObj &b)
void	swap (HandleBase &a, HandleBase &b)
void	swap (FileInPath &a, FileInPath &b)
void	swap (BasicHandle &a, BasicHandle &b)
template<typename K , typename T >
void	swap (MapOfVectors< K, T > &lhs, MapOfVectors< K, T > &rhs)
template<class T >
void	swap (EDCollection< T > &a, EDCollection< T > &b)
template<class T >
void	swap (RefGetter< T > &a, RefGetter< T > &b)
template<typename C , typename T , typename F >
void	swap (RefVector< C, T, F > &a, RefVector< C, T, F > &b)
template<typename ID , typename C , typename P >
void	swap (IDVectorMap< ID, C, P > &a, IDVectorMap< ID, C, P > &b)
template<typename T >
void	swap (PtrVector< T > &lhs, PtrVector< T > &rhs)
void	swap (DataFrameContainer &lhs, DataFrameContainer &rhs)
template<typename T >
void	swap (value_ptr< T > &vp1, value_ptr< T > &vp2)
template<typename T >
void	swap (edm::RefToBaseProd< T > const &lhs, edm::RefToBaseProd< T > const &rhs)
template<typename ID , typename C , typename P >
void	swap (RangeMap< ID, C, P > &a, RangeMap< ID, C, P > &b)
template<int I>
void	swap (Hash< I > &a, Hash< I > &b)
template<typename C >
void	swap (RefProd< C > const &lhs, RefProd< C > const &rhs)
template<typename T >
void	swap (ValueMap< T > &lhs, ValueMap< T > &rhs)
template<class T >
void	swap (DetSetLazyVector< T > &a, DetSetLazyVector< T > &b)
template<typename KeyRefProd , typename CVal , typename KeyRef , typename SizeType , typename KeyReferenceHelper >
void	swap (AssociationVector< KeyRefProd, CVal, KeyRef, SizeType, KeyReferenceHelper > &a, AssociationVector< KeyRefProd, CVal, KeyRef, SizeType, KeyReferenceHelper > &b)
void	swap (InputProductHolder &a, InputProductHolder &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)
void	swap (ScheduledProductHolder &a, ScheduledProductHolder &b)
template<class T >
void	swap (RefToBase< T > &a, RefToBase< T > &b)
void	swap (UnscheduledProductHolder &a, UnscheduledProductHolder &b)
template<typename T , typename SORT >
void	swap (SortedCollection< T, SORT > &a, SortedCollection< T, SORT > &b)
template<typename T >
void	swap (View< T > &lhs, View< T > &rhs)
template<typename T , unsigned int M, typename P >
void	swap (OwnArray< T, M, P > &a, OwnArray< T, M, P > &b)
template<typename T , typename P >
void	swap (OwnVector< T, P > &a, OwnVector< T, P > &b)
template<class T >
void	swap (DetSetVector< T > &a, DetSetVector< T > &b)
void	swap (SourceProductHolder &a, SourceProductHolder &b)
template<class T >
void	swap (LazyGetter< T > &a, LazyGetter< T > &b)
static void	throwAmbiguousException (const char *where, TypeID const &productType, std::string const &label, std::string const &instance, std::string const &process)
static void	throwCorruptionException (char const *where, std::string const &branchName)
void	throwExceptionWithText (char const *txt)
void	throwMissingDictionariesException ()
static void	throwProductDeletedException (const char *where, TypeID const &productType, std::string const &label, std::string const &instance, std::string const &process)
static void	throwProductDeletedException (ProductID const &pid, edm::EventPrincipal::ConstProductHolderPtr const phb)
static void	throwProductNotFoundException (char const *where, errors::ErrorCodes error, BranchID const &bid)
std::vector< std::string >	tokenize (std::string const &input, std::string const &separator)
	breaks the input string into tokens, delimited by the separator More...
template<typename T >
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")
std::string	typeDemangle (char const *mangledName)
std::string	uniqueSharedResourceName ()
bool	untaintString (char const *pattern, char const *regexp)
bool	value_type_of (TypeWithDict const &t, TypeWithDict &found_type)
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...
	wantSummary_ (tns.wantSummary())
std::string	withoutQuotes (std::string const &from)
std::string	wrappedClassName (std::string const &iFullName)
bool	wrapper_type_of (TypeWithDict const &possible_wrapper, TypeWithDict &found_wrapped_type)

Variables
	__pad0__
	actions
	areg
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
volatile std::atomic< bool > shutdown_flag	false
static char const *	fmt_Guid
static StringSet	foundTypes_
MallocOptionSetter	global_malloc_options
const int	init_size = 1024*1024
static unsigned long long const	kAveEventPerSec = 200ULL
static unsigned long long const	kNanoSecPerSec = 1000000000ULL
static StringSet	missingTypes_
static const unsigned char	MLSCRIBE_RUNNING_INDICATOR = 29
	prealloc
	preg
	processConfiguration
static ProcessHistory const	s_emptyProcessHistory
static std::atomic < Principal::CacheIdentifier_t >	s_nextIdentifier
thread_local EDProductGetter const *	s_productGetter = 0
static unsigned int const	shift = 8 * sizeof(unsigned int)
volatile std::atomic< bool >	shutdown_flag
static pset::TypeTrans const	sTypeTranslations

Detailed Description

A PluginFactory for concrete instances of class KalmanAlignmentMetricsUpdator.

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

classes declaration

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

HLT enums.

A PluginFactory for updators for the KalmanAlignmentAlgorithm.

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.

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

A filter for particles in the user-defined kinematic acceptabce.

Author

Patrick Janot

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>

Helper functions for making stream modules

Description: [one line class summary]

Usage: <usage>

----------------------

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

---

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

----------------------

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>

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

StreamDQMDeserializer.h

Utility class for translating streamer message objects into DQM objects (monitor elements)

StreamDQMSerializer.h

Utility class for translating DQM objects (monitor elements) into streamer message objects.

StreamDQMDeserializer.cc

Utility class for deserializing streamer message objects into DQM objects (monitor elements)

StreamDQMSerializer.cc

Utility class for serializing DQM objects (monitor elements) into streamer message objects.

StreamSerializer.cc

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

jet parton energy corrections

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.

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 21 of file UnixSignalHandlers.h.

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

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

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

Definition at line 57 of file EventEntryInfo.h.

typedef unsigned int edm::EventNumber_t

Definition at line 30 of file EventID.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 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 boost::shared_ptr<reftobase::RefHolderBase> edm::helper_ptr

Definition at line 44 of file EDProductfwd.h.

typedef reftobase::RefVectorHolderBase edm::helper_vector

Definition at line 45 of file EDProductfwd.h.

typedef boost::shared_ptr< reftobase::RefVectorHolderBase > edm::helper_vector_ptr

Definition at line 46 of file EDProductfwd.h.

typedef long long int edm::HRTimeDiffType

Definition at line 81 of file HRRealTime.h.

typedef unsigned long long int edm::HRTimeType

Definition at line 82 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 &, InputSourceDescription 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 31 of file EventID.h.

typedef unsigned int edm::LumiNumber_t

Definition at line 31 of file EventRange.h.

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

Definition at line 15 of file Factory.h.

typedef Hash<ModuleDescriptionType> edm::ModuleDescriptionID

Definition at line 55 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<PCaloHit> edm::PCaloHitContainer

Definition at line 8 of file PCaloHitContainer.h.

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

Definition at line 13 of file ConfigurationHandshake.h.

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

Definition at line 10 of file ConfigurationHandshake.h.

typedef PoolSource edm::PoolRASource

Definition at line 80 of file PoolSource.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 int edm::ProductHolderIndex

Definition at line 8 of file ProductHolderIndex.h.

typedef unsigned short edm::ProductIndex

Definition at line 26 of file ProductID.h.

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

Definition at line 82 of file ProductProvenance.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 29 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 32 of file EventRange.h.

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

Definition at line 10 of file SelectedProducts.h.

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

Definition at line 12 of file SelectedProducts.h.

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

Definition at line 104 of file StreamedProducts.h.

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

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

typedef std::set<std::string> edm::StringSet

Definition at line 17 of file DictionaryTools.h.

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 45 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 16 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 354 of file Schedule.cc.

Enumeration Type Documentation

anonymous enum

Enumerator
kChildSucceed
kChildExitBadly
kChildSegv
kMaxChildAction

Definition at line 679 of file EventProcessor.cc.

       {
    kChildSucceed,
    kChildExitBadly,
    kChildSegv,
    kMaxChildAction
  };

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

{ PRODUCT_TYPE, ELEMENT_TYPE };

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

Enumerator
ProductHolderIndexValuesBit
ProductHolderIndexInvalid
ProductHolderIndexInitializing
ProductHolderIndexAmbiguous

Definition at line 11 of file ProductHolderIndex.h.

                                {

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

    ProductHolderIndexInvalid = std::numeric_limits<unsigned int>::max(),
    ProductHolderIndexInitializing = std::numeric_limits<unsigned int>::max() - 1,
    ProductHolderIndexAmbiguous = std::numeric_limits<unsigned int>::max() - 2
  };

enum edm::TypeMemberQuery

Enumerator
InheritedDefault
InheritedNo
InheritedAlso

Definition at line 39 of file TypeWithDict.h.

                       {
    InheritedDefault = Reflex::INHERITEDMEMBERS_DEFAULT,
    InheritedNo = Reflex::INHERITEDMEMBERS_NO,
    InheritedAlso = Reflex::INHERITEDMEMBERS_ALSO
  };

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(), and cms::Exception::setAlreadyPrinted().

Referenced by callWithTryCatchAndPrint(), edm::StreamSchedule::processOneEvent(), edm::GlobalSchedule::processOneGlobal(), edm::WorkerManager::processOneOccurrence(), and edm::StreamSchedule::processOneStream().

                                                 {
    if (context != 0 && 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);
    }
  }

edm::all_output_communicators_

(

)

Referenced by endpathsAreActive_().

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

Referenced by edm::EventContentAnalyzer::analyze(), CaloVNoiseSignalGenerator::contains(), maybeThrowMissingDictionaryException(), 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 AlCaHLTBitMon_ParallelJobs::p.

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

std::string const & edm::BranchTypeToAuxBranchName

(

BranchType const &

branchType

)

Definition at line 118 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 114 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 126 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 110 of file BranchType.cc.

References ZMuMuCategoriesSequences_cff::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 134 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 106 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 138 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 130 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 122 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 102 of file BranchType.cc.

References patZpeak::events, InEvent, InRun, edmLumisInFiles::lumis, and gather_cfg::runs.

Referenced by ProvenanceDumper::work_().

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

std::string const & edm::BranchTypeToString

(

BranchType const &

branchType

)

Definition at line 98 of file BranchType.cc.

References event(), InEvent, InRun, fjr2json::lumi, and DTTTrigCorrFirst::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();
  }

static void edm::check ( Principal const &  p, std::string const &  id, edm::ModuleCallingContext const *  mcc  )

static

Definition at line 82 of file GetProductCheckerOutputModule.cc.

References edm::Principal::begin(), edm::BranchDescription::branchID(), edm::OutputHandle::desc(), edm::Principal::end(), edm::hlt::Exception, edm::Principal::getByLabel(), edm::Principal::getForOutput(), and PRODUCT_TYPE.

Referenced by SegmentsTrackAssociator::associate(), edm::StreamerInputFile::openStreamerFile(), EcalTrivialConditionRetriever::produceEcalLaserAlphas(), edm::DataMixingMuonWorker::putMuon(), edm::GetProductCheckerOutputModule::write(), edm::GetProductCheckerOutputModule::writeLuminosityBlock(), and edm::GetProductCheckerOutputModule::writeRun().

                                                                                                  {
      for(Principal::const_iterator it = p.begin(), itEnd = p.end();
          it != itEnd;
          ++it) {
         if(*it) {
           if (!(*it)->singleProduct()) continue;

            BranchID branchID = (*it)->branchDescription().branchID();
            OutputHandle const oh = p.getForOutput(branchID, false, mcc);
            
            if(0 != oh.desc() && oh.desc()->branchID() != branchID) {
               throw cms::Exception("BranchIDMissMatch") << "While processing " << id << " request for BranchID " << branchID << " returned BranchID " << oh.desc()->branchID() << "\n";
            }
           
            TypeID const& tid((*it)->branchDescription().unwrappedTypeID());
            BasicHandle bh = p.getByLabel(PRODUCT_TYPE, tid,
            (*it)->branchDescription().moduleLabel(),
            (*it)->branchDescription().productInstanceName(),
            (*it)->branchDescription().processName(),
                                          nullptr, mcc);
            
            /*This doesn't appear to be an error, it just means the Product isn't available, which can be legitimate
            if(!bh.product()) {
               throw cms::Exception("GetByLabelFailure") << "While processing " << id << " getByLabel request for " << (*it)->productDescription().moduleLabel()
                  << " '" << (*it)->productDescription().productInstanceName() << "' " << (*it)->productDescription().processName() << " failed\n.";
            }*/
            if(0 != bh.provenance() && bh.provenance()->branchDescription().branchID() != branchID) {
               throw cms::Exception("BranchIDMissMatch") << "While processing " << id << " getByLabel request for " << (*it)->branchDescription().moduleLabel()
                  << " '" << (*it)->branchDescription().productInstanceName() << "' " << (*it)->branchDescription().processName()
                  << "\n should have returned BranchID " << branchID << " but returned BranchID " << bh.provenance()->branchDescription().branchID() << "\n";
            }
         }
      }
   }

void edm::checkDictionaries	(	std::string const &	name,
		bool	noComponents = false
	)

Definition at line 187 of file DictionaryTools.cc.

References edm::TypeWithDict::byName(), createPayload::checkType, foundTypes(), missingTypes(), AlCaHLTBitMon_QueryRunRegistry::string, and edmStreamStallGrapher::t.

Referenced by edm::PoolOutputModule::beginJob(), loadCap(), loadMissingDictionaries(), and maybeThrowMissingDictionaryException().

                                                                   {
    TypeWithDict null;
    TypeWithDict t(TypeWithDict::byName(name));
    if(t == null) {
      if(name == std::string("void")) {
        foundTypes().insert(name);
      } else {
        missingTypes().insert(name);
      }
      return;
    }
    checkType(t, noComponents);
  }

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

Definition at line 6 of file CommonExceptions.cc.

References edm::hlt::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.

Referenced by ESDataCertificationTask::endJob(), ESDaqInfoTask::endJob(), ESPedestalClient::endJob(), ESSummaryClient::endJob(), ESDcsInfoTask::endJob(), ESIntegrityClient::endJob(), ESPedestalClient::endRun(), ESSummaryClient::endRun(), ESIntegrityClient::endRun(), PhysicsTools::MVATrainer::setCleanup(), and edm::Factory::~Factory().

  {
    delete v.second;
  }

void edm::clearLoggedErrorsSummary

(

unsigned int

iStreamID

)

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

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

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

Definition at line 290 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(), 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	(	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,
		EventID const &	rh
	)

Definition at line 38 of file EventRange.cc.

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

Referenced by Vispa.Gui.PortConnection.PointToPointConnection::belongsToRoute(), FWSiStripClusterProxyBuilder::build(), contains(), Vispa.Views.LineDecayView.DecayNode::containsPoint(), Vispa.Views.LineDecayView.DecayLine::containsPoint(), CaloTowersCreationAlgo::convert(), MultipleScatteringGeometry::detLayers(), Vispa.Gui.ConnectableWidget.ConnectableWidget::dropAreaPort(), pat::PATElectronProducer::fillElectron2(), pat::PATMuonProducer::fillMuon(), 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(), and CaloTowersCreationAlgo::rescaleTowers().

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

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, alignCSCRings::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 alignCSCRings::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::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 compareJSON::const, h, edm::Wrapper< T >::product(), edm::handleimpl::throwConvertTypeError(), edm::handleimpl::throwInvalidReference(), and wrapper.

Referenced by edm::detail::NamedEventSelector::fill(), edm::Event::get(), PileUpEventPrincipal::getByLabel(), edm::EventBase::getByLabel(), edm::RunBase::getByLabel(), edm::LuminosityBlock::getByLabel(), edm::Run::getByLabel(), edm::Event::getByLabel(), edm::LuminosityBlockBase::getByLabel(), edm::LuminosityBlock::getByToken(), edm::Run::getByToken(), edm::Event::getByToken(), edm::PrincipalGetAdapter::getManyByType(), and FRDEventOutputModule< Consumer >::write().

                                 {
    if(bh.failedToGet()) {
      Handle<T> h(std::move(bh.whyFailedFactory()));
      result = std::move(h);
      return;
    }
    void const* basicWrapper = bh.wrapper();
    if(basicWrapper == 0) {
      handleimpl::throwInvalidReference();
    }
    if(!(bh.interface()->dynamicTypeInfo() == typeid(T))) {
      handleimpl::throwConvertTypeError(typeid(T), bh.interface()->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 dtNoiseDBValidation_cfg::cerr, edm::hlt::Exception, edm::BasicHandle::failedToGet(), edm::ObjectWithDict::get(), h, edm::BasicHandle::id(), edm::errors::InvalidReference, edm::WrapperHolder::isValid(), edm::errors::LogicError, edm::TypeWithDict::name(), edm::BasicHandle::provenance(), edm::Handle< FWGenericObject >::setWhyFailed(), edm::Handle< FWGenericObject >::type(), edm::BasicHandle::whyFailed(), edm::convertException::wrap(), edm::WrapperHolder::wrappedTypeInfo(), edm::WrapperHolder::wrapper(), and edm::BasicHandle::wrapperHolder().

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

  WrapperHolder originalWrap = orig.wrapperHolder();
  if(!originalWrap.isValid()) {
    throw edm::Exception(edm::errors::InvalidReference,"NullPointer")
      << "edm::BasicHandle has null pointer to Wrapper";
  }
  
  edm::ObjectWithDict wrap(edm::TypeWithDict(originalWrap.wrappedTypeInfo()), const_cast<void*>(originalWrap.wrapper()));
  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 edm::hlt::Exception, edm::ObjectWithDict::get(), h, edm::errors::InvalidReference, edm::WrapperHolder::isValid(), edm::errors::LogicError, edm::TypeWithDict::name(), edm::Handle< GenericObject >::setWhyFailedFactory(), edm::Handle< GenericObject >::type(), edm::convertException::wrap(), edm::WrapperHolder::wrappedTypeInfo(), and edm::WrapperHolder::wrapper().

{
  if(orig.failedToGet()) {
    result.setWhyFailedFactory(orig.whyFailedFactory());
    return;
  }
  WrapperHolder originalWrap = orig.wrapperHolder();
  if(!originalWrap.isValid()) {
    throw Exception(errors::InvalidReference,"NullPointer")
      << "edm::BasicHandle has null pointer to Wrapper";
  }
  
  ObjectWithDict wrap(originalWrap.wrappedTypeInfo(), const_cast<void*>(originalWrap.wrapper()));
  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);
}

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 filterCSVwithJSON::copy, and f.

Referenced by edm::service::ThreadSafeLogMessageLoggerScribe::configure_dest(), edm::service::MessageLoggerScribe::configure_dest(), dumpEventHeader(), dumpInitHeader(), MsgTools::fillNames(), edm::ProductRegistry::initializeLookupTables(), 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 200 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 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(), evf::FastMonitoringService::makePathLegenda(), 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(), alignCSCRings::e, split(), and groupFilesInBlocks::temp.

                                                        {
    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, and alignCSCRings::e.

                                            {
    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(), alignCSCRings::e, split(), and groupFilesInBlocks::temp.

                                                       {
    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 alignCSCRings::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(), alignCSCRings::e, split(), and groupFilesInBlocks::temp.

                                                                {
    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, and alignCSCRings::e.

                                                  {
    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(), alignCSCRings::e, split(), and groupFilesInBlocks::temp.

                                                             {
    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 alignCSCRings::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(), alignCSCRings::e, split(), and groupFilesInBlocks::temp.

                                                                      {
    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 bookConverter::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(), alignCSCRings::e, split(), and groupFilesInBlocks::temp.

                                                          {
    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, trackerHits::c, alignCSCRings::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(), alignCSCRings::e, split(), AlCaHLTBitMon_QueryRunRegistry::string, and groupFilesInBlocks::temp.

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

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

                                                              {
     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 event(), fjr2json::lumi, DTTTrigCorrFirst::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(), 0, 0);
    unsigned int lumi = (tokens.size() == 2 ? 0 : strtoul(tokens[1].c_str(), 0, 0));
    unsigned int event = strtoul(tokens[tokens.size() - 1].c_str(), 0, 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().

                                                              {
      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 fjr2json::lumi, DTTTrigCorrFirst::run, and tokenize().

                                                             {
      std::vector<std::string> tokens = edm::tokenize(from, ":");
      assert(tokens.size() == 2);
      unsigned int run = strtoul(tokens[0].c_str(), 0, 0);
      unsigned int lumi = strtoul(tokens[1].c_str(), 0, 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().

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

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

                                                                 {
    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(), alignCSCRings::e, split(), and groupFilesInBlocks::temp.

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

unsigned int edm::decodeInt ( unsigned char *  v )

inline

Definition at line 33 of file Messages.h.

References a, b, and trackerHits::c.

Referenced by edm::MsgCode::getCode(), edm::EventMsg::getDataSize(), edm::InitMsg::getDataSize(), edm::EventMsg::getEventNumber(), edm::EventMsg::getRunNumber(), edm::EventMsg::getTotalSegs(), and edm::EventMsg::getWhichSeg().

  {
    // first four bytes are code,  LSB first
    unsigned int a=v[0], b=v[1], c=v[2], d=v[3];
    a|=(b<<8)|(c<<16)|(d<<24);
    return a;
  }

std::string const & edm::dictionaryPlugInPrefix

(

)

Definition at line 22 of file DictionaryTools.cc.

References prof2calltree::prefix, and AlCaHLTBitMon_QueryRunRegistry::string.

Referenced by edm::ProductRegistryHelper::addToRegistry(), edm::service::InitRootHandlers::InitRootHandlers(), and loadCap().

                                            {
    static std::string const prefix("LCGReflex/");
    return prefix;
  }

void edm::disableAllSigs

(

sigset_t *

oldset

)

Definition at line 36 of file UnixSignalHandlers.cc.

References MUST_BE_ZERO.

Referenced by installCustomHandler(), and MulticoreRunLumiEventChecker::postForkReacquireResources().

    {
      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 165 of file MessageSender.cc.

References errorSummaryIsBeingKept, and run_regression::ret.

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, NULL, 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) {
      MUST_BE_ZERO(sigaddset(&myset,num));
      MUST_BE_ZERO(sigaction(num,&tmpact,NULL));
      }
      
      MUST_BE_ZERO(pthread_sigmask(SIG_BLOCK,&myset,0));
#endif
    }

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

Definition at line 85 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 lessThan(), 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

(

const std::string &

name

)

Definition at line 31 of file ClassFiller.cc.

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

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

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

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.

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

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

ELseverityLevel const edm::ELdebugGen

(

)

Definition at line 260 of file ELseverityLevel.cc.

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

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

ELseverityLevel const edm::ELerrorGen

(

)

Definition at line 278 of file ELseverityLevel.cc.

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

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

ELseverityLevel const edm::ELhighestSeverityGen

(

)

Definition at line 296 of file ELseverityLevel.cc.

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

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

ELseverityLevel const edm::ELinfoGen

(

)

Definition at line 266 of file ELseverityLevel.cc.

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

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

ELseverityLevel const edm::ELsevereGen

(

)

Definition at line 290 of file ELseverityLevel.cc.

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

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

ELseverityLevel const edm::ELunspecifiedGen

(

)

Definition at line 284 of file ELseverityLevel.cc.

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

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

ELseverityLevel const edm::ELwarningGen

(

)

Definition at line 272 of file ELseverityLevel.cc.

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

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

ELseverityLevel const edm::ELzeroSeverityGen

(

)

Definition at line 254 of file ELseverityLevel.cc.

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

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

bool edm::EnableLoggedErrorsSummary

(

)

Definition at line 160 of file MessageSender.cc.

References errorSummaryIsBeingKept, and run_regression::ret.

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 76 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, alignCSCRings::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, alignCSCRings::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, alignCSCRings::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, alignCSCRings::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, alignCSCRings::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, alignCSCRings::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, alignCSCRings::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, alignCSCRings::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().

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

                                                              {
     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(), and edm::EventID::run().

                                                   {
    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(), and AlCaHLTBitMon_QueryRunRegistry::string.

                                                              {
      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(), and AlCaHLTBitMon_QueryRunRegistry::string.

                                                                        {
    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(), and AlCaHLTBitMon_QueryRunRegistry::string.

                                                                           {
    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(), and AlCaHLTBitMon_QueryRunRegistry::string.

                                                                 {
    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, alignCSCRings::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>

void edm::encodeInt ( unsigned int  i, unsigned char *  v  )

inline

Definition at line 41 of file Messages.h.

Referenced by edm::MsgCode::setCode(), edm::EventMsg::setDataSize(), edm::InitMsg::setDataSize(), edm::EventMsg::setEventNumber(), edm::EventMsg::setRunNumber(), edm::EventMsg::setTotalSegs(), and edm::EventMsg::setWhichSeg().

  {
    v[0]=i&0xff;
    v[1]=(i>>8)&0xff;
    v[2]=(i>>16)&0xff;
    v[3]=(i>>24)&0xff;
  }

edm::endpathsAreActive_

(

true

)

Definition at line 374 of file Schedule.cc.

References actions, all_output_communicators_(), areg, trackerHits::c, filterCSVwithJSON::copy, edm::maker::ModuleHolder::createOutputModuleCommunicator(), i, loadMissingDictionaries(), moduleRegistry_(), n, prealloc, preg, processConfiguration, edm::pset::setProcessParameterSetID(), findQualityFiles::size, AlCaHLTBitMon_QueryRunRegistry::string, and groupFilesInBlocks::temp.

  {
    assert(0<prealloc.numberOfStreams());
    streamSchedules_.reserve(prealloc.numberOfStreams());
    for(unsigned int i=0; i<prealloc.numberOfStreams();++i) {
      streamSchedules_.emplace_back(std::shared_ptr<StreamSchedule>{new StreamSchedule{resultsInserter_.get(),moduleRegistry_,proc_pset,tns,prealloc, preg,branchIDListHelper,actions,areg,processConfiguration,nullptr==subProcPSet,StreamID{i},processContext}});
    }
    
    //TriggerResults are injected automatically by StreamSchedules and are
    // unknown to the ModuleRegistry
    const std::string kTriggerResults("TriggerResults");
    std::vector<std::string> modulesToUse;
    modulesToUse.reserve(streamSchedules_[0]->allWorkers().size());
    for(auto const& worker : streamSchedules_[0]->allWorkers()) {
      if(worker->description().moduleLabel() != kTriggerResults) {
        modulesToUse.push_back(worker->description().moduleLabel());
      }
    }
    //The unscheduled modules are at the end of the list, but we want them at the front
    unsigned int n = streamSchedules_[0]->numberOfUnscheduledModules();
    if(n>0) {
      std::vector<std::string> temp;
      temp.reserve(modulesToUse.size());
      auto itBeginUnscheduled = modulesToUse.begin()+modulesToUse.size()-n;
      std::copy(itBeginUnscheduled,modulesToUse.end(),
                std::back_inserter(temp));
      std::copy(modulesToUse.begin(),itBeginUnscheduled,std::back_inserter(temp));
      temp.swap(modulesToUse);
    }
    globalSchedule_.reset( new GlobalSchedule{ resultsInserter_.get(),
      moduleRegistry_,
      modulesToUse,
      proc_pset, preg, prealloc,
      actions,areg,processConfiguration,processContext });
    
    //TriggerResults is not in the top level ParameterSet so the call to
    // reduceParameterSet would fail to find it. Just remove it up front.
    std::set<std::string> usedModuleLabels;
    for( auto const worker: allWorkers()) {
      if(worker->description().moduleLabel() != kTriggerResults) {
        usedModuleLabels.insert(worker->description().moduleLabel());
      }
    }
    std::vector<std::string> modulesInConfig(proc_pset.getParameter<std::vector<std::string> >("@all_modules"));
    std::map<std::string, std::vector<std::pair<std::string, int> > > outputModulePathPositions;
    reduceParameterSet(proc_pset, tns.getEndPaths(), modulesInConfig, usedModuleLabels,
                       outputModulePathPositions);
    processEDAliases(proc_pset, processConfiguration->processName(), preg);
    proc_pset.registerIt();
    pset::setProcessParameterSetID(proc_pset.id());
    processConfiguration->setParameterSetID(proc_pset.id());
    processConfiguration->setProcessConfigurationID();

    // This is used for a little sanity-check to make sure no code
    // modifications alter the number of workers at a later date.
    size_t all_workers_count = allWorkers().size();

    moduleRegistry_->forAllModuleHolders([this](maker::ModuleHolder* iHolder){
      auto comm = iHolder->createOutputModuleCommunicator();
      if (comm) {
        all_output_communicators_.emplace_back(boost::shared_ptr<OutputModuleCommunicator>{comm.release()});
      }      
    });
    // Now that the output workers are filled in, set any output limits or information.
    limitOutput(proc_pset, branchIDListHelper.branchIDLists());

    loadMissingDictionaries();

    // Sanity check: make sure nobody has added a worker after we've
    // already relied on the WorkerManager being full.
    assert (all_workers_count == allWorkers().size());

    branchIDListHelper.updateFromRegistry(preg);

    preg.setFrozen();

    for (auto c : all_output_communicators_) {
      c->setEventSelectionInfo(outputModulePathPositions, preg.anyProductProduced());
      c->selectProducts(preg);
    }

  } // Schedule::Schedule

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.

References x.

Referenced by isnan().

    {
      return x !=x;
    }

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(), python.tagInventory::entries, edm::ParameterSet::getParameterSet(), edm::ParameterSet::getParameterSetVector(), edm::ParameterSet::getUntrackedParameterSet(), edm::ParameterSet::getUntrackedParameterSetVector(), getDQMSummary::iter, python.Node::node, 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;

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

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

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

Definition at line 165 of file EventProcessor.cc.

References edm::eventsetup::ComponentFactory< T >::get(), edm::ParameterSet::getParameter(), edm::ParameterSet::getPSetForUpdate(), and edm::ParameterSet::registerIt().

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

                                               {
    boost::shared_ptr<EDLooperBase> vLooper;

    std::vector<std::string> loopers = params.getParameter<std::vector<std::string> >("@all_loopers");

    if(loopers.size() == 0) {
       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;

  }

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

static

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

static void edm::fillModuleInPathTimingSummary ( Path const &  path, size_t  which, ModuleInPathTimingSummary &  sum  )

static

Definition at line 651 of file StreamSchedule.cc.

References edm::ModuleInPathTimingSummary::cpuTime, edm::Worker::description(), edm::Path::getWorker(), edm::ModuleInPathTimingSummary::moduleLabel, edm::ModuleDescription::moduleLabel(), edm::ModuleInPathTimingSummary::realTime, edm::Path::timeCpuReal(), create_public_lumi_plots::times, edm::Path::timesFailed(), edm::ModuleInPathTimingSummary::timesVisited, and edm::Path::timesVisited().

Referenced by fillPathTimingSummary().

                                                                {
    sum.timesVisited = +path.timesVisited(which);
    auto times = path.timeCpuReal(which);
    sum.cpuTime  += times.first;
    sum.realTime += path.timesFailed(which);
    sum.moduleLabel  = path.getWorker(which)->description().moduleLabel();
  }

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

static

Definition at line 601 of file StreamSchedule.cc.

References edm::PathSummary::bitPosition, edm::Path::bitPosition(), fillModuleInPathSummary(), 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::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.size()==0) {
      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]);
      }
    }
  }

static void edm::fillPathTimingSummary ( Path const &  path, PathTimingSummary &  sum  )

static

Definition at line 662 of file StreamSchedule.cc.

References edm::PathTimingSummary::bitPosition, edm::Path::bitPosition(), edm::PathTimingSummary::cpuTime, fillModuleInPathTimingSummary(), i, edm::PathTimingSummary::moduleInPathSummaries, edm::PathTimingSummary::name, edm::Path::name(), edm::PathTimingSummary::realTime, edm::Path::size(), groupFilesInBlocks::temp, edm::Path::timeCpuReal(), create_public_lumi_plots::times, edm::PathTimingSummary::timesRun, and edm::Path::timesRun().

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

                                                                  {
    sum.name        = path.name();
    sum.bitPosition = path.bitPosition();
    sum.timesRun    += path.timesRun();
    auto times = path.timeCpuReal();
    sum.cpuTime  += times.first;
    sum.realTime += times.second;
    
    Path::size_type sz = path.size();
    if(sum.moduleInPathSummaries.size()==0) {
      std::vector<ModuleInPathTimingSummary> temp(sz);
      for (size_t i = 0; i != sz; ++i) {
        fillModuleInPathTimingSummary(path, i, temp[i]);
      }
      sum.moduleInPathSummaries.swap(temp);
    } else {
      assert(sz == sum.moduleInPathSummaries.size());
      for (size_t i = 0; i != sz; ++i) {
        fillModuleInPathTimingSummary(path, i, sum.moduleInPathSummaries[i]);
      }
    }
  }

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

References edm::detail::reallyfillPtrVector().

Referenced by edm::helpers::PtrSetter< T >::fill().

                                              {
    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 97 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 106 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 115 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.

                                              {
    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 492 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,
		helper_vector &	helpers
	)

Definition at line 79 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,
		helper_vector &	helpers
	)

Definition at line 89 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,
		helper_vector &	helpers
	)

Definition at line 99 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,
		helper_vector &	helpers
	)

Definition at line 109 of file FillView.h.

References edm::detail::reallyFillView().

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

template<typename T >

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

inline

Definition at line 193 of file PtrVector.h.

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

                                                         {
    obj.fillView(pointers);
  }

template<typename C , typename T , typename F >

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

inline

Definition at line 205 of file RefVector.h.

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

template<typename T >

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

inline

Definition at line 249 of file RefToBaseVector.h.

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

                                                 {
    obj.fillView(pointers);
  }

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, helper_vector &  helpers  )

inline

Definition at line 275 of file AssociationVector.h.

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

Referenced by edm::helpers::ViewFiller< T >::fill(), edm::helpers::ViewFiller< RefToBaseVector< T > >::fill(), and edm::helpers::ViewFiller< PtrVector< T > >::fill().

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

template<class T >

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

inline

Definition at line 422 of file DetSetVector.h.

  {
    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, helper_vector &  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 P >

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

inline

Definition at line 444 of file OwnVector.h.

References edm::OwnVector< T, 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, helper_vector &  helpers  )

inline

Definition at line 452 of file SortedCollection.h.

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

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

static

Definition at line 635 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 625 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();
  }

static void edm::fillWorkerTimingSummary ( Worker const *  pw, WorkerTimingSummary &  sum  )

static

Definition at line 696 of file StreamSchedule.cc.

References fillWorkerTimingSummaryAux().

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

                                                                      {
    fillWorkerTimingSummaryAux(*pw, sum);
  }

static void edm::fillWorkerTimingSummaryAux ( Worker const &  w, WorkerTimingSummary &  sum  )

static

Definition at line 686 of file StreamSchedule.cc.

References edm::WorkerTimingSummary::cpuTime, edm::Worker::description(), edm::ModuleDescription::moduleLabel(), edm::WorkerTimingSummary::moduleLabel, edm::WorkerTimingSummary::realTime, edm::Worker::timeCpuReal(), create_public_lumi_plots::times, edm::WorkerTimingSummary::timesRun, edm::Worker::timesRun(), edm::WorkerTimingSummary::timesVisited, and edm::Worker::timesVisited().

Referenced by fillWorkerTimingSummary().

                                                                        {
    sum.timesVisited += w.timesVisited();
    sum.timesRun     += w.timesRun();
    auto times = w.timeCpuReal();
    sum.cpuTime  += times.first;
    sum.realTime += times.second;
    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 spr::find().

Referenced by edm::RootFile::fillIndexIntoFile(), edm::ParameterSet::fromString(), edm::EventPrincipal::unscheduledFill(), 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 spr::find().

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

bool edm::find_nested_type_named	(	std::string const &	nested_type,
		TypeWithDict const &	type_to_search,
		TypeWithDict &	found_type
	)

Definition at line 31 of file DictionaryTools.cc.

References edm::TypeWithDict::nestedType().

Referenced by is_PtrVector(), is_RefToBaseVector(), is_RefVector(), value_type_of(), and wrapper_type_of().

                                                   {
    // Look for a sub-type named 'nested_type'
    TypeWithDict foundType = typeToSearch.nestedType(nested_type);
    if(bool(foundType)) {
      found_type = foundType;
      return true;
    }
    return false;
  }

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(), HLTSeedL1LogicScalers::beginRun(), DynamicTruncation::compatibleDets(), edm::service::ELoutput::emitToken(), PF_PU_FirstVertexTracks::produce(), PFCand_NoPU_WithAM::produce(), 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(), dqmservices::DQMFileIterator::logFileAction(), DQMRootSource::logFileAction(), and RFIOFile::retryRead().

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

Referenced by edm::WorkerManager::beginJob(), edm::ParameterSwitch< T >::checkAndGetLabelsAndTypes_(), edm::detail::TriggerResultsBasedEventSelector::clear(), edm::Path::clearCounters(), edm::StreamSchedule::clearCounters(), edm::Schedule::closeOutputFiles(), edm::StreamSchedule::fillEndPath(), edm::StreamSchedule::fillTrigPath(), edm::RootOutputTree::fillTTree(), loadCap(), main(), edm::Schedule::openNewOutputFilesIfNeeded(), edm::Schedule::openOutputFiles(), edm::Schedule::postForkReacquireResources(), edm::Schedule::preForkReleaseResources(), edm::EDLooperBase::prepareForNextLoop(), edm::ConfigurationDescriptions::print(), edm::ParameterSetDescription::print(), edm::ParameterSwitch< T >::printNestedContent_(), edm::eventsetup::EventSetupProvider::proxyProviderDescriptions(), edm::WorkerManager::resetAll(), edm::eventsetup::EventSetupRecordProvider::resetProxies(), edm::eventsetup::EventSetupProvider::resetRecordPlusDependentRecords(), edm::eventsetup::EventSetupRecordProvider::resetRecordToProxyPointers(), edm::eventsetup::EventSetupRecordProvider::resetTransients(), edm::Schedule::respondToCloseInputFile(), edm::Schedule::respondToOpenInputFile(), edm::eventsetup::EventSetupRecordProvider::setDependentProviders(), edm::eventsetup::EventSetupRecordProvider::usePreferred(), edm::ConfigurationDescriptions::validate(), edm::ParameterSetDescription::validate(), edm::AllowedLabelsDescriptionBase::validate_(), edm::ParameterWildcard< ParameterSetDescription >::validate_(), edm::ParameterWildcard< std::vector< ParameterSet > >::validate_(), edm::ParameterSetDescription::writeCfi(), edm::ParameterDescription< std::vector< ParameterSet > >::writeCfi_(), edm::ConfigurationDescriptions::writeCfis(), edm::Schedule::writeLumi(), edm::Schedule::writeRun(), edm::writeParameterValue::writeVector(), edm::Event::~Event(), edm::Factory::~Factory(), edm::LuminosityBlock::~LuminosityBlock(), and edm::Run::~Run().

                                      {
    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 40 of file JobReport.cc.

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

StringSet & edm::foundTypes

(

)

Definition at line 181 of file DictionaryTools.cc.

References foundTypes_.

Referenced by checkDictionaries().

                          {
    // The only purpose of this cache is to stop infinite recursion.
    // ROOT maintains its own internal cache.
    return foundTypes_;
  }

bool edm::FreshErrorsExist

(

unsigned int

iStreamID

)

Definition at line 170 of file MessageSender.cc.

References errorSummaryMaps.

Referenced by HLTLogMonitorFilter::filter(), and edm::LogErrorHarvester::produce().

                                                {
    assert(iStreamID<errorSummaryMaps.size());
    return  errorSummaryMaps[iStreamID].size()>0;
  }

std::vector< std::string > const & edm::getAllTriggerNames

(

)

Definition at line 23 of file getAllTriggerNames.cc.

References edm::service::TriggerNamesService::getTrigPaths().

Referenced by edm::OutputModule::OutputModule(), edm::one::OutputModuleBase::OutputModuleBase(), edm::StreamerOutputModuleBase::serializeRegistry(), and edm::SubProcess::SubProcess().

                                                   {
    Service<service::TriggerNamesService> tns;
    return tns->getTrigPaths();
  }

void edm::getCodeTable

(

Exception::CodeMap *&

setme

)

Definition at line 50 of file EDMException.cc.

References edm::errors::FilledMap::trans_.

Referenced by edm::Exception::codeToString().

                                              {
    static errors::FilledMap fm;
    setme = &fm.trans_;
  }

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.

                                                                                                        {
    char *p = ::getenv(name.c_str());
    return (p ? std::string(p) : defaultValue); 
  }

EventBuffer * edm::getEventBuffer	(	int	event_size_max,
		int	queue_depth_max
	)

Definition at line 28 of file BufferArea.cc.

References b.

  {
    std::auto_ptr<EventBuffer> b(new EventBuffer(es,qd));
    holder.v_.push_front(b.get());
    return b.release();
  }

int edm::getFileFormatVersion

(

)

Definition at line 4 of file GetFileFormatVersion.cc.

Referenced by edm::RootOutputFile::writeFileFormatVersion().

{ return 19; }

MallocOptionSetter & edm::getGlobalOptionSetter

(

)

Definition at line 219 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 953 of file ParameterSet.cc.

References edm::errors::Configuration, edm::hlt::Exception, edm::pset::Registry::instance(), and query::result.

Referenced by edm::ParameterSetEntry::fillPSet(), edm::VParameterSetEntry::fillVPSet(), findBinOfMaximum(), edm::ParameterSet::getParameter(), edm::OutputModule::setEventSelectionInfo(), and edm::one::OutputModuleBase::setEventSelectionInfo().

                                            {
    ParameterSet const* result = 0;
    if(0 == (result = pset::Registry::instance()->getMapped(id))) {
      throw Exception(errors::Configuration, "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::getProcessParameterSet

(

)

Definition at line 82 of file Registry.cc.

References edm::errors::EventCorruption, edm::hlt::Exception, edm::pset::Registry::getMapped(), edm::pset::Registry::instance(), edm::errors::LogicError, query::result, and edm::pset::s_ProcessParameterSetID.

Referenced by DQMDcsInfoClient::beginRun(), HLTPrescaleRecorder::beginRun(), DQMDcsInfo::bookHistograms(), DQMEventInfo::bookHistograms(), CentralityProvider::CentralityProvider(), ProbeTreeProducer::endJob(), HLTAnalyzer::endJob(), TagProbeFitTreeProducer::endJob(), getCentralityBinsFromDB(), and edm::service::PrescaleService::postBeginJob().

                                               {

    if (!pset::s_ProcessParameterSetID.isValid()) {
      throw edm::Exception(errors::LogicError)
        << "Illegal attempt to access the process top level parameter set ID\n"
        << "before that parameter set has been frozen and registered.\n"
        << "The parameter set can be changed during module validation,\n"
        << "which occurs concurrently with module construction.\n"
        << "It is illegal to access the parameter set before it is frozen.\n";
    }

    pset::Registry const& reg = *pset::Registry::instance();
    ParameterSet const* result;
    if (nullptr == (result = reg.getMapped(pset::s_ProcessParameterSetID))) {
      throw edm::Exception(errors::EventCorruption, "Unknown ParameterSetID")
        << "Unable to find the ParameterSet for id: "
        << pset::s_ProcessParameterSetID
        << ";\nthis was supposed to be the process ParameterSet\n";
    }
    return *result;
  }

template<typename T >

T const * edm::getProduct ( RefCore const &  ref )

inline

Definition at line 33 of file RefCoreGet.h.

References compareJSON::const, edm::RefCore::isTransient(), edm::RefCore::nullPointerForTransientException(), AlCaHLTBitMon_ParallelJobs::p, and edm::RefCore::productPtr().

Referenced by edm::EventPrincipal::readFromSource_(), edm::RunPrincipal::resolveProductImmediate(), and edm::LuminosityBlockPrincipal::resolveProductImmediate().

                                 {
    T const* p = static_cast<T const*>(ref.productPtr());
    if (p != 0) return p;
    if (ref.isTransient()) {
      ref.nullPointerForTransientException(typeid(T));
    }
    return refcore::getProductPtr_<T>(ref);
  }

template<typename PROD >

boost::shared_ptr<Wrapper<PROD> const> edm::getProductByTag ( Principal const &  ep, InputTag const &  tag, ModuleCallingContext const *  mcc  )

inline

Definition at line 278 of file Principal.h.

References edm::WrapperInterfaceBase::dynamicTypeInfo(), edm::Principal::findProductByTag(), edm::ProductData::getInterface(), PROD, query::result, edm::handleimpl::throwConvertTypeError(), and edm::ProductData::wrapper_.

                                                                                               {
    TypeID tid = TypeID(typeid(PROD));
    ProductData const* result = ep.findProductByTag(tid, tag, mcc);
    if(result == nullptr) {
      return boost::shared_ptr<Wrapper<PROD> const>(); 
    }

    if(result->getInterface() &&
       (!(result->getInterface()->dynamicTypeInfo() == typeid(PROD)))) {
      handleimpl::throwConvertTypeError(typeid(PROD), result->getInterface()->dynamicTypeInfo());
    }
    return boost::static_pointer_cast<Wrapper<PROD> const>(result->wrapper_);
  }

template<typename C , typename T , typename F , typename KEY >

T const* edm::getPtr ( RefCore const &  product, KEY const &  iKey  )

inline

Definition at line 40 of file RefItemGet.h.

References edm::refitem::GetPtrImpl< C, T, F, KEY >::getPtr_(), and AlCaHLTBitMon_ParallelJobs::p.

                                                           {
    T const* p=refitem::GetPtrImpl<C, T, F, KEY>::getPtr_(product, iKey);
    return p;
  }

template<typename C , typename T , typename F , typename KEY >

T const* edm::getPtr_ ( RefCore const &  product, KEY const &  key  )

inline

Definition at line 34 of file RefItemGet.h.

References edm::refitem::GetPtrImpl< C, T, F, KEY >::getPtr_().

                                                           {
    return refitem::GetPtrImpl<C, T, F, KEY>::getPtr_(product, key);
  }

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 edm::reftobase::Holder< T, REF >::isEqualTo(), edm::reftobase::RefHolder< REF >::isEqualTo(), reco::modules::MatcherBase< C1, C2, M >::produce(), and AssociatedVariableCollectionSelector< InputCollection, VarCollection, Selector, OutputCollection, StoreContainer, RefAdder >::select().

                                                                                  { 
    return helper::MatcherGetRef<C>::getRef( c, k ); 
  }

std::string edm::getReleaseVersion

(

)

Definition at line 7 of file GetReleaseVersion.cc.

References AlCaHLTBitMon_QueryRunRegistry::string, and STRINGIFY.

Referenced by HcalLaserEventFilter::beginJob(), DQMEventInfo::bookHistograms(), BTagValidator::BTagValidator(), edm::DaqProvenanceHelper::daqInit(), edm::ScheduleItems::initMisc(), edm::LHEProvenanceHelper::lheInit(), DQMProvInfo::makeProvInfo(), PrimaryVertexAnalyzer::PrimaryVertexAnalyzer(), PrimaryVertexAnalyzer4PU::PrimaryVertexAnalyzer4PU(), 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

)

Definition at line 78 of file ClassFiller.cc.

References edm::TypeID::className().

Referenced by edm::StreamerInputSource::deserializeRegistry(), dumpInitVerbose(), and edm::StreamSerializer::serializeRegistry().

                                            {
    TypeID const type(ti);
    return getRootClass(type.className());
  }

UnscheduledHandler * edm::getUnscheduledHandler

(

EventPrincipal const &

ep

)

Definition at line 97 of file WorkerT.cc.

References edm::EventPrincipal::unscheduledHandler().

                                                                      {
    return ep.unscheduledHandler().get();
  }

std::string edm::getUuid

(

TTree *

uuidTree

)

Definition at line 98 of file CollUtil.cc.

References edm::FileID::fid(), NewTree::fid, and edm::poolNames::fileIdentifierBranchName().

                                     {
    FileID fid;
    FileID *fidPtr = &fid;
    uuidTree->SetBranchAddress(poolNames::fileIdentifierBranchName().c_str(), &fidPtr);
    uuidTree->GetEntry(0);
    return fid.fid();
  }

std::string edm::glob2reg

(

std::string const &

pattern

)

Definition at line 22 of file RegexMatch.cc.

References listBenchmarks::pattern, and AlCaHLTBitMon_QueryRunRegistry::string.

Referenced by triggerExpression::L1Reader::init(), triggerExpression::L1TechReader::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.

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

                          {
  edm::MessageLoggerQ::MLqSHT ( ); // Shut the logger up
}

HRTimeType edm::hrRealTime ( )

inline

Definition at line 85 of file HRRealTime.h.

                                 {
    return details::rdtsc();
  }

void edm::installCustomHandler	(	int	signum,
		CFUNC	func
	)

Definition at line 93 of file UnixSignalHandlers.cc.

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

Referenced by edm::EventProcessor::forkProcess(), 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 106 of file UnixSignalHandlers.cc.

References MUST_BE_ZERO, and NULL.

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,NULL) != 0) {
      perror("sigaction failed");
      abort();
      }
      
      sigset_t newset;
      MUST_BE_ZERO(sigemptyset(&newset));
      MUST_BE_ZERO(sigaddset(&newset,mysig));
      MUST_BE_ZERO(pthread_sigmask(SIG_UNBLOCK,&newset,0));
    }

bool edm::is_glob

(

std::string const &

pattern

)

Definition at line 18 of file RegexMatch.cc.

Referenced by triggerExpression::HLTReader::init(), triggerExpression::L1Reader::init(), HLTHighLevel::init(), and edm::EventSelector::init().

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

bool edm::is_PtrVector	(	TypeWithDict const &	possible_ref_vector,
		TypeWithDict &	value_type
	)

Definition at line 56 of file DictionaryTools.cc.

References find_nested_type_named(), AlCaHLTBitMon_QueryRunRegistry::string, and edm::TypeWithDict::templateName().

Referenced by edm::ProductHolderIndexHelper::insert().

                                         {

    static std::string const template_name("edm::PtrVector");
    static std::string const member_type("member_type");
    static std::string const val_type("value_type");
    if(template_name == possibleRefVector.templateName()) {
      TypeWithDict ptrType;
      if(find_nested_type_named(val_type, possibleRefVector, ptrType)) {
        return find_nested_type_named(val_type, ptrType, value_type);
      }
    }
    return false;
  }

bool edm::is_RefToBaseVector	(	TypeWithDict const &	possible_ref_vector,
		TypeWithDict &	value_type
	)

Definition at line 72 of file DictionaryTools.cc.

References find_nested_type_named(), AlCaHLTBitMon_QueryRunRegistry::string, and edm::TypeWithDict::templateName().

Referenced by edm::ProductHolderIndexHelper::insert().

                                               {

    static std::string const template_name("edm::RefToBaseVector");
    static std::string const member_type("member_type");
    if(template_name == possibleRefVector.templateName()) {
      return find_nested_type_named(member_type, possibleRefVector, value_type);
    }
    return false;
  }

bool edm::is_RefVector	(	TypeWithDict const &	possible_ref_vector,
		TypeWithDict &	value_type
	)

Definition at line 44 of file DictionaryTools.cc.

References find_nested_type_named(), AlCaHLTBitMon_QueryRunRegistry::string, and edm::TypeWithDict::templateName().

Referenced by edm::ProductHolderIndexHelper::insert().

                                         {

    static std::string const template_name("edm::RefVector");
    static std::string const member_type("member_type");
    if(template_name == possibleRefVector.templateName()) {
      return find_nested_type_named(member_type, possibleRefVector, value_type);
    }
    return false;
  }

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

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

Referenced by SiStripQualityHotStripIdentifier::algoAnalyze(), FedChannelConnection::apvPairNumber(), L1GtTriggerMenuLiteProducer::beginRunProduce(), CommissioningHistosUsingDb::buildDetInfo(), JetPlusTrackCorrector::calculateCorr(), OldThreeThresholdAlgorithm::clusterizeDetUnit_(), SiStripEventSummary::commissioningInfo(), sistrip::SpyUnpacker::createDigis(), sistrip::RawToDigiUnpacker::createDigis(), sistrip::DigiToRaw::createFedBuffers_(), sistrip::DigiToRaw::DigiToRaw(), sistrip::DigiToRawModule::DigiToRawModule(), SiStripBadAPVAlgorithmFromClusterOccupancy::extractBadAPVs(), SiStripBadAPVandHotStripAlgorithmFromClusterOccupancy::extractBadAPVSandStrips(), SiStripHotStripAlgorithmFromClusterOccupancy::extractBadStrips(), LaserAlignmentEventFilter::filter(), BSCTrigger::getBSCNum(), sistrip::RawToDigiUnpacker::handleException(), HLTMuonTrackMassFilter::hltFilter(), HLTMuonL1RegionalFilter::hltFilter(), HLTMuonL2PreFilter::hltFilter(), HLTMuonL1Filter::hltFilter(), HLTMuonL1RegionalFilter::HLTMuonL1RegionalFilter(), HLTMuonL2PreFilter::HLTMuonL2PreFilter(), FedChannelConnection::i2cAddr(), SiStripFedZeroSuppression::IsAValidDigi(), SiStripBadAPVandHotStripAlgorithmFromClusterOccupancy::iterativeSearch(), SiStripHotStripAlgorithmFromClusterOccupancy::iterativeSearch(), JetPlusTrackCorrector::jtaUsingEventData(), L1GtRsObjectKeysOnlineProd::keyL1GtPrescaleFactorsAlgoTrig(), L1GtRsObjectKeysOnlineProd::keyL1GtPrescaleFactorsTechTrig(), L1GtRsObjectKeysOnlineProd::keyL1GtTriggerMaskAlgoTrig(), L1GtRsObjectKeysOnlineProd::keyL1GtTriggerMaskTechTrig(), L1GtRsObjectKeysOnlineProd::keyL1GtTriggerMaskVetoTechTrig(), L1GetHistLimits::l1HistLimits(), FedChannelConnection::lldChannel(), sistrip::RawToDigiUnpacker::locateStartOfFedBuffer(), jpt::Map::Map(), JetPlusTrackCorrector::matchTracks(), L1GtTriggerMaskAlgoTrigConfigOnlineProd::newObject(), L1GtTriggerMaskTechTrigConfigOnlineProd::newObject(), L1GtTriggerMaskVetoTechTrigConfigOnlineProd::newObject(), L1GtParametersConfigOnlineProd::newObject(), L1GtPrescaleFactorsAlgoTrigConfigOnlineProd::newObject(), L1GtPrescaleFactorsTechTrigConfigOnlineProd::newObject(), L1GtPsbSetupConfigOnlineProd::newObject(), L1GtTriggerMenuConfigOnlineProd::newObject(), L1GtTriggerMenuXmlParser::parseCalo(), l1t::TriggerMenuXmlParser::parseCalo(), L1GtTriggerMenuXmlParser::parseCastor(), L1GtTriggerMenuXmlParser::parseCorrelation(), L1GtTriggerMenuXmlParser::parseEnergySum(), L1GtTriggerMenuXmlParser::parseHfBitCounts(), L1GtTriggerMenuXmlParser::parseHfRingEtSums(), L1GtTriggerMenuXmlParser::parseJetCounts(), L1GtTriggerMenuXmlParser::parseMuon(), l1t::TriggerMenuXmlParser::parseMuon(), jpt::Efficiency::print(), QuarkoniaTrackSelector::produce(), L1GlobalTriggerRecordProducer::produce(), BSCTrigger::produce(), TriggerSummaryProducerAOD::produce(), sistrip::RawToDigiModule::RawToDigiModule(), sistrip::RawToDigiUnpacker::RawToDigiUnpacker(), SiStripHotStripAlgorithmFromClusterOccupancy::setNumberOfEvents(), sistrip::SpyDigiConverterModule::SpyDigiConverterModule(), sistrip::SpyUnpacker::SpyUnpacker(), sistrip::SpyUnpackerModule::SpyUnpackerModule(), SiStripFedZeroSuppression::suppress(), sistrip::RawToDigiUnpacker::triggerFed(), L1GtfeExtWord::unpack(), L1GtfeWord::unpack(), L1TcsWord::unpack(), L1GtFdlWord::unpack(), L1GlobalTriggerEvmRawToDigi::unpackHeader(), PedsFullNoiseHistosUsingDb::update(), ApvTimingHistosUsingDb::update(), PedestalsHistosUsingDb::update(), sistrip::RawToDigiModule::updateCabling(), sistrip::RawToDigiUnpacker::updateEventSummary(), L1GtTriggerMenuXmlParser::workAlgorithm(), l1t::TriggerMenuXmlParser::workAlgorithm(), L1GtTriggerMenuXmlParser::workTechTrigger(), l1t::TriggerMenuXmlParser::workTechTrigger(), L1GtPatternWriter::writePatterns(), sistrip::DigiToRaw::~DigiToRaw(), sistrip::DigiToRawModule::~DigiToRawModule(), sistrip::RawToDigiModule::~RawToDigiModule(), sistrip::RawToDigiUnpacker::~RawToDigiUnpacker(), sistrip::SpyDigiConverterModule::~SpyDigiConverterModule(), sistrip::SpyUnpacker::~SpyUnpacker(), and sistrip::SpyUnpackerModule::~SpyUnpackerModule().

                      {
  return ((!edm::MessageDrop::debugAlwaysSuppressed)        // 9/27/10 mf
         && edm::MessageDrop::instance()->debugEnabled );
}

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

inline

Definition at line 119 of file ProcessHistory.h.

References isAncestor().

                                                                 {
    return isAncestor(b, a);
  }

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 ECAL2DPositionCalcWithDepthCorr::calculateAndSetPositionActual(), isFinite(), isNotFinite(), and reco::tau::PFRecoTauEnergyAlgorithmPlugin::operator()().

template<>

bool edm::isFinite ( float  x )

inline

Definition at line 16 of file isFinite.h.

References prof2calltree::l, findQualityFiles::v, and x.

                         {
    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 prof2calltree::l, findQualityFiles::v, and x.

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

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

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

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

{ return detail::isnan(f); }

bool edm::isnan ( double  d )

inline

Definition at line 71 of file math.h.

References equal_isnan().

{ return equal_isnan(d); }

bool edm::isnan ( long double  q )

inline

Definition at line 73 of file math.h.

References edm::detail::isnan().

{ return detail::isnan(q); }

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(), CaloHitRespoNew::add(), EcalHitResponse::add(), CaloHitResponse::add(), ElectronCalibration::analyze(), ElectronCalibrationUniv::analyze(), Vx3DHLTAnalyzer::analyze(), JetTagPlotter::analyzeTag(), DetIdAssociator::buildMap(), GsfVertexWeightCalculator::calculate(), Basic2DGenericPFlowPositionCalc::calculateAndSetPositionActual(), GsfElectronAlgo::calculateShowerShape(), GsfElectronFull5x5Filler::calculateShowerShape_full5x5(), GsfElectronAlgo::calculateShowerShape_full5x5(), KFFittingSmoother::checkForNans(), TwoBodyDecayEstimator::checkValues(), Qjets::d_ij(), CaloRecoTauDiscriminationAgainstElectron::discriminate(), HLTScalersClient::endLuminosityBlock(), MagGeometry::fieldInTesla(), AlignmentExtendedCorrelationsStore::fillCovariance(), AlignmentExtendedCorrelationsStore::fillCovarianceT(), MatrixFillMap::fillEBMap(), MatrixFillMap::fillEEMap(), ClusterFillMap::fillMap(), DivisiveVertexFinder::findVertexes(), DivisiveVertexFinder::findVertexesAlt(), BSFitter::Fit(), KFTrajectoryFitter::fitOne(), sim::Field::GetFieldValue(), SequentialVertexFitter< 5 >::hasNan(), ConversionFastHelix::helixStateAtVertex(), 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(), cms::CkfTrackCandidateMakerBase::produceBase(), IMACalibBlock::riempiMtr(), IMACalibBlock::riempiVtr(), EBHitResponse::run(), HcalSiPMHitResponse::run(), EcalHitResponse::run(), PVFitter::runFitter(), SimpleCosmicBONSeeder::seeds(), ConversionFastHelix::straightLineStateAtVertex(), KinematicConstrainedVertexUpdator::update(), PrimaryVertexMonitor::vertexPlots(), 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 226 of file EventPrincipal.h.

References edm::EventPrincipal::aux(), and isSameEvent().

                                                                {
    return isSameEvent(a.aux(), b.aux());
  }

bool edm::isTransientEqual	(	ParameterSet const &	a,
		ParameterSet const &	b
	)

Definition at line 866 of file ParameterSet.cc.

References alignCSCRings::e, f, i, j, gen::k, Pi, edm::ParameterSet::psetTable(), edm::ParameterSet::tbl(), and edm::ParameterSet::vpsetTable().

Referenced by edm::eventsetup::EventSetupsController::getESProducerAndRegisterProcess(), edm::eventsetup::EventSetupsController::getESSourceAndRegisterProcess(), and operator==().

                                                                      {
    if(a.tbl().size() != b.tbl().size()) {
        return false;
    }
    if(a.psetTable().size() != b.psetTable().size()) {
        return false;
    }
    if(a.vpsetTable().size() != b.vpsetTable().size()) {
        return false;
    }
    typedef ParameterSet::table::const_iterator Ti;
    for (Ti i = a.tbl().begin(), e = a.tbl().end(),
            j = b.tbl().begin(), f = b.tbl().end();
            i != e && j != f; ++i, ++j) {
      if(*i != *j) {
        return false;
      }
    }
    typedef ParameterSet::psettable::const_iterator Pi;
    for (Pi i = a.psetTable().begin(), e = a.psetTable().end(),
            j = b.psetTable().begin(), f = b.psetTable().end();
            i != e && j != f; ++i, ++j) {
      if(i->first != j->first) {
        return false;
      }
      if(i->second.isTracked() != j->second.isTracked()) {
        return false;
      }
      if(!isTransientEqual(i->second.pset(), j->second.pset())) {
        return false;
      }
    }
    typedef ParameterSet::vpsettable::const_iterator PVi;
    for (PVi i = a.vpsetTable().begin(), e = a.vpsetTable().end(),
             j = b.vpsetTable().begin(), f = b.vpsetTable().end();
             i != e && j != f; ++i, ++j) {
      if(i->first != j->first) {
        return false;
      }
      if(i->second.isTracked() != j->second.isTracked()) {
        return false;
      }
      std::vector<ParameterSet> const& iv = i->second.vpset();
      std::vector<ParameterSet> const& jv = j->second.vpset();
      if(iv.size() != jv.size()) {
        return false;
      }
      for (size_t k = 0; k < iv.size(); ++k) {
        if(!isTransientEqual(iv[k], jv[k])) {
          return false;
        }
      }
    }
    return true;
  }

bool edm::isWarningEnabled

(

)

Definition at line 81 of file MessageLogger.cc.

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

Referenced by 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 298 of file Trie.h.

References hitfit::char, alignCSCRings::e, diffTwoXMLs::label, AlCaHLTBitMon_ParallelJobs::p, and findQualityFiles::v.

                                                                                     {
    typedef TrieNode<T> const node_base;
    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::EDFilter::baseType(), edm::stream::EDAnalyzerBase::baseType(), edm::stream::EDFilterBase::baseType(), edm::stream::EDProducerBase::baseType(), edm::OutputModule::baseType(), and edm::InputSource::baseType().

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

void edm::loadCap

(

const std::string &

name

)

Definition at line 20 of file ClassFiller.cc.

References checkDictionaries(), dictionaryPlugInPrefix(), relativeConstraints::empty, FDEBUG, for_all(), edmplugin::PluginCapabilities::get(), edmplugin::PluginCapabilities::load(), combine::missing, and missingTypes().

Referenced by edm::StreamerInputSource::declareStreamers(), and loadExtraClasses().

                                      {
    FDEBUG(1) << "Loading dictionary for " << name << "\n";
    edmplugin::PluginCapabilities::get()->load(dictionaryPlugInPrefix() + name);
    checkDictionaries(name);
    if (!missingTypes().empty()) {
      StringSet missing = missingTypes();
      missingTypes().clear();
      for_all(missing, loadCap);
    }
  }

void edm::loadExtraClasses

(

)

Definition at line 43 of file ClassFiller.cc.

References run_regression::done, loadCap(), and AlCaHLTBitMon_QueryRunRegistry::string.

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

                          {
    static bool done = false;
    if (done == false) {
    loadCap(std::string("edm::StreamedProduct"));
    loadCap(std::string("std::vector<edm::StreamedProduct>"));
    loadCap(std::string("edm::SendEvent"));
    loadCap(std::string("std::vector<edm::BranchDescription>"));
    loadCap(std::string("edm::SendJobHeader"));
    }
    G__SetCatchException(0);
    ROOT::Cintex::Cintex::Enable();
    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 m.

Referenced by edm::ELseverityLevel::ELseverityLevel().

                            {
    
    static ELmap  m;
    
    
    m[ ELzeroSeverity.getSymbol()   ] = ELseverityLevel::ELsev_zeroSeverity
    , m[ ELzeroSeverity.getName()     ] = ELseverityLevel::ELsev_zeroSeverity
    , m[ ELzeroSeverity.getInputStr() ] = ELseverityLevel::ELsev_zeroSeverity
    , m[ ELzeroSeverity.getVarName()  ] = ELseverityLevel::ELsev_zeroSeverity
    ;
    
    m[ ELdebug.getSymbol()   ] = ELseverityLevel::ELsev_success
    , m[ ELdebug.getName()     ] = ELseverityLevel::ELsev_success
    , m[ ELdebug.getInputStr() ] = ELseverityLevel::ELsev_success
    , m[ ELdebug.getVarName()  ] = ELseverityLevel::ELsev_success
    ;
    
    m[ ELinfo.getSymbol()   ] = ELseverityLevel::ELsev_info
    , m[ ELinfo.getName()     ] = ELseverityLevel::ELsev_info
    , m[ ELinfo.getInputStr() ] = ELseverityLevel::ELsev_info
    , m[ ELinfo.getVarName()  ] = ELseverityLevel::ELsev_info
    ;
    
    m[ ELwarning.getSymbol()   ] = ELseverityLevel::ELsev_warning
    , m[ ELwarning.getName()     ] = ELseverityLevel::ELsev_warning
    , m[ ELwarning.getInputStr() ] = ELseverityLevel::ELsev_warning
    , m[ ELwarning.getVarName()  ] = ELseverityLevel::ELsev_warning
    ;
    
    m[ ELerror.getSymbol()   ] = ELseverityLevel::ELsev_error
    , m[ ELerror.getName()     ] = ELseverityLevel::ELsev_error
    , m[ ELerror.getInputStr() ] = ELseverityLevel::ELsev_error
    , m[ ELerror.getVarName()  ] = ELseverityLevel::ELsev_error
    ;
    
    m[ ELunspecified.getSymbol()   ] = ELseverityLevel::ELsev_unspecified
    , m[ ELunspecified.getName()     ] = ELseverityLevel::ELsev_unspecified
    , m[ ELunspecified.getInputStr() ] = ELseverityLevel::ELsev_unspecified
    , m[ ELunspecified.getVarName()  ] = ELseverityLevel::ELsev_unspecified
    ;
    
    m[ ELsevere.getSymbol()   ] = ELseverityLevel::ELsev_severe
    , m[ ELsevere.getName()     ] = ELseverityLevel::ELsev_severe
    , m[ ELsevere.getInputStr() ] = ELseverityLevel::ELsev_severe
    , m[ ELsevere.getVarName()  ] = ELseverityLevel::ELsev_severe
    ;
    
    m[ ELhighestSeverity.getSymbol()   ] = ELseverityLevel::ELsev_highestSeverity
    , m[ ELhighestSeverity.getName()     ] = ELseverityLevel::ELsev_highestSeverity
    , m[ ELhighestSeverity.getInputStr() ] = ELseverityLevel::ELsev_highestSeverity
    , m[ ELhighestSeverity.getVarName()  ] = ELseverityLevel::ELsev_highestSeverity
    ;
    
    return m;
    
  }

void edm::loadMissingDictionaries

(

)

Definition at line 223 of file DictionaryTools.cc.

References checkDictionaries(), relativeConstraints::empty, combine::missing, missingTypes(), and throwMissingDictionariesException().

Referenced by edm::WorkerManager::beginJob(), and endpathsAreActive_().

                                 {
    while (!missingTypes().empty()) {
      StringSet missing(missingTypes());
      for (StringSet::const_iterator it = missing.begin(), itEnd = missing.end();
         it != itEnd; ++it) {
        try {
          gROOT->GetClass(it->c_str(), kTRUE);
        }
        // We don't want to fail if we can't load a plug-in.
        catch(...) {}
      }
      missingTypes().clear();
      for (StringSet::const_iterator it = missing.begin(), itEnd = missing.end();
         it != itEnd; ++it) {
        checkDictionaries(*it);
      }
      if (missingTypes() == missing) {
        break;
      }
    }
    if (missingTypes().empty()) {
      return;
    }
    throwMissingDictionariesException();
  }

std::vector< ErrorSummaryEntry > edm::LoggedErrorsOnlySummary

(

unsigned int

iStreamID

)

Definition at line 203 of file MessageSender.cc.

References alignCSCRings::e, ELerror, end, errorSummaryMaps, i, combine::key, python.multivaluedict::sort(), and findQualityFiles::v.

                                                                               {    //  ChangeLog 2
    std::vector<ErrorSummaryEntry> v;
    assert(iStreamID < errorSummaryMaps.size());
    auto const& errorSummaryMap =errorSummaryMaps[iStreamID];
    auto end = errorSummaryMap.end();
    for (auto i = errorSummaryMap.begin();
         i != end; ++i) {
      auto const& key = i->first;
      if (key.severity >= edm::ELerror) {
        ErrorSummaryEntry e{key.category,key.module,key.severity};
        e.count = i->second.value().load(std::memory_order_acquire);
        v.push_back(e);
      }
    }
    std::sort(v.begin(),v.end());
    return v;
  }

std::vector< ErrorSummaryEntry > edm::LoggedErrorsSummary

(

unsigned int

iStreamID

)

Definition at line 175 of file MessageSender.cc.

References alignCSCRings::e, end, errorSummaryMaps, i, combine::key, python.multivaluedict::sort(), and findQualityFiles::v.

Referenced by HLTLogMonitorFilter::filter(), and edm::LogErrorHarvester::produce().

                                                                           {
    assert(iStreamID<errorSummaryMaps.size());
    auto const& errorSummaryMap =errorSummaryMaps[iStreamID];
    std::vector<ErrorSummaryEntry> v;
    auto end = errorSummaryMap.end();
    for (auto i = errorSummaryMap.begin();
         i != end; ++i) {
      auto const& key = i->first;
      ErrorSummaryEntry e{key.category,key.module,key.severity};

      e.count = i->second.value().load(std::memory_order_acquire);
      v.push_back(e);
    }
    std::sort(v.begin(),v.end());
    return v;
  }

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

                                  {
    if (tr != 0) {
      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.

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.

                                                      {
    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 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 AlCaHLTBitMon_ParallelJobs::p.

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

template<typename T >

std::shared_ptr<HandleExceptionFactory> edm::makeHandleExceptionFactory

(

T &&

iFunctor

)

Definition at line 48 of file FunctorHandleExceptionFactory.h.

Referenced by edm::Event::get(), edm::Principal::getByLabel(), fwlite::LuminosityBlockBase::getByLabelImpl(), fwlite::EventBase::getByLabelImpl(), fwlite::RunBase::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,
		ProductRegistry &	preg,
		boost::shared_ptr< BranchIDListHelper >	branchIDListHelper,
		boost::shared_ptr< ActivityRegistry >	areg,
		boost::shared_ptr< ProcessConfiguration const >	processConfiguration,
		PreallocationConfiguration const &	allocations
	)

Definition at line 97 of file EventProcessor.cc.

References cms::Exception::addContext(), edm::errors::Configuration, SurfaceDeformationFactory::create(), edm::hlt::Exception, edm::InputSourceFactory::get(), reco::get(), edm::ParameterSet::getParameter(), edm::ParameterSet::getPSetForUpdate(), edm::ModuleDescription::getUniqueID(), edm::ParameterSet::id(), input, edm::InputSourceFactory::makeInputSource(), edm::CommonParams::maxEventsInput_, edm::CommonParams::maxLumisInput_, 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 == 0) {
      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::auto_ptr<ParameterSetDescriptionFillerBase> filler(
      ParameterSetDescriptionFillerPluginFactory::get()->create(modtype));
    ConfigurationDescriptions descriptions(filler->baseType());
    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, areg, common.maxEventsInput_, common.maxLumisInput_, 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());
      });
    }
    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 61 of file Principal.cc.

References cppFunctionSkipper::exception, edm::hlt::Exception, PRODUCT_TYPE, and edm::errors::ProductNotFound.

Referenced by edm::Principal::getByLabel().

                                                                                                                                {
    std::shared_ptr<cms::Exception> exception(new 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,
		boost::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
	)

Definition at line 472 of file DetSetVector.h.

References cmsHarvester::index, edm::errors::InvalidReference, and edm::Exception::throwThis().

Referenced by makeRefToDetSetVector().

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

Ref< typename HandleT::element_type, typename HandleT::element_type::value_type::value_type> edm::makeRefToDetSetLazyVector	(	const HandleT &	iHandle,
		det_id_type	iDetID,
		typename HandleT::element_type::value_type::const_iterator	itIter
	)

Definition at line 284 of file DetSetLazyVector.h.

References cmsHarvester::index.

Referenced by makeRefToDetSetLazyVector().

                                                                          {
      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::makeRefToDetSetLazyVector	(	const HandleT &	iHandle,
		det_id_type	iDetID,
		typename HandleT::element_type::value_type::iterator	itIter
	)

Definition at line 296 of file DetSetLazyVector.h.

References makeRefToDetSetLazyVector().

                                                                    {
      typedef typename HandleT::element_type Vec;
      typename Vec::detset::const_iterator itIter2 = itIter;
      return makeRefToDetSetLazyVector(iHandle,iDetID,itIter2);
   }

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.

References cmsHarvester::index.

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
	)

Definition at line 494 of file DetSetVector.h.

References makeRefTo().

                                                                    {
    typedef typename HandleT::element_type Vec;
    typename Vec::detset::const_iterator itIter2 = itIter;
    return makeRefTo(iHandle,iDetID,itIter2);
  }

template<typename T >

Ref< LazyGetter<T>, T, FindValue<T> > edm::makeRefToLazyGetter	(	const Handle< LazyGetter< T > > &	handle,
		const uint32_t	index
	)

Definition at line 545 of file LazyGetter.h.

References patZpeak::handle, and cmsHarvester::index.

{return Ref< LazyGetter<T>, T, FindValue<T> >(handle,index);}

std::string edm::match	(	BranchDescription const &	a,
		BranchDescription const &	b,
		std::string const &	fileName
	)

Definition at line 309 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::eventsetup::EventSetupProvider::checkESProducerSharing(), edm::eventsetup::EventSetupProvider::doRecordsMatch(), edm::EventSelector::identical(), ConversionTools::matchedConversion(), ConversionTools::matchedPromptElectron(), edm::ProductRegistry::merge(), reco::modules::MCMatchCandRefSelector::newEvent(), edm::InputTagMatch::operator()(), HLTTauRefCombiner::produce(), and CosmicMuonLinksProducer::sharedHits().

                                   {
    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 136 of file LuminosityBlockID.h.

                                                                                         {
    return (rh < lh ? lh : rh);
  }

EventID const& edm::max ( EventID const &  lh, EventID const &  rh  )

inline

Definition at line 137 of file EventID.h.

Referenced by edm::helper::Filler< Association< C > >::add(), L1TEfficiencyPlotHandler::book(), DTLocalTriggerSynchTest::bookChambHistos(), DTTriggerEfficiencyTest::bookChambHistos(), TIBLayerBuilder::constructRings(), DTDigitizer::driftTimeFromParametrization(), DTRunConditionVarClient::endRun(), MuonPFAnalyzer::fillInRange(), merge(), DTLocalTriggerBaseTest::phiRange(), and DTTriggerLutTest::runClientDiagnostic().

                                                           {
    return (rh < lh ? lh : rh);
  }

const unsigned int edm::maxIDlength

(

200

)

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

static void edm::maybeThrowMissingDictionaryException ( TypeID const &  productType, bool  isElement, std::vector< std::string > const &  missingDictionaries  )

static

Definition at line 38 of file Principal.cc.

References binary_search_all(), checkDictionaries(), edm::TypeID::className(), throwMissingDictionariesException(), and wrappedClassName().

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

                                                                                                                                   {
    if(binary_search_all(missingDictionaries, productType.className())) {
      checkDictionaries(isElement ? productType.className() : wrappedClassName(productType.className()), false);
      throwMissingDictionariesException();
    }
  }

bool edm::merge	(	LuminosityBlockRange &	lh,
		LuminosityBlockRange &	rh
	)

Definition at line 78 of file LuminosityBlockRange.cc.

References begin, end, edm::LuminosityBlockRange::endLumiID(), max(), min(), overlaps(), and edm::LuminosityBlockRange::startLumiID().

Referenced by sortAndRemoveOverlaps().

                                                                 {
    if (overlaps(lh, rh)) {
      LuminosityBlockID begin = min(lh.startLumiID(), rh.startLumiID());
      LuminosityBlockID end = max(lh.endLumiID(), rh.endLumiID());
      rh = lh = LuminosityBlockRange(begin, end);
      return true;
    }
    return false;
  }

LuminosityBlockID const& edm::min ( LuminosityBlockID const &  lh, LuminosityBlockID const &  rh  )

inline

Definition at line 131 of file LuminosityBlockID.h.

                                                                                         {
    return (rh < lh ? rh : lh);
  }

EventID const& edm::min ( EventID const &  lh, EventID const &  rh  )

inline

Definition at line 132 of file EventID.h.

Referenced by L1TEfficiencyPlotHandler::book(), DTLocalTriggerSynchTest::bookChambHistos(), DTTriggerEfficiencyTest::bookChambHistos(), DTRunConditionVarClient::endRun(), DTLocalTriggerTest::fillGlobalSummary(), MuonPFAnalyzer::fillInRange(), merge(), DTLocalTriggerBaseTest::phiRange(), and edm::Lumi3DReWeighting::weight3D().

                                                           {
    return (rh < lh ? rh : lh);
  }

StringSet & edm::missingTypes

(

)

Definition at line 177 of file DictionaryTools.cc.

References missingTypes_.

Referenced by checkDictionaries(), loadCap(), loadMissingDictionaries(), and throwMissingDictionariesException().

                            {
    return missingTypes_;
  }

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 cms::ProducerAnalyzer::analyze(), HLTMonBitSummary::beginRun(), FourVectorHLTOnline::beginRun(), FourVectorHLTOffline::beginRun(), edm::DaqProvenanceHelper::DaqProvenanceHelper(), AlignableTracker::detsToAlignables(), SiPixelTrackerMap::drawModule(), edm::LHEProvenanceHelper::fillCommonProcessParameterSet(), egHLT::trigTools::getL1SeedFilterOfPath(), pos::PixelPortcardMap::getName(), 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");
  }

edm::moduleRegistry_

(

new

ModuleRegistry()

)

Referenced by endpathsAreActive_().

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

Definition at line 69 of file EDProductGetter.cc.

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

                                                                                                  {
    if (prodGetter != nullptr) return prodGetter;
        throw Exception(errors::InvalidReference, refType)
    << "Attempt to construct a " << refType << " with ProductID " << productID << "\n"
    << "but with a null pointer to a product getter.\n"
    << "The product getter pointer passed to the constructor must refer\n"
    << "to a real getter, such as an EventPrincipal.\n";
  }

static Principal::CacheIdentifier_t edm::nextIdentifier ( )

inlinestatic

Definition at line 121 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,
		std::string const &	trname
	)

Definition at line 50 of file CollUtil.cc.

References gather_cfg::cout, and MainPageGenerator::tree.

Referenced by format_vstring(), edm::RootFile::readEntryDescriptionTree(), edm::RootFile::readParentageTree(), and ProvenanceDumper::work_().

                                                           {
    TTree *tree = (TTree*)hdl->Get(trname.c_str());
    if (tree) {
      return tree->GetEntries();
    } else {
      std::cout << "ERR cannot find a TTree named \"" << trname << "\""
                << std::endl;
      return -1;
    }
  }

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

{return !(lh == rh);}

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

inline

Definition at line 47 of file RunLumiEntryInfo.h.

References b.

{ return !(a==b); }

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

inline

Definition at line 56 of file EventEntryInfo.h.

References b.

{ return !(a==b); }

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

inline

Definition at line 58 of file ProductID.h.

                                                            {
    return !(lh == rh);
  }

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

inline

Definition at line 60 of file EventEntryDescription.h.

References b.

{ return !(a==b); }

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

inline

Definition at line 63 of file TypeID.h.

References b.

                                                           {
    return !(a == b);
  }

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

inline

Definition at line 66 of file BranchKey.h.

References b.

                                                     {
    return !(a == b);
  }

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

inline

Definition at line 69 of file Parentage.h.

References b.

{ return !(a == b); }

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

inline

Definition at line 74 of file TypeIDBase.h.

References b.

   { return !(a==b); }

template<class X , class Y >

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

Definition at line 75 of file debugging_allocator.h.

{ return false; }

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

inline

Definition at line 80 of file ProcessConfiguration.h.

References b.

                                                                           {
    return !(a == b);
  }

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

inline

Definition at line 81 of file ProductProvenance.h.

References b.

{ return !(a == b); }

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

inline

Definition at line 104 of file RefCore.h.

                                                     {
    return !(lhs == rhs);
  }

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

inline

Definition at line 110 of file ProcessHistory.h.

References b.

                                                               {
    return !(a==b);
  }

template<typename KEY >

bool edm::operator!=	(	RefVectorBase< KEY > const &	lhs,
		RefVectorBase< KEY > const &	rhs
	)

Inequality operator.

Definition at line 112 of file RefVectorBase.h.

                                                                           {
    return !(lhs == rhs);
  }

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

template<typename T >

bool edm::operator!= ( View< T > const &  lhs, View< T > const &  rhs  )

inline

Definition at line 372 of file View.h.

                                                     {
    return !(lhs == rhs);
  }

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

inline

Definition at line 153 of file FileIndex.h.

References mathSSE::lh.

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

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

inline

Definition at line 176 of file ProductRegistry.h.

References b.

                                                                 {
    return !(a == b);
  }

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

inline

Definition at line 183 of file TypeWithDict.h.

References b.

                                                                       {
    return !(a == b);
  }

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

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

inline

Definition at line 205 of file Entry.h.

References b.

                                             {
    return !(a == b);
  }

template<typename T >

bool edm::operator!= ( RefToBaseProd< T > const &  lhs, RefToBaseProd< T > const &  rhs  )

inline

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

template<typename C >

bool edm::operator!= ( RefProd< C > const &  lhs, RefProd< C > const &  rhs  )

inline

Definition at line 226 of file RefProd.h.

                                                           {
    return !(lhs == rhs);
  }

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

                                                                           {
    return !(lhs == rhs);
  }

template<typename T , typename U >

bool edm::operator!= ( U const &  lhs, atomic_value_ptr< T > const &  rhs  )

inline

Definition at line 229 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 T , typename U >

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

inline

Definition at line 230 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 242 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 T >

bool edm::operator!= ( Ptr< T > const &  lhs, Ptr< T > const &  rhs  )

inline

Definition at line 248 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 291 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 298 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 305 of file FwdRef.h.

                                                                  {
    return !(lhs == rhs);
  }

bool edm::operator!= ( ParameterSet const &  a, ParameterSet const &  b  )

inline

Definition at line 329 of file ParameterSet.h.

References b.

                                                           {
    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 649 of file Ref.h.

                                                               {
    return !(lhs == rhs);
  }

std::auto_ptr< ParameterDescriptionNode > edm::operator&&	(	ParameterDescriptionNode const &	node_left,
		ParameterDescriptionNode const &	node_right
	)

Definition at line 193 of file ParameterDescriptionNode.cc.

                                                         {
    return std::auto_ptr<ParameterDescriptionNode>(new ANDGroupDescription(node_left, node_right));
  }

std::auto_ptr< ParameterDescriptionNode > edm::operator&&	(	std::auto_ptr< ParameterDescriptionNode >	node_left,
		ParameterDescriptionNode const &	node_right
	)

Definition at line 199 of file ParameterDescriptionNode.cc.

                                                         {
    return std::auto_ptr<ParameterDescriptionNode>(new ANDGroupDescription(node_left, node_right));
  }

std::auto_ptr< ParameterDescriptionNode > edm::operator&&	(	ParameterDescriptionNode const &	node_left,
		std::auto_ptr< ParameterDescriptionNode >	node_right
	)

Definition at line 205 of file ParameterDescriptionNode.cc.

                                                               {
    return std::auto_ptr<ParameterDescriptionNode>(new ANDGroupDescription(node_left, node_right));
  }

std::auto_ptr< ParameterDescriptionNode > edm::operator&&	(	std::auto_ptr< ParameterDescriptionNode >	node_left,
		std::auto_ptr< ParameterDescriptionNode >	node_right
	)

Definition at line 211 of file ParameterDescriptionNode.cc.

                                                               {
    return std::auto_ptr<ParameterDescriptionNode>(new ANDGroupDescription(node_left, node_right));
  }

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

Definition at line 2431 of file ParameterSet.cc.

References edm::ParameterSet::False, edm::ParameterSet::True, and edm::ParameterSet::Unknown.

                                                     {
    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 71 of file RefVectorIterator.h.

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

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

inline

Definition at line 68 of file ProductProvenance.h.

References edm::ProductProvenance::branchID().

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

template<class T >

bool edm::operator< ( DetSet< T > const &  x, DetSet< T > const &  y  )

inline

Definition at line 90 of file DetSet.h.

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

References x, and detailsBasic3DVector::y.

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

References x, and detailsBasic3DVector::y.

                                                {
    return x < y.detId();
  }

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

inline

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

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

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< ( View< T > const &  lhs, View< T > const &  rhs  )

inline

Definition at line 379 of file View.h.

                                                    {
    return std::lexicographical_compare(lhs.begin(), lhs.end(),
                                        rhs.begin(), rhs.end());
  }

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

inline

Definition at line 177 of file TypeWithDict.h.

References edm::TypeWithDict::typeInfo().

                                                                      {
    return a.typeInfo().before(b.typeInfo());
  }

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

template<typename T >

bool edm::operator< ( RefToBaseProd< T > const &  lhs, RefToBaseProd< T > const &  rhs  )

inline

Definition at line 215 of file RefToBaseProd.h.

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

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

Definition at line 267 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 C >

bool edm::operator< ( RefProd< C > const &  lhs, RefProd< C > const &  rhs  )

inline

Definition at line 233 of file RefProd.h.

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

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 255 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 314 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 321 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 328 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 656 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, 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 BranchTypeToString().

                                                           {
    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,
		FileFormatVersion const &	ff
	)

Definition at line 106 of file FileFormatVersion.cc.

References edm::FileFormatVersion::value().

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

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

inline

Definition at line 40 of file RunLumiEntryInfo.h.

References edm::RunLumiEntryInfo::write().

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

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

inline

Definition at line 49 of file EventEntryInfo.h.

References edm::EventEntryInfo::write().

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

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

Definition at line 81 of file ProductSelector.cc.

References edm::ProductSelector::print().

  {
    gs.print(os);
    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,
		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, EventEntryDescription const &  p  )

inline

Definition at line 53 of file EventEntryDescription.h.

References edm::EventEntryDescription::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, Parentage const &  p  )

inline

Definition at line 62 of file Parentage.h.

References edm::Parentage::write().

                                                 {
    p.write(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 &	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 &	os,
		ParentContext const &	pc
	)

Definition at line 89 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,
		GlobalContext const &	gc
	)

Definition at line 22 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::GlobalContext::luminosityBlockIndex(), edm::Timestamp::microsecondOffset(), edm::GlobalContext::processContext(), edm::GlobalContext::runIndex(), edm::GlobalContext::timestamp(), edm::GlobalContext::transition(), edm::Timestamp::unixTime(), edm::RunIndex::value(), and edm::LuminosityBlockIndex::value().

                                                                  {
    os << "GlobalContext: transition = ";
    switch (gc.transition()) {
    case GlobalContext::Transition::kBeginJob:
      os << "BeginJob";
      break;
    case GlobalContext::Transition::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 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,
		TypeID const &	id
	)

Definition at line 131 of file TypeID.cc.

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

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

inline

Definition at line 70 of file LuminosityBlockAuxiliary.h.

References edm::LuminosityBlockAuxiliary::write().

                                                                {
    p.write(os);
    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 &  os, ProductProvenance const &  p  )

inline

Definition at line 74 of file ProductProvenance.h.

References edm::ProductProvenance::write().

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

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

Definition at line 220 of file InputTag.cc.

References edm::InputTag::instance(), edm::InputTag::label(), LaserDQM_cfg::process, 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,
		StreamContext const &	sc
	)

Definition at line 35 of file StreamContext.cc.

References edm::StreamContext::eventID(), edm::StreamContext::kBeginLuminosityBlock, edm::StreamContext::kBeginRun, edm::StreamContext::kBeginStream, edm::StreamContext::kEndLuminosityBlock, edm::StreamContext::kEndRun, edm::StreamContext::kEndStream, edm::StreamContext::kEvent, edm::StreamContext::kInvalid, edm::StreamContext::luminosityBlockIndex(), edm::Timestamp::microsecondOffset(), edm::StreamContext::processContext(), edm::StreamContext::runIndex(), edm::StreamContext::streamID(), edm::StreamContext::timestamp(), edm::StreamContext::transition(), edm::Timestamp::unixTime(), edm::RunIndex::value(), and edm::LuminosityBlockIndex::value().

                                                                  {
    os << "StreamContext: StreamID = " << sc.streamID()
       << " transition = ";
    switch (sc.transition()) {
    case StreamContext::Transition::kBeginStream:
      os << "BeginStream";
      break;
    case StreamContext::Transition::kBeginRun:
      os << "BeginRun";
      break;
    case StreamContext::Transition::kBeginLuminosityBlock:
      os << "BeginLuminosityBlock";
      break;
    case StreamContext::Transition::kEvent:
      os << "Event";
      break;
    case StreamContext::Transition::kEndLuminosityBlock:
      os << "EndLuminosityBlock";
      break;
    case StreamContext::Transition::kEndRun:
      os << "EndRun";
      break;
    case StreamContext::Transition::kEndStream:
      os << "EndStream";
      break;
    case StreamContext::Transition::kInvalid:
      os << "Invalid";
      break;
    }
    os << "\n    " << sc.eventID()
       << "\n    runIndex = " << sc.runIndex().value()
       << "  luminosityBlockIndex = " << sc.luminosityBlockIndex().value()
       << "  unixTime = " << sc.timestamp().unixTime()
       << " microsecondOffset = " << sc.timestamp().microsecondOffset() <<"\n";
    if(sc.processContext()) {
      os << "    " << *sc.processContext(); 
    }
    return os;
  }

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

inline

Definition at line 102 of file ModuleDescription.h.

References edm::ModuleDescription::write().

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

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

inline

Definition at line 105 of file Provenance.h.

References edm::Provenance::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 i, n, edm::HLTGlobalStatus::size(), edm::HLTGlobalStatus::state(), and runonSM::text.

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

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

Definition at line 120 of file JobReport.cc.

References print().

                                                                       {
    return print(os,f);
  }

template<class T >

ErrorObj& edm::operator<< ( ErrorObj &  e, const T &  t  )

inline

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

Definition at line 288 of file ErrorObj.cc.

References edm::ErrorObj::opltlt().

                                                      {
  return e.opltlt(s);
}

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

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 142 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,
		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, ProductRegistry const &  pr  )

inline

Definition at line 182 of file ProductRegistry.h.

References edm::ProductRegistry::print().

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

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

Definition at line 534 of file TypeWithDict.cc.

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

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

inline

Definition at line 206 of file ProductHolder.h.

References edm::ProductHolderBase::write().

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

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

inline

Definition at line 214 of file BranchDescription.h.

References edm::BranchDescription::write().

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

template<typename PROD >

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

inline

Definition at line 238 of file PrincipalGetAdapter.h.

References h.

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

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

Definition at line 244 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 245 of file Hash.h.

References h.

                                               {
    return h.print(os);
  }

template<typename C , typename T , typename F >

std::ostream& edm::operator<<	(	std::ostream &	os,
		RefVector< C, T, F > const &	r
	)

Definition at line 255 of file RefVector.h.

References alignCSCRings::e, 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 114 of file JobReport.cc.

References print().

                                                                       {
    return print(os,f);
  }

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

Definition at line 117 of file JobReport.cc.

References print().

                                                                        {
    return print(os,f);
  }

std::ostream& edm::operator<<	(	std::ostream &	os,
		ParameterSet const &	pset
	)

Definition at line 946 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 alignCSCRings::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(), i, edm::Entry::isTracked(), kTVESInputTag, edm::Entry::rep, dqm_diff::start, AlCaHLTBitMon_QueryRunRegistry::string, sTypeTranslations, edm::pset::TypeTrans::table_, o2o::tags, 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.size()) {
           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.

{return !(rh < lh);}

template<typename T >

bool edm::operator<= ( View< T > const &  lhs, View< T > const &  rhs  )

inline

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

{return lh.fid() == rh.fid();}

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

Definition at line 38 of file Parentage.cc.

References edm::Parentage::parents().

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

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

Definition at line 72 of file debugging_allocator.h.

{ return true; }

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

Definition at line 85 of file ProductProvenance.cc.

References edm::ProductProvenance::branchID(), edm::ProductProvenance::noParentage(), and edm::ProductProvenance::parentageID().

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

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== ( RefCore const &  lhs, RefCore const &  rhs  )

inline

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

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

inline

Definition at line 104 of file ProcessHistory.h.

References edm::ProcessHistory::data().

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

template<typename KEY >

bool edm::operator==	(	RefVectorBase< KEY > const &	lhs,
		RefVectorBase< KEY > const &	rhs
	)

Equality operator.

Definition at line 105 of file RefVectorBase.h.

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

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

Definition at line 67 of file Provenance.cc.

References edm::Provenance::product().

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

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== ( FileIndex::Element const &  lh, FileIndex::Element const &  rh  )

inline

Definition at line 150 of file FileIndex.h.

References mathSSE::lh.

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

template<typename T >

bool edm::operator== ( View< T > const &  lhs, View< T > const &  rhs  )

inline

Definition at line 363 of file View.h.

References cond::serialization::equal().

                                                     {
    return
      lhs.size() == rhs.size() &&
      std::equal(lhs.begin(), lhs.end(), rhs.begin());
  }

bool edm::operator== ( edm::FileInPath const &  a, edm::FileInPath const &  b  )

inline

Definition at line 156 of file FileInPath.h.

References edm::FileInPath::location(), and edm::FileInPath::relativePath().

  {
    return a.location() == b.location() && a.relativePath() == b.relativePath();      
  }

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

inline

Definition at line 170 of file ProductRegistry.h.

References edm::ProductRegistry::productList().

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

bool edm::operator==	(	TypeWithDict const &	a,
		TypeWithDict const &	b
	)

Definition at line 529 of file TypeWithDict.cc.

References edm::TypeWithDict::typeInfo().

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

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

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

template<typename T >

bool edm::operator== ( RefToBaseProd< T > const &  lhs, RefToBaseProd< T > const &  rhs  )

inline

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

template<typename C >

bool edm::operator== ( RefProd< C > const &  lhs, RefProd< C > const &  rhs  )

inline

Definition at line 219 of file RefProd.h.

References edm::RefProd< T >::refCore().

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

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

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

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

Definition at line 302 of file BranchDescription.cc.

References edm::BranchDescription::branchAliases(), combinable(), and edm::BranchDescription::dropped().

                                                                     {
    return combinable(a, b) &&
       (a.dropped() == b.dropped()) &&
       (a.branchAliases() == b.branchAliases());
  }

template<typename T , typename U >

bool edm::operator== ( U const &  lhs, atomic_value_ptr< T > const &  rhs  )

inline

Definition at line 223 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 T , typename U >

bool edm::operator== ( value_ptr< T > const &  lhs, U const &  rhs  )

inline

Definition at line 224 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 236 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 T >

bool edm::operator== ( Ptr< T > const &  lhs, Ptr< T > const &  rhs  )

inline

Definition at line 241 of file Ptr.h.

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

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 255 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 267 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 279 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 )
    ;
  }

bool edm::operator==	(	ParameterSet const &	a,
		ParameterSet const &	b
	)

Definition at line 859 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 cond::serialization::equal().

                                               {
    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 cond::serialization::equal().

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

   { return b<a; }

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

inline

Definition at line 141 of file FileIndex.h.

References mathSSE::lh.

{return rh < lh;}

template<typename T >

bool edm::operator> ( View< T > const &  lhs, View< T > const &  rhs  )

inline

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

{return !(lh < rh);}

template<typename T >

bool edm::operator>= ( View< T > const &  lhs, View< T > const &  rhs  )

inline

Definition at line 399 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 149 of file FileInPath.h.

References edm::FileInPath::read().

  {
    fip.read(is);
    return is;
  }

std::auto_ptr< ParameterDescriptionCases< bool > > edm::operator>>	(	bool	caseValue,
		ParameterDescriptionNode const &	node
	)

Definition at line 134 of file ParameterDescriptionNode.cc.

References edm::ParameterDescriptionNode::clone().

                                                   {
    std::auto_ptr<ParameterDescriptionNode> clonedNode(node.clone());
    return caseValue >> clonedNode;
  }

std::auto_ptr< ParameterDescriptionCases< int > > edm::operator>>	(	int	caseValue,
		ParameterDescriptionNode const &	node
	)

Definition at line 141 of file ParameterDescriptionNode.cc.

References edm::ParameterDescriptionNode::clone().

                                                   {
    std::auto_ptr<ParameterDescriptionNode> clonedNode(node.clone());
    return caseValue >> clonedNode;
  }

std::auto_ptr< ParameterDescriptionCases< std::string > > edm::operator>>	(	std::string const &	caseValue,
		ParameterDescriptionNode const &	node
	)

Definition at line 148 of file ParameterDescriptionNode.cc.

References edm::ParameterDescriptionNode::clone().

                                                   {
    std::auto_ptr<ParameterDescriptionNode> clonedNode(node.clone());
    return caseValue >> clonedNode;
  }

std::auto_ptr< ParameterDescriptionCases< std::string > > edm::operator>>	(	char const *	caseValue,
		ParameterDescriptionNode const &	node
	)

Definition at line 155 of file ParameterDescriptionNode.cc.

References edm::ParameterDescriptionNode::clone().

                                                   {
    std::auto_ptr<ParameterDescriptionNode> clonedNode(node.clone());
    return caseValue >> clonedNode;
  }

std::auto_ptr< ParameterDescriptionCases< bool > > edm::operator>>	(	bool	caseValue,
		std::auto_ptr< ParameterDescriptionNode >	node
	)

Definition at line 162 of file ParameterDescriptionNode.cc.

References python.Node::node.

                                                         {
    return std::auto_ptr<ParameterDescriptionCases<bool> >(
      new ParameterDescriptionCases<bool>(caseValue, node));
  }

std::auto_ptr< ParameterDescriptionCases< int > > edm::operator>>	(	int	caseValue,
		std::auto_ptr< ParameterDescriptionNode >	node
	)

Definition at line 169 of file ParameterDescriptionNode.cc.

References python.Node::node.

                                                         {
    return std::auto_ptr<ParameterDescriptionCases<int> >(
      new ParameterDescriptionCases<int>(caseValue, node));
  }

std::auto_ptr< ParameterDescriptionCases< std::string > > edm::operator>>	(	std::string const &	caseValue,
		std::auto_ptr< ParameterDescriptionNode >	node
	)

Definition at line 176 of file ParameterDescriptionNode.cc.

References python.Node::node.

                                                         {
    return std::auto_ptr<ParameterDescriptionCases<std::string> >(
      new ParameterDescriptionCases<std::string>(caseValue, node));
  }

std::auto_ptr< ParameterDescriptionCases< std::string > > edm::operator>>	(	char const *	caseValue,
		std::auto_ptr< ParameterDescriptionNode >	node
	)

Definition at line 183 of file ParameterDescriptionNode.cc.

References python.Node::node, and AlCaHLTBitMon_QueryRunRegistry::string.

                                                         {
    std::string caseValueString(caseValue);
    return std::auto_ptr<ParameterDescriptionCases<std::string> >(
      new ParameterDescriptionCases<std::string>(caseValue, node));
  }

std::auto_ptr< ParameterDescriptionNode > edm::operator^	(	ParameterDescriptionNode const &	node_left,
		ParameterDescriptionNode const &	node_right
	)

Definition at line 245 of file ParameterDescriptionNode.cc.

                                                        {
    return std::auto_ptr<ParameterDescriptionNode>(new XORGroupDescription(node_left, node_right));
  }

std::auto_ptr< ParameterDescriptionNode > edm::operator^	(	std::auto_ptr< ParameterDescriptionNode >	node_left,
		ParameterDescriptionNode const &	node_right
	)

Definition at line 251 of file ParameterDescriptionNode.cc.

                                                        {
    return std::auto_ptr<ParameterDescriptionNode>(new XORGroupDescription(node_left, node_right));
  }

std::auto_ptr< ParameterDescriptionNode > edm::operator^	(	ParameterDescriptionNode const &	node_left,
		std::auto_ptr< ParameterDescriptionNode >	node_right
	)

Definition at line 257 of file ParameterDescriptionNode.cc.

                                                              {
    return std::auto_ptr<ParameterDescriptionNode>(new XORGroupDescription(node_left, node_right));
  }

std::auto_ptr< ParameterDescriptionNode > edm::operator^	(	std::auto_ptr< ParameterDescriptionNode >	node_left,
		std::auto_ptr< ParameterDescriptionNode >	node_right
	)

Definition at line 263 of file ParameterDescriptionNode.cc.

                                                              {
    return std::auto_ptr<ParameterDescriptionNode>(new XORGroupDescription(node_left, node_right));
  }

std::auto_ptr< ParameterDescriptionCases< bool > > edm::operator||	(	std::auto_ptr< ParameterDescriptionCases< bool > >	left,
		std::auto_ptr< ParameterDescriptionCases< bool > >	right
	)

Definition at line 8 of file ParameterDescriptionCases.cc.

References getDQMSummary::iter, python.multivaluedict::map(), and python.Node::node.

                                                                  {

    std::auto_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::auto_ptr<ParameterDescriptionNode> node(iter->second->clone());
      left->insert(caseValue, node);
    }
    return left;
  }

std::auto_ptr< ParameterDescriptionCases< int > > edm::operator||	(	std::auto_ptr< ParameterDescriptionCases< int > >	left,
		std::auto_ptr< ParameterDescriptionCases< int > >	right
	)

Definition at line 23 of file ParameterDescriptionCases.cc.

References getDQMSummary::iter, python.multivaluedict::map(), and python.Node::node.

                                                                 {

    std::auto_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::auto_ptr<ParameterDescriptionNode> node(iter->second->clone());
      left->insert(caseValue, node);
    }
    return left;
  }

std::auto_ptr< ParameterDescriptionCases< std::string > > edm::operator||	(	std::auto_ptr< ParameterDescriptionCases< std::string > >	left,
		std::auto_ptr< ParameterDescriptionCases< std::string > >	right
	)

Definition at line 38 of file ParameterDescriptionCases.cc.

References getDQMSummary::iter, python.multivaluedict::map(), python.Node::node, and AlCaHLTBitMon_QueryRunRegistry::string.

                                                                       {

    std::auto_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::auto_ptr<ParameterDescriptionNode> node(iter->second->clone());
      left->insert(caseValue, node);
    }
    return left;
  }

std::auto_ptr< ParameterDescriptionNode > edm::operator||	(	ParameterDescriptionNode const &	node_left,
		ParameterDescriptionNode const &	node_right
	)

Definition at line 219 of file ParameterDescriptionNode.cc.

                                                         {
    return std::auto_ptr<ParameterDescriptionNode>(new ORGroupDescription(node_left, node_right));
  }

std::auto_ptr< ParameterDescriptionNode > edm::operator||	(	std::auto_ptr< ParameterDescriptionNode >	node_left,
		ParameterDescriptionNode const &	node_right
	)

Definition at line 225 of file ParameterDescriptionNode.cc.

                                                         {
    return std::auto_ptr<ParameterDescriptionNode>(new ORGroupDescription(node_left, node_right));
  }

std::auto_ptr< ParameterDescriptionNode > edm::operator||	(	ParameterDescriptionNode const &	node_left,
		std::auto_ptr< ParameterDescriptionNode >	node_right
	)

Definition at line 231 of file ParameterDescriptionNode.cc.

                                                               {
    return std::auto_ptr<ParameterDescriptionNode>(new ORGroupDescription(node_left, node_right));
  }

std::auto_ptr< ParameterDescriptionNode > edm::operator||	(	std::auto_ptr< ParameterDescriptionNode >	node_left,
		std::auto_ptr< ParameterDescriptionNode >	node_right
	)

Definition at line 237 of file ParameterDescriptionNode.cc.

                                                               {
    return std::auto_ptr<ParameterDescriptionNode>(new ORGroupDescription(node_left, 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 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 ClusterAnalyzer::analyze(), HLTInfo::analyze(), GsfElectronProducer::beginEvent(), GsfElectronBaseProducer::beginEvent(), edm::EventProcessor::EventProcessor(), EcalSelectiveReadoutProducer::getBinOfMax(), edm::EventProcessor::init(), moduleName(), PFCandidateDQMAnalyzer::PFCandidateDQMAnalyzer(), PFJetDQMAnalyzer::PFJetDQMAnalyzer(), PFMETDQMAnalyzer::PFMETDQMAnalyzer(), SiPixelHistoricInfoDQMClient::SiPixelHistoricInfoDQMClient(), and SiPixelHistoricInfoEDAClient::SiPixelHistoricInfoEDAClient().

                                                                 {
    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

template<>

std::string edm::ParameterSet::getParameter< std::string >

(

char const *

name

)

const

template<>

std::vector<double> edm::ParameterSet::getParameter< std::vector< double > >

(

std::string const &

name

)

const

template<>

std::vector<double> edm::ParameterSet::getParameter< std::vector< double > >

(

char const *

name

)

const

template<>

std::vector<ESInputTag> edm::ParameterSet::getParameter< std::vector< ESInputTag > >

(

std::string const &

name

)

const

template<>

std::vector<ESInputTag> edm::ParameterSet::getParameter< std::vector< ESInputTag > >

(

char const *

name

)

const

Definition at line 1752 of file ParameterSet.cc.

References mergeVDriftHistosByStation::name.

                                                                            {
      return retrieve(name).getVESInputTag();
   }

template<>

std::vector<EventID> edm::ParameterSet::getParameter< std::vector< EventID > >

(

std::string const &

name

)

const

template<>

std::vector<EventID> edm::ParameterSet::getParameter< std::vector< EventID > >

(

char const *

name

)

const

template<>

std::vector<EventRange> edm::ParameterSet::getParameter< std::vector< EventRange > >

(

std::string const &

name

)

const

template<>

std::vector<EventRange> edm::ParameterSet::getParameter< std::vector< EventRange > >

(

char const *

name

)

const

template<>

std::vector<InputTag> edm::ParameterSet::getParameter< std::vector< InputTag > >

(

std::string const &

name

)

const

template<>

std::vector<InputTag> edm::ParameterSet::getParameter< std::vector< InputTag > >

(

char const *

name

)

const

template<>

std::vector<int> edm::ParameterSet::getParameter< std::vector< int > >

(

std::string const &

name

)

const

template<>

std::vector<int> edm::ParameterSet::getParameter< std::vector< int > >

(

char const *

name

)

const

template<>

std::vector<long long> edm::ParameterSet::getParameter< std::vector< long long > >

(

std::string const &

name

)

const

template<>

std::vector<long long> edm::ParameterSet::getParameter< std::vector< long long > >

(

char const *

name

)

const

template<>

std::vector<LuminosityBlockID> edm::ParameterSet::getParameter< std::vector< LuminosityBlockID > >

(

std::string const &

name

)

const

template<>

std::vector<LuminosityBlockID> edm::ParameterSet::getParameter< std::vector< LuminosityBlockID > >

(

char const *

name

)

const

template<>

std::vector<LuminosityBlockRange> edm::ParameterSet::getParameter< std::vector< LuminosityBlockRange > >

(

std::string const &

name

)

const

template<>

std::vector<LuminosityBlockRange> edm::ParameterSet::getParameter< std::vector< LuminosityBlockRange > >

(

char const *

name

)

const

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 alignCSCRings::e, edm::pdtentry::getPdtEntryVector(), and mergeVDriftHistosByStation::name.

                                                                                                         {
    Entry const& e = retrieve(name);
    return pdtentry::getPdtEntryVector(e, name.c_str());
  }

template<>

std::vector<PdtEntry> edm::ParameterSet::getParameter< std::vector< PdtEntry > > ( char const *  name ) const

inline

Definition at line 110 of file PdtEntry.h.

References alignCSCRings::e, edm::pdtentry::getPdtEntryVector(), and mergeVDriftHistosByStation::name.

                                                                                                    {
    Entry const& e = retrieve(name);
    return pdtentry::getPdtEntryVector(e, name);
  }

template<>

std::vector<std::string> edm::ParameterSet::getParameter< std::vector< std::string > >

(

std::string const &

name

)

const

template<>

std::vector<std::string> edm::ParameterSet::getParameter< std::vector< std::string > >

(

char const *

name

)

const

template<>

std::vector<unsigned int> edm::ParameterSet::getParameter< std::vector< unsigned int > >

(

std::string const &

name

)

const

template<>

std::vector<unsigned int> edm::ParameterSet::getParameter< std::vector< unsigned int > >

(

char const *

name

)

const

template<>

std::vector<unsigned long long> edm::ParameterSet::getParameter< std::vector< unsigned long long > >

(

std::string const &

name

)

const

template<>

std::vector<unsigned long long> edm::ParameterSet::getParameter< std::vector< unsigned long long > >

(

char const *

name

)

const

template<>

std::vector<std::string> edm::ParameterSet::getParameterNamesForType< std::vector< PdtEntry > > ( bool  trackiness ) const

inline

Definition at line 138 of file PdtEntry.h.

References filterCSVwithJSON::copy.

                                                                                                                {
    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

template<>

std::string edm::ParameterSet::getUntrackedParameter< std::string >

(

std::string const &

name

)

const

template<>

std::string edm::ParameterSet::getUntrackedParameter< std::string >	(	char const *	name,
		std::string const &	defaultValue
	)		const

template<>

std::string edm::ParameterSet::getUntrackedParameter< std::string >

(

char const *

name

)

const

template<>

std::vector<double> edm::ParameterSet::getUntrackedParameter< std::vector< double > >

(

std::string const &

name

)

const

template<>

std::vector<double> edm::ParameterSet::getUntrackedParameter< std::vector< double > >	(	std::string const &	name,
		std::vector< double > const &	defaultValue
	)		const

template<>

std::vector<double> edm::ParameterSet::getUntrackedParameter< std::vector< double > >

(

char const *

name

)

const

template<>

std::vector<double> edm::ParameterSet::getUntrackedParameter< std::vector< double > >	(	char const *	name,
		std::vector< double > const &	defaultValue
	)		const

template<>

std::vector<ESInputTag> edm::ParameterSet::getUntrackedParameter< std::vector< ESInputTag > >	(	std::string const &	name,
		std::vector< ESInputTag > const &	defaultValue
	)		const

Definition at line 1469 of file ParameterSet.cc.

References edm::Entry::getVESInputTag(), and mergeVDriftHistosByStation::name.

                                                                                                                {
      Entry const* entryPtr = retrieveUntracked(name);
      return entryPtr == 0 ? defaultValue : entryPtr->getVESInputTag();
   }

template<>

std::vector<ESInputTag> edm::ParameterSet::getUntrackedParameter< std::vector< ESInputTag > >

(

std::string const &

name

)

const

Definition at line 1477 of file ParameterSet.cc.

References mergeVDriftHistosByStation::name.

                                                                                          {
      return getEntryPointerOrThrow_(name)->getVESInputTag();
   }

template<>

std::vector<ESInputTag> edm::ParameterSet::getUntrackedParameter< std::vector< ESInputTag > >	(	char const *	name,
		std::vector< ESInputTag > const &	defaultValue
	)		const

Definition at line 2099 of file ParameterSet.cc.

References edm::Entry::getVESInputTag(), and mergeVDriftHistosByStation::name.

                                                                                                                {
      Entry const* entryPtr = retrieveUntracked(name);
      return entryPtr == 0 ? defaultValue : entryPtr->getVESInputTag();
   }

template<>

std::vector<ESInputTag> edm::ParameterSet::getUntrackedParameter< std::vector< ESInputTag > >

(

char const *

name

)

const

Definition at line 2107 of file ParameterSet.cc.

References mergeVDriftHistosByStation::name.

                                                                                     {
      return getEntryPointerOrThrow_(name)->getVESInputTag();
   }

template<>

std::vector<EventID> edm::ParameterSet::getUntrackedParameter< std::vector< EventID > >	(	std::string const &	name,
		std::vector< EventID > const &	defaultValue
	)		const

template<>

std::vector<EventID> edm::ParameterSet::getUntrackedParameter< std::vector< EventID > >

(

std::string const &

name

)

const

template<>

std::vector<EventID> edm::ParameterSet::getUntrackedParameter< std::vector< EventID > >

(

char const *

name

)

const

template<>

std::vector<EventID> edm::ParameterSet::getUntrackedParameter< std::vector< EventID > >	(	char const *	name,
		std::vector< EventID > const &	defaultValue
	)		const

template<>

std::vector<EventRange> edm::ParameterSet::getUntrackedParameter< std::vector< EventRange > >

(

std::string const &

name

)

const

template<>

std::vector<EventRange> edm::ParameterSet::getUntrackedParameter< std::vector< EventRange > >	(	std::string const &	name,
		std::vector< EventRange > const &	defaultValue
	)		const

template<>

std::vector<EventRange> edm::ParameterSet::getUntrackedParameter< std::vector< EventRange > >

(

char const *

name

)

const

template<>

std::vector<EventRange> edm::ParameterSet::getUntrackedParameter< std::vector< EventRange > >	(	char const *	name,
		std::vector< EventRange > const &	defaultValue
	)		const

template<>

std::vector<InputTag> edm::ParameterSet::getUntrackedParameter< std::vector< InputTag > >

(

std::string const &

name

)

const

template<>

std::vector<InputTag> edm::ParameterSet::getUntrackedParameter< std::vector< InputTag > >	(	std::string const &	name,
		std::vector< InputTag > const &	defaultValue
	)		const

template<>

std::vector<InputTag> edm::ParameterSet::getUntrackedParameter< std::vector< InputTag > >

(

char const *

name

)

const

template<>

std::vector<InputTag> edm::ParameterSet::getUntrackedParameter< std::vector< InputTag > >	(	char const *	name,
		std::vector< InputTag > const &	defaultValue
	)		const

template<>

std::vector<int> edm::ParameterSet::getUntrackedParameter< std::vector< int > >

(

std::string const &

name

)

const

template<>

std::vector<int> edm::ParameterSet::getUntrackedParameter< std::vector< int > >	(	std::string const &	name,
		std::vector< int > const &	defaultValue
	)		const

template<>

std::vector<int> edm::ParameterSet::getUntrackedParameter< std::vector< int > >	(	char const *	name,
		std::vector< int > const &	defaultValue
	)		const

template<>

std::vector<int> edm::ParameterSet::getUntrackedParameter< std::vector< int > >

(

char const *

name

)

const

template<>

std::vector<long long> edm::ParameterSet::getUntrackedParameter< std::vector< long long > >

(

std::string const &

name

)

const

template<>

std::vector<long long> edm::ParameterSet::getUntrackedParameter< std::vector< long long > >	(	std::string const &	name,
		std::vector< long long > const &	defaultValue
	)		const

template<>

std::vector<long long> edm::ParameterSet::getUntrackedParameter< std::vector< long long > >

(

char const *

name

)

const

template<>

std::vector<long long> edm::ParameterSet::getUntrackedParameter< std::vector< long long > >	(	char const *	name,
		std::vector< long long > const &	defaultValue
	)		const

template<>

std::vector<LuminosityBlockID> edm::ParameterSet::getUntrackedParameter< std::vector< LuminosityBlockID > >

(

std::string const &

name

)

const

template<>

std::vector<LuminosityBlockID> edm::ParameterSet::getUntrackedParameter< std::vector< LuminosityBlockID > >	(	std::string const &	name,
		std::vector< LuminosityBlockID > const &	defaultValue
	)		const

template<>

std::vector<LuminosityBlockID> edm::ParameterSet::getUntrackedParameter< std::vector< LuminosityBlockID > >

(

char const *

name

)

const

template<>

std::vector<LuminosityBlockID> edm::ParameterSet::getUntrackedParameter< std::vector< LuminosityBlockID > >	(	char const *	name,
		std::vector< LuminosityBlockID > const &	defaultValue
	)		const

template<>

std::vector<LuminosityBlockRange> edm::ParameterSet::getUntrackedParameter< std::vector< LuminosityBlockRange > >	(	std::string const &	name,
		std::vector< LuminosityBlockRange > const &	defaultValue
	)		const

template<>

std::vector<LuminosityBlockRange> edm::ParameterSet::getUntrackedParameter< std::vector< LuminosityBlockRange > >

(

std::string const &

name

)

const

template<>

std::vector<LuminosityBlockRange> edm::ParameterSet::getUntrackedParameter< std::vector< LuminosityBlockRange > >

(

char const *

name

)

const

template<>

std::vector<LuminosityBlockRange> edm::ParameterSet::getUntrackedParameter< std::vector< LuminosityBlockRange > >	(	char const *	name,
		std::vector< LuminosityBlockRange > const &	defaultValue
	)		const

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 alignCSCRings::e, edm::pdtentry::getPdtEntryVector(), and mergeVDriftHistosByStation::name.

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

inline

Definition at line 122 of file PdtEntry.h.

References alignCSCRings::e, edm::pdtentry::getPdtEntryVector(), and mergeVDriftHistosByStation::name.

                                                                                  {
    Entry const* e = retrieveUntracked(name);
    if (e == 0) return defaultValue;
    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 alignCSCRings::e, edm::pdtentry::getPdtEntryVector(), and mergeVDriftHistosByStation::name.

                                                                                  {
    Entry const* e = retrieveUntracked(name);
    if (e == 0) return defaultValue;
    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 alignCSCRings::e, edm::pdtentry::getPdtEntryVector(), and mergeVDriftHistosByStation::name.

                                                                                                             {
    Entry const* e = getEntryPointerOrThrow_(name);
    return pdtentry::getPdtEntryVector(*e, name);
  }

template<>

std::vector<std::string> edm::ParameterSet::getUntrackedParameter< std::vector< std::string > >

(

std::string const &

name

)

const

template<>

std::vector<std::string> edm::ParameterSet::getUntrackedParameter< std::vector< std::string > >	(	std::string const &	name,
		std::vector< std::string > const &	defaultValue
	)		const

template<>

std::vector<std::string> edm::ParameterSet::getUntrackedParameter< std::vector< std::string > >

(

char const *

name

)

const

template<>

std::vector<std::string> edm::ParameterSet::getUntrackedParameter< std::vector< std::string > >	(	char const *	name,
		std::vector< std::string > const &	defaultValue
	)		const

template<>

std::vector<unsigned int> edm::ParameterSet::getUntrackedParameter< std::vector< unsigned int > >	(	std::string const &	name,
		std::vector< unsigned int > const &	defaultValue
	)		const

template<>

std::vector<unsigned int> edm::ParameterSet::getUntrackedParameter< std::vector< unsigned int > >

(

std::string const &

name

)

const

template<>

std::vector<unsigned int> edm::ParameterSet::getUntrackedParameter< std::vector< unsigned int > >	(	char const *	name,
		std::vector< unsigned int > const &	defaultValue
	)		const

template<>

std::vector<unsigned int> edm::ParameterSet::getUntrackedParameter< std::vector< unsigned int > >

(

char const *

name

)

const

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

template<>

std::vector<unsigned long long> edm::ParameterSet::getUntrackedParameter< std::vector< unsigned long long > >

(

std::string const &

name

)

const

template<>

std::vector<unsigned long long> edm::ParameterSet::getUntrackedParameter< std::vector< unsigned long long > >

(

char const *

name

)

const

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

std::string edm::parameterTypeEnumToString

(

ParameterTypes

iType

)

Definition at line 55 of file ParameterDescriptionNode.cc.

References TYPE_TO_NAME.

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.

std::auto_ptr< ParameterSet > edm::popSubProcessParameterSet

(

ParameterSet &

parameterSet

)

Definition at line 550 of file SubProcess.cc.

References edm::ParameterSet::getUntrackedParameter(), and edm::ParameterSet::popParameterSet().

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()) {
      assert(subProcesses.size() == 1U);
      assert(subProcesses[0] == "@sub_process");
      return parameterSet.popParameterSet(subProcesses[0]);
    }
    return std::auto_ptr<ParameterSet>(nullptr);
  }

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 edmStreamStallGrapher::t.

Referenced by printEventLists().

                                                                                                                            {
    IndexIntoFile indexIntoFile;
    IndexIntoFile *findexPtr = &indexIntoFile;
    if (metaDataTree->FindBranch(poolNames::indexIntoFileBranchName().c_str()) != 0) {
      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 = 0;
    assert(0 != eventsTree);
    char const* const kEventAuxiliaryBranchName = "EventAuxiliary";
    if(eventsTree->FindBranch(kEventAuxiliaryBranchName) != 0){
      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 edmStreamStallGrapher::t.

Referenced by printEventsInLumis().

                                                                                                                               {
    IndexIntoFile indexIntoFile;
    IndexIntoFile *findexPtr = &indexIntoFile;
    if (metaDataTree->FindBranch(poolNames::indexIntoFileBranchName().c_str()) != 0) {
      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";
  }

edm::preallocConfig_

(

prealloc

)

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()) != 0) {
      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()) != 0) {
      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 66 of file JobReport.cc.

References formatFile(), edm::JobReport::InputFile::inputSourceClassName, edm::JobReport::InputFile::inputType, and edm::JobReport::InputFile::numEventsRead.

Referenced by operator<<(), and EcalDigiToRaw::produce().

                                               {

    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 78 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 96 of file JobReport.cc.

References edm::JobReport::RunReport::lumiSectionsToNEvents, bookConverter::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 mergeVDriftHistosByStation::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.

                                                       { }

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, and i.

                                     {
    if (tree != 0) {
      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 = 0,
		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,
		edm::JobReport *	jobRep = 0,
		int	rc = -1
	)

Definition at line 28 of file ExceptionMessages.cc.

References cms::Exception::explainSelf(), edm::JobReport::reportError(), and AlCaHLTBitMon_QueryRunRegistry::string.

Referenced by edm::EDLooperBase::doDuringLoop(), edm::Worker::doWork(), edm::Path::handleWorkerFailure(), edm::StreamSchedule::processOneEvent(), and edm::WorkerManager::processOneOccurrence().

                                                                                                           {
    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 << " -------------------------------------------------";
    if(jobRep) jobRep->reportError(shortDesc, longDesc.str(), rc);
  } 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(0 != metaDataTree);

    FileFormatVersion fileFormatVersion;
    FileFormatVersion *fftPtr = &fileFormatVersion;
    if (metaDataTree->FindBranch(poolNames::fileFormatVersionBranchName().c_str()) != 0) {
      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(0 != metaDataTree);

    FileFormatVersion fileFormatVersion;
    FileFormatVersion *fftPtr = &fileFormatVersion;
    if (metaDataTree->FindBranch(poolNames::fileFormatVersionBranchName().c_str()) != 0) {
      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 getDQMSummary::iter, combine::key, and getGTfromDQMFile::obj.

                              {
    hdl->ls();
    TList *keylist = hdl->GetListOfKeys();
    TIterator *iter = keylist->MakeIterator();
    TKey *key = 0;
    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(), NewTree::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();
  }

void edm::public_base_classes	(	TypeWithDict const &	type,
		std::vector< TypeWithDict > &	baseTypes
	)

Definition at line 249 of file DictionaryTools.cc.

References newFWLiteAna::base, edm::BaseWithDict::isPublic(), search_all(), edm::TypeWithDict::typeInfo(), and edm::BaseWithDict::typeOf().

Referenced by edm::ProductHolderIndexHelper::insert().

                                                               {

    TypeWithDict type(typeID.typeInfo());
    if(type.isClass()) {
      R__LOCKGUARD(gCINTMutex);
      TypeBases bases(type);
      for(auto const& basex : bases) {
        BaseWithDict base(basex);
        if(base.isPublic()) {

          TypeWithDict baseRflxType = base.typeOf();
          if(bool(baseRflxType)) {
            TypeWithDict baseType(baseRflxType.typeInfo()); 

            // Check to make sure this base appears only once in the
            // inheritance heirarchy.
            if(!search_all(baseTypes, baseType)) {
              // Save the type and recursive look for its base types
              baseTypes.push_back(baseType);
              public_base_classes(baseType, baseTypes);
            }
            // 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";
            }
            */
          }
        }
      }
    }
  }

std::string edm::pythonFileToConfigure

(

const std::string &

iPythonFileName

)

Definition at line 14 of file pythonFileToConfigure.cc.

References edmPickEvents::command, pythonToCppException(), query::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 edm::hlt::Exception, NULL, and GsfMatrixTools::trace().

Referenced by pythonFileToConfigure(), PythonProcessDesc::read(), readPSetsFrom(), and FWPathsPopup::scheduleReloadEvent().

 {
  using namespace boost::python;
  PyObject *exc=NULL, *val=NULL, *trace=NULL;
  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 edm::errors::Configuration, edm::hlt::Exception, lut2db_cfg::filename, input, query::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; 
    }

boost::shared_ptr< ParameterSet > edm::readConfig

(

std::string const &

config

)

Definition at line 42 of file MakeParameterSets.cc.

References PythonProcessDesc::parameterSet().

                                      {
    PythonProcessDesc pythonProcessDesc(config);
    return pythonProcessDesc.parameterSet();
  }

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

boost::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(), dbtoconf::object, PythonParameterSet::pset(), pythonToCppException(), and edm::ParameterSet::swap().

Referenced by main().

                                         {
    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();
    }
    boost::shared_ptr<ParameterSet> returnValue(new ParameterSet);
    theProcessPSet.pset().swap(*returnValue);
    return returnValue;
  }

void edm::reenableSigs

(

sigset_t *

oldset

)

Definition at line 68 of file UnixSignalHandlers.cc.

References MUST_BE_ZERO.

Referenced by installCustomHandler(), and MulticoreRunLumiEventChecker::postForkReacquireResources().

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

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 PFEGammaAlgo::attachPSClusters(), PFEGammaProducer::createSingleLegConversions(), EGammaMvaEleEstimator::isoMvaValue(), reco::tau::PFRecoTauChargedHadronFromPFCandidatePlugin::operator()(), pat::PATSecondaryVertexSlimmer::produce(), pat::PATTauSlimmer::produce(), pat::PATMuonSlimmer::produce(), pat::PATElectronSlimmer::produce(), pat::PATJetSlimmer::produce(), GEDPhotonCoreProducer::produce(), pat::PATPhotonSlimmer::produce(), TauGenJetProducer::produce(), pat::Muon::sourceCandidatePtr(), pat::Electron::sourceCandidatePtr(), reco::PFTau::sourceCandidatePtr(), and pat::Photon::sourceCandidatePtr().

                                                                                                  {
    typedef typename C::value_type T;
    if (ref.isNull()) {
      return Ptr<T>();
    }
    if (ref.isTransient()) {
      return Ptr<T>(ref.product(), ref.key());
    } else if (not ref.hasProductCache()) {
      return Ptr<T>(ref.id(), ref.key(), ref.productGetter());
    }
    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,
		boost::regex const &	regexp
	)

Definition at line 30 of file RegexMatch.cc.

References i.

Referenced by triggerExpression::HLTReader::init(), HLTHighLevel::init(), edm::EventSelector::init(), dqmservices::DQMStreamerReader::matchTriggerSel(), 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 (boost::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(), and regexMatch().

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

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

Referenced by FilterOR::accept(), TkTrackingRegionsMargin< float >::add(), edm::eventsetup::EventSetupRecord::add(), pos::PixelConfigFile::addAlias(), HcalHardwareXml::addHardware(), FWTrackHitsDetailView::addModules(), FWConvTrackHitsDetailView::addModules(), Hector::addPartToHepMC(), SurveyInputTrackerFromDB::addSurveyInfo(), SurveyMisalignmentInput::addSurveyInfo(), gen::EvtGenInterface::addToHepMC(), gen::EvtGenLHCInterface::addToHepMC(), EcalPreshowerGeometry::alignmentTransformIndexLocal(), PFCandConnector::analyseNuclearWPrim(), PFCandConnector::analyseNuclearWSec(), SiStripThresholdBuilder::analyze(), EcalDQMonitorTask::analyze(), RPCGeometryServTest::analyze(), DTNoiseCalibration::analyze(), BxTiming::analyze(), LHEAnalyzer::analyze(), HcalQIEDataCheck::analyze(), DTPreCalibrationTask::analyze(), HcalPedestalWidthsCheck::analyze(), cms::HcalConstantsASCIIWriter::analyze(), DTNoiseTask::analyze(), DTAlbertoBenvenutiTask::analyze(), AnaMuonCaloCleaner::analyze(), TestMuonCaloCleaner::analyze(), HeavyFlavorValidation::analyze(), DTTestPulsesTask::analyze(), L1TRPCTPG::analyze(), DTDigiTask::analyze(), HLTScalers::analyze(), L1GtAnalyzer::analyzeL1GtUtilsCore(), SiStripBadAPVAlgorithmFromClusterOccupancy::AnalyzeOccupancy(), SiStripBadAPVandHotStripAlgorithmFromClusterOccupancy::AnalyzeOccupancy(), SurveyDataConverter::applyFineSurveyInfo(), TrackerHitAssociator::associateHit(), L1GtTriggerMenuTester::associateL1SeedsHltPath(), ShallowTree::beginJob(), Tracker_OldtoNewConverter::beginJob(), BxTiming::beginRun(), HLTSeedL1LogicScalers::beginRun(), TrigResRateMon::beginRun(), FourVectorHLTOffline::beginRun(), GctFormatTranslateV35::blockToRctEmCand(), GctFormatTranslateV38::blockToRctEmCand(), GctFormatTranslateMCLegacy::blockToRctEmCand(), ora::RelationalDeleter::build(), CSCGeometryParsFromDD::build(), RunRangeDependentPedeLabeler::buildRunRangeDependencyMap(), SeedFromGenericPairOrTriplet::buildSeed(), CocoaUnitDefinition::BuildUnitsTable(), ALIUnitDefinition::BuildUnitsTable(), CSCEventData::calcALCTcrc(), FWInvMassDialog::Calculate(), JetPartonMatching::calculate(), ClusterShapeAlgo::Calculate_Covariances(), ClusterShapeAlgo::Calculate_e3x2(), ClusterShapeAlgo::Calculate_e3x3(), ClusterShapeAlgo::Calculate_e4x4(), ClusterShapeAlgo::Calculate_e5x5(), MultipleAlgoIterator::calculatePedestal(), ReflectedIterator::calculatePedestal(), PileUpSubtractor::calculatePedestal(), PedeLabelerBase::calibrationParamFromLabel(), cert_plot(), HiggsValidation::MonitoredDecays::channel(), AlignmentTwoBodyDecayTrackSelector::checkMETMass(), edm::Principal::checkUniquenessAndType(), TrackCleaner::cleanTracks(), SimTrackManager::cleanTracksWithHistory(), EcalClusterToolsT< noZS >::cluster2ndMoments(), L1TLSBlock::computeErrorFromRange(), GaussianSumUtilities1D::computeMode(), SiStripFecCabling::connections(), DDHCalBarrelAlgo::constructGeneralVolume(), DDHCalEndcapAlgo::constructGeneralVolume(), DDHCalBarrelAlgo::constructInsideDetectors(), DDHCalBarrelAlgo::constructInsideLayers(), DDHCalEndcapAlgo::constructInsideModule(), DDHCalEndcapAlgo::constructInsideModule0(), DDHCalBarrelAlgo::constructInsideSector(), DDHCalEndcapAlgo::constructInsideSector(), DDHCalBarrelAlgo::constructMidLayer(), DDHCalEndcapAlgo::constructScintLayer(), DDHCalBarrelAlgo::constructSideLayer(), CaloTowersCreationAlgo::convert(), GctFormatTranslateV35::convertBlock(), GctFormatTranslateMCLegacy::convertBlock(), GctFormatTranslateV38::convertBlock(), popcon::PopConSourceHandler< CastorPedestals >::convertFromOld(), copyObject(), FFTJetCorrectorSequence< Jet, InitialConverter, FinalConverter >::correct(), GsfBetheHeitlerUpdator::correctedFirstMean(), GsfBetheHeitlerUpdator::correctedFirstVar(), TauJetCorrector::correction(), JetPartonCorrector::correction(), FourVectorHLTOnline::countHLTGroupBXHitsEndLumiBlock(), TrigResRateMon::countHLTGroupBXHitsEndLumiBlock(), FourVectorHLTOffline::countHLTGroupBXHitsEndLumiBlock(), LatencyHistosUsingDb::create(), PFCand_AssoMapAlgos::CreatePFCandToVertexMap(), PF_PU_AssoMapAlgos::CreateTrackToVertexMap(), PFCand_AssoMapAlgos::CreateVertexToPFCandMap(), PF_PU_AssoMapAlgos::CreateVertexToTrackMap(), PFRecoTauDiscriminationByInvMass::discriminate(), SurveyPxbDicer::doDice(), VectorDoublet< Vector3D, Vector3D >::dot(), DTSC::DTSectCollsort2(), MuScleFit::duringFastLoop(), ZeeCalibration::duringLoop(), EcalClusterToolsT< noZS >::e2nd(), EcalDQMonitorTask::EcalDQMonitorTask(), EcalMonitorPrescaler::EcalMonitorPrescaler(), EcalClusterToolsT< noZS >::eMax(), edm::service::ELoutput::emitToken(), TowerBlockFormatter::EndEvent(), IsoTrig::endJob(), AlcaBeamMonitor::endLuminosityBlock(), DTtTrigCalibrationTest::endLuminosityBlock(), DTNoiseTest::endLuminosityBlock(), AlcaBeamMonitorClient::endRun(), cond::serialization::access< T, typename std::enable_if< std::is_integral< T >::value or std::is_enum< T >::value >::type >::equal_(), cond::serialization::access< T, typename std::enable_if< std::is_floating_point< T >::value >::type >::equal_(), cond::serialization::access< std::string >::equal_(), cond::serialization::access< std::bitset< N > >::equal_(), cond::serialization::access< T, typename std::enable_if< std::is_pointer< T >::value >::type >::equal_(), cond::serialization::access< T[N]>::equal_(), DDTIDModulePosAlgo::execute(), DDTrackerXYZPosAlgo::execute(), DDTrackerZPosAlgo::execute(), DDPixBarStackLinearGap::execute(), DDPixFwdDiskAlgo::execute(), DDPixBarTPGStackLayerAlgo::execute(), DDPixBarLayerUpgradeAlgo::execute(), DDPixBarLayerUpgradeAlgoCoverage::execute(), DDPixBarStackLayerAlgo::execute(), DDPixBarStackLinear::execute(), DDPixBarStackTrigLayerAlgo::execute(), DDBHMAngular::execute(), DDHCalForwardAlgo::execute(), DDHCalTBCableAlgo::execute(), DDHCalTBZposAlgo::execute(), DDTIBLayerAlgo_MTCC::execute(), DDTIBRadCableAlgo_MTCC::execute(), DDPixBarLayerAlgo::execute(), DDTECCoolAlgo::execute(), DDTECOptoHybAlgo::execute(), DDTIBLayerAlgo::execute(), DDTIDModuleAlgo::execute(), DDTOBAxCableAlgo::execute(), DDTOBRadCableAlgo::execute(), DDTOBRodAlgo::execute(), DDTrackerLinear::execute(), DDTrackerLinearXY::execute(), DDTrackerPhiAltAlgo::execute(), DDTrackerPhiAlgo::execute(), DDHCalFibreBundle::execute(), DDHCalLinearXY::execute(), DDTECAxialCableAlgo::execute(), DDTECModuleAlgo::execute(), DDTECPhiAlgo::execute(), DDTECPhiAltAlgo::execute(), DDTIDAxialCableAlgo::execute(), DDTIDRingAlgo::execute(), DDTrackerAngular::execute(), DDTrackerAngularV1::execute(), DDPixFwdBlades::execute(), CommissioningHistograms::extractHistograms(), PatZToMuMuAnalyzer::fill(), PatJetAnalyzer::fill(), TopSingleLepton::MonitorEnsemble::fill(), SingleTopTChannelLepton::MonitorEnsemble::fill(), HLTOfflineDQMTopSingleLepton::MonitorSingleLepton::fill(), TopDiLeptonOffline::MonitorEnsemble::fill(), HLTOfflineDQMTopDiLepton::MonitorDiLepton::fill(), OutInConversionSeedFinder::fillClusterSeeds(), GenParticleProducer::fillDaughters(), DTLocalTriggerTest::fillGlobalSummary(), TrigResRateMon::fillHltMatrix(), FourVectorHLTOffline::fillHltMatrix(), edm::RootFile::fillIndexIntoFile(), EcalTrigPrimFunctionalAlgo::fillMap(), SiStripCMMonitorPlugin::fillMaps(), SiStripNoisesDQM::fillMEsForLayer(), SiStripBackPlaneCorrectionDQM::fillMEsForLayer(), SiStripLorentzAngleDQM::fillMEsForLayer(), SiStripPedestalsDQM::fillMEsForLayer(), SiStripThresholdDQM::fillMEsForLayer(), SiStripApvGainsDQM::fillMEsForLayer(), SiStripQualityDQM::fillMEsForLayer(), SiPixelUtility::fillPaveText(), ProbeTreeProducer::filter(), CSCDigiValidator::filter(), Hector::filterD1(), Hector::filterFP420(), Hector::filterZDC(), pftools::SpaceManager::findCalibrator(), EcalTBCrystalMap::findCrystalAngles(), SymmetryFit::findUsableMinMax(), CosmicMuonSmoother::fit(), GsfTrajectoryFitter::fitOne(), KFTrajectoryFitter::fitOne(), alpgen::fixEventHiggsTTbar(), alpgen::fixEventSingleTop(), alpgen::fixEventTTbar(), NuclearTester::fwdEstimate(), edm::RangeMap< int, std::vector< float >, edm::CopyPolicy< float > >::get(), DTTPGParameters::get(), DTLVStatus::get(), edm::helper::IndexRangeAssociation::get(), DTHVStatus::get(), DTRangeT0::get(), DTTtrig::get(), DTDeadFlag::get(), DTPerformance::get(), DTStatusFlag::get(), DTMtime::get(), GctFormatTranslateBase::getBlockDescription(), CalibrationInterface< CategoryT, CalibDataT >::getCalibData(), CaloGeometryHelper::getClosestCell(), egHLT::ComCodes::getCodeName(), egHLT::TrigCodes::TrigBitSetMap::getCodeName(), lumi::fPoly::getCorrection(), SiStripPsuDetIdMap::getDcuId(), SiStripPsuDetIdMap::getDetectorLocation(), egHLT::trigTools::getFiltersPassed(), LMFCorrCoefDat::getFlag(), metsig::SignAlgoResolutions::getfunc(), EcalLaserDbService::getLaserCorrection(), pftools::IO::GetLineData(), EcalElectronicsMapping::getLMNumber(), PileUpSubtractor::getMeanAtTower(), FillInfoPopConSourceHandler::getNewObjects(), pftools::IO::GetNextLineData(), trigger::TriggerEventWithRefs::getObjects(), PileUpSubtractor::getPileUpAtTower(), LMFCorrCoefDat::getSeqID(), LMFCorrCoefDat::getSequence(), PileUpSubtractor::getSigmaAtTower(), RPCSeedPattern::getSpecialAlgorithmErrorMatrix(), SiStripBaseCondObjDQM::getSummaryMEs(), ZIterativeAlgorithmWithFit::getWeight(), SimTrackManager::giveMotherNeeded(), HLTEgammaDoubleLegCombFilter::hltFilter(), HLTEgammaEtFilterPairs::hltFilter(), HLTJetTag< T >::hltFilter(), HLTJetSortedVBFFilter< T >::hltFilter(), SimTrackManager::idSavedTrack(), L1MuGMTLUT::Init(), init_filter(), L1GtUtils::LogicalExpressionL1Results::initialize(), egammaisolation::EgammaRange< float >::inside(), muonisolation::Range< float >::inside(), TRange< int >::inside(), PixelRecoRange< float >::inside(), EcalTBDaqFormatter::interpretRawData(), EcalTB07DaqFormatter::interpretRawData(), APVCyclePhaseProducerFromL1TS::isBadRun(), TtGenEvent::isFullLeptonic(), AntiElectronIDCut2::isInEcalCrack(), RPCFw::isMajor(), CSCDDUMap::item(), CSCChamberMap::item(), CSCCrateMap::item(), TtEvent::jetLeptonCombination(), L1GtUtils::LogicalExpressionL1Results::l1Results(), fftjetcms::LinInterpolatedTable1D::LinInterpolatedTable1D(), G4SimEvent::load(), dqmservices::DQMFileIterator::LumiEntry::load_json(), dqmservices::DQMFileIterator::EorEntry::load_json(), CalorimetryManager::loadFromEcalBarrel(), CalorimetryManager::loadFromEcalEndcap(), CalorimetryManager::loadFromHcal(), pos::PixelConfigFile::makeKey(), SiStripHitEffFromCalibTree::makeTKMap(), match(), JetPartonMatching::matchingPtOrderedMinDist(), egammaisolation::EgammaRange< float >::max(), muonisolation::Range< float >::max(), TRange< int >::max(), PixelRecoRange< float >::max(), egammaisolation::EgammaRange< float >::mean(), muonisolation::Range< float >::mean(), TRange< int >::mean(), PixelRecoRange< float >::mean(), lhef::LHEReader::next(), Quantile::next(), MultipleAlgoIterator::offsetCorrectJets(), ReflectedIterator::offsetCorrectJets(), PileUpSubtractor::offsetCorrectJets(), DDValuePair::operator const double &(), DDValuePair::operator double &(), PhysicsTools::AtomicId::operator!=(), ddsvaluesCmp::operator()(), CastorDbASCIIIO::DetIdLess::operator()(), reco::tau::RecoTauDiscriminantFromDiscriminator::operator()(), reco::tau::RecoTauPiZeroStripPlugin::operator()(), reco::tau::RecoTauPiZeroStripPlugin2::operator()(), L1MuGMTExtendedCand::Rank::operator()(), SimpleL1MuGMTCand::Rank::operator()(), PhysicsTools::AtomicId::operator<(), operator<<(), PhysicsTools::AtomicId::operator<=(), PhysicsTools::AtomicId::operator==(), PhysicsTools::AtomicId::operator>(), PhysicsTools::AtomicId::operator>=(), ClusterClusterMapping::overlap(), MomentumDependentPedeLabeler::parameterLabel(), DDLParser::parseFile(), DDLParser::parseOneFile(), reco::modules::TrackerTrackHitFilter::parseStoN(), PartitionGenerator::partitions(), L1MuDTAssignmentUnit::PhiAU(), PhiBorderFinder::PhiBorderFinder(), cond::PayLoadInspector< DataT >::plot(), HiggsValidation::MonitoredDecays::position(), SiStripRegionCabling::position(), HLTConfigProvider::prescaleValues(), HLTConfigProvider::prescaleValuesInDetail(), Quantile::prev(), TtFullLeptonicEvent::print(), egHLT::TrigCodes::TrigBitSetMap::printCodes(), hcalCalib::Process(), PFAlgoTestBenchElectrons::processBlock(), PFAlgo::processBlock(), cscdqm::EventProcessor::processCSC(), DDLSpecPar::processElement(), DDLNumeric::processElement(), DDLString::processElement(), CandOneToManyDeltaRMatcher::produce(), TtFullLepKinSolutionProducer::produce(), PFConversionProducer::produce(), PFTrackProducer::produce(), DTFakeT0ESProducer::produce(), L1ExtraParticleMapProd::produce(), PF_PU_FirstVertexTracks::produce(), reco::modules::TrackMultiSelector::produce(), PFCand_NoPU_WithAM::produce(), JetPlusTrackProducerAA::produce(), PixelJetPuId::produce(), reco::PhysObjectMatcher< C1, C2, S, D, Q >::produce(), RunManager::produce(), RunManagerMT::produce(), NuclearTrackCorrector::produce(), edm::eventsetup::EventSetupProvider::proxyProviderDescriptions(), RBorderFinder::RBorderFinder(), RunSummaryRead::readData(), L1TriggerScalerRead::readData(), SiStripDetVOffBuilder::readLastValueFromFile(), FedRawDataInputSource::readWorker(), RealQuadEquation::RealQuadEquation(), CSCEfficiency::recHitSegment_Efficiencies(), CSCEfficiency::recSimHitEfficiency(), SiStripDetVOffBuilder::reduce(), SiStripDetVOffBuilder::reduction(), CandidateSeededTrackingRegionsProducer::regions(), edm::ESProxyFactoryProducer::registerFactoryWithKey(), jsoncollector::FastMonitor::registerGlobalMonitorable(), pftools::CaloWindow::relativePosition(), L1GtUtils::LogicalExpressionL1Results::reset(), L1TOccupancyClientHistogramService::resetHisto(), SiPixelHistoricInfoEDAClient::retrieveMEs(), TkTrackingRegionsMargin< float >::right(), EcalClusterToolsT< noZS >::roundnessBarrelSuperClusters(), EcalClusterToolsT< noZS >::roundnessBarrelSuperClustersUserExtended(), reco::modules::TrackerTrackHitFilter::Rule::Rule(), DTTSS::run(), DTTSM::run(), DTSC::run(), EcalTrigPrimFunctionalAlgo::run_part2(), DTLocalTriggerLutTest::runClientDiagnostic(), DTTriggerEfficiencyTest::runClientDiagnostic(), SortCollectionSelector< InputCollection, Comparator, OutputCollection, StoreContainer, RefAdder >::select(), FWTableView::selectCollection(), MuScleFit::selectMuons(), PhotonConversionTrajectorySeedProducerFromSingleLegAlgo::selectPriVtxCompatibleWithTrack(), DTLVStatus::set(), DTTPGParameters::set(), DTRangeT0::set(), DTHVStatus::set(), DTTtrig::set(), DTPerformance::set(), DTStatusFlag::set(), DTDeadFlag::set(), DTMtime::set(), PFElectronAlgo::SetActive(), EcalDeadCellTriggerPrimitiveFilter::setEvtRecHitstatus(), egHLT::trigTools::setFiltersObjPasses(), FWEventItemsManager::setFrom(), TauJetCorrector::setParameters(), JetPartonCorrector::setParameters(), DDLSolid::setReference(), ConvBremSeedProducer::sharedHits(), ora::Sequences::sinchronize(), ora::Sequences::sinchronizeAll(), SiStripGainESProducerTemplate< TDependentRecord, TInputRecord >::SiStripGainNormalizationFunction(), egammaisolation::EgammaRange< float >::sort(), muonisolation::Range< float >::sort(), PixelRecoRange< float >::sort(), TRange< int >::sort(), edm::OneToManyWithQualityGeneric< std::vector< reco::Track >, std::vector< reco::Vertex >, int, unsigned int >::sort(), PF_PU_AssoMapAlgos::SortAssociationMap(), PFCand_AssoMapAlgos::SortPFCandAssociationMap(), DTTSM::sortTSM2(), DTTSS::sortTSS2(), DAClusterizerInZ::split(), DAClusterizerInZ_vect::split(), CombinationGenerator< T >::splitInTwoCollections(), SiStripZeroSuppression::storeCMN(), L1MuGMTLUT::PortDecoder::str(), RPCDigiL1Link::strip(), StripCPE::StripCPE(), cond::PayLoadInspector< DataT >::summary(), MagGeoBuilderFromDDD::summary(), CompositeLogicalTrajectoryFilter::TBC(), L3MuonTrajectoryBuilder::trajectories(), TwoBodyDecayTrajectoryFactory::trajectories(), GsfTrajectorySmoother::trajectory(), MonopoleSteppingAction::update(), LatencyHistosUsingDb::update(), TauJetCorrector::ParametrizationTauJet::value(), viewNameFrom(), MuonAssociatorByHits::write_matched_simtracks(), and VirtualJetProducer::writeJets().

                                                                    {
    return p.second;
  }

template<typename T >

void edm::SetCustomStreamer

(

)

Definition at line 41 of file CustomStreamer.h.

References GetRecoTauVFromDQM_MC_cff::cl, and className().

                      {
    TClass *cl = gROOT->GetClass(TypeID(typeid(T)).className().c_str());
    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, and className().

                              {
    TClass *cl = gROOT->GetClass(TypeID(typeid(T)).className().c_str());
    if (cl->GetStreamer() == 0) {
      cl->AdoptStreamer(new CustomStreamer<T>());
    }
  }

void edm::setMaxLoggedErrorsSummaryIndicies

(

unsigned int

iMax

)

Definition at line 197 of file MessageSender.cc.

References errorSummaryMaps.

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

                                                            {
    assert(0==errorSummaryMaps.size());
    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 75 of file setPtr.h.

References edm::detail::reallySetPtr().

Referenced by edm::helpers::PtrSetter< T >::set().

                            {
    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 84 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 93 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 102 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.

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

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

                           {
    obj.setPtr(toType, index, ptr);
  }

void edm::setRefCoreStreamer

(

bool

resetAll = false

)

Definition at line 77 of file RefCoreStreamer.cc.

References GetRecoTauVFromDQM_MC_cff::cl, and edm::EDProductGetter::switchProductGetter().

Referenced by edm::StreamerInputSource::deserializeEvent(), edm::RootDelayedReader::getProduct_(), edm::service::InitRootHandlers::InitRootHandlers(), edm::ReducedProvenanceReader::readProvenance(), edm::FullProvenanceReader::readProvenance(), edm::OldProvenanceReader::readProvenance(), edm::RootFile::RootFile(), and edm::RootOutputTree::writeTTree().

                                         {
    {
      TClass *cl = gROOT->GetClass("edm::RefCore");
      TClassStreamer *st = cl->GetStreamer();
      if (st == 0) {
        cl->AdoptStreamer(new RefCoreStreamer());
      }
      {
        TClass *cl = gROOT->GetClass("edm::RefCoreWithIndex");
        TClassStreamer *st = cl->GetStreamer();
        if (st == 0) {
          cl->AdoptStreamer(new RefCoreWithIndexStreamer());
        }
      }
    }
    EDProductGetter::switchProductGetter(0);
  }

EDProductGetter const * edm::setRefCoreStreamer

(

EDProductGetter const *

ep

)

Definition at line 95 of file RefCoreStreamer.cc.

References GetRecoTauVFromDQM_MC_cff::cl, and edm::EDProductGetter::switchProductGetter().

                                                                       {
    EDProductGetter const* returnValue=0;
    if (ep != 0) {
      {
        TClass *cl = gROOT->GetClass("edm::RefCore");
        TClassStreamer *st = cl->GetStreamer();
        if (st == 0) {
          cl->AdoptStreamer(new RefCoreStreamer());
        }
      }
      {
        TClass *cl = gROOT->GetClass("edm::RefCoreWithIndex");
        TClassStreamer *st = cl->GetStreamer();
        if (st == 0) {
          cl->AdoptStreamer(new RefCoreWithIndexStreamer());
        }
      }
      returnValue = edm::EDProductGetter::switchProductGetter(ep);
    }
    return returnValue;
  }

void edm::setStandAloneMessageThreshold

(

edm::ELseverityLevel const &

severity

)

Definition at line 139 of file MessageLogger.cc.

References edm::MessageLoggerQ::standAloneThreshold().

                                                                       {
  edm::MessageLoggerQ::standAloneThreshold(severity);
}

void edm::setStreamedProductStreamer

(

)

Definition at line 37 of file StreamedProductStreamer.cc.

References GetRecoTauVFromDQM_MC_cff::cl.

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

                               {
    TClass *cl = gROOT->GetClass("edm::StreamedProduct");
    cl->AdoptStreamer(new StreamedProductStreamer());
  }

void edm::sigInventory

(

)

Definition at line 137 of file UnixSignalHandlers.cc.

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

edm::size_

(

0

)

Definition at line 181 of file OwnArray.h.

Referenced by edm::IndexIntoFile::IndexIntoFileItrImpl::advanceToNextLumiOrRun(), edm::IndexIntoFile::IndexIntoFileItrImpl::advanceToNextRun(), edm::OwnArray< T, MAX_SIZE, P >::back(), edm::OwnArray< T, MAX_SIZE, P >::clear(), edm::OwnArray< T, MAX_SIZE, P >::empty(), edm::OwnArray< T, MAX_SIZE, P >::erase(), edm::MultiAssociation< C >::LazyFiller::fill(), TkDetMap::getDetsForLayer(), edm::IndexIntoFile::IndexIntoFileItrImpl::initializeRun(), edm::OwnArray< T, MAX_SIZE, P >::is_back_safe(), InputFile::moveToPreviousChunk(), edm::IndexIntoFile::IndexIntoFileItrImpl::next(), edm::IndexIntoFile::IndexIntoFileItrImpl::operator==(), edm::OwnArray< T, MAX_SIZE, P >::pop_back(), dqmstorepb::protobuf_AssignDesc_DQMServices_2fCore_2fsrc_2fROOTFilePB_2eproto(), edm::OwnArray< T, MAX_SIZE, P >::push_back(), and edm::OwnArray< T, MAX_SIZE, P >::size().

                                     : data_{{0}}, size_(0) {
  }

edm::size_

(

n

)

Definition at line 185 of file OwnArray.h.

                                                : data_{{0}}, size_(n) {
  }

template<typename RandomAccessSequence >

void edm::sort_all ( RandomAccessSequence &  s )

inline

wrappers for std::sort

Definition at line 120 of file Algorithms.h.

References python.multivaluedict::sort().

Referenced by CompareToObjectMapRecord::analyze(), edm::EventContentAnalyzer::EventContentAnalyzer(), CaloVNoiseSignalGenerator::fillDetIds(), edm::PoolOutputModule::fillSelectedItemList(), edm::ProductSelector::initialize(), edm::MixingModule::MixingModule(), ConvertObjectMapRecord::produce(), edm::RootOutputFile::RootOutputFile(), 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, and python.multivaluedict::sort().

                                                  {
    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 alignCSCRings::e, i, merge(), and sort_all().

                                                                    {
    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 alignCSCRings::e, i, and sort_all().

Referenced by 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(), and edm::RootFile::RootFile().

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(), alignCSCRings::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().

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

(

const std::string &

path

)

Definition at line 4 of file stemFromPath.cc.

References begin, and end.

Referenced by edm::RootFile::validateFile().

                                                {
    auto begin = path.rfind("/");
    if (begin == std::string::npos) {
      begin = path.rfind(":");
      if (begin == std::string::npos) {
        // shouldn't really happen?
        begin = 0;
      } else {
        begin += 1;
      }
    } else {
      begin += 1;
    }
    auto end = path.find(".", begin);
    return path.substr(begin, end - begin);
  }

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 trackerHits::c, and cmsHarvester::index.

Referenced by 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(), customizeTrackingMonitorSeedNumber::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::swap ( ProductID &  a, ProductID &  b  )

inline

Definition at line 49 of file ProductID.h.

References edm::ProductID::swap().

                                        {
    a.swap(b);
  }

void edm::swap ( ProductData &  a, ProductData &  b  )

inline

Definition at line 55 of file ProductData.h.

References edm::ProductData::swap().

                                                   {
    a.swap(b);
  }

void edm::swap ( Parentage &  a, Parentage &  b  )

inline

Definition at line 56 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 ( ESHandleBase &  a, ESHandleBase &  b  )

inline

Definition at line 76 of file ESHandle.h.

References edm::ESHandleBase::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 98 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 ( 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 edm::IndexIntoFile::doneFileInitialization(), edm::IndexIntoFile::IndexIntoFileItr::IndexIntoFileItr(), edm::IndexIntoFile::inputFileClosed(), edm::EDCollection< T >::operator=(), edm::RefToBaseVector< T >::operator=(), edm::RefToBaseProd< T >::operator=(), edm::SortedCollection< T, SORT >::operator=(), edm::OwnVector< T, P >::operator=(), edm::DetSetVector< T >::operator=(), edm::IDVectorMap< ID, C, P >::operator=(), DynamicTruncation::sort(), edm::InputProductHolder::swap_(), edm::ScheduledProductHolder::swap_(), edm::UnscheduledProductHolder::swap_(), and edm::SourceProductHolder::swap_().

                                                             {
    lhs.swap(rhs);
  }

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

inline

Definition at line 119 of file OutputHandle.h.

References edm::OutputHandle::swap().

                                         {
    a.swap(b);
  }

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

template<typename KEY >

void edm::swap ( RefVectorBase< KEY > &  a, RefVectorBase< KEY > &  b  )

inline

swap two vectors

Definition at line 120 of file RefVectorBase.h.

                                                       {
    a.swap(b);
  }

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

inline

Definition at line 122 of file RefCore.h.

References edm::RefCore::swap().

                                                       {
    lhs.swap(rhs);
  }

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

inline

Definition at line 133 of file RefCoreWithIndex.h.

References edm::RefCoreWithIndex::swap().

                                                                         {
    lhs.swap(rhs);
  }

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 ( HandleBase &  a, HandleBase &  b  )

inline

Definition at line 134 of file HandleBase.h.

References edm::HandleBase::swap().

                                     {
    a.swap(b);
  }

void edm::swap ( FileInPath &  a, FileInPath &  b  )

inline

Definition at line 136 of file FileInPath.h.

References edm::FileInPath::swap().

  {
    a.swap(b);
  }

void edm::swap ( BasicHandle &  a, BasicHandle &  b  )

inline

Definition at line 147 of file BasicHandle.h.

References edm::BasicHandle::swap().

                                       {
    a.swap(b);
  }

template<typename K , typename T >

void edm::swap ( MapOfVectors< K, T > &  lhs, MapOfVectors< K, T > &  rhs  )

inline

Definition at line 160 of file MapOfVectors.h.

References edm::MapOfVectors< K, T >::swap().

                                                         {
    lhs.swap(rhs);
  }

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

template<class T >

void edm::swap ( RefGetter< T > &  a, RefGetter< T > &  b  )

inline

Definition at line 178 of file RefGetter.h.

References edm::RefGetter< T >::swap().

    {
      a.swap(b);
    }

template<typename C , typename T , typename F >

void edm::swap ( RefVector< C, T, F > &  a, RefVector< C, T, F > &  b  )

inline

Definition at line 178 of file RefVector.h.

References a, and b.

                                                                 {
    a.swap(b);
  }

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

inline

Definition at line 207 of file PtrVector.h.

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

                                             {
    lhs.swap(rhs);
  }

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

inline

Definition at line 213 of file DataFrameContainer.h.

References edm::DataFrameContainer::swap().

                                                         {
    lhs.swap(rhs);
  }

template<typename T >

void edm::swap ( value_ptr< T > &  vp1, value_ptr< T > &  vp2  )

inline

Definition at line 216 of file value_ptr.h.

References edm::value_ptr< T >::swap().

{ vp1.swap(vp2); }

template<typename T >

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

inline

Definition at line 220 of file RefToBaseProd.h.

References edm::RefToBaseProd< T >::swap().

                                                                                   {
    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 222 of file RangeMap.h.

References edm::RangeMap< ID, C, P >::swap().

                                                       {
    a.swap(b);
  }

template<int I>

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

inline

Definition at line 238 of file Hash.h.

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

                               {
    a.swap(b);
  }

template<typename C >

void edm::swap ( RefProd< C > const &  lhs, RefProd< C > const &  rhs  )

inline

Definition at line 239 of file RefProd.h.

References edm::RefProd< T >::swap().

                                                          {
    lhs.swap(rhs);
  }

template<typename T >

void edm::swap ( ValueMap< T > &  lhs, ValueMap< T > &  rhs  )

inline

Definition at line 250 of file ValueMap.h.

References edm::ValueMap< T >::swap().

                                                {
    lhs.swap(rhs);
  }

template<class T >

void edm::swap ( DetSetLazyVector< T > &  a, DetSetLazyVector< T > &  b  )

inline

Definition at line 258 of file DetSetLazyVector.h.

  {
    a.swap(b);
  }

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

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

                                                                                         {
    a.swap(b);
  }

void edm::swap ( InputProductHolder &  a, InputProductHolder &  b  )

inline

Definition at line 264 of file ProductHolder.h.

References edm::ProductHolderBase::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.

                                                           {
    a.swap(b);
  }

template<typename C >

void edm::swap ( MultiAssociation< C > &  lhs, MultiAssociation< C > &  rhs  )

inline

Definition at line 292 of file MultiAssociation.h.

{ lhs.swap(rhs); }

void edm::swap ( ParameterSet &  a, ParameterSet &  b  )

inline

Definition at line 319 of file ParameterSet.h.

References edm::ParameterSet::swap().

                                               {
    a.swap(b);
  }

void edm::swap ( ScheduledProductHolder &  a, ScheduledProductHolder &  b  )

inline

Definition at line 331 of file ProductHolder.h.

References edm::ProductHolderBase::swap().

                                                                         {
    a.swap(b);
  }

template<class T >

void edm::swap ( RefToBase< T > &  a, RefToBase< T > &  b  )

inline

Definition at line 354 of file RefToBase.h.

References edm::RefToBase< T >::swap().

  {
    a.swap(b);
  }

void edm::swap ( UnscheduledProductHolder &  a, UnscheduledProductHolder &  b  )

inline

Definition at line 360 of file ProductHolder.h.

References edm::ProductHolderBase::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.

                                                                   {
    a.swap(b);
  }

template<typename T >

void edm::swap ( View< T > &  lhs, View< T > &  rhs  )

inline

Definition at line 406 of file View.h.

                                        {
    lhs.swap(rhs);
  }

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<typename T , typename P >

void edm::swap ( OwnVector< T, P > &  a, OwnVector< T, P > &  b  )

inline

Definition at line 433 of file OwnVector.h.

References a, and b.

                                                                    {
    a.swap(b);
  }

template<class T >

void edm::swap ( DetSetVector< T > &  a, DetSetVector< T > &  b  )

inline

Definition at line 441 of file DetSetVector.h.

  {
    a.swap(b);
  }

void edm::swap ( SourceProductHolder &  a, SourceProductHolder &  b  )

inline

Definition at line 477 of file ProductHolder.h.

References edm::ProductHolderBase::swap().

                                                                   {
    a.swap(b);
  }

template<class T >

void edm::swap ( LazyGetter< T > &  a, LazyGetter< T > &  b  )

inline

Definition at line 519 of file LazyGetter.h.

References edm::LazyGetter< T >::swap().

    {
      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 90 of file Principal.cc.

References cppFunctionSkipper::exception.

Referenced by edm::Principal::findProductByLabel(), and edm::PrincipalGetAdapter::getByToken_().

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

static void edm::throwCorruptionException ( char const *  where, std::string const &  branchName  )

static

Definition at line 54 of file Principal.cc.

References edm::errors::EventCorruption, and edm::hlt::Exception.

Referenced by edm::Principal::checkUniquenessAndType().

                                                                           {
    throw Exception(errors::EventCorruption)
       << "Principal::" << where <<": Product on branch " << branchName << " occurs twice in the same event.\n";
  }

void edm::throwExceptionWithText

(

char const *

txt

)

Definition at line 230 of file BranchDescription.cc.

References alignCSCRings::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

(

)

Definition at line 201 of file DictionaryTools.cc.

References begin, edm::errors::DictionaryNotFound, relativeConstraints::empty, end, edm::hlt::Exception, and missingTypes().

Referenced by loadMissingDictionaries(), and maybeThrowMissingDictionaryException().

                                           {
    if(!missingTypes().empty()) {
      std::ostringstream ostr;
      for (StringSet::const_iterator it = missingTypes().begin(), itEnd = missingTypes().end();
           it != itEnd; ++it) {
        ostr << *it << "\n\n";
      }
      throw Exception(errors::DictionaryNotFound)
        << "No REFLEX data dictionary found for the following classes:\n\n"
        << ostr.str()
        << "Most likely each 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.";
    }
  }

static void edm::throwProductDeletedException ( const char *  where, TypeID const &  productType, std::string const &  label, std::string const &  instance, std::string const &  process  )

static

Definition at line 78 of file Principal.cc.

References cppFunctionSkipper::exception.

                                                                                                                                                         {
    ProductDeletedException exception;
    exception << "Principal::" << where << ": The product 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"
      << "Was already deleted. This means there is a configuration error.\n"
      << "The module which is asking for this data must be configured to state that it will read this data.";
    throw exception;
  }

static void edm::throwProductDeletedException ( ProductID const &  pid, edm::EventPrincipal::ConstProductHolderPtr const  phb  )

static

Definition at line 233 of file EventPrincipal.cc.

References cppFunctionSkipper::exception.

Referenced by edm::EventPrincipal::getByProductID(), and edm::Principal::getForOutput().

                                                                                                                   {
    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 47 of file Principal.cc.

References edm::hlt::Exception.

Referenced by edm::Principal::getForOutput(), and edm::Principal::getProvenance().

                                                                                                {
    throw Exception(error, "InvalidID")
      << "Principal::" << where << ": no product with given branch id: "<< bid << "\n";
  }

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

breaks the input string into tokens, delimited by the separator

Definition at line 57 of file Parse.cc.

References copy_all(), query::result, and cmsHarvester::sep.

Referenced by MomentumDependentPedeLabeler::buildMomentumDependencyMap(), RunRangeDependentPedeLabeler::buildRunRangeDependencyMap(), decode(), editESInputTag(), editInputTag(), editVInputTag(), edm::ESInputTag::ESInputTag(), edm::FileInPath::initialize_(), edm::InputTag::InputTag(), AlignmentProducer::makeNonOverlappingRunRanges(), MultiEventFilter::MultiEventFilter(), and PasswordReader::readPassword().

                                                                  {
      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 i, list(), and query::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 i, n, getGTfromDQMFile::obj, dbtoconf::object, and query::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 AnalysisRootpleProducer::analyze(), OccupancyPlotter::analyze(), JetAnalyzer::analyze(), METAnalyzer::analyze(), moduleName(), and parameterSet().

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

static

Referenced by moduleName().

std::string edm::typeDemangle

(

char const *

mangledName

)

Definition at line 109 of file TypeDemangler.cc.

References ora::ClassUtils::demangledName(), edm::hlt::Exception, ntuplemaker::status, and AlCaHLTBitMon_QueryRunRegistry::string.

Referenced by PhysicsTools::VarProcessor::deriv(), PhysicsTools::MVAComputer::evalInternal(), and edm::serviceregistry::ServicesManager::ServicesManager().

                                        {
    int status = 0;
    size_t* const nullSize = 0;
    char* const null = 0;
    
    // 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 used by REFLEX.
    // The order of these is important.
    // No space after comma
    replaceString(demangledName, ", ", ",");
    // Strip default allocator
    std::string const allocator(",std::allocator<");
    removeParameter(demangledName, allocator);
    // Strip default comparator
    std::string const comparator(",std::less<");
    removeParameter(demangledName, comparator);
    // Replace 'std::string' with 'std::basic_string<char>'.
    replaceDelimitedString(demangledName, "std::string", "std::basic_string<char>");
    // Put const qualifier before identifier.
    constBeforeIdentifier(demangledName);
    // No two consecutive '>' 
    replaceString(demangledName, ">>", "> >");
    return demangledName;
  }

std::string edm::uniqueSharedResourceName

(

)

Definition at line 18 of file SharedResourceNames.cc.

References counter, and contentValuesCheck::ss.

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

                                                         {
    boost::regex rexp(regexp);
    return boost::regex_match(pattern, rexp);
  }

bool edm::value_type_of ( TypeWithDict const &  t, TypeWithDict &  found_type  )

inline

Definition at line 31 of file DictionaryTools.h.

References find_nested_type_named().

Referenced by edm::ProductHolderIndexHelper::insert().

                                                                 {
    return find_nested_type_named("value_type", t, found_type);
  }

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(), GenParticleProducer::GenParticleProducer(), reco::modules::NamedCandCombinerBase::NamedCandCombinerBase(), pat::PATElectronProducer::PATElectronProducer(), pat::PATGenericParticleProducer::PATGenericParticleProducer(), pat::PATJetProducer::PATJetProducer(), pat::PATMuonProducer::PATMuonProducer(), pat::PATPFParticleProducer::PATPFParticleProducer(), pat::PATPhotonProducer::PATPhotonProducer(), pat::PATSingleVertexSelector::PATSingleVertexSelector(), pat::PATTauProducer::PATTauProducer(), pat::PATTriggerEventProducer::PATTriggerEventProducer(), pat::PATMuonProducer::readIsolationLabels(), pat::PATPhotonProducer::readIsolationLabels(), pat::PATElectronProducer::readIsolationLabels(), ReducedESRecHitCollectionProducer::ReducedESRecHitCollectionProducer(), ReducedRecHitCollectionProducer::ReducedRecHitCollectionProducer(), SeedCombiner::SeedCombiner(), SiStripClusterizer::SiStripClusterizer(), SiStripZeroSuppression::SiStripZeroSuppression(), and TrackerDpgAnalysis::TrackerDpgAnalysis().

  {
    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 hitfit::char, alignCSCRings::e, diffTwoXMLs::label, AlCaHLTBitMon_ParallelJobs::p, and findQualityFiles::v.

                                                                            {
    typedef TrieNode<T> const node_base;
    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());
    }
  }

edm::wantSummary_

(

tns.

wantSummary()

)

std::string edm::withoutQuotes

(

std::string const &

from

)

Definition at line 36 of file Parse.cc.

References query::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::PoolOutputModule::beginJob(), edm::StreamerInputSource::buildClassCache(), BareRootProductGetter::createNewBuffer(), edm::StreamerInputSource::declareStreamers(), fwlite::DataGetterHelper::getByProductID(), edm::root::FWLiteDelayedReader::getTheProduct(), edm::BranchDescription::initFromDictionary(), edm::ProductRegistry::initializeLookupTables(), maybeThrowMissingDictionaryException(), and edm::StreamedProduct::setNewClassType().

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

bool edm::wrapper_type_of ( TypeWithDict const &  possible_wrapper, TypeWithDict &  found_wrapped_type  )

inline

Definition at line 38 of file DictionaryTools.h.

References find_nested_type_named().

                                            {
    return find_nested_type_named("wrapped_type",
                  possible_wrapper,
                  found_wrapped_type);
  }

Variable Documentation

edm::__pad0__

Definition at line 369 of file Schedule.cc.

edm::actions

Definition at line 369 of file Schedule.cc.

Referenced by endpathsAreActive_(), edm::GlobalSchedule::GlobalSchedule(), and edm::WorkerMaker< T >::makeWorker().

edm::areg

Definition at line 369 of file Schedule.cc.

Referenced by endpathsAreActive_(), and edm::Worker::setActivityRegistry().

int const edm::bufSize = 128

static

Definition at line 24 of file Guid.cc.

Referenced by edm::RootOutputTree::addAuxiliary(), evf::compute_crc(), 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 264 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 282 of file ELseverityLevel.cc.

Referenced by loadMap(), and LoggedErrorsOnlySummary().

ELslGen edm::ELerrorGen

ELslProxy< ELhighestSeverityGen > const edm::ELhighestSeverity

Definition at line 300 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 270 of file ELseverityLevel.cc.

Referenced by loadMap().

ELslGen edm::ELinfoGen

ELslProxy< ELsevereGen > const edm::ELsevere

Definition at line 294 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 288 of file ELseverityLevel.cc.

Referenced by edm::ELextendedID::clear(), and loadMap().

ELslGen edm::ELunspecifiedGen

ELslProxy< ELwarningGen > const edm::ELwarning

Definition at line 276 of file ELseverityLevel.cc.

Referenced by edm::service::ELdestination::changeFile(), edm::service::ELdestination::clearSummary(), edm::service::ELdestination::flush(), loadMap(), edm::MessageSender::ErrorObjDeleter::operator()(), edm::service::ELdestination::summarization(), and edm::service::ELdestination::summary().

ELslGen edm::ELwarningGen

ELslProxy< ELzeroSeverityGen > const edm::ELzeroSeverity

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

volatile std::atomic<bool> shutdown_flag edm::false

Definition at line 22 of file UnixSignalHandlers.cc.

Referenced by L1GtTriggerMenuConfigOnlineProd::addJetCountsCondition(), GsfElectronAlgo::addPflowInfo(), SiStripGainFromCalibTree::algoAnalyze(), SiStripGainFromCalibTree::algoAnalyzeTheTree(), ora::MappingToSchema::alter(), ElectronMcSignalValidator::analyze(), ElectronAnalyzer::analyze(), ElectronTagProbeAnalyzer::analyze(), DQMHcalPhiSymAlCaReco::analyze(), L1CondDBIOVWriter::analyze(), L1CondDBPayloadWriter::analyze(), SiStripElectronAnalyzer::analyze(), HLXMonitor::analyze(), L1TdeRCT::analyze(), TrigResRateMon::analyze(), cond::Cipher::b64encrypt(), AlignmentTrackSelector::basicCuts(), HLXMonitor::beginJob(), FWTrackingParticleProxyBuilderFullFramework::build(), FWPSetTableManager::cellDataIsSortable(), FWGeometryTableManagerBase::cellDataIsSortable(), pos::PixelNameTranslation::checkFor(), SiStripElectronAlgo::coarseHitSelection(), pos::PixelHdwAddress::compare(), MuRodBarrelLayer::compatibleDets(), GsfElectronAlgo::completeElectrons(), EcalTPGParamBuilder::computeLinearizerParam(), pos::PixelConfigFile::configurationDataExists(), ElectronMomentumCorrector::correct(), reco::BeamHaloSummary::CSCLooseHaloId(), reco::BeamHaloSummary::CSCTightHaloId(), HcalTTPDigiProducer::decision(), DDHtmlLpDetails::details(), DDHtmlMaDetails::details(), DDHtmlRoDetails::details(), DetectorStateFilter::DetectorStateFilter(), DetStatus::DetStatus(), edmtest::DQMReferenceHistogramRootFileEventSetupAnalyzer::DQMReferenceHistogramRootFileEventSetupAnalyzer(), DQMStoreStats::DQMStoreStats(), edmtest::DQMXMLFileEventSetupAnalyzer::DQMXMLFileEventSetupAnalyzer(), SiPixelTrackerMap::drawModule(), EcalDCCTB07UnpackingModule::EcalDCCTB07UnpackingModule(), reco::BeamHaloSummary::EcalLooseHaloId(), EcalTBDigiProducer::EcalTBDigiProducer(), reco::BeamHaloSummary::EcalTightHaloId(), cond::Cipher::encrypt(), equivalent(), ForwardMeasurementEstimator::estimate(), BarrelMeasurementEstimator::estimate(), ElectronAnalyzer::etCut(), ElectronTagProbeAnalyzer::etCut(), DQMAnalyzer::etCut(), L1ExtraParticleMapProd::evaluateForwardRapidityGap(), FWECALDetailViewBuilder::fillData(), TrackerGeometricDetESModule::fillDescriptions(), TrackerDigiGeometryESModule::fillDescriptions(), GenHFHadronMatcher::fillDescriptions(), l1t::DataWriter::fillLastTriggerKeyList(), TopDecaySubset::fillListing(), TopInitSubset::fillOutput(), l1t::OMDSReader::QueryResults::fillVariableFromRow(), EcalGenEvtSelectorFrag::filter(), HLTHcalCalibTypeFilter::filter(), HcalCalibTypeFilter::filter(), RPCRecHitFilter::filter(), ElectronSeedProducer::filterClusters(), FilterScrapingPixelProbability::FilterScrapingPixelProbability(), GenHFHadronMatcher::findHadronJets(), GenHFHadronMatcher::findInMothers(), MuonSeedBuilder::foundMatchingSegment(), ElectronAnalyzer::generalCut(), ElectronTagProbeAnalyzer::generalCut(), DQMAnalyzer::generalCut(), SiStripConfigDb::getDeviceDescriptions(), BTagPerformanceAnalyzerOnData::getEtaPtBin(), BTagPerformanceAnalyzerMC::getEtaPtBin(), SiStripConfigDb::getFedConnections(), cond::persistency::IOV::Table::getLastIov(), pos::PixelPortcardMap::getName(), L1ConfigOnlineProdBase< TRcd, TData >::getObjectKey(), reco::BeamHaloSummary::GlobalLooseHaloId(), reco::BeamHaloSummary::GlobalTightHaloId(), DTSegmentCand::good(), reco::BeamHaloSummary::HcalLooseHaloId(), reco::BeamHaloSummary::HcalTightHaloId(), HLTHcalNZSFilter::hltFilter(), HLTHcalSimpleRecHitFilter::hltFilter(), HSCPTreeBuilder::HSCPTreeBuilder(), ElectronAnalyzer::idCut(), ElectronTagProbeAnalyzer::idCut(), DQMAnalyzer::idCut(), MuonSeedBuilder::IdentifyShowering(), reco::GsfElectron::init(), KalmanAlignmentAlgorithm::initializeAlignmentParameters(), CaloSamples::isBlank(), ConversionFinder::isFromConversion(), TransientTrackInVertices::isInVertex(), HcalTTPDigiProducer::isMasked(), IsolatedGenParticles::IsolatedGenParticles(), IsolatedTracksNxN::IsolatedTracksNxN(), ElectronAnalyzer::isolationCut(), ElectronTagProbeAnalyzer::isolationCut(), DQMAnalyzer::isolationCut(), JetMETDQMDCSFilter::JetMETDQMDCSFilter(), EEHitResponse::keepBlank(), ESHitResponse::keepBlank(), EBHitResponse::keepBlank(), main(), EcalDeadChannelRecoveryNN< EBDetId >::makeNxNMatrice_RelDC(), EcalDeadChannelRecoveryNN< EEDetId >::makeNxNMatrice_RelDC(), EcalDeadChannelRecoveryNN< DetIdT >::makeNxNMatrice_RelMC(), gen::JetMatchingMGFastJet::match(), cond::SessionImpl::open(), Flight2DSvFilter::operator()(), operator<(), CaloCellId::operator==(), HWWFunctions::passMuonRingsMVA(), HWWFunctions::passMuonRingsMVAFO(), PFProducer::PFProducer(), PhotonAnalyzer::photonSelection(), ZToMuMuGammaAnalyzer::photonSelection(), edm::service::PathTimerService::postBeginJob(), HcalTTPTriggerRecord::produce(), GsfElectronCoreProducer::produce(), DistortedPFCandProducer::produce(), HcalCalibFEDSelector::produce(), L1ExtraParticleMapProd::produce(), JetDeltaRValueMapProducer< T >::produce(), HiSpikeCleaner::produce(), AlCaECALRecHitReducer::produce(), reco::modules::TrackerTrackHitFilter::produce(), reco::modules::CosmicTrackSplitter::produce(), SiStripElectronAlgo::projectPhiBand(), SiStripPartition::pset(), SiStripDbParams::pset(), gen::Pythia6Gun::Pythia6Gun(), EcalTPGParamBuilder::realignBaseline(), EcalDeadChannelRecoveryNN< DetIdT >::recover(), FWConversionProxyBuilder::requestCommon(), FWElectronProxyBuilder::requestCommon(), FWJetProxyBuilder::requestCommon(), pos::PixelNameTranslation::ROCexists(), MuonSeedCleaner::SeedCandidates(), ElectronAnalyzer::selected(), ElectronTagProbeAnalyzer::selected(), DQMAnalyzer::selected(), cond::persistency::IOV::Table::selectLatest(), cond::persistency::IOV::Table::selectLatestByGroup(), cond::persistency::IOV::Table::selectSnapshotByGroup(), GsfElectronAlgo::setAmbiguityData(), GsfElectronAlgo::setCutBasedPreselectionFlag(), SimpleEventFilter::SimpleEventFilter(), SimpleMetricsUpdator::SimpleMetricsUpdator(), PedsOnlyAnalysis::summary(), NoiseAnalysis::summary(), PedestalsAnalysis::summary(), PedsFullNoiseAnalysis::summary(), TrackCountingComputer::TrackCountingComputer(), TwoBodyDecayTrajectoryFactory::trajectories(), DQMAnalyzer::trigger(), HLTPerformanceInfo::uniqueModule(), l1t::DataWriter::updateIOV(), TiXmlPrinter::VisitEnter(), CaloGeometryDBReader::writeFlag(), edmtest::DQMReferenceHistogramRootFileEventSetupAnalyzer::~DQMReferenceHistogramRootFileEventSetupAnalyzer(), and edmtest::DQMXMLFileEventSetupAnalyzer::~DQMXMLFileEventSetupAnalyzer().

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.

Referenced by edm::Guid::toString().

StringSet edm::foundTypes_

static

Definition at line 27 of file DictionaryTools.cc.

Referenced by foundTypes().

MallocOptionSetter edm::global_malloc_options

Definition at line 217 of file MallocOpts.cc.

Referenced by getGlobalOptionSetter().

const int edm::init_size = 1024*1024

Definition at line 18 of file StreamDQMSerializer.cc.

unsigned long long const edm::kAveEventPerSec = 200ULL

static

Definition at line 17 of file ProducerSourceBase.cc.

Referenced by edm::ProducerSourceBase::fillDescription().

unsigned long long const edm::kNanoSecPerSec = 1000000000ULL

static

Definition at line 16 of file ProducerSourceBase.cc.

Referenced by edm::ProducerSourceBase::fillDescription().

StringSet edm::missingTypes_

static

Definition at line 28 of file DictionaryTools.cc.

Referenced by missingTypes().

const unsigned char edm::MLSCRIBE_RUNNING_INDICATOR = 29

static

Definition at line 121 of file MessageDrop.h.

Referenced by FlushMessageLog(), isMessageProcessingSetUp(), edm::service::MessageLoggerScribe::run(), run_app(), and edm::service::SingleThreadMSPresence::SingleThreadMSPresence().

edm::prealloc

Definition at line 369 of file Schedule.cc.

Referenced by endpathsAreActive_().

edm::preg

Definition at line 369 of file Schedule.cc.

Referenced by endpathsAreActive_().

edm::processConfiguration

Definition at line 369 of file Schedule.cc.

Referenced by pat::PATTriggerEventProducer::beginRun(), pat::PATTriggerProducer::beginRun(), endpathsAreActive_(), HLTConfigProvider::init(), FWFileEntry::openFile(), and edm::poolNames::processConfigurationBranchName().

ProcessHistory const edm::s_emptyProcessHistory

static

Definition at line 34 of file Principal.cc.

Referenced by edm::Principal::fillPrincipal().

std::atomic<Principal::CacheIdentifier_t> edm::s_nextIdentifier

static

Definition at line 120 of file Principal.cc.

Referenced by nextIdentifier().

thread_local EDProductGetter const* edm::s_productGetter = 0

Definition at line 78 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 HcalTriggerPrimitiveAlgo::analyze(), EcalTPGParamBuilder::analyze(), L1TCSCTF::analyze(), HcalTriggerPrimitiveAlgo::analyzeHF(), BeamSpotAlignmentParameters::apply(), RigidBodyAlignmentParameters::apply(), TwoBowedSurfacesAlignmentParameters::apply(), KalmanAlignmentAlgorithm::applyAlignmentParameters(), MuScleFitUtils::applyScale(), CSCTFTrackBuilder::buildTracks(), barrelUtil::calculatePhiWindow(), SiStripMonitorMuonHLT::createMEs(), DEutils< T >::DEDigi(), InitialState::Evolve(), PFPhotonClusters::FillClusterShape(), Py8toJetInput::fillJetAlgoInput(), MiniFloatConverter::float32to16round(), RPCTBMuon::PACOut::fromBits(), RPCTBMuon::TBOut::fromBits(), RPCTBMuon::TCOut::fromBits(), RPCTBMuon::HSBOut::fromBits(), RPCTBMuon::FSBOut::fromBits(), popcon::EcalLaser_weekly_Linearization::getNewObjects(), popcon::EcalLaser_weekly_Linearization_Check::getNewObjects(), OptOModifiedRhomboidPrism::getRotatedPlate(), HcalNumberingFromDDD::getShift(), cond::EcalDQMChannelStatusHelper::getValues(), cond::EcalDCSTowerStatusHelper::getValues(), cond::EcalDQMTowerStatusHelper::getValues(), cond::EcalTPGCrystalStatusHelper::getValues(), BeamSpotAlignmentParameters::globalParameters(), RigidBodyAlignmentParameters::globalParameters(), HcalNumberingFromDDD::HcalCellTypes(), PixelTripletNoTipGenerator::hitTriplets(), FFTJetPFPileupCleaner::isRemovable(), npstat::ArrayND< Numeric, StackLen, StackDim >::linearFill(), npstat::ArrayND< Numeric, StackLen, StackDim >::linearFillLoop(), fftjetcms::LinInterpolatedTable1D::LinInterpolatedTable1D(), L1MuDTPtaLut::load(), HcalTTPDigiProducer::produce(), DistortedMuonProducerFromDB::produce(), pat::PATMETSlimmer::produce(), ParticleReplacerParticleGun::produce(), ShiftedMETcorrInputProducer::produce(), ShiftedPFCandidateProducerForPFMEtMVA::produce(), ShiftedPFCandidateProducerForNoPileUpPFMEt::produce(), ShiftedParticleProducerT< T >::produce(), ShiftedJetProducerT< T, Textractor >::produce(), pat::PATMETSlimmer::OneMETShift::readAndSet(), CSCTFSectorProcessor::run(), CSCTFSPCoreLogic::run(), BackgroundHandler::setParameters(), FFTJetPFPileupCleaner::setRemovalBit(), pat::MET::setShift(), pat::MET::shiftedP2(), pat::MET::shiftedP4(), pat::MET::shiftedSumEt(), DTTracoChip::storeCorr(), DTTracoChip::storeUncorr(), SiStripTemplate::sxtemp(), RPCTBMuon::PACOut::toBits(), RPCTBMuon::TBOut::toBits(), RPCTBMuon::TCOut::toBits(), RPCTBMuon::HSBOut::toBits(), RPCTBMuon::FSBOut::toBits(), HcalTrigTowerGeometry::towerIds(), BeamSpotAlignmentParameters::translation(), RigidBodyAlignmentParameters::translation(), DCCEEEventBlock::unpack(), DCCEBEventBlock::unpack(), CSCTFEvent::unpack(), LatencyHistosUsingDb::update(), edm::LuminosityBlockID::value(), and CastorCORData::wasMarkAndPassZS().

volatile std::atomic<bool> edm::shutdown_flag

Referenced by edm::EventProcessor::checkForAsyncStopRequest(), ep_sigusr2(), edm::EventProcessor::forkProcess(), FedRawDataInputSource::nextEvent(), evf::FastMonitoringService::preGlobalEndLumi(), and FedRawDataInputSource::readSupervisor().

pset::TypeTrans const edm::sTypeTranslations

static

Definition at line 78 of file Entry.cc.

Referenced by edm::Entry::Entry(), operator<<(), and edm::Entry::throwValueError().