edm Namespace Reference

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

Namespaces
namespace	actions
namespace	cc
namespace	clonehelper
namespace	daqsource
namespace	detail
namespace	details
namespace	detailsTrie
namespace	dslv
namespace	dslvdetail
namespace	dsrvdetail
namespace	edmmltest
namespace	errors
namespace	es
namespace	event_processor
namespace	eventsetup
namespace	evtSel
namespace	extensioncord
namespace	fillDetails
namespace	friendlyname
namespace	handleimpl
namespace	hash_detail
namespace	helper
namespace	helpers
namespace	hlt
namespace	lazydetail
namespace	math_private
namespace	messagedrop
namespace	multicore
namespace	pdtentry
namespace	poolNames
namespace	principal_get_adapter_detail
namespace	productstatus
namespace	pset
namespace	python
namespace	rec_dep
namespace	refcore
namespace	refhelper
namespace	refitem
namespace	reftobase
namespace	root
namespace	rootfix
namespace	roottree
namespace	service
namespace	serviceregistry
namespace	test
namespace	typelookup
namespace	writeParameterValue
Classes
class	ActionTable
class	ActivityRegistry
class	AllowedLabelsDescription
class	AllowedLabelsDescription< ParameterSetDescription >
class	AllowedLabelsDescription< std::vector< ParameterSet > >
class	AllowedLabelsDescriptionBase
class	AnalyzerWrapper
class	ANDGroupDescription
class	AndHelper
class	AsciiOutputModule
class	AssertHandler
class	Association
class	AssociationMap
class	AssociationVector
class	AssociativeIterator
class	BaseFlatGunProducer
class	BaseFlatGunSource
class	BasicAnalyzer
class	BasicFilter
class	BasicHandle
class	BeamHaloProducer
class	BeamHaloSource
class	BMixingModule
class	BoolCache
class	BoolCacheStreamer
class	BranchChildren
class	BranchDescription
struct	BranchEntryDescription
class	BranchID
class	BranchIDListHelper
struct	BranchKey
class	BranchMapper
class	BranchMapperWithReader
class	CFWriter
struct	ClonePolicy
class	CloningPtr
class	CodedException
struct	CommonParams
class	Compare_Index
class	Compare_Index_Run
class	Compare_Run_Lumi_EventEntry
struct	CompareRefDetSet
struct	CompareTypeInBranchTypeConstBranchDescription
class	ComposedSelectorWrapper
class	ConditionsInEventBlock
class	ConditionsInLumiBlock
class	ConditionsInRunBlock
class	ConfigurableInputSource
class	ConfigurationDescriptions
struct	ConfigurationHandshake
class	ConstBranchDescription
class	ConstProductRegistry
class	ConstPtrCache
class	ConstPtrCacheStreamer
struct	CopyPolicy
class	CosMuoGenProducer
class	CosMuoGenSource
class	CountAndLimit
class	CPUTimer
class	CurrentProcessingContext
class	CustomStreamer
class	DaqSource
class	DataFrame
class	DataFrameContainer
class	DataMixingEMDigiWorker
class	DataMixingEMWorker
class	DataMixingGeneralTrackWorker
class	DataMixingHcalDigiWorker
class	DataMixingHcalDigiWorkerProd
class	DataMixingHcalWorker
class	DataMixingModule
class	DataMixingMuonWorker
class	DataMixingSiPixelWorker
class	DataMixingSiStripRawWorker
class	DataMixingSiStripWorker
class	debugging_allocator
struct	debugvalue
class	DelayedReader
class	DescriptionFillerForESProducers
class	DescriptionFillerForESSources
class	DescriptionFillerForServices
struct	DetSet
class	DetSetLazyVector
class	DetSetRefVector
class	DetSetVector
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	DQMHttpSource
class	DuplicateChecker
class	EDAnalyzer
class	EDCollection
class	EDFilter
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	EDProduct
class	EDProductGetter
class	ELextendedID
class	ELlog4cplus
class	ELseverityLevel
struct	ELslProxy
class	EmptyESSource
class	EmptyGroupDescription
class	EmptySource
class	Entry
class	EntryDescription
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	EventExtractor
class	EventID
class	EventMsg
class	EventPrincipal
class	EventProcessHistoryID
class	EventProcessor
class	EventRange
class	EventSelector
class	EventSetup
class	EventSetupRecordDataGetter
class	EventSetupRecordIntervalFinder
class	EventSkipperByID
class	EventStreamHttpReader
struct	EventSummary
class	EventTime
class	Exception
class	ExceptionCollector
class	ExhumeProducer
class	ExpoRandomPtGunProducer
class	ExpoRandomPtGunSource
class	ExtensionCord
class	ExternalInputSource
class	Factory
class	FileBlock
class	FileCatalogItem
class	FileFormatVersion
class	FileID
class	FileIndex
class	FileInPath
class	FileLocator
class	FileRandomKEThetaGunProducer
struct	FilledGroupPtr
class	FilterObjectWrapper
class	FilterWrapper
struct	FindRegion
struct	FindValue
class	FixedPUGenerator
class	FlatBaseThetaGunProducer
class	FlatBaseThetaGunSource
class	FlatEGunASCIIWriter
class	FlatRandomEGunProducer
class	FlatRandomEGunSource
class	FlatRandomEThetaGunProducer
class	FlatRandomEThetaGunSource
class	FlatRandomOneOverPtGunProducer
class	FlatRandomPtGunProducer
class	FlatRandomPtGunSource
class	FlatRandomPtThetaGunProducer
class	FlatRandomPtThetaGunSource
class	FUShmOutputModule
class	FwdPtr
class	FwdRef
struct	FWGenericObject
	This class is just a 'tag' used to allow a specialization of edm::Handle. More...
class	FWLiteFilterWrapper
class	GeneratedInputSource
class	GeneratorFilter
struct	GenericObject
	This class is just a 'tag' used to allow a specialization of edm::Handle. More...
class	GenericObjectOwner
class	GenericSelectorByValueMap
class	GenHIEvent
class	GetProductCheckerOutputModule
class	Group
struct	GroupData
class	GroupSelector
class	GroupSelectorRules
class	Guid
class	H2RootNtplSource
class	HadronizerFilter
class	Handle
class	Handle< FWGenericObject >
class	Handle< GenericObject >
class	HandleBase
struct	has_fillView
struct	has_fillView< AssociationVector< KeyRefProd, CVal, KeyRef, SizeType, KeyReferenceHelper > >
struct	has_fillView< edm::DetSetVector< T > >
struct	has_fillView< edm::OwnVector< T, P > >
struct	has_fillView< edm::RefVector< C, T, F > >
struct	has_fillView< edm::SortedCollection< T, SORT > >
struct	has_fillView< edm::Vector< T > >
struct	has_fillView< PtrVector< T > >
struct	has_fillView< RefToBaseVector< T > >
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_match
struct	has_match< AndHelper< A, B > >
struct	has_match< NotHelper< A > >
struct	has_match< OrHelper< A, B > >
struct	has_match< SelectorBase >
struct	has_setPtr
struct	has_setPtr< edm::OwnVector< T, P > >
struct	has_setPtr< edm::SortedCollection< T, SORT > >
struct	has_setPtr< std::deque< T, A > >
struct	has_setPtr< std::list< T, A > >
struct	has_setPtr< std::set< T, A > >
struct	has_setPtr< std::vector< bool, A > >
struct	has_setPtr< std::vector< T, A > >
class	Hash
class	HcalNoiseStorage
class	HepMCProduct
class	HiMixingModule
class	HiMixingWorker
class	HiMixingWorkerBase
class	History
class	HLTGlobalStatus
class	HLTPathStatus
class	IDVectorMap
class	IEventProcessor
class	IfExistsDescription
class	IllegalParameters
class	IndexIntoFile
class	InitMsg
class	InputAnalyzer
class	InputFile
class	InputFileCatalog
class	InputGroup
class	InputSource
struct	InputSourceDescription
class	InputSourceFactory
class	InputTag
class	InputTagSelector
class	IOVSyncValue
struct	IsMergeable
struct	IsNotMergeable
class	IterateNTimesLooper
class	JobHeaderDecoder
class	JobHeaderExtractor
class	JobHeaderInserter
class	JobReport
struct	key_traits
struct	key_traits< std::pair< U, V > >
struct	key_traits< std::string >
class	LazyAdapter
class	LazyGetter
class	LazyUnpacker
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	LumiKey
class	LuminosityBlock
class	LuminosityBlockAux
class	LuminosityBlockAuxiliary
class	LuminosityBlockBase
class	LuminosityBlockID
class	LuminosityBlockPrincipal
class	LuminosityBlockRange
class	LumiReWeighting
struct	MainParameterSet
class	Maker
class	MallocOptionSetter
struct	MallocOpts
class	MapOfVectors
class	MatchAllSelector
class	MCFileSource
struct	MergeableCounter
struct	MessageDrop
class	MessageLoggerQ
class	MessageSender
class	MixingModule
class	MixingWorker
class	MixingWorkerBase
class	ModuleChanger
class	ModuleDescription
struct	ModuleInPathSummary
class	ModuleLabelSelector
class	ModuleTime
class	MsgCode
class	MultiAssociation
class	MultiParticleInConeGunProducer
class	MultiParticleInConeGunSource
class	NavigateEventsLooper
struct	NewPolicy
class	NoDelayedReader
class	NotHelper
class	OccurrenceTraits< EventPrincipal, BranchActionBegin >
class	OccurrenceTraits< LuminosityBlockPrincipal, BranchActionBegin >
class	OccurrenceTraits< LuminosityBlockPrincipal, BranchActionEnd >
class	OccurrenceTraits< RunPrincipal, BranchActionBegin >
class	OccurrenceTraits< RunPrincipal, BranchActionEnd >
class	OneToMany
class	OneToManyWithQuality
class	OneToManyWithQualityGeneric
class	OneToOne
class	OneToOneGeneric
class	OneToValue
class	ORGroupDescription
class	OrHelper
class	OrphanHandle
class	OrphanHandle< GenericObjectOwner >
class	OrphanHandleBase
struct	Other
class	OutletBase
class	OutputHandle
class	OutputModule
struct	OutputModuleDescription
class	OutputWorker
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	Path
struct	PathSummary
class	PileUp
class	PoissonPUGenerator
class	PomwigProducer
class	PoolOutputModule
class	PoolSource
class	Prescaler
class	Presence
class	PresenceFactory
class	Principal
class	PrincipalCache
class	PrincipalGetAdapter
class	PrintEventSetupContent
class	PrintEventSetupDataRetrieval
class	ProblemTracker
class	ProcessConfiguration
class	ProcessDesc
class	ProcessHistory
class	ProcessingController
class	ProcessNameSelector
class	ProcessOneOccurrence
class	ProducedGroup
class	ProducerBase
class	ProductID
class	ProductIDStreamer
class	ProductInstanceNameSelector
class	ProductLookupIndex
class	ProductProvenance
class	ProductRegistry
	author Stefano ARGIRO author Bill Tanenbaum More...
class	ProductRegistryHelper
class	Provenance
class	ProvenanceAdaptor
class	ProvenanceCheckerOutputModule
class	Ptr
class	PtrHolder
class	PtrVector
class	PtrVectorBase
class	PtrVectorItr
class	PUGenerator
class	RandomEngineStates
class	RandomFilter
class	RandomNumberGenerator
class	RangeMap
class	RawInputSource
struct	RecordInParentfull
struct	RecordInParentless
class	Ref
class	RefBase
class	RefCore
class	RefCoreCheckTransientOnWriteStreamer
class	RefCoreStreamer
class	RefGetter
class	RefItem
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
class	RunDualStopwatches
class	RunID
class	RunKey
class	RunLumiEntryInfo
class	RunPrincipal
class	RunStopwatch
class	Schedule
class	ScheduledGroup
class	ScheduleInfo
struct	ScheduleItems
class	SecSourceAnalyzer
class	Selector
class	SelectorBase
class	SendEvent
class	SendJobHeader
class	Service
class	ServiceRegistry
class	ServiceToken
class	SignallingProductRegistry
class	SimpleOutlet
class	SingleConsumerQ
class	SiteLocalConfig
class	SortedCollection
class	SourceGroup
class	StatsCount
class	StreamDQMDeserializer
class	StreamDQMSerializer
class	StreamedProduct
class	StreamerFileReader
class	StreamerFileWriter
struct	StreamerFileWriterEventParams
struct	StreamerFileWriterHeaderParams
class	StreamerInputFile
class	StreamerInputModule
class	StreamerInputSource
class	StreamerOutputModule
class	StreamerOutputModuleBase
class	StreamSerializer
struct	StrictWeakOrdering
class	SubProcess
class	Suppress_LogDebug_
class	TestHandle
class	TestMix
class	TestMixedSource
struct	TimeOfDay
class	TimeoutPoolOutputModule
class	Timestamp
class	TRandomAdaptor
struct	TransEntry
class	Transient
class	TransientDataFrame
class	TransientProductLookupMap
class	TransientStreamer
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
class	TypeID
class	TypeIDBase
class	TypeInBranchType
class	UnknownModuleException
	Exception thrown when trying to instance a module which is not registered to the system. More...
class	UnscheduledCallProducer
class	UnscheduledGroup
class	UnscheduledHandler
class	UnscheduledHandlerSentry
class	UpdateGetterAdapter
class	ValidityInterval
class	value_ptr
struct	value_ptr_traits
struct	value_ptr_traits< IndexIntoFile::IndexIntoFileItrImpl >
struct	value_ptr_traits< ParameterDescriptionNode >
struct	value_ptr_traits< SelectorBase >
class	ValueHolderECGetter
class	ValueMap
class	Vector
class	VectorInputSource
class	VectorInputSourceFactory
class	View
class	ViewBase
class	VParameterSetEntry
class	Worker
class	WorkerInPath
class	WorkerMaker
struct	WorkerParams
class	WorkerRegistry
struct	WorkerSummary
class	WorkerT
class	Wrapper
class	XMLOutputModule
class	XORGroupDescription
Typedefs
typedef unsigned int	BranchDescriptionIndex
typedef std::vector < BranchID::value_type >	BranchIDList
typedef edm::detail::ThreadSafeIndexedRegistry < BranchIDList, BranchIDListHelper >	BranchIDListRegistry
typedef std::vector< BranchIDList >	BranchIDLists
typedef unsigned short	BranchListIndex
typedef std::vector < BranchListIndex >	BranchListIndexes
typedef unsigned char	byte_t
typedef void(*	CFUNC )(int, siginfo_t *, void *)
typedef uint32_t	det_id_type
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 EntryDescriptionRegistry::collection_type	EntryDescriptionMap
typedef edm::detail::ThreadSafeRegistry < edm::EntryDescriptionID, edm::EventEntryDescription >	EntryDescriptionRegistry
typedef std::map < ErrorSummaryMapKey, unsigned int >::iterator	ErrorSummaryMapIterator
typedef ErrorSummaryEntry	ErrorSummaryMapKey
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 ParentageRegistry::collection_type	ParentageMap
typedef edm::detail::ThreadSafeRegistry < edm::ParentageID, edm::Parentage >	ParentageRegistry
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 ProcessConfigurationRegistry::collection_type	ProcessConfigurationMap
typedef edm::detail::ThreadSafeRegistry < edm::ProcessConfigurationID, edm::ProcessConfiguration >	ProcessConfigurationRegistry
typedef ProcessConfigurationRegistry::vector_type	ProcessConfigurationVector
typedef Hash< ProcessHistoryType >	ProcessHistoryID
typedef ProcessHistoryRegistry::collection_type	ProcessHistoryMap
typedef edm::detail::ThreadSafeRegistry < edm::ProcessHistoryID, edm::ProcessHistory >	ProcessHistoryRegistry
typedef ProcessHistoryRegistry::vector_type	ProcessHistoryVector
typedef unsigned short	ProcessIndex
typedef std::string	ProcessingTask
typedef unsigned short	ProductIndex
typedef std::vector < ProductProvenance >	ProductProvenanceVector
typedef byte_t	ProductStatus
typedef unsigned int	ProductTransientIndex
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 * >	Selections
typedef boost::array < Selections, NumBranchTypes >	SelectionsArray
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::set< std::string >	StringSet
typedef std::vector< std::string >	StringVector
typedef unsigned long long	TimeValue_t
typedef detail::CachedProducts::handle_t	Trig
typedef std::map < edm::ParameterSetID, edm::TriggerNames >	TriggerNamesMap
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 { BranchActionBegin = 0, BranchActionEnd = 1 }
enum	BranchType { InEvent = 0, InLumi = 1, InRun = 2, NumBranchTypes }
enum	HashedTypes {   ModuleDescriptionType, ParameterSetType, ProcessHistoryType, ProcessConfigurationType,   EntryDescriptionType, ParentageType }
enum	JobMode { GridJobMode, ReleaseValidationJobMode, AnalysisJobMode, NilJobMode }
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	Verbosity { Silent = 0, Concise = 2, Normal = 5, Detailed = 10 }
enum	WildcardValidationCriteria { RequireZeroOrMore, RequireAtLeastOne, RequireExactlyOne }
Functions
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
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 &	BranchTypeToProductStatusBranchName (BranchType const &branchType)
std::string const &	BranchTypeToProductTreeName (BranchType const &branchType)
std::string const &	BranchTypeToString (BranchType const &branchType)
static void	check (Principal const &p, std::string const &id)
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)
static Guid const	clid_null (std::string("00000000-0000-0000-0000-000000000000"))
bool	combinable (BranchDescription const &a, BranchDescription const &b)
bool	contains (EventRange const &lh, EventID const &rh)
bool	contains (EventRange const &lh, EventRange const &rh)
bool	contains (LuminosityBlockRange const &lh, LuminosityBlockID const &rh)
bool	contains (LuminosityBlockRange const &lh, LuminosityBlockRange 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 (EventAux const &from, EventAuxiliary &to)
void	conversion (LuminosityBlockAux const &from, LuminosityBlockAuxiliary &to)
void	conversion (RunAux const &from, RunAuxiliary &to)
void	convert_handle (BasicHandle const &orig, Handle< GenericObject > &result)
	specialize this function for GenericHandle
void	convert_handle (BasicHandle const &orig, Handle< FWGenericObject > &result)
	specialize this function forFWGenericHandle
template<class T >
void	convert_handle (BasicHandle const &orig, Handle< T > &result)
template<typename ForwardSequence , typename Func >
Func	copy_all (ForwardSequence &s, Func f)
	wrappers for copy
template<typename T1 , typename T2 , typename T3 , typename ToT >
void	copyFromTo (ESProducts< T1, T2, T3 > &iFrom, ToT &iTo)
std::string	createGlobalIdentifier ()
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 &)
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 &)
unsigned int	decodeInt (unsigned char *v)
	DEFINE_FWK_MODULE (HiMixingModule)
void	disableAllSigs (sigset_t *oldset)
bool	DisableLoggedErrorsSummary ()
void	disableRTSigs ()
void	disableSignal (sigset_t *newset, int signum)
bool	distinct (EventRange const &lh, EventRange const &rh)
bool	distinct (LuminosityBlockRange const &lh, LuminosityBlockRange const &rh)
void	doBuildRealData (const std::string &name)
ELseverityLevel const	ELabortGen ()
ELseverityLevel const	ELerror2Gen ()
ELseverityLevel const	ELerrorGen ()
ELseverityLevel const	ELfatalGen ()
ELseverityLevel const	ELhighestSeverityGen ()
ELseverityLevel const	ELincidentalGen ()
ELseverityLevel const	ELinfoGen ()
ELseverityLevel const	ELnextEventGen ()
ELseverityLevel const	ELsevere2Gen ()
ELseverityLevel const	ELsevereGen ()
ELseverityLevel const	ELsuccessGen ()
ELseverityLevel const	ELunspecifiedGen ()
ELseverityLevel const	ELwarning2Gen ()
ELseverityLevel const	ELwarningGen ()
ELseverityLevel const	ELzeroSeverityGen ()
bool	EnableLoggedErrorsSummary ()
void	enableSignal (sigset_t *newset, int signum)
bool	encode (std::string &, edm::EventID const &)
bool	encode (std::string &, std::vector< edm::EventID > const &)
bool	encode (std::string &, edm::LuminosityBlockID const &)
bool	encode (std::string &, std::vector< edm::LuminosityBlockID > const &)
bool	encode (std::string &, edm::LuminosityBlockRange const &)
bool	encode (std::string &, std::vector< edm::LuminosityBlockRange > const &)
bool	encode (std::string &, edm::EventRange const &)
bool	encode (std::string &, std::vector< edm::EventRange > const &)
bool	encode (std::string &, ParameterSet const &)
bool	encode (std::string &, std::vector< ParameterSet > const &)
bool	encode (std::string &, bool)
bool	encode (std::string &, std::vector< bool > const &)
bool	encode (std::string &, int)
bool	encode (std::string &, unsigned int)
bool	encode (std::string &, std::vector< unsigned int > const &)
bool	encode (std::string &, std::vector< 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 &)
void	encodeInt (unsigned int i, unsigned char *v)
void	endmsg (ErrorLog &)
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)
static void	fillInProcessIndexes (TransientProductLookupMap::ProductLookupIndexList::iterator iIt, TransientProductLookupMap::ProductLookupIndexList::iterator iEnd, std::vector< std::string > const &iNameOrder)
static void	fillLookup (Reflex::Type const &type, ProductTransientIndex const &index, ConstBranchDescription const *branchDesc, TransientProductLookupMap::FillFromMap &oMap)
boost::shared_ptr< EDLooperBase >	fillLooper (eventsetup::EventSetupProvider &cp, ParameterSet &params, CommonParams const &common)
void	fillModuleInPathSummary (Path const &, ModuleInPathSummary &)
void	fillModuleInPathSummary (Path const &path, size_t which, ModuleInPathSummary &sum)
void	fillPathSummary (Path const &path, PathSummary &sum)
void	fillProductRegistryTransients (std::vector< ProcessConfiguration > const &pcVec, ProductRegistry const &preg, bool okToRegister=false)
void	fillProductRegistryTransients (ProcessConfiguration const &pc, ProductRegistry const &preg, bool okToRegister=false)
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 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<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 SORT >
void	fillPtrVector (SortedCollection< T, SORT > const &obj, std::type_info const &toType, std::vector< unsigned long > const &indices, std::vector< void const * > &ptrs)
template<typename T , typename 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 >
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 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<typename T , typename P >
void	fillView (OwnVector< T, P > const &obj, ProductID const &id, std::vector< void const * > &pointers, helper_vector &helpers)
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<typename T >
void	fillView (PtrVector< T > const &obj, std::vector< void const * > &pointers)
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<class T >
void	fillView (DetSetVector< T > 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 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 , typename SORT >
void	fillView (SortedCollection< T, SORT > const &obj, ProductID const &id, std::vector< void const * > &pointers, helper_vector &helpers)
template<typename T >
void	fillView (Vector< T > const &obj, ProductID const &id, std::vector< void const * > &pointers, helper_vector &helpers)
void	fillWorkerSummary (Worker const *pw, WorkerSummary &sum)
void	fillWorkerSummaryAux (Worker const &w, WorkerSummary &sum)
template<typename ForwardSequence , typename Predicate >
ForwardSequence::iterator	find_if_in_all (ForwardSequence &s, Predicate const &p)
template<typename ForwardSequence , typename Predicate >
ForwardSequence::const_iterator	find_if_in_all (ForwardSequence const &s, Predicate const &p)
	wrappers for std::find
template<typename ForwardSequence , typename Datum >
ForwardSequence::const_iterator	find_in_all (ForwardSequence const &s, Datum const &d)
	wrappers for std::find
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, Reflex::Type const &type_to_search, Reflex::Type &found_type)
bool	find_nested_type_named (std::string const &nested_type, Type const &type_to_search, Type &found_type)
template<typename Key , typename Value >
Value &	findOrAssert (std::map< Key, Value > &m, Key const &k)
template<typename Key , typename Value >
Value const &	findOrAssert (std::map< Key, Value > const &m, Key const &k)
template<typename Key , typename Value >
Value	findOrDefault (std::map< Key, Value > const &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 &	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
template<typename S , typename T >
S &	formatFile (T const &f, S &os)
static char *	formatTime (const time_t t)
bool	FreshErrorsExist ()
Type	get_final_type (Type t)
std::vector< BranchDescription const * >	getAllBranchDescriptions ()
std::vector< std::string > const &	getAllTriggerNames ()
void	getCodeTable (edm::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 ()
std::string	getName (Reflex::Type &cc)
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)
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)
edm::ProductRegistry	getRegFromFile (std::string const &filename)
std::string	getReleaseVersion ()
int	getSigNum ()
TClass *	getTClass (const std::type_info &ti)
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 (Reflex::Type const &possible_ref_vector, Reflex::Type &value_type)
bool	is_RefToBaseVector (Reflex::Type const &possible_ref_vector, Reflex::Type &value_type)
bool	is_RefVector (Reflex::Type const &possible_ref_vector, Reflex::Type &value_type)
bool	isAncestor (ProcessHistory const &a, ProcessHistory const &b)
bool	isDebugEnabled ()
bool	isDescendant (ProcessHistory const &a, ProcessHistory const &b)
bool	isErrorEnabled ()
bool	isInfoEnabled ()
bool	isMessageProcessingSetUp ()
bool	isnan (float f)
bool	isnan (long double q)
bool	isnan (double d)
bool	isSameEvent (EventPrincipal const &a, EventPrincipal const &b)
bool	isSameEvent (EventAuxiliary const &a, EventAuxiliary 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
static const std::string	kBaseType ("OutputModule")
static std::string const	kBaseType ("Source")
static const std::string	kBaseType ("EDAnalyzer")
static const std::string	kBaseType ("EDFilter")
static const std::string	kBaseType ("EDProducer")
static const TimeValue_t	kLowMask (0xFFFFFFFF)
bool	lessThan (EventRange const &lh, EventRange const &rh)
bool	lessThan (LuminosityBlockRange const &lh, LuminosityBlockRange const &rh)
bool	lessThanSpecial (EventRange const &lh, EventRange const &rh)
void	loadCap (const std::string &name)
void	loadExtraClasses ()
static ELmap const &	loadMap ()
std::vector< ErrorSummaryEntry >	LoggedErrorsOnlySummary ()
std::vector< ErrorSummaryEntry >	LoggedErrorsSummary ()
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
template<typename ForwardSequence , typename Datum >
ForwardSequence::iterator	lower_bound_all (ForwardSequence &s, Datum const &d)
template<typename ForwardSequence , typename Datum , typename Predicate >
ForwardSequence::iterator	lower_bound_all (ForwardSequence &s, Datum const &d, Predicate p)
template<typename ForwardSequence , typename Datum , typename Predicate >
ForwardSequence::const_iterator	lower_bound_all (ForwardSequence const &s, Datum const &d, Predicate p)
boost::shared_ptr< InputSource >	makeInput (ParameterSet &params, CommonParams const &common, ProductRegistry &preg, PrincipalCache &pCache, boost::shared_ptr< ActivityRegistry > areg, boost::shared_ptr< ProcessConfiguration > processConfiguration)
void	makeParameterSets (std::string const &configtext, boost::shared_ptr< ParameterSet > &main)
	essentially the same as the previous method
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::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 >	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, BranchDescription::MatchMode m)
std::string	match (ConstBranchDescription const &a, ConstBranchDescription const &b, std::string const &fileName, BranchDescription::MatchMode m)
EventID const &	max (EventID const &lh, EventID const &rh)
LuminosityBlockID const &	max (LuminosityBlockID const &lh, LuminosityBlockID const &rh)
const unsigned int	maxIDlength (200)
bool	merge (LuminosityBlockRange &lh, LuminosityBlockRange &rh)
EventID const &	min (EventID const &lh, EventID const &rh)
LuminosityBlockID const &	min (LuminosityBlockID const &lh, LuminosityBlockID const &rh)
StringSet &	missingTypes ()
EDProductGetter const *	mustBeNonZero (EDProductGetter const *prodGetter, std::string refType, ProductID const &productID)
Long64_t	numEntries (TFile *hdl, std::string const &trname)
TFile *	openFileHdl (std::string const &fname)
template<class A >
boost::enable_if_c< has_match < A >::value, NotHelper< A > >::type	operator! (A const &a)
template<typename T >
bool	operator!= (View< T > const &, View< T > const &)
bool	operator!= (ELseverityLevel const &e1, ELseverityLevel const &e2)
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!= (RefCore const &lhs, RefCore 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)
bool	operator!= (BranchKey const &a, BranchKey const &b)
template<typename KEY >
bool	operator!= (RefBase< KEY > const &lhs, RefBase< KEY > const &rhs)
bool	operator!= (EventEntryDescription const &a, EventEntryDescription const &b)
bool	operator!= (EventEntryInfo const &a, EventEntryInfo const &b)
template<typename T >
bool	operator!= (FwdPtr< T > const &lhs, FwdPtr< T > const &rhs)
bool	operator!= (Entry const &a, Entry const &b)
template<typename KEY >
bool	operator!= (RefItem< KEY > const &lhs, RefItem< KEY > const &rhs)
bool	operator!= (FileID const &lh, FileID const &rh)
template<typename C , typename T , typename F >
bool	operator!= (FwdRef< C, T, F > const &lhs, FwdRef< C, T, F > const &rhs)
template<typename C >
bool	operator!= (RefProd< C > const &lhs, RefProd< C > const &rhs)
bool	operator!= (FileIndex::Element const &lh, FileIndex::Element const &rh)
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 >
bool	operator!= (RefToBaseProd< T > const &lhs, RefToBaseProd< T > const &rhs)
template<class X , class Y >
bool	operator!= (debugging_allocator< X > const &, debugging_allocator< Y > const &) throw ()
template<typename C , typename T , typename F >
bool	operator!= (RefVector< C, T, F > const &lhs, RefVector< C, T, F > const &rhs)
bool	operator!= (Parentage const &a, Parentage const &b)
bool	operator!= (ProcessConfiguration const &a, ProcessConfiguration const &b)
bool	operator!= (ProcessHistory const &a, ProcessHistory const &b)
template<typename KEY >
bool	operator!= (RefVectorBase< KEY > const &lhs, RefVectorBase< KEY > const &rhs)
	Inequality operator.
bool	operator!= (ProductID const &lh, ProductID const &rh)
bool	operator!= (ProductProvenance const &a, ProductProvenance const &b)
bool	operator!= (ProductRegistry const &a, ProductRegistry const &b)
bool	operator!= (RunLumiEntryInfo const &a, RunLumiEntryInfo const &b)
template<typename T >
bool	operator!= (Ptr< T > const &lhs, Ptr< T > 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<class A , class B >
boost::enable_if_c< has_match < A >::value &&has_match< B > ::value, AndHelper< A, B > >::type	operator&& (A const &a, B const &b)
template<typename C >
Association< C >	operator+ (const Association< C > &a1, const Association< C > &a2)
template<typename C , typename T , typename F >
RefVectorIterator< C, T, F >	operator+ (typename RefVectorIterator< C, T, F >::difference n, RefVectorIterator< C, T, F > const &iter)
template<typename T >
ValueMap< T >	operator+ (const ValueMap< T > &a1, const ValueMap< T > &a2)
bool	operator< (ConstBranchDescription const &a, ConstBranchDescription const &b)
template<typename T >
bool	operator< (View< T > const &, View< T > const &)
template<typename KEY >
bool	operator< (RefBase< KEY > const &lhs, RefBase< KEY > const &rhs)
bool	operator< (BranchDescription const &a, BranchDescription const &b)
template<typename T >
bool	operator< (Ptr< T > const &lhs, Ptr< T > const &rhs)
bool	operator< (RefCore const &lhs, RefCore const &rhs)
bool	operator< (EventEntryInfo const &a, EventEntryInfo const &b)
template<typename T >
bool	operator< (FwdPtr< T > const &lhs, FwdPtr< T > const &rhs)
bool	operator< (ELseverityLevel const &e1, ELseverityLevel const &e2)
bool	operator< (EventProcessHistoryID const &lh, EventProcessHistoryID const &rh)
template<typename KEY >
bool	operator< (RefItem< KEY > const &lhs, RefItem< KEY > const &rhs)
bool	operator< (FileIndex::Element const &lh, FileIndex::Element const &rh)
template<typename C >
bool	operator< (RefProd< C > const &lhs, RefProd< C > const &rhs)
template<class T >
bool	operator< (DetSet< T > const &x, DetSet< T > const &y)
template<typename T >
bool	operator< (RefToBaseProd< T > const &lhs, RefToBaseProd< 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< (ProcessConfiguration const &a, ProcessConfiguration const &b)
bool	operator< (ProductID const &lh, ProductID const &rh)
bool	operator< (ProductProvenance const &a, ProductProvenance const &b)
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< (BranchKey const &a, BranchKey const &b)
bool	operator< (RunLumiEntryInfo const &a, RunLumiEntryInfo const &b)
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 &ost, const MallocOpts &)
std::ostream &	operator<< (std::ostream &os, ConstBranchDescription const &p)
std::ostream &	operator<< (std::ostream &os, BranchKey const &bk)
std::ostream &	operator<< (std::ostream &os, Group const &g)
std::ostream &	operator<< (std::ostream &os, BranchMapper const &p)
std::ostream &	operator<< (std::ostream &os, Entry const &entry)
std::ostream &	operator<< (std::ostream &os, ParameterSet const &pset)
std::ostream &	operator<< (std::ostream &os, BranchDescription const &p)
std::ostream &	operator<< (std::ostream &os, const GroupSelector &gs)
std::ostream &	operator<< (std::ostream &os, ParameterSetEntry const &psetEntry)
template<typename PROD >
std::ostream &	operator<< (std::ostream &os, Handle< PROD > const &h)
std::ostream &	operator<< (std::ostream &ost, InputTag const &tag)
std::ostream &	operator<< (std::ostream &os, VParameterSetEntry const &vpsetEntry)
template<class T >
ErrorObj &	operator<< (ErrorObj &e, const T &t)
std::ostream &	operator<< (std::ostream &os, TimeOfDay const &tod)
ErrorObj &	operator<< (ErrorObj &e, const char s[])
std::ostream &	operator<< (std::ostream &os, JobReport::LumiSectionReport const &rep)
std::ostream &	operator<< (std::ostream &os, JobReport::OutputFile const &f)
std::ostream &	operator<< (std::ostream &os, BranchType const &branchType)
std::ostream &	operator<< (std::ostream &os, ProductRegistry const &pr)
std::ostream &	operator<< (std::ostream &os, const EventAuxiliary &p)
std::ostream &	operator<< (std::ostream &os, EventEntryDescription const &p)
std::ostream &	operator<< (std::ostream &os, const ELseverityLevel &sev)
std::ostream &	operator<< (std::ostream &os, EventEntryInfo const &p)
std::ostream &	operator<< (std::ostream &oStream, EventID const &iID)
std::ostream &	operator<< (std::ostream &oStream, EventRange const &iID)
std::ostream &	operator<< (std::ostream &os, JobReport::RunReport const &f)
edm::MessageSender &	operator<< (edm::MessageSender &os, JobReport::InputFile const &f)
edm::MessageSender &	operator<< (edm::MessageSender &os, JobReport::OutputFile const &f)
edm::MessageSender &	operator<< (edm::MessageSender &os, JobReport::RunReport const &f)
std::ostream &	operator<< (std::ostream &os, const edm::FileInPath &fip)
std::ostream &	operator<< (std::ostream &os, FileFormatVersion const &ff)
std::ostream &	operator<< (std::ostream &os, FileID const &id)
std::ostream &	operator<< (std::ostream &os, FileIndex const &fileIndex)
template<int I>
std::ostream &	operator<< (std::ostream &os, Hash< I > const &h)
std::ostream &	operator<< (std::ostream &os, const LuminosityBlockAuxiliary &p)
std::ostream &	operator<< (std::ostream &oStream, LuminosityBlockID const &iID)
std::ostream &	operator<< (std::ostream &oStream, LuminosityBlockRange const &iID)
std::ostream &	operator<< (std::ostream &os, ModuleDescription const &p)
std::ostream &	operator<< (std::ostream &os, ParameterSetBlob const &blob)
std::ostream &	operator<< (std::ostream &os, Parentage const &p)
std::ostream &	operator<< (std::ostream &os, ProcessConfiguration const &pc)
template<typename C , typename T , typename F >
std::ostream &	operator<< (std::ostream &os, RefVector< C, T, F > const &r)
std::ostream &	operator<< (std::ostream &ost, const HLTGlobalStatus &hlt)
	Formatted printout of trigger tbale.
std::ostream &	operator<< (std::ostream &ost, ProcessHistory const &ph)
std::ostream &	operator<< (std::ostream &os, ProductID const &id)
std::ostream &	operator<< (std::ostream &os, ProductProvenance const &p)
std::ostream &	operator<< (std::ostream &os, EntryDescription const &p)
std::ostream &	operator<< (std::ostream &os, Provenance const &p)
std::ostream &	operator<< (std::ostream &os, const RunAuxiliary &p)
std::ostream &	operator<< (std::ostream &oStream, RunID const &iID)
std::ostream &	operator<< (std::ostream &os, JobReport::InputFile const &f)
std::ostream &	operator<< (std::ostream &os, RunLumiEntryInfo const &p)
std::ostream &	operator<< (std::ostream &os, TypeID const &id)
std::ostream &	operator<< (std::ostream &os, BranchID const &id)
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)
bool	operator== (BranchDescription const &a, BranchDescription const &b)
template<typename T >
bool	operator== (View< T > const &, View< T > const &)
bool	operator== (BranchKey const &a, BranchKey const &b)
bool	operator== (ConstBranchDescription const &a, ConstBranchDescription const &b)
template<typename T , typename SORT >
bool	operator== (SortedCollection< T, SORT > const &a, SortedCollection< T, SORT > const &b)
bool	operator== (ProductProvenance const &a, ProductProvenance const &b)
bool	operator== (EventEntryDescription const &a, EventEntryDescription const &b)
template<typename C , typename T , typename F >
bool	operator== (Ref< C, T, F > const &lhs, Ref< C, T, F > const &rhs)
template<typename KEY >
bool	operator== (RefBase< KEY > const &lhs, RefBase< KEY > const &rhs)
template<typename T >
bool	operator== (FwdPtr< T > const &lhs, FwdPtr< T > const &rhs)
template<typename T , typename U >
bool	operator== (U const &lhs, value_ptr< T > const &rhs)
bool	operator== (ELseverityLevel const &e1, ELseverityLevel const &e2)
bool	operator== (EventEntryInfo const &a, EventEntryInfo const &b)
template<class X , class Y >
bool	operator== (debugging_allocator< X > const &, debugging_allocator< Y > const &) throw ()
template<typename KEY >
bool	operator== (RefItem< KEY > const &lhs, RefItem< KEY > const &rhs)
bool	operator== (Entry const &a, Entry const &b)
template<typename C , typename T , typename F >
bool	operator== (Ref< C, T, F > const &lhs, FwdRef< C, T, F > const &rhs)
bool	operator== (edm::FileInPath const &a, edm::FileInPath const &b)
template<typename C , typename T , typename F >
bool	operator== (FwdRef< C, T, F > const &lhs, Ref< C, T, F > const &rhs)
bool	operator== (FileID const &lh, FileID const &rh)
template<typename C >
bool	operator== (RefProd< C > const &lhs, RefProd< C > const &rhs)
bool	operator== (FileIndex::Element const &lh, FileIndex::Element const &rh)
bool	operator== (ParameterSet const &a, ParameterSet const &b)
template<typename T >
bool	operator== (RefToBaseProd< T > const &lhs, RefToBaseProd< T > const &rhs)
template<typename C , typename T , typename F >
bool	operator== (FwdRef< C, T, F > const &lhs, FwdRef< C, T, F > const &rhs)
bool	operator== (RefCore const &lhs, RefCore const &rhs)
template<class T >
bool	operator== (RefToBaseVector< T > const &a, RefToBaseVector< T > const &b)
bool	operator== (Parentage const &a, Parentage const &b)
template<typename C , typename T , typename F >
bool	operator== (RefVector< C, T, F > const &lhs, RefVector< C, T, F > const &rhs)
bool	operator== (ProcessConfiguration const &a, ProcessConfiguration const &b)
bool	operator== (ProcessHistory const &a, ProcessHistory const &b)
template<typename KEY >
bool	operator== (RefVectorBase< KEY > const &lhs, RefVectorBase< KEY > const &rhs)
	Equality operator.
bool	operator== (ProductID const &lh, ProductID const &rh)
template<typename T , typename SORT , typename ALLOC >
bool	operator== (SortedCollection< T, SORT > const &c, std::vector< T, ALLOC > const &v)
bool	operator== (Provenance const &a, Provenance const &b)
bool	operator== (ProductRegistry const &a, ProductRegistry const &b)
template<typename T , typename U >
bool	operator== (value_ptr< T > const &lhs, U const &rhs)
template<typename T >
bool	operator== (Ptr< T > const &lhs, Ptr< T > const &rhs)
bool	operator== (RunLumiEntryInfo const &a, RunLumiEntryInfo const &b)
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)
bool	operator> (TypeID const &a, TypeID const &b)
bool	operator> (const TypeIDBase &a, const TypeIDBase &b)
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)
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 < bool > >	operator>> (bool caseValue, ParameterDescriptionNode const &node)
std::auto_ptr < ParameterDescriptionCases < int > >	operator>> (int caseValue, ParameterDescriptionNode const &node)
std::auto_ptr < ParameterDescriptionCases < int > >	operator>> (int caseValue, std::auto_ptr< ParameterDescriptionNode > node)
std::auto_ptr < ParameterDescriptionCases < std::string > >	operator>> (char const *caseValue, std::auto_ptr< ParameterDescriptionNode > node)
std::istream &	operator>> (std::istream &is, FileInPath &fip)
std::auto_ptr < ParameterDescriptionCases < std::string > >	operator>> (std::string 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 < 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 < ParameterDescriptionNode >	operator|| (ParameterDescriptionNode const &node_left, ParameterDescriptionNode const &node_right)
std::auto_ptr < ParameterDescriptionCases < std::string > >	operator|| (std::auto_ptr< ParameterDescriptionCases< std::string > >, std::auto_ptr< ParameterDescriptionCases< std::string > >)
template<class A , class B >
boost::enable_if_c< has_match < A >::value &&has_match< B > ::value, OrHelper< A, B > >::type	operator|| (A const &a, B const &b)
bool	overlaps (EventRange const &lh, EventRange const &rh)
bool	overlaps (LuminosityBlockRange const &lh, LuminosityBlockRange const &rh)
template<>
std::string	ParameterSet::getParameter< std::string > (char const *name) const
template<>
std::string	ParameterSet::getParameter< std::string > (std::string 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 > > (char const *name) const
template<>
std::vector< ESInputTag >	ParameterSet::getParameter< std::vector< ESInputTag > > (std::string 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 > > (char const *name) const
template<>
std::vector< InputTag >	ParameterSet::getParameter< std::vector< InputTag > > (std::string 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 > > (char const *name) const
template<>
std::vector< long long >	ParameterSet::getParameter< std::vector< long long > > (std::string 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 > > (char const *name) const
template<>
std::vector< LuminosityBlockRange >	ParameterSet::getParameter< std::vector< LuminosityBlockRange > > (std::string const &name) const
template<>
std::vector< PdtEntry >	ParameterSet::getParameter< std::vector< PdtEntry > > (char const *name) const
template<>
std::vector< PdtEntry >	ParameterSet::getParameter< std::vector< PdtEntry > > (std::string const &name) const
template<>
std::vector< std::string >	ParameterSet::getParameter< std::vector< std::string > > (std::string const &name) const
template<>
std::vector< std::string >	ParameterSet::getParameter< std::vector< std::string > > (char const *name) const
template<>
std::vector< unsigned int >	ParameterSet::getParameter< std::vector< unsigned int > > (char const *name) const
template<>
std::vector< unsigned int >	ParameterSet::getParameter< std::vector< unsigned int > > (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< unsigned long long >	ParameterSet::getParameter< std::vector< unsigned long long > > (std::string 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, std::vector< double > const &defaultValue) const
template<>
std::vector< double >	ParameterSet::getUntrackedParameter< std::vector< double > > (char const *name) const
template<>
std::vector< ESInputTag >	ParameterSet::getUntrackedParameter< std::vector< ESInputTag > > (std::string const &name, std::vector< ESInputTag > const &defaultValue) const
template<>
std::vector< ESInputTag >	ParameterSet::getUntrackedParameter< std::vector< ESInputTag > > (std::string const &name) const
template<>
std::vector< ESInputTag >	ParameterSet::getUntrackedParameter< std::vector< ESInputTag > > (char const *name) const
template<>
std::vector< ESInputTag >	ParameterSet::getUntrackedParameter< std::vector< ESInputTag > > (char const *name, std::vector< ESInputTag > const &defaultValue) const
template<>
std::vector< EventID >	ParameterSet::getUntrackedParameter< std::vector< EventID > > (char const *name) const
template<>
std::vector< EventID >	ParameterSet::getUntrackedParameter< std::vector< EventID > > (std::string const &name, std::vector< EventID > const &defaultValue) const
template<>
std::vector< EventID >	ParameterSet::getUntrackedParameter< std::vector< EventID > > (std::string const &name) const
template<>
std::vector< EventID >	ParameterSet::getUntrackedParameter< std::vector< EventID > > (char const *name, std::vector< EventID > const &defaultValue) const
template<>
std::vector< 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, std::vector< EventRange > const &defaultValue) const
template<>
std::vector< EventRange >	ParameterSet::getUntrackedParameter< std::vector< EventRange > > (char const *name) const
template<>
std::vector< InputTag >	ParameterSet::getUntrackedParameter< std::vector< InputTag > > (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< 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 > > (std::string const &name) const
template<>
std::vector< int >	ParameterSet::getUntrackedParameter< std::vector< int > > (char 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 > > (std::string const &name) const
template<>
std::vector< int >	ParameterSet::getUntrackedParameter< std::vector< int > > (char const *name, std::vector< int > const &defaultValue) const
template<>
std::vector< long long >	ParameterSet::getUntrackedParameter< std::vector< long long > > (std::string const &name, std::vector< long long > const &defaultValue) const
template<>
std::vector< long long >	ParameterSet::getUntrackedParameter< std::vector< long long > > (std::string const &name) const
template<>
std::vector< long long >	ParameterSet::getUntrackedParameter< std::vector< long long > > (char const *name, 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< LuminosityBlockID >	ParameterSet::getUntrackedParameter< std::vector< LuminosityBlockID > > (char 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 > > (std::string const &name, std::vector< LuminosityBlockID > const &defaultValue) const
template<>
std::vector< LuminosityBlockID >	ParameterSet::getUntrackedParameter< std::vector< LuminosityBlockID > > (std::string const &name) const
template<>
std::vector< 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 > > (char const *name, std::vector< LuminosityBlockRange > const &defaultValue) const
template<>
std::vector< LuminosityBlockRange >	ParameterSet::getUntrackedParameter< std::vector< LuminosityBlockRange > > (char const *name) const
template<>
std::vector< LuminosityBlockRange >	ParameterSet::getUntrackedParameter< std::vector< LuminosityBlockRange > > (std::string const &name) const
template<>
std::vector< PdtEntry >	ParameterSet::getUntrackedParameter< std::vector< PdtEntry > > (std::string const &name) const
template<>
std::vector< PdtEntry >	ParameterSet::getUntrackedParameter< std::vector< PdtEntry > > (std::string const &name, std::vector< PdtEntry > const &defaultValue) const
template<>
std::vector< PdtEntry >	ParameterSet::getUntrackedParameter< std::vector< PdtEntry > > (char const *name, std::vector< PdtEntry > const &defaultValue) const
template<>
std::vector< PdtEntry >	ParameterSet::getUntrackedParameter< std::vector< PdtEntry > > (char const *name) 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< 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< unsigned int >	ParameterSet::getUntrackedParameter< std::vector< unsigned int > > (std::string const &name) const
template<>
std::vector< unsigned int >	ParameterSet::getUntrackedParameter< std::vector< unsigned int > > (std::string const &name, std::vector< unsigned int > const &defaultValue) const
template<>
std::vector< unsigned int >	ParameterSet::getUntrackedParameter< std::vector< unsigned int > > (char const *name, std::vector< unsigned int > const &defaultValue) const
template<>
std::vector< unsigned int >	ParameterSet::getUntrackedParameter< std::vector< unsigned int > > (char const *name) const
template<>
std::vector< unsigned long long >	ParameterSet::getUntrackedParameter< std::vector< unsigned long long > > (std::string const &name, std::vector< unsigned long long > const &defaultValue) 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
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 > > (std::string const &name) const
std::string	parameterTypeEnumToString (ParameterTypes iType)
std::auto_ptr< ParameterSet >	popSubProcessParameterSet (ParameterSet &parameterSet)
static void	postIndexIntoFilePrintEventLists (TFile *tfl, FileFormatVersion const &fileFormatVersion, TTree *metaDataTree)
static void	preIndexIntoFilePrintEventLists (TFile *tfl, FileFormatVersion const &fileFormatVersion, TTree *metaDataTree)
template<typename S >
S &	print (S &os, JobReport::RunReport const &rep)
template<typename S >
S &	print (S &os, JobReport::InputFile const &f)
template<typename S >
S &	print (S &os, JobReport::OutputFile const &f)
template<typename RecordT >
void	print_eventsetup_record_dependencies (std::ostream &oStream, std::string const &iIndent=std::string())
template<typename TFirst , typename TEnd >
void	print_eventsetup_record_dependencies (std::ostream &oStream, std::string iIndent, TFirst const *, TEnd const *iEnd)
template<typename T >
void	print_eventsetup_record_dependencies (std::ostream &oStream, std::string, T const *, T const *)
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 &oStream, std::string const &, boost::mpl::false_)
void	printBadAllocException (char const *prog=0, edm::JobReport *jobRep=0, int rc=-1)
void	printBranchNames (TTree *tree)
void	printCmsException (cms::Exception &e, char const *prog=0, edm::JobReport *jobRep=0, int rc=-1)
void	printEventLists (TFile *tfl)
void	printStdException (std::exception &e, char const *prog=0, edm::JobReport *jobRep=0, int rc=-1)
void	printTrees (TFile *hdl)
void	printUnknownException (char const *prog=0, edm::JobReport *jobRep=0, int rc=-1)
void	printUuids (TTree *uuidTree)
BranchID	productIDToBranchID (ProductID const &pid, BranchIDLists const &lists, BranchListIndexes const &indexes)
void	public_base_classes (Reflex::Type const &type, std::vector< Reflex::Type > &baseTypes)
void	public_base_classes (Type const &type, std::vector< Type > &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
boost::shared_ptr< ParameterSet >	readConfig (std::string const &config, int argc, char *argv[])
	same, but with arguments
boost::shared_ptr< ParameterSet >	readConfig (std::string const &config)
std::auto_ptr< SendJobHeader >	readHeaderFromStream (std::ifstream &ist)
std::auto_ptr< SendJobHeader >	readHeaderFromStream (ifstream &ist)
boost::shared_ptr< ParameterSet >	readPSetsFrom (std::string const &fileOrString)
void	reenableSigs (sigset_t *oldset)
template<class T >
T const *	reflex_cast (void *raw, Reflex::Type const &dynamicType)
void const *	reflex_pointer_adjust (void *raw, Type const &dynamicType, std::type_info const &toType)
void const *	reflex_pointer_adjust (void *raw, Reflex::Type const &dynamicType, std::type_info const &toType)
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)
bool	registryIsSubset (SendJobHeader const &, ProductRegistry const &reg)
bool	registryIsSubset (SendJobHeader const &sd, SendJobHeader const &ref)
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)
void	setCacheStreamers ()
template<typename T >
void	SetCustomStreamer (T const &)
template<typename T >
void	SetCustomStreamer ()
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 >
void	setPtr (std::vector< T, A > const &obj, std::type_info const &iToType, unsigned long iIndex, void const *&oPtr)
template<typename T , typename P >
void	setPtr (OwnVector< T, P > const &obj, std::type_info const &toType, unsigned long index, void const *&ptr)
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 A >
void	setPtr (std::list< T, A > 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)
void	setRefCoreStreamer (bool resetAll=false)
EDProductGetter const *	setRefCoreStreamer (EDProductGetter const *ep, bool oldFormat=false, bool productIDwasLong=false)
void	setStandAloneMessageThreshold (std::string const &severity)
template<typename T >
void	SetTransientStreamer ()
template<typename T >
void	SetTransientStreamer (T const &)
void	setTransientStreamers ()
void	sigInventory ()
void	snapshotMessageLog ()
template<typename RandomAccessSequence >
void	sort_all (RandomAccessSequence &s)
	wrappers for std::sort
template<typename RandomAccessSequence , typename Predicate >
void	sort_all (RandomAccessSequence &s, Predicate p)
std::vector< EventRange > &	sortAndRemoveOverlaps (std::vector< EventRange > &eventRange)
std::vector < LuminosityBlockRange > &	sortAndRemoveOverlaps (std::vector< LuminosityBlockRange > &lumiRange)
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 , typename Predicate >
void	stable_sort_all (RandomAccessSequence &s, Predicate p)
template<typename RandomAccessSequence >
void	stable_sort_all (RandomAccessSequence &s)
	wrappers for std::stable_sort
std::string	stripLeadingDirectoryTree (const std::string &file)
template<class T >
void	swap (RefToBase< T > &a, RefToBase< T > &b)
template<typename C >
void	swap (edm::RefProd< C > const &lhs, edm::RefProd< C > const &rhs)
template<class T >
void	swap (LazyGetter< T > &a, LazyGetter< T > &b)
template<typename T >
void	swap (View< T > &lhs, View< T > &rhs)
template<typename C >
void	swap (Association< C > &lhs, Association< C > &rhs)
void	swap (edm::RefCore &lhs, edm::RefCore &rhs)
template<typename K , typename T >
void	swap (MapOfVectors< K, T > &lhs, MapOfVectors< K, T > &rhs)
template<typename T , typename C >
void	swap (DetSetRefVector< T, C > &a, DetSetRefVector< T, C > &b)
template<class T >
void	swap (DetSetVector< T > &a, DetSetVector< 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 (ParameterSet &a, ParameterSet &b)
template<typename T >
void	swap (Vector< T > &a, Vector< T > &b)
template<class T >
void	swap (RefToBaseVector< T > &a, RefToBaseVector< T > &b)
template<class T >
void	swap (RefGetter< T > &a, RefGetter< T > &b)
void	swap (SourceGroup &a, SourceGroup &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 (value_ptr< T > &vp1, value_ptr< T > &vp2)
void	swap (OutputHandle &a, OutputHandle &b)
void	swap (HandleBase &a, HandleBase &b)
void	swap (DataFrameContainer &lhs, DataFrameContainer &rhs)
template<int I>
void	swap (Hash< I > &a, Hash< I > &b)
template<typename C >
void	swap (MultiAssociation< C > &lhs, MultiAssociation< C > &rhs)
template<class T >
void	swap (DetSetLazyVector< T > &a, DetSetLazyVector< T > &b)
void	swap (InputGroup &a, InputGroup &b)
template<typename T >
void	swap (PtrVector< T > &lhs, PtrVector< T > &rhs)
void	swap (ScheduledGroup &a, ScheduledGroup &b)
void	swap (TriggerResults &lhs, TriggerResults &rhs)
template<typename T >
void	swap (ValueMap< T > &lhs, ValueMap< T > &rhs)
template<typename ID , typename C , typename P >
void	swap (RangeMap< ID, C, P > &a, RangeMap< ID, C, P > &b)
void	swap (GroupData &a, GroupData &b)
void	swap (UnscheduledGroup &a, UnscheduledGroup &b)
void	swap (Parentage &a, Parentage &b)
template<typename C , typename T , typename F >
void	swap (RefVector< C, T, F > &a, RefVector< C, T, F > &b)
template<class T >
void	swap (DetSet< T > &a, DetSet< T > &b)
void	swap (BasicHandle &a, BasicHandle &b)
void	swap (OrphanHandleBase &a, OrphanHandleBase &b)
void	swap (FileInPath &a, FileInPath &b)
void	swap (HLTGlobalStatus &lhs, HLTGlobalStatus &rhs)
	Free swap function.
template<typename T >
void	swap (edm::RefToBaseProd< T > const &lhs, edm::RefToBaseProd< T > const &rhs)
template<class T , class P >
void	swap (CloningPtr< T, P > &a, CloningPtr< T, P > &b)
void	swap (ProductID &a, ProductID &b)
void	swap (ESHandleBase &a, ESHandleBase &b)
template<typename T , typename SORT >
void	swap (SortedCollection< T, SORT > &a, SortedCollection< T, SORT > &b)
template<class T >
void	swap (EDCollection< T > &a, EDCollection< T > &b)
template<typename T , typename P >
void	swap (OwnVector< T, P > &a, OwnVector< T, P > &b)
template<typename KEY >
void	swap (RefVectorBase< KEY > &a, RefVectorBase< KEY > &b)
	swap two vectors
void	swap (ProcessHistory &a, ProcessHistory &b)
void	throwExceptionWithText (char const *txt)
std::vector< std::string >	tokenize (std::string const &input, std::string const &separator)
	breaks the input string into tokens, delimited by the separator
template<typename T >
boost::python::list	toPythonList (const std::vector< T > &v)
template<typename T >
std::vector< T >	toVector (boost::python::list &l)
void	typeDemangle (char const *mangledName, std::string &demangledName)
bool	value_type_of (Reflex::Type const &t, Reflex::Type &found_type)
template<typename V , typename T >
void	walkTrie (V &v, TrieNode< T > const &n, std::string const &label="")
	visit each node of the trie
std::string	withoutQuotes (std::string const &from)
std::string	wrappedClassName (std::string const &iFullName)
bool	wrapper_type_of (Reflex::Type const &possible_wrapper, Reflex::Type &found_wrapped_type)
Variables
debugvalue	debugit
LogDebug_	dummyLogDebugObject_
LogTrace_	dummyLogTraceObject_
ELslProxy< ELabortGen > const	ELabort
ELslGen	ELabortGen
ELslProxy< ELerrorGen > const	ELerror
ELslProxy< ELerror2Gen > const	ELerror2
ELslGen	ELerror2Gen
ELslGen	ELerrorGen
ELslProxy< ELfatalGen > const	ELfatal
ELslGen	ELfatalGen
ELslProxy < ELhighestSeverityGen > const	ELhighestSeverity
ELslGen	ELhighestSeverityGen
ELslProxy< ELincidentalGen > const	ELincidental
ELslGen	ELincidentalGen
ELslProxy< ELinfoGen > const	ELinfo
ELslGen	ELinfoGen
ELslProxy< ELnextEventGen > const	ELnextEvent
ELslGen	ELnextEventGen
ELslProxy< ELsevereGen > const	ELsevere
ELslProxy< ELsevere2Gen > const	ELsevere2
ELslGen	ELsevere2Gen
ELslGen	ELsevereGen
ELslProxy< ELsuccessGen > const	ELsuccess
ELslGen	ELsuccessGen
ELslProxy< ELunspecifiedGen > const	ELunspecified
ELslGen	ELunspecifiedGen
ELslProxy< ELwarningGen > const	ELwarning
ELslProxy< ELwarning2Gen > const	ELwarning2
ELslGen	ELwarning2Gen
ELslGen	ELwarningGen
ELslProxy< ELzeroSeverityGen > const	ELzeroSeverity
ELslGen	ELzeroSeverityGen
static char const *	fmt_Guid = "%08lX-%04hX-%04hX-%02hhX%02hhX-%02hhX%02hhX%02hhX%02hhX%02hhX%02hhX"
MallocOptionSetter	global_malloc_options
const int	init_size = 1024*1024
static unsigned int const	kAveEventPerSec = 200U
static unsigned int const	kNanoSecPerSec = 1000000000U
static const unsigned char	MLSCRIBE_RUNNING_INDICATOR = 29
static TriggerNamesMap::const_iterator	previousTriggerName
static EDProductGetter const *	s_productGetter = 0
static unsigned int const	shift = 8 * sizeof(unsigned int)
volatile bool	shutdown_flag = false
boost::mutex	signum_lock
volatile int	signum_value
static pset::TypeTrans const	sTypeTranslations
TransEntry	table []
static TriggerNamesMap	triggerNamesMap
boost::mutex	usr2_lock

---

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

Date:

2007/12/21 22:42:30

Revision:

1.3

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

CurrentProcessingContext is a class that carries information about the current event processing context. Each module in a framework job can access its CurrentProcessingContext *when that module is active in event processing*. At such a time, the CurrentProcessingContext will provide information about that module's place in the schedule, *as seen at that moment*.

N.B.: An individual module instance can appear in more than one path; this is why CurrentProcessingContext reports the module's place in the schedule as seen at the time of execution. This is also why the module can not be queried for this information when it is not active in processing.

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

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

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>

ExceptionCollector is a utility class that can be used to make sure that each function or functor in a sequence of calls is invoked even if a previous function throws. Each function/functor must take no arguments and return a void. boost::bind can be used to convert a function taking arguments into a function taking no arguments. The exception strings are saved in a cms::Exception for optional rethrow.

Here is an example:

ExceptionCollector c;

c.call(boost_bind(&MyClass::myFunction, myClassPtr)); c.call(boost_bind(&MyClass::myOtherFunction, myClassPtr, myArgPtr)); c.call(boost_bind(&myFreeFunction, myArgPtr)); if (c.hasThrown()) c.rethrow();

This insures that all three functions will be called before any exceptionis thrown.

A ThreadSafeIndexedRegistry is used to keep track of the instances of some type 'value_typed', stored in a vector.

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!

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

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

---

Typedef Documentation

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 edm::detail::ThreadSafeIndexedRegistry<BranchIDList, BranchIDListHelper> edm::BranchIDListRegistry

Definition at line 9 of file BranchIDListRegistry.h.

typedef BranchIDListRegistry::collection_type 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 unsigned char edm::byte_t

Definition at line 14 of file ProductStatus.h.

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

Definition at line 21 of file UnixSignalHandlers.h.

typedef uint32_t edm::det_id_type

Definition at line 20 of file DetSet.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 EntryDescriptionRegistry::collection_type edm::EntryDescriptionMap

Definition at line 14 of file EntryDescriptionRegistry.h.

typedef edm::detail::ThreadSafeRegistry<edm::EntryDescriptionID, edm::EventEntryDescription> edm::EntryDescriptionRegistry

Definition at line 13 of file EntryDescriptionRegistry.h.

typedef std::map<ErrorSummaryMapKey, unsigned int>::iterator edm::ErrorSummaryMapIterator

Definition at line 24 of file MessageSender.h.

typedef ErrorSummaryEntry edm::ErrorSummaryMapKey

Definition at line 22 of file MessageSender.h.

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

Definition at line 60 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 154 of file FWGenericHandle.h.

typedef Handle<GenericObject> edm::GenericHandle

Definition at line 147 of file GenericHandle.h.

typedef boost::shared_ptr<reftobase::RefHolderBase> edm::helper_ptr

Definition at line 43 of file EDProductfwd.h.

typedef reftobase::RefVectorHolderBase edm::helper_vector

Definition at line 44 of file EDProductfwd.h.

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

Definition at line 45 of file EDProductfwd.h.

typedef long long int edm::HRTimeDiffType

Definition at line 70 of file HRRealTime.h.

typedef unsigned long long int edm::HRTimeType

Definition at line 71 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 52 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 56 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 23 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 ParentageRegistry::collection_type edm::ParentageMap

Definition at line 14 of file ParentageRegistry.h.

typedef edm::detail::ThreadSafeRegistry<edm::ParentageID, edm::Parentage> edm::ParentageRegistry

Definition at line 13 of file ParentageRegistry.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 15 of file ConfigurationHandshake.h.

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

Definition at line 12 of file ConfigurationHandshake.h.

typedef PoolSource edm::PoolRASource

Definition at line 75 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 ProcessConfigurationRegistry::collection_type edm::ProcessConfigurationMap

Definition at line 11 of file ProcessConfigurationRegistry.h.

typedef edm::detail::ThreadSafeRegistry<edm::ProcessConfigurationID,edm::ProcessConfiguration> edm::ProcessConfigurationRegistry

Definition at line 10 of file ProcessConfigurationRegistry.h.

typedef ProcessConfigurationRegistry::vector_type edm::ProcessConfigurationVector

Definition at line 12 of file ProcessConfigurationRegistry.h.

typedef Hash<ProcessHistoryType> edm::ProcessHistoryID

Definition at line 9 of file ProcessHistoryID.h.

typedef ProcessHistoryRegistry::collection_type edm::ProcessHistoryMap

Definition at line 11 of file ProcessHistoryRegistry.h.

typedef edm::detail::ThreadSafeRegistry<edm::ProcessHistoryID,edm::ProcessHistory> edm::ProcessHistoryRegistry

Definition at line 10 of file ProcessHistoryRegistry.h.

typedef ProcessHistoryRegistry::vector_type edm::ProcessHistoryVector

Definition at line 12 of file ProcessHistoryRegistry.h.

typedef unsigned short edm::ProcessIndex

Definition at line 25 of file ProductID.h.

typedef std::string edm::ProcessingTask

Definition at line 8 of file ProcessingTask.h.

typedef unsigned short edm::ProductIndex

Definition at line 26 of file ProductID.h.

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

Definition at line 89 of file ProductProvenance.h.

typedef byte_t edm::ProductStatus

Definition at line 15 of file ProductStatus.h.

typedef unsigned int edm::ProductTransientIndex

Definition at line 22 of file ProductTransientIndex.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 28 of file ESProxyFactoryProducer.cc.

typedef std::string edm::ReleaseVersion

Definition at line 7 of file ReleaseVersion.h.

typedef RunLumiEntryInfo edm::RunEntryInfo

Definition at line 53 of file RunLumiEntryInfo.h.

typedef unsigned int edm::RunNumber_t

Definition at line 32 of file EventRange.h.

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

Definition at line 10 of file Selections.h.

typedef boost::array<Selections, NumBranchTypes> edm::SelectionsArray

Definition at line 12 of file Selections.h.

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

Definition at line 99 of file StreamedProducts.h.

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

Definition at line 67 of file StreamedProducts.h.

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

Definition at line 12 of file SimTrackContainer.h.

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

Definition at line 13 of file SimVertexContainer.h.

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

Definition at line 14 of file SimVertexContainer.h.

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

Definition at line 15 of file SimVertexContainer.h.

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

Definition at line 16 of file SimVertexContainer.h.

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

Definition at line 22 of file ReflexTools.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 27 of file Timestamp.h.

typedef detail::CachedProducts::handle_t edm::Trig

Definition at line 31 of file OutputModule.h.

typedef std::map<edm::ParameterSetID, edm::TriggerNames> edm::TriggerNamesMap

Definition at line 29 of file EventBase.cc.

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

Definition at line 78 of file Entry.cc.

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

Definition at line 16 of file GroupSelector.cc.

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

Definition at line 15 of file VectorInputSourceFactory.h.

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

Definition at line 30 of file ParameterSet.h.

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

Definition at line 136 of file Schedule.cc.

---

Enumeration Type Documentation

anonymous enum

Enumerator:

kChildSucceed
kChildExitBadly
kChildSegv
kMaxChildAction

Definition at line 840 of file EventProcessor.cc.

       {
    kChildSucceed,
    kChildExitBadly,
    kChildSegv,
    kMaxChildAction
  };

enum edm::BranchActionType

Enumerator:

BranchActionBegin
BranchActionEnd

Definition at line 12 of file BranchActionType.h.

                        {
    BranchActionBegin = 0,
    BranchActionEnd = 1
  };

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

Enumerator:

GridJobMode
ReleaseValidationJobMode
AnalysisJobMode
NilJobMode

Definition at line 15 of file JobMode.h.

               {
         GridJobMode
       , ReleaseValidationJobMode
       , AnalysisJobMode
       , NilJobMode
  };

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

template<class FP >

bool edm::asm_isnan

(

FP

x

)

[inline]

Definition at line 44 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(), edm::GroupSelector::selected(), and edm::EventSkipperByID::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 L1TEmulatorMonitor_cff::p.

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

std::string const & edm::BranchTypeToAuxBranchName

(

BranchType const &

branchType

)

Definition at line 112 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 108 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 120 of file BranchType.cc.

References InEvent, and InRun.

Referenced by edm::RootOutputFile::RootOutputFile(), 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 104 of file BranchType.cc.

References ZMuMuCategoriesSequences_cff::eventInfo, InEvent, and InRun.

                                                                          { // 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 124 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 100 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 128 of file BranchType.cc.

References InEvent, and InRun.

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

std::string const & edm::BranchTypeToProductStatusBranchName

(

BranchType const &

branchType

)

Definition at line 116 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 96 of file BranchType.cc.

References patZpeak::events, InEvent, InRun, and getRunRegistry::runs.

Referenced by ProvenanceDumper::work_().

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

std::string const & edm::BranchTypeToString

(

BranchType const &

branchType

)

Definition at line 92 of file BranchType.cc.

References event(), InEvent, InRun, fjr2json::lumi, and DTTTrigCorrFirst::run.

Referenced by operator<<().

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

static void edm::check	(	Principal const &	p,
		std::string const &	id
	)		[static]

Definition at line 79 of file GetProductCheckerOutputModule.cc.

References edm::Principal::begin(), edm::Provenance::branchDescription(), edm::BranchDescription::branchID(), edm::ConstBranchDescription::branchID(), edm::OutputHandle::desc(), edm::Principal::end(), Exception, edm::Principal::getByLabel(), edm::Principal::getForOutput(), edm::BasicHandle::provenance(), and cond::rpcobtemp::temp.

Referenced by SegmentsTrackAssociator::associate(), edm::StreamerInputFile::openStreamerFile(), 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) {
            BranchID branchID = (*it)->branchDescription().branchID();
            OutputHandle const oh = p.getForOutput(branchID, false);
            
            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 tid((*it)->branchDescription().type().TypeInfo());
            size_t temp = 0;
            int tempCount = -1;
            BasicHandle bh = p.getByLabel(tid,
            (*it)->branchDescription().moduleLabel(),
            (*it)->branchDescription().productInstanceName(),
            (*it)->branchDescription().processName(),
            temp, tempCount);
            
            /*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 198 of file ReflexTools.cc.

References createPayload::checkType, and missingTypes().

Referenced by loadCap().

                                                                   {
    Type null;
    Type t = Type::ByName(name);
    if(t == null) {
      missingTypes().insert(name);
      return;
    }
    checkType(Type::ByName(name), noComponents);
  }

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

Definition at line 6 of file CommonExceptions.cc.

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

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

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

static void edm::cleanup

(

const Factory::MakerMap::value_type &

v

)

[static]

Definition at line 12 of file Factory.cc.

Referenced by ESDataCertificationTask::endJob(), ESSummaryClient::endJob(), EBClusterTaskExtras::endJob(), ESIntegrityTask::endJob(), ESDcsInfoTask::endJob(), ESDaqInfoTask::endJob(), ESPedestalTask::endJob(), ESIntegrityClient::endJob(), ESRawDataTask::endJob(), EEClusterTaskExtras::endJob(), ESPedestalClient::endJob(), ESFEDIntegrityTask::endJob(), ESTrendTask::endJob(), ESIntegrityClient::endRun(), ESPedestalClient::endRun(), ESSummaryClient::endRun(), PhysicsTools::MVATrainer::setCleanup(), and edm::Factory::~Factory().

  {
    delete v.second;
  }

static Guid const edm::clid_null

(

std::

string"00000000-0000-0000-0000-000000000000"

)

[static]

Referenced by edm::Guid::null().

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

Definition at line 275 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	(	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 FWHFRecHitProxyBuilder::build(), contains(), CaloTowersCreationAlgo::convert(), MultipleScatteringGeometry::detLayers(), pat::PATElectronProducer::fillElectron2(), pat::PATMuonProducer::fillMuon(), 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	(	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 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.

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.

Referenced by split().

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

  return e;

}  // contextual_find_not()

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::EventAuxiliary::processHistoryID_, edm::EventAux::processHistoryID_, edm::EventAux::time_, and edm::EventAuxiliary::time_.

Referenced by FWConversionProxyBuilder::requestCommon(), fwlite::Event::updateAux(), fwlite::Run::updateAux(), and fwlite::LuminosityBlock::updateAux().

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

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

Definition at line 12 of file LuminosityBlockAux.cc.

References edm::LuminosityBlockAuxiliary::beginTime_, edm::LuminosityBlockAuxiliary::endTime_, edm::LuminosityBlockAuxiliary::id_, edm::LuminosityBlockAux::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 12 of file RunAux.cc.

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

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

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

specialize this function for GenericHandle

Definition at line 19 of file GenericHandle.cc.

References Exception, edm::BasicHandle::failedToGet(), h, edm::BasicHandle::id(), edm::errors::InvalidReference, edm::errors::LogicError, edm::BasicHandle::provenance(), edm::Handle< GenericObject >::setWhyFailed(), edm::Handle< GenericObject >::type(), edm::BasicHandle::whyFailed(), wrap(), and edm::BasicHandle::wrapper().

{
  if(orig.failedToGet()) {
    result.setWhyFailed(orig.whyFailed());
    return;
  }
  EDProduct const* originalWrap = orig.wrapper();
  if (originalWrap == 0)
    throw edm::Exception(edm::errors::InvalidReference,"NullPointer")
      << "edm::BasicHandle has null pointer to Wrapper";
  
  //Since a pointer to an EDProduct is not necessarily the same as a pointer to the actual type
  // (compilers are allowed to offset the two) we must get our object via a two step process
  Reflex::Object edproductObject(Reflex::Type::ByTypeInfo(typeid(EDProduct)), const_cast<EDProduct*>(originalWrap));
  assert(edproductObject != Reflex::Object());
  
  Reflex::Object wrap(edproductObject.CastObject(edproductObject.DynamicType()));
  assert(wrap != Reflex::Object());
  
  Reflex::Object product(wrap.Get("obj"));
  if(!product){
    throw edm::Exception(edm::errors::LogicError)<<"GenericObject could not find 'obj' member";
  }
  if(product.TypeOf().IsTypedef()){
    //For a 'Reflex::Typedef' the 'ToType' method returns the actual type
    // this is needed since you are now allowed to 'invoke' methods of a 'Typedef'
    // only for a 'real' class
    product = Reflex::Object(product.TypeOf().ToType(), product.Address());
    assert(!product.TypeOf().IsTypedef());
  }
  //NOTE: comparing on type doesn't seem to always work! The problem appears to be if we have a typedef
  if(product.TypeOf()!=result.type() &&
     !product.TypeOf().IsEquivalentTo(result.type()) &&
     product.TypeOf().TypeInfo()!= result.type().TypeInfo()){
    throw edm::Exception(edm::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);
}

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

specialize this function forFWGenericHandle

Definition at line 19 of file FWGenericHandle.cc.

References benchmark_cfg::cerr, Exception, edm::BasicHandle::failedToGet(), h, edm::BasicHandle::id(), edm::errors::InvalidReference, edm::errors::LogicError, edm::BasicHandle::provenance(), edm::Handle< FWGenericObject >::setWhyFailed(), edm::Handle< FWGenericObject >::type(), edm::BasicHandle::whyFailed(), wrap(), and edm::BasicHandle::wrapper().

{
  if(orig.failedToGet()) {
    result.setWhyFailed(orig.whyFailed());
    return;
  }
  EDProduct const* originalWrap = orig.wrapper();
  if (originalWrap == 0)
    throw edm::Exception(edm::errors::InvalidReference,"NullPointer")
      << "edm::BasicHandle has null pointer to Wrapper";
  
  //Since a pointer to an EDProduct is not necessarily the same as a pointer to the actual type
  // (compilers are allowed to offset the two) we must get our object via a two step process
  Reflex::Object edproductObject(Reflex::Type::ByTypeInfo(typeid(EDProduct)), const_cast<EDProduct*>(originalWrap));
  assert(edproductObject != Reflex::Object());
  
  Reflex::Object wrap(edproductObject.CastObject(edproductObject.DynamicType()));
  assert(wrap != Reflex::Object());
  
  Reflex::Object product(wrap.Get("obj"));
  
  if(!product){
    throw edm::Exception(edm::errors::LogicError)<<"FWGenericObject could not find 'obj' member";
  }
  if(product.TypeOf().IsTypedef()){
    //For a 'Reflex::Typedef' the 'ToType' method returns the actual type
    // this is needed since you are now allowed to 'invoke' methods of a 'Typedef'
    // only for a 'real' class
    product = Reflex::Object(product.TypeOf().ToType(), product.Address());
    assert(!product.TypeOf().IsTypedef());
  }
  // NOTE: comparing on type doesn't seem to always work! The problem appears to be if we have a typedef
  if(product.TypeOf()!=result.type() &&
     !product.TypeOf().IsEquivalentTo(result.type()) &&
     product.TypeOf().TypeInfo()!= result.type().TypeInfo()){
        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);
}

template<class T >

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

Definition at line 17 of file ConvertHandle.h.

References compareJSON::const, edm::BasicHandle::failedToGet(), h, edm::Wrapper< T >::product(), edm::BasicHandle::provenance(), edm::handleimpl::throwConvertTypeError(), edm::handleimpl::throwInvalidReference(), edm::BasicHandle::whyFailed(), wrap(), and edm::BasicHandle::wrapper().

Referenced by edm::Event::get(), edm::PrincipalGetAdapter::get(), edm::Event::getByLabel(), edm::RunBase::getByLabel(), edm::EventBase::getByLabel(), edm::PrincipalGetAdapter::getByLabel(), edm::LuminosityBlockBase::getByLabel(), edm::PrincipalGetAdapter::getByType(), edm::PrincipalGetAdapter::getMany(), and edm::PrincipalGetAdapter::getManyByType().

                                         {
    if(orig.failedToGet()) {
      Handle<T> h(orig.whyFailed());
      h.swap(result);
      return;
    }
    EDProduct const* originalWrap = orig.wrapper();
    if (originalWrap == 0) {
      handleimpl::throwInvalidReference();
    }
    Wrapper<T> const* wrap = dynamic_cast<Wrapper<T> const*>(originalWrap);
    if (wrap == 0) {
      handleimpl::throwConvertTypeError(originalWrap);
    }

    Handle<T> h(wrap->product(), orig.provenance());
    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::MessageLoggerScribe::configure_dest(), dumpEventHeader(), dumpInitHeader(), MsgTools::fillNames(), edm::es::Label::operator()(), operator<<(), edm::GroupSelector::print(), edm::hash_detail::print_(), 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);
     }

data doxygen doxygen gen CMSSW_4_2_8 src FWCore Utilities src GlobalIdentifier cc std::string edm::createGlobalIdentifier

(

)

Definition at line 7 of file GlobalIdentifier.cc.

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

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

Definition at line 744 of file types.cc.

References event(), fjr2json::lumi, DTTTrigCorrFirst::run, tokenize(), and EcalElecEmulTccFlatFileProducerFromTPG_cfg::tokens.

                                                   {
    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 775 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 808 of file types.cc.

References fjr2json::lumi, DTTTrigCorrFirst::run, tokenize(), and EcalElecEmulTccFlatFileProducerFromTPG_cfg::tokens.

                                                             {
      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 833 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 867 of file types.cc.

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

                                                                {
    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 893 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 924 of file types.cc.

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

                                                      {
    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 958 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 1151 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 1170 of file types.cc.

References b, decode(), split(), and cond::rpcobtemp::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>

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

Definition at line 67 of file types.cc.

Referenced by 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(), cond::XMLAuthenticationService::XMLAuthenticationService::processFile(), cond::DecodingKey::readFromString(), 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 87 of file types.cc.

References b, decode(), split(), and cond::rpcobtemp::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 134 of file types.cc.

References b.

                                            {
    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 223 of file types.cc.

References b, decode(), split(), and cond::rpcobtemp::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 319 of file types.cc.

References b.

                                                     {
    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 388 of file types.cc.

References b, decode(), split(), and cond::rpcobtemp::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 178 of file types.cc.

References b.

                                                  {
    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 272 of file types.cc.

References b, decode(), split(), and cond::rpcobtemp::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 354 of file types.cc.

References b.

                                                           {
    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 435 of file types.cc.

References b, decode(), split(), and cond::rpcobtemp::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 484 of file types.cc.

References Capri::details::from(), infinity, and 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 528 of file types.cc.

References b, decode(), split(), and cond::rpcobtemp::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 574 of file types.cc.

References b, trackerHits::c, 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 1097 of file types.cc.

References b, decode(), split(), and cond::rpcobtemp::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 619 of file types.cc.

References cond::rpcobtemp::temp.

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

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

Definition at line 645 of file types.cc.

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

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

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

Definition at line 695 of file types.cc.

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

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

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

edm::DEFINE_FWK_MODULE

(

HiMixingModule

)

void edm::disableAllSigs

(

sigset_t *

oldset

)

Definition at line 59 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 18 of file LoggedErrorsSummary.cc.

References edm::MessageSender::errorSummaryIsBeingKept, and runTheMatrix::ret.

Referenced by edm::LogErrorHarvester::endJob().

                                 {
  bool ret = MessageSender::errorSummaryIsBeingKept;
  MessageSender::errorSummaryIsBeingKept = false;
  return ret;
}

void edm::disableRTSigs

(

)

Definition at line 69 of file UnixSignalHandlers.cc.

References MUST_BE_ZERO, and NULL.

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 108 of file UnixSignalHandlers.cc.

References MUST_BE_ZERO.

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

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

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

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

void edm::doBuildRealData

(

const std::string &

name

)

Definition at line 34 of file ClassFiller.cc.

References edm::errors::Configuration, Exception, FDEBUG, and getName().

Referenced by edm::StreamerInputSource::buildClassCache(), and stor::HLTInfo::buildClassCache().

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

ELseverityLevel const edm::ELabortGen

(

)

Definition at line 398 of file ELseverityLevel.cc.

References edm::ELseverityLevel::ELsev_abort.

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

ELseverityLevel const edm::ELerror2Gen

(

)

Definition at line 368 of file ELseverityLevel.cc.

References edm::ELseverityLevel::ELsev_error2.

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

ELseverityLevel const edm::ELerrorGen

(

)

Definition at line 362 of file ELseverityLevel.cc.

References edm::ELseverityLevel::ELsev_error.

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

ELseverityLevel const edm::ELfatalGen

(

)

Definition at line 404 of file ELseverityLevel.cc.

References edm::ELseverityLevel::ELsev_fatal.

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

ELseverityLevel const edm::ELhighestSeverityGen

(

)

Definition at line 410 of file ELseverityLevel.cc.

References edm::ELseverityLevel::ELsev_highestSeverity.

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

ELseverityLevel const edm::ELincidentalGen

(

)

Definition at line 332 of file ELseverityLevel.cc.

References edm::ELseverityLevel::ELsev_incidental.

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

ELseverityLevel const edm::ELinfoGen

(

)

Definition at line 344 of file ELseverityLevel.cc.

References edm::ELseverityLevel::ELsev_info.

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

ELseverityLevel const edm::ELnextEventGen

(

)

Definition at line 374 of file ELseverityLevel.cc.

References edm::ELseverityLevel::ELsev_next.

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

ELseverityLevel const edm::ELsevere2Gen

(

)

Definition at line 392 of file ELseverityLevel.cc.

References edm::ELseverityLevel::ELsev_severe2.

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

ELseverityLevel const edm::ELsevereGen

(

)

Definition at line 386 of file ELseverityLevel.cc.

References edm::ELseverityLevel::ELsev_severe.

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

ELseverityLevel const edm::ELsuccessGen

(

)

Definition at line 338 of file ELseverityLevel.cc.

References edm::ELseverityLevel::ELsev_success.

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

ELseverityLevel const edm::ELunspecifiedGen

(

)

Definition at line 380 of file ELseverityLevel.cc.

References edm::ELseverityLevel::ELsev_unspecified.

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

ELseverityLevel const edm::ELwarning2Gen

(

)

Definition at line 356 of file ELseverityLevel.cc.

References edm::ELseverityLevel::ELsev_warning2.

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

ELseverityLevel const edm::ELwarningGen

(

)

Definition at line 350 of file ELseverityLevel.cc.

References edm::ELseverityLevel::ELsev_warning.

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

ELseverityLevel const edm::ELzeroSeverityGen

(

)

Definition at line 326 of file ELseverityLevel.cc.

References edm::ELseverityLevel::ELsev_zeroSeverity.

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

bool edm::EnableLoggedErrorsSummary

(

)

Definition at line 12 of file LoggedErrorsSummary.cc.

References edm::MessageSender::errorSummaryIsBeingKept, and runTheMatrix::ret.

Referenced by edm::LogErrorHarvester::beginJob().

                                 {
  bool ret = MessageSender::errorSummaryIsBeingKept;
  MessageSender::errorSummaryIsBeingKept = true;
  return ret;
}

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

Definition at line 99 of file UnixSignalHandlers.cc.

References MUST_BE_ZERO.

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

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

Definition at line 758 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 791 of file types.cc.

References encode().

                                                              {
      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 820 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 849 of file types.cc.

References encode().

                                                                        {
    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 880 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 907 of file types.cc.

References encode().

                                                                           {
    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 938 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 972 of file types.cc.

References encode().

                                                                 {
    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 1159 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 1192 of file types.cc.

References b, and encode().

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

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

Definition at line 76 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 109 of file types.cc.

References b, and encode().

                                                        {
    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 158 of file types.cc.

References Capri::details::from().

                                     {
    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,
		unsigned int	from
	)

Definition at line 339 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 410 of file types.cc.

References b, and encode().

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

Definition at line 246 of file types.cc.

References b, and encode().

                                                       {
    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,
		long long	from
	)

Definition at line 202 of file types.cc.

References Capri::details::from().

                                           {
    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 295 of file types.cc.

References b, and encode().

                                                             {
    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 373 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 457 of file types.cc.

References b, and encode().

                                                                      {
    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 513 of file types.cc.

References Capri::details::from().

                                        {
    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 549 of file types.cc.

References b, and encode().

                                                          {
    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 987 of file types.cc.

References b, from_hex(), NONE, and to_hex_rep().

                                                  {
    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              to += to_hex_rep(*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':  {
              to += to_hex_rep(10);
              state = NONE;
              break;
            }
            case 't':  {
              to += to_hex_rep(9);
              state = NONE;
              break;
            }
            default:  {
              to += to_hex_rep(*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:  {
              to += to_hex_rep(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:  {
              to += to_hex_rep(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 1122 of file types.cc.

References b, and encode().

                                                             {
    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 631 of file types.cc.

References Capri::details::from().

                                                   {
    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 653 of file types.cc.

References edm::InputTag::encode().

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

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

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

Definition at line 703 of file types.cc.

References edm::ESInputTag::encode().

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

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

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

void edm::endmsg

(

ErrorLog &

)

Referenced by cond::XMLAuthenticationService::XMLAuthenticationService::initialize(), cond::XMLAuthenticationService::XMLAuthenticationService::processFile(), and cond::XMLAuthenticationService::XMLAuthenticationService::verifyFileName().

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

Definition at line 27 of file UnixSignalHandlers.cc.

References FDEBUG, and shutdown_flag.

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

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

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

Definition at line 42 of file ELstring.cc.

References indexGen::s2.

Referenced by edm::service::ELstatistics::formSummary().

                                                    {

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

static void edm::fillInProcessIndexes	(	TransientProductLookupMap::ProductLookupIndexList::iterator	iIt,
		TransientProductLookupMap::ProductLookupIndexList::iterator	iEnd,
		std::vector< std::string > const &	iNameOrder
	)		[static]

Definition at line 159 of file TransientProductLookupMap.cc.

References getHLTprescales::index.

Referenced by edm::TransientProductLookupMap::fillFrom(), and edm::TransientProductLookupMap::reorderIfNecessary().

                                                                {
     //NOTE the iterators are already in the same order as iNameOrder
     std::vector<std::string>::const_reverse_iterator itNO = iNameOrder.rbegin();
     unsigned int index = 0;
     for(; iIt != iEnd; ++iIt) {
        if(iIt->isFirst()) {
           itNO = iNameOrder.rbegin();
           index = 0;
        }
        while(*itNO != iIt->branchDescription()->processName()) {
           ++itNO;
           assert(itNO != iNameOrder.rend());
           ++index;
        }
        iIt->setProcessIndex(index);
     }
  }

static void edm::fillLookup	(	Reflex::Type const &	type,
		ProductTransientIndex const &	index,
		ConstBranchDescription const *	branchDesc,
		TransientProductLookupMap::FillFromMap &	oMap
	)		[static]

Definition at line 216 of file ProductRegistry.cc.

References edm::ConstBranchDescription::branchType(), and getHLTprescales::index.

Referenced by edm::ProductRegistry::initializeLookupTables().

                                                         {
    oMap[std::make_pair(TypeInBranchType(TypeID(type.TypeInfo()),
                                         branchDesc->branchType()),
                                         branchDesc)] = index;
  }

boost::shared_ptr<EDLooperBase> edm::fillLooper	(	eventsetup::EventSetupProvider &	cp,
		ParameterSet &	params,
		CommonParams const &	common
	)

Definition at line 323 of file EventProcessor.cc.

References reco::get(), edm::ParameterSet::getParameter(), edm::ParameterSet::getPSetForUpdate(), edm::CommonParams::passID_, edm::CommonParams::processName_, edm::ParameterSet::registerIt(), and edm::CommonParams::releaseVersion_.

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(cp,
                                                        *providerPSet,
                                                        common.processName_,
                                                        common.releaseVersion_,
                                                        common.passID_);
      }
      return vLooper;

  }

void edm::fillModuleInPathSummary	(	Path const &	,
		ModuleInPathSummary &
	)

Definition at line 952 of file Schedule.cc.

Referenced by fillPathSummary().

                                                             {
  }

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

Definition at line 956 of file Schedule.cc.

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

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

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

Definition at line 967 of file Schedule.cc.

References edm::PathSummary::bitPosition, edm::Path::bitPosition(), fillModuleInPathSummary(), i, edm::PathSummary::moduleInPathSummaries, edm::PathSummary::name, edm::Path::name(), edm::Path::size(), cond::rpcobtemp::temp, edm::PathSummary::timesExcept, edm::Path::timesExcept(), edm::PathSummary::timesFailed, edm::Path::timesFailed(), edm::Path::timesPassed(), edm::PathSummary::timesPassed, edm::PathSummary::timesRun, and edm::Path::timesRun().

Referenced by edm::Schedule::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();
    std::vector<ModuleInPathSummary> temp(sz);
    for (size_t i = 0; i != sz; ++i) {
      fillModuleInPathSummary(path, i, temp[i]);
    }
    sum.moduleInPathSummaries.swap(temp);
  }

void edm::fillProductRegistryTransients	(	std::vector< ProcessConfiguration > const &	pcVec,
		ProductRegistry const &	preg,
		bool	okToRegister = false
	)

Definition at line 66 of file FillProductRegistryTransients.cc.

References i.

Referenced by edm::StreamerInputSource::mergeIntoRegistry(), edm::RootFile::RootFile(), edm::Schedule::Schedule(), TFWLiteSelectorBasic::setupNewFile(), and ProvenanceDumper::work_().

                                                                                                                              {
    typedef std::vector<ProcessConfiguration>::const_iterator PCIter;
    for(PCIter i = pcVec.begin(), iEnd = pcVec.end(); i != iEnd; ++i) {
      fillProductRegistryTransients(*i, preg, okToRegister);
    }
  }

void edm::fillProductRegistryTransients	(	ProcessConfiguration const &	pc,
		ProductRegistry const &	preg,
		bool	okToRegister = false
	)

Definition at line 20 of file FillProductRegistryTransients.cc.

References edm::ParameterSet::empty(), edm::ParameterSet::existsAs(), edm::ParameterSet::getParameter(), edm::ParameterSet::getParameterSet(), edm::ParameterSet::id(), edm::ProcessConfiguration::id(), collect_tpl::input, edm::detail::ThreadSafeRegistry< KEY, T, E >::instance(), edm::ParameterSet::isRegistered(), moduleLabel(), edm::BranchDescription::moduleLabel(), edm::BranchDescription::moduleNames(), edm::ProcessConfiguration::parameterSetID(), edm::BranchDescription::parameterSetIDs(), edm::ProcessConfiguration::processName(), edm::BranchDescription::processName(), edm::ProductRegistry::productList(), edm::ParameterSet::registerIt(), and LaserTracksInput_cfi::source.

                                                                                                                {
    std::string const triggerResults = std::string("TriggerResults");
    std::string const triggerResultsInserter = std::string("TriggerResultsInserter");
    std::string const triggerPaths = std::string("@trigger_paths");
    std::string const source = std::string("source");
    std::string const input = std::string("@main_input");
    ProcessConfigurationID pcid = pc.id();
    std::string const& processName = pc.processName();
    ParameterSetID const& processParameterSetID = pc.parameterSetID();
    ParameterSet const* processParameterSet = pset::Registry::instance()->getMapped(processParameterSetID);
    if(0 == processParameterSet || processParameterSet->empty()) {
      return;
    }
    for(ProductRegistry::ProductList::const_iterator it = preg.productList().begin(),
        itEnd = preg.productList().end();
        it != itEnd; ++it) {
      BranchDescription const& bd = it->second;
      if(processName != bd.processName()) {
        continue;
      }
      std::string moduleLabel = bd.moduleLabel();
      bool isTriggerResults = (moduleLabel == triggerResults);
      if(isTriggerResults) {
        moduleLabel = triggerPaths;
      } else if(moduleLabel == source) {
        moduleLabel = input;
      }
      if(processParameterSet->existsAs<ParameterSet>(moduleLabel)) {
        ParameterSet const& moduleParameterSet = processParameterSet->getParameterSet(moduleLabel);
        if(okToRegister && !moduleParameterSet.isRegistered()) {
          ParameterSet moduleParameterSetCopy = processParameterSet->getParameterSet(moduleLabel);
          moduleParameterSetCopy.registerIt();
          bd.parameterSetIDs().insert(std::make_pair(pcid, moduleParameterSetCopy.id()));
        } else {
          bd.parameterSetIDs().insert(std::make_pair(pcid, moduleParameterSet.id()));
        }
        if(isTriggerResults) {
          bd.moduleNames().insert(std::make_pair(pcid, triggerResultsInserter));
        } else {
          bd.moduleNames().insert(std::make_pair(pcid, moduleParameterSet.getParameter<std::string>("@module_type")));
        }
      }
    }
  }

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

References edm::detail::reallyfillPtrVector().

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

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

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

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

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

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

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

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

References edm::detail::reallyfillPtrVector().

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

References edm::detail::reallyfillPtrVector().

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

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

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

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

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

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

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

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

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

Definition at line 192 of file PtrVector.h.

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

                                                         {
    obj.fillView(pointers);
  }

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

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

Definition at line 415 of file DetSetVector.h.

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

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

References edm::RefVector< C, T, F >::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 444 of file SortedCollection.h.

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

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

template<typename T >

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

Definition at line 255 of file Vector.h.

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

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

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

Definition at line 994 of file Schedule.cc.

References fillWorkerSummaryAux().

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

                                                          {
    fillWorkerSummaryAux(*pw, sum);
  }

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

Definition at line 984 of file Schedule.cc.

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

Referenced by fillWorkerSummary().

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

template<typename ForwardSequence , typename Predicate >

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

Definition at line 61 of file Algorithms.h.

References L1TEmulatorMonitor_cff::p.

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

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 L1TEmulatorMonitor_cff::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::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,
		Reflex::Type const &	type_to_search,
		Reflex::Type &	found_type
	)

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

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

Definition at line 32 of file ReflexTools.cc.

References get_final_type(), and i.

                                           {
    // Look for a sub-type named 'nested_type'
    for(Type_Iterator
           i = type_to_search.SubType_Begin(),
           e = type_to_search.SubType_End();
           i != e;
           ++i) {
      if(i->Name() == nested_type) {
        found_type = get_final_type(*i);
        return true;
      }
    }
    return false;
  }

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::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::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 const& edm::findOrDefault	(	std::map< Key, Value > const &	m,
		Key const &	k,