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

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

struct	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

class	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

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

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

template<typename ForwardSequence , typename Datum , typename Predicate >
bool	binary_search_all (ForwardSequence const &s, Datum const &d, Predicate p)

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

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

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

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

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

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

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

std::string const &	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 (LuminosityBlockRange const &lh, LuminosityBlockID const &rh)

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

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

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

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

template<class FwdIter >
FwdIter	contextual_find (FwdIter b, FwdIter e, char first, char sep, char last)

template<class FwdIter >
FwdIter	contextual_find_not (FwdIter b, FwdIter e, char first, char sep, char last)

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

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

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

template<class T >
void	convert_handle (BasicHandle const &orig, Handle< T > &result)

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

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

template<typename ForwardSequence , typename Func >
Func	copy_all (ForwardSequence &s, Func f)
	wrappers for copy More...

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

std::string	createGlobalIdentifier ()

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

unsigned int	decodeInt (unsigned char *v)

	DEFINE_FWK_MODULE (HiMixingModule)

void	disableAllSigs (sigset_t *oldset)

bool	DisableLoggedErrorsSummary ()

void	disableRTSigs ()

void	disableSignal (sigset_t *newset, int signum)

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

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

void	doBuildRealData (const std::string &name)

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

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

bool	encode (std::string &, int)

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

bool	encode (std::string &, unsigned int)

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

bool	encode (std::string &, long long)

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

bool	encode (std::string &, unsigned long long)

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

bool	encode (std::string &, double)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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 >
void	fillPtrVector (std::vector< T, A > const &obj, std::type_info const &iToType, std::vector< unsigned long > const &iIndicies, std::vector< void const * > &oPtr)

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

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

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

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

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

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

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

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

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

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

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

template<typename 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 >
void	fillView (RefToBaseVector< T > const &obj, std::vector< void const * > &pointers)

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

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

template<typename T , typename SORT >
void	fillView (SortedCollection< T, SORT > 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)

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

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

template<typename ForwardSequence , typename Predicate >
ForwardSequence::const_iterator	find_if_in_all (ForwardSequence const &s, Predicate const &p)
	wrappers for std::find More...

template<typename ForwardSequence , typename Predicate >
ForwardSequence::iterator	find_if_in_all (ForwardSequence &s, Predicate const &p)

template<typename ForwardSequence , typename Datum >
ForwardSequence::const_iterator	find_in_all (ForwardSequence const &s, Datum const &d)
	wrappers for std::find More...

template<typename ForwardSequence , typename Datum >
ForwardSequence::iterator	find_in_all (ForwardSequence &s, Datum const &d)

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

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

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

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

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

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

template<typename T , typename U >
T	first (std::pair< T, U > const &p)

void	FlushMessageLog ()

template<typename ForwardSequence , typename Func >
Func	for_all (ForwardSequence &s, Func f)
	wrapper for std::for_each More...

template<typename S , typename T >
S &	formatFile (T const &f, S &os)

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

bool	isnan (long double q)

bool	isSameEvent (EventAuxiliary const &a, EventAuxiliary const &b)

bool	isSameEvent (EventPrincipal const &a, EventPrincipal const &b)

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

bool	isWarningEnabled ()

template<typename V , typename T >
bool	iterateTrieLeaves (V &v, TrieNode< T > const &n, std::string const &label="")
	visits only leaf nodes More...

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

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

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

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

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

static const TimeValue_t	kLowMask (0xFFFFFFFF)

bool	lessThan (LuminosityBlockRange const &lh, LuminosityBlockRange const &rh)

bool	lessThan (EventRange const &lh, EventRange const &rh)

bool	lessThanSpecial (EventRange const &lh, EventRange const &rh)

void	loadCap (const std::string &name)

void	loadExtraClasses ()

static ELmap const &	loadMap ()

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

template<typename ForwardSequence , typename Datum >
ForwardSequence::iterator	lower_bound_all (ForwardSequence &s, Datum const &d)

template<typename ForwardSequence , typename Datum , typename Predicate >
ForwardSequence::const_iterator	lower_bound_all (ForwardSequence const &s, Datum const &d, Predicate p)

template<typename ForwardSequence , typename Datum , typename Predicate >
ForwardSequence::iterator	lower_bound_all (ForwardSequence &s, Datum const &d, Predicate p)

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

template<class HandleT >
Ref< typename HandleT::element_type, typename HandleT::element_type::value_type::value_type >	makeRefTo (const HandleT &iHandle, det_id_type iDetID, typename HandleT::element_type::value_type::const_iterator itIter)

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

template<class HandleT >
Ref< typename HandleT::element_type, typename HandleT::element_type::value_type::value_type >	makeRefToDetSetLazyVector (const HandleT &iHandle, det_id_type iDetID, typename HandleT::element_type::value_type::iterator itIter)

template<class HandleT >
Ref< typename HandleT::element_type, typename HandleT::element_type::value_type::value_type >	makeRefToDetSetRefVector (const HandleT &iHandle, det_id_type iDetID, typename HandleT::element_type::value_type::const_iterator itIter)

template<class HandleT >
Ref< typename HandleT::element_type, typename HandleT::element_type::value_type::value_type >	makeRefToDetSetRefVector (const HandleT &iHandle, det_id_type iDetID, typename HandleT::element_type::value_type::iterator itIter)

template<class HandleT >
Ref< typename HandleT::element_type, typename HandleT::element_type::value_type::value_type >	makeRefToDetSetVector (const HandleT &iHandle, det_id_type iDetID, typename HandleT::element_type::value_type::iterator itIter)

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

std::string	match (ConstBranchDescription const &a, ConstBranchDescription const &b, std::string const &fileName, BranchDescription::MatchMode m)

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

LuminosityBlockID const &	max (LuminosityBlockID const &lh, LuminosityBlockID const &rh)

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

const unsigned int	maxIDlength (200)

bool	merge (LuminosityBlockRange &lh, LuminosityBlockRange &rh)

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

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

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)

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

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

template<typename KEY >
bool	operator!= (RefItem< KEY > const &lhs, RefItem< KEY > const &rhs)

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

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

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

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

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

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

template<typename KEY >
bool	operator!= (RefBase< KEY > const &lhs, RefBase< KEY > const &rhs)

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

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

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

bool	operator!= (ProductProvenance const &a, ProductProvenance 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. More...

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

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

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

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

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

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

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

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

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

template<typename C , typename T , typename F >
bool	operator!= (RefVector< C, T, F > const &lhs, RefVector< C, T, F > const &rhs)

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

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

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

template<typename C , typename T , typename F >
bool	operator!= (FwdRef< C, T, F > const &lhs, FwdRef< C, T, F > const &rhs)

template<typename C , typename T , typename F >
bool	operator!= (Ref< C, T, F > const &lhs, FwdRef< C, T, F > const &rhs)

template<typename C , typename T , typename F >
bool	operator!= (FwdRef< C, T, F > const &lhs, Ref< C, T, F > const &rhs)

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

template<typename C , typename T , typename F >
bool	operator!= (Ref< C, T, F > const &lhs, Ref< C, T, F > const &rhs)

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

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

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

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

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

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

template<typename C , typename T , typename F >
RefVectorIterator< C, T, F >	operator+ (typename RefVectorIterator< C, T, F >::difference n, RefVectorIterator< C, T, F > const &iter)

template<typename C >
Association< C >	operator+ (const Association< C > &a1, const Association< C > &a2)

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

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

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

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

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

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

template<typename KEY >
bool	operator< (RefItem< KEY > const &lhs, RefItem< KEY > const &rhs)

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

template<typename KEY >
bool	operator< (RefBase< KEY > const &lhs, RefBase< KEY > const &rhs)

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

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

template<class T >
bool	operator< (DetSet< T > const &x, DetSet< T > const &y)

template<class T >
bool	operator< (DetSet< T > const &x, det_id_type y)

template<class T >
bool	operator< (det_id_type x, DetSet< T > const &y)

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

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

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

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

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

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

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

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

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

template<typename C , typename T , typename F >
bool	operator< (FwdRef< C, T, F > const &lhs, FwdRef< C, T, F > const &rhs)

template<typename C , typename T , typename F >
bool	operator< (Ref< C, T, F > const &lhs, FwdRef< C, T, F > const &rhs)

template<typename C , typename T , typename F >
bool	operator< (FwdRef< C, T, F > const &lhs, Ref< C, T, F > const &rhs)

template<typename C , typename T , typename F >
bool	operator< (Ref< C, T, F > const &lhs, Ref< C, T, F > const &rhs)

std::ostream &	operator<< (std::ostream &os, TimeOfDay const &tod)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

edm::MessageSender &	operator<< (edm::MessageSender &os, JobReport::InputFile const &f)

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

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

std::ostream &	operator<< (std::ostream &os, VParameterSetEntry const &vpsetEntry)

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

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

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

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

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

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

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

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

std::ostream &	operator<< (std::ostream &os, const edm::FileInPath &fip)

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

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

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

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

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

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

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

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

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

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

std::ostream &	operator<< (std::ostream &os, JobReport::LumiSectionReport const &rep)

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

std::ostream &	operator<< (std::ostream &os, Entry const &entry)

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

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

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

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

template<typename KEY >
bool	operator== (RefItem< KEY > const &lhs, RefItem< KEY > const &rhs)

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

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

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

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

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

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

template<typename KEY >
bool	operator== (RefBase< KEY > const &lhs, RefBase< KEY > const &rhs)

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

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

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

bool	operator== (ProductProvenance const &a, ProductProvenance 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. More...

template<class T >
bool	operator== (RefToBaseVector< T > const &a, RefToBaseVector< T > const &b)

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

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

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

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

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

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

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

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

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

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

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

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

template<typename C , typename T , typename F >
bool	operator== (RefVector< C, T, F > const &lhs, RefVector< C, T, F > const &rhs)

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

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

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

template<typename C , typename T , typename F >
bool	operator== (FwdRef< C, T, F > const &lhs, FwdRef< C, T, F > const &rhs)

template<typename C , typename T , typename F >
bool	operator== (Ref< C, T, F > const &lhs, FwdRef< C, T, F > const &rhs)

template<typename C , typename T , typename F >
bool	operator== (FwdRef< C, T, F > const &lhs, Ref< C, T, F > const &rhs)

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

template<typename C , typename T , typename F >
bool	operator== (Ref< C, T, F > const &lhs, Ref< C, T, F > const &rhs)

template<typename T , typename SORT , typename ALLOC >
bool	operator== (SortedCollection< T, SORT > const &c, std::vector< T, ALLOC > const &v)

template<typename T , typename SORT >
bool	operator== (SortedCollection< T, SORT > const &a, SortedCollection< T, SORT > const &b)

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

bool	operator> (const TypeIDBase &a, const TypeIDBase &b)

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

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

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

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

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

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

std::istream &	operator>> (std::istream &is, FileInPath &fip)

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

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

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

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

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

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

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

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

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

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

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

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

std::auto_ptr < ParameterDescriptionCases < bool > >	operator\|\| (std::auto_ptr< ParameterDescriptionCases< bool > >, std::auto_ptr< ParameterDescriptionCases< bool > >)

std::auto_ptr < ParameterDescriptionCases < int > >	operator\|\| (std::auto_ptr< ParameterDescriptionCases< int > >, std::auto_ptr< ParameterDescriptionCases< int > >)

std::auto_ptr < ParameterDescriptionCases < std::string > >	operator\|\| (std::auto_ptr< ParameterDescriptionCases< std::string > >, std::auto_ptr< ParameterDescriptionCases< std::string > >)

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)

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)

bool	overlaps (LuminosityBlockRange const &lh, LuminosityBlockRange const &rh)

bool	overlaps (EventRange const &lh, EventRange const &rh)

template<>
std::string	ParameterSet::getParameter< std::string > (std::string const &name) const

template<>
std::string	ParameterSet::getParameter< std::string > (char const *name) const

template<>
std::vector< double >	ParameterSet::getParameter< std::vector< double > > (std::string const &name) const

template<>
std::vector< double >	ParameterSet::getParameter< std::vector< double > > (char const *name) const

template<>
std::vector< ESInputTag >	ParameterSet::getParameter< std::vector< ESInputTag > > (std::string const &name) const

template<>
std::vector< ESInputTag >	ParameterSet::getParameter< std::vector< ESInputTag > > (char const *name) const

template<>
std::vector< EventID >	ParameterSet::getParameter< std::vector< EventID > > (std::string const &name) const

template<>
std::vector< EventID >	ParameterSet::getParameter< std::vector< EventID > > (char const *name) const

template<>
std::vector< EventRange >	ParameterSet::getParameter< std::vector< EventRange > > (std::string const &name) const

template<>
std::vector< EventRange >	ParameterSet::getParameter< std::vector< EventRange > > (char const *name) const

template<>
std::vector< InputTag >	ParameterSet::getParameter< std::vector< InputTag > > (std::string const &name) const

template<>
std::vector< InputTag >	ParameterSet::getParameter< std::vector< InputTag > > (char const *name) const

template<>
std::vector< int >	ParameterSet::getParameter< std::vector< int > > (std::string const &name) const

template<>
std::vector< int >	ParameterSet::getParameter< std::vector< int > > (char const *name) const

template<>
std::vector< long long >	ParameterSet::getParameter< std::vector< long long > > (std::string const &name) const

template<>
std::vector< long long >	ParameterSet::getParameter< std::vector< long long > > (char const *name) const

template<>
std::vector< LuminosityBlockID >	ParameterSet::getParameter< std::vector< LuminosityBlockID > > (std::string const &name) const

template<>
std::vector< LuminosityBlockID >	ParameterSet::getParameter< std::vector< LuminosityBlockID > > (char const *name) const

template<>
std::vector< LuminosityBlockRange >	ParameterSet::getParameter< std::vector< LuminosityBlockRange > > (std::string const &name) const

template<>
std::vector< LuminosityBlockRange >	ParameterSet::getParameter< std::vector< LuminosityBlockRange > > (char const *name) const

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

template<>
std::vector< PdtEntry >	ParameterSet::getParameter< std::vector< PdtEntry > > (std::string const &name) const

template<>
std::vector< std::string >	ParameterSet::getParameter< std::vector< std::string > > (std::string const &name) const

template<>
std::vector< std::string >	ParameterSet::getParameter< std::vector< std::string > > (char const *name) const

template<>
std::vector< unsigned int >	ParameterSet::getParameter< std::vector< unsigned int > > (std::string const &name) const

template<>
std::vector< unsigned int >	ParameterSet::getParameter< std::vector< unsigned int > > (char const *name) const

template<>
std::vector< unsigned long long >	ParameterSet::getParameter< std::vector< unsigned long long > > (std::string const &name) const

template<>
std::vector< unsigned long long >	ParameterSet::getParameter< std::vector< unsigned long long > > (char const *name) const

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

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

template<>
std::string	ParameterSet::getUntrackedParameter< std::string > (std::string const &name) const

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

template<>
std::string	ParameterSet::getUntrackedParameter< std::string > (char const *name) const

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

template<>
std::vector< double >	ParameterSet::getUntrackedParameter< std::vector< double > > (std::string const &name) const

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

template<>
std::vector< EventID >	ParameterSet::getUntrackedParameter< std::vector< EventID > > (std::string const &name) const

template<>
std::vector< EventID >	ParameterSet::getUntrackedParameter< std::vector< EventID > > (char const *name) const

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

template<>
std::vector< EventRange >	ParameterSet::getUntrackedParameter< std::vector< EventRange > > (std::string const &name) const

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

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

template<>
std::vector< EventRange >	ParameterSet::getUntrackedParameter< std::vector< EventRange > > (char const *name) const

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

template<>
std::vector< InputTag >	ParameterSet::getUntrackedParameter< std::vector< InputTag > > (std::string const &name) const

template<>
std::vector< InputTag >	ParameterSet::getUntrackedParameter< std::vector< InputTag > > (char const *name) const

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

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

template<>
std::vector< int >	ParameterSet::getUntrackedParameter< std::vector< int > > (std::string const &name) const

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

template<>
std::vector< int >	ParameterSet::getUntrackedParameter< std::vector< int > > (char const *name) const

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

template<>
std::vector< long long >	ParameterSet::getUntrackedParameter< std::vector< long long > > (std::string const &name) const

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

template<>
std::vector< LuminosityBlockID >	ParameterSet::getUntrackedParameter< std::vector< LuminosityBlockID > > (std::string const &name) const

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

template<>
std::vector< LuminosityBlockID >	ParameterSet::getUntrackedParameter< std::vector< LuminosityBlockID > > (char const *name) const

template<>
std::vector< LuminosityBlockRange >	ParameterSet::getUntrackedParameter< std::vector< LuminosityBlockRange > > (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) const

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

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

template<>
std::vector< PdtEntry >	ParameterSet::getUntrackedParameter< std::vector< PdtEntry > > (std::string const &name) const

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

template<>
std::vector< PdtEntry >	ParameterSet::getUntrackedParameter< std::vector< PdtEntry > > (char const *name) const

template<>
std::vector< std::string >	ParameterSet::getUntrackedParameter< std::vector< std::string > > (std::string const &name) const

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

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

template<>
std::vector< std::string >	ParameterSet::getUntrackedParameter< std::vector< std::string > > (char const *name) const

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

template<>
std::vector< unsigned int >	ParameterSet::getUntrackedParameter< std::vector< unsigned int > > (std::string const &name) const

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

template<>
std::vector< unsigned int >	ParameterSet::getUntrackedParameter< std::vector< unsigned int > > (char const *name) const

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

template<>
std::vector< unsigned long long >	ParameterSet::getUntrackedParameter< std::vector< unsigned long long > > (std::string const &name) const

template<>
std::vector< unsigned long long >	ParameterSet::getUntrackedParameter< std::vector< unsigned long long > > (char const *name, 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

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::InputFile const &f)

template<typename S >
S &	print (S &os, JobReport::OutputFile const &f)

template<typename S >
S &	print (S &os, JobReport::RunReport const &rep)

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

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

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

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

template<typename RecordT >
void	print_eventsetup_record_dependencies_recursive (std::ostream &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 More...

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

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

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, Reflex::Type const &dynamicType, std::type_info const &toType)

void const *	reflex_pointer_adjust (void *raw, 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 ()

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

template<typename T , typename A >
void	setPtr (std::vector< T, A > const &obj, std::type_info const &iToType, unsigned long iIndex, void const *&oPtr)

template<typename T , typename A >
void	setPtr (std::list< T, A > const &obj, std::type_info const &iToType, unsigned long iIndex, void const *&oPtr)

template<typename T , typename A >
void	setPtr (std::deque< T, A > const &obj, std::type_info const &iToType, unsigned long iIndex, void const *&oPtr)

template<typename T , typename A , typename Comp >
void	setPtr (std::set< T, A, Comp > const &obj, std::type_info const &iToType, unsigned long iIndex, void const *&oPtr)

template<typename T , typename SORT >
void	setPtr (SortedCollection< T, SORT > const &obj, std::type_info const &toType, unsigned long index, void const *&ptr)

template<typename T , typename P >
void	setPtr (OwnVector< T, P > const &obj, std::type_info const &toType, unsigned long index, void const *&ptr)

void	setRefCoreStreamer (bool resetAll=false)

EDProductGetter const *	setRefCoreStreamer (EDProductGetter const *ep, 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 More...

template<typename RandomAccessSequence , typename Predicate >
void	sort_all (RandomAccessSequence &s, Predicate p)

std::vector < LuminosityBlockRange > &	sortAndRemoveOverlaps (std::vector< LuminosityBlockRange > &lumiRange)

std::vector< EventRange > &	sortAndRemoveOverlaps (std::vector< EventRange > &eventRange)

template<class OutIter >
bool	split (OutIter result, std::string const &string_to_split, char first, char sep, char last)

void	squelchStandAloneMessageCategory (std::string const &category)

template<typename RandomAccessSequence >
void	stable_sort_all (RandomAccessSequence &s)
	wrappers for std::stable_sort More...

template<typename RandomAccessSequence , typename Predicate >
void	stable_sort_all (RandomAccessSequence &s, Predicate p)

std::string	stripLeadingDirectoryTree (const std::string &file)

void	swap (ProductID &a, ProductID &b)

void	swap (GroupData &a, GroupData &b)

void	swap (Parentage &a, Parentage &b)

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

void	swap (ESHandleBase &a, ESHandleBase &b)

void	swap (OrphanHandleBase &a, OrphanHandleBase &b)

void	swap (ProcessHistory &a, ProcessHistory &b)

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

void	swap (TriggerResults &lhs, TriggerResults &rhs)

void	swap (HandleBase &a, HandleBase &b)

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

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

void	swap (BasicHandle &a, BasicHandle &b)

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

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

void	swap (OutputHandle &a, OutputHandle &b)

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

void	swap (FileInPath &a, FileInPath &b)

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

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

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

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

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

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

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

template<int I>
void	swap (Hash< I > &a, Hash< I > &b)

void	swap (DataFrameContainer &lhs, DataFrameContainer &rhs)

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

void	swap (InputGroup &a, InputGroup &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)

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

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

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

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

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

void	swap (ScheduledGroup &a, ScheduledGroup &b)

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

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

void	swap (ParameterSet &a, ParameterSet &b)

void	swap (UnscheduledGroup &a, UnscheduledGroup &b)

void	swap (SourceGroup &a, SourceGroup &b)

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

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

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

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

template<typename T , typename P >
void	swap (OwnVector< T, P > &a, OwnVector< T, P > &b)

template<class T >
void	swap (LazyGetter< T > &a, LazyGetter< T > &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 More...

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

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

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/07/06 12:54:47

Revision:: 1.2

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 43 of file math.h.

References flags.

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

template<typename ForwardSequence , typename Datum >

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

inline

wrappers for std::binary_search

Definition at line 76 of file Algorithms.h.

Referenced by edm::EventContentAnalyzer::analyze(), CaloVNoiseSignalGenerator::contains(), 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::ConstBranchDescription::branchID(), edm::BranchDescription::branchID(), edm::OutputHandle::desc(), edm::Principal::end(), edm::hlt::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 edm::hlt::Exception, and edm::errors::InvalidReference.

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

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

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

static

Definition at line 12 of file Factory.cc.

Referenced by ESDataCertificationTask::endJob(), ESPedestalTask::endJob(), ESIntegrityTask::endJob(), ESRawDataTask::endJob(), ESDaqInfoTask::endJob(), ESFEDIntegrityTask::endJob(), ESPedestalClient::endJob(), ESDcsInfoTask::endJob(), ESSummaryClient::endJob(), ESTrendTask::endJob(), ESIntegrityClient::endJob(), EEClusterTaskExtras::endJob(), EBClusterTaskExtras::endJob(), ESPedestalClient::endRun(), ESSummaryClient::endRun(), ESIntegrityClient::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	(	LuminosityBlockRange const &	lh,
		LuminosityBlockID const &	rh
	)

Definition at line 52 of file LuminosityBlockRange.cc.

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

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

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

Definition at line 59 of file LuminosityBlockRange.cc.

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

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

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

Definition at line 38 of file EventRange.cc.

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

Referenced by python.Vispa.Gui.PortConnection.PointToPointConnection::belongsToRoute(), FWHFRecHitProxyBuilder::build(), contains(), python.Vispa.Views.LineDecayView.DecayNode::containsPoint(), python.Vispa.Views.LineDecayView.DecayLine::containsPoint(), CaloTowersCreationAlgo::convert(), MultipleScatteringGeometry::detLayers(), python.Vispa.Gui.ConnectableWidget.ConnectableWidget::dropAreaPort(), pat::PATElectronProducer::fillElectron2(), pat::PATMuonProducer::fillMuon(), python.Vispa.Main.StartupScreen.StartupScreen::mouseMoveEvent(), python.Vispa.Gui.MenuWidget.MenuWidget::mouseMoveEvent(), python.Vispa.Gui.MenuWidget.MenuWidget::mousePressEvent(), python.Vispa.Gui.PortWidget.PortWidget::mouseReleaseEvent(), python.Vispa.Gui.ConnectableWidgetOwner.ConnectableWidgetOwner::propagateEventUnderConnectionWidget(), and CaloTowersCreationAlgo::rescaleTowers().

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

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

Definition at line 49 of file EventRange.cc.

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

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

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

Definition at line 45 of file EventRange.cc.

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

Referenced by contains().

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

template<class FwdIter >

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

Definition at line 48 of file split.h.

References b.

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	(	LuminosityBlockAux const &	from,
		LuminosityBlockAuxiliary &	to
	)

Definition at line 12 of file LuminosityBlockAux.cc.

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

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

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

Definition at line 12 of file RunAux.cc.

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

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

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

Definition at line 9 of file EventAux.cc.

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

Referenced by edm::RootFile::fillLumiAuxiliary(), edm::RootFile::fillRunAuxiliary(), edm::RootFile::fillThisEventAuxiliary(), FWConversionProxyBuilder::requestCommon(), fwlite::Run::updateAux(), fwlite::LuminosityBlock::updateAux(), and fwlite::Event::updateAux().

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

template<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::EventBase::getByLabel(), edm::RunBase::getByLabel(), edm::Event::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);
   }

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, edm::hlt::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);
 }

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

specialize this function for GenericHandle

Definition at line 19 of file GenericHandle.cc.

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

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

std::string edm::createGlobalIdentifier ( )

Definition at line 6 of file GlobalIdentifier.cc.

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

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

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

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

Definition at line 67 of file types.cc.

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

Definition at line 664 of file types.cc.

References decode().

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

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

Definition at line 695 of file types.cc.

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

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

Definition at line 714 of file types.cc.

References decode().

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

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

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

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	(	LuminosityBlockRange const &	lh,
		LuminosityBlockRange const &	rh
	)

Definition at line 74 of file LuminosityBlockRange.cc.

References lessThan().

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

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

Definition at line 72 of file EventRange.cc.

References lessThan(), and edm::EventRange::startLumi().

Referenced by overlaps().

                                                             {
     assert((lh.startLumi() == 0) == (rh.startLumi() == 0));
     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, edm::hlt::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,
		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,
		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,
		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,
		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, evf::utils::state, 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 &	to,
		std::vector< edm::InputTag > const &	from
	)

Definition at line 678 of file types.cc.

References encode().

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

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

Definition at line 703 of file types.cc.

References edm::ESInputTag::encode().

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

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

Definition at line 728 of file types.cc.

References encode().

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

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

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

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 61 of file math.h.

References x.

Referenced by isnan().

     {
       return x !=x;
     }

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

Definition at line 88 of file FillDescriptionFromPSet.cc.

References edm::ParameterSetDescription::add(), edm::ParameterSetDescription::addNode(), edm::ParameterSetDescription::addUntracked(), python.tagInventory::entries, edm::ParameterSet::getParameterSet(), edm::ParameterSet::getParameterSetVector(), edm::ParameterSet::getUntrackedParameterSet(), edm::ParameterSet::getUntrackedParameterSetVector(), 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 edm::eventsetup::ComponentFactory< T >::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().

952 {

953 }

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::ModuleInPathSummary::timesExcept, edm::Path::timesExcept(), edm::ModuleInPathSummary::timesFailed, edm::Path::timesFailed(), edm::ModuleInPathSummary::timesPassed, edm::Path::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::PathSummary::timesPassed, edm::Path::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::detail::ThreadSafeRegistry< KEY, T, E >::getMapped(), edm::ParameterSet::getParameter(), edm::ParameterSet::getParameterSet(), edm::ProcessConfiguration::id(), edm::ParameterSet::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 >

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

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

template<typename T , typename P >

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

inline

Definition at line 525 of file OwnVector.h.

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

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

template<class T , class A >

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

Definition at line 79 of file FillView.h.

References edm::detail::reallyFillView().

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

template<class T , class A >

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

Definition at line 89 of file FillView.h.

References edm::detail::reallyFillView().

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

template<class T , class A >

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

Definition at line 99 of file FillView.h.

References edm::detail::reallyFillView().

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

template<class T , class A , class Comp >

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

Definition at line 109 of file FillView.h.

References edm::detail::reallyFillView().

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

template<typename T >

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

inline

Definition at line 192 of file PtrVector.h.

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

                                                          {
     obj.fillView(pointers);
   }

template<typename C , typename T , typename F >

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

inline

Definition at line 197 of file RefVector.h.

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

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

void edm::fillView	(	AssociationVector< KeyRefProd, CVal, KeyRef, SizeType, KeyReferenceHelper > const &	obj,
		ProductID const &	id,
		std::vector< void const * > &	pointers,
		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< T >::fill(), edm::helpers::ViewFiller< RefToBaseVector< T > >::fill(), and edm::helpers::ViewFiller< PtrVector< T > >::fill().

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

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.

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

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

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::WorkerSummary::timesExcept, edm::Worker::timesExcept(), edm::WorkerSummary::timesFailed, edm::Worker::timesFailed(), edm::WorkerSummary::timesPassed, edm::Worker::timesPassed(), edm::WorkerSummary::timesRun, edm::Worker::timesRun(), edm::WorkerSummary::timesVisited, and edm::Worker::timesVisited().

Referenced by fillWorkerSummary().

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

template<typename ForwardSequence , typename Predicate >

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

inline

wrappers for std::find

Definition at line 54 of file Algorithms.h.

References L1TEmulatorMonitor_cff::p.

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

template<typename ForwardSequence , typename Predicate >

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

inline

Definition at line 61 of file Algorithms.h.

References 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::RootFile::fillIndexIntoFile(), edm::ParameterSet::fromString(), edm::EventPrincipal::unscheduledFill(), and edm::BranchIDListHelper::updateFromInput().

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

template<typename ForwardSequence , typename Datum >

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

inline

Definition at line 39 of file Algorithms.h.

References spr::find().

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

bool edm::find_nested_type_named	(	std::string const &	nested_type,
		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 const& edm::findOrAssert	(	std::map< Key, Value > const &	m,
		Key const &	k
	)

inline

Definition at line 58 of file Map.h.

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

template<typename Key , typename Value >

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

inline

Definition at line 67 of file Map.h.

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

template<typename Key , typename Value >

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

inline

Definition at line 28 of file Map.h.

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

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

template<typename Key , typename Value >

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

inline

Definition at line 36 of file Map.h.

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

template<typename Key , typename Value >

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

inline

Definition at line 47 of file Map.h.

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

template<typename Key , typename Value >

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

inline

Definition at line 18 of file Map.h.

References gen::k.

                                                     {
     return m[k];
   }

template<typename T , typename U >

T edm::first ( std::pair< T, U > const & p )

Definition at line 199 of file ParameterSet.cc.

Referenced by edm::TrieNode< T >::_sequentialSearch(), HLTSeedL1LogicScalers::beginRun(), edm::DaqSource::defaultWebPage(), edm::ELlog4cplus::emit(), edm::service::ELoutput::emitToken(), HICMeasurementEstimator::setCuts(), edm::TypeID::stripTemplate(), and edm::TrieNode< T >::subNodeByLabel().

                                                                    {
     return p.first;
   }

void edm::FlushMessageLog ( )

Definition at line 94 of file MessageLogger.cc.

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

Referenced by edm::InputFile::logFileAction(), edm::StreamerInputFile::logFileAction(), and RFIOFile::retryRead().

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

template<typename ForwardSequence , typename Func >

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

inline

wrapper for std::for_each

Function templates that provide wrappers for standard algorithms, avoiding some duplication and assuring that incommensurate iterators are not used.

Definition at line 16 of file Algorithms.h.

References f.

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

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

template<typename S , typename T >

S& edm::formatFile	(	T const &	f,
		S &	os
	)

Definition at line 430 of file JobReport.h.

Referenced by print().

                                    {
 
     if (f.fileHasBeenClosed) {
       os << "\n<State  Value=\"closed\"/>";
     } else {
       os << "\n<State  Value=\"open\"/>";
     }
 
     os << "\n<LFN>" << TiXmlText(f.logicalFileName) << "</LFN>";
     os << "\n<PFN>" << TiXmlText(f.physicalFileName) << "</PFN>";
     os << "\n<Catalog>" << TiXmlText(f.catalog) << "</Catalog>";
     os << "\n<ModuleLabel>" << TiXmlText(f.moduleLabel) << "</ModuleLabel>";
     os << "\n<GUID>" << f.guid << "</GUID>";
     os << "\n<Branches>";
     for (std::vector<std::string>::const_iterator iBranch = f.branchNames.begin(),
         iBranchEnd = f.branchNames.end();
         iBranch != iBranchEnd;
         ++iBranch) {
       os << "\n  <Branch>" << TiXmlText(*iBranch) << "</Branch>";
     }
     os << "\n</Branches>";
     return os;
   }

static char* edm::formatTime ( const time_t t )

static

Definition at line 57 of file ELlog4cplus.cc.

References trackerHits::c.

Referenced by edm::ELlog4cplus::ELlog4cplus(), edm::ELlog4cplus::log(), and Vx3DHLTAnalyzer::writeToFile().

                                             {
 
 static char ts[] = "dd-Mon-yyyy hh:mm:ss XYZ";
 
 
 #ifdef ANALTERNATIVE
   char * c  = ctime( &t );                      // 6/14/99 mf Can't be static!
   strncpy( ts+ 0, c+ 8, 2 );  // dd
   strncpy( ts+ 3, c+ 4, 3 );  // Mon
   strncpy( ts+ 7, c+20, 4 );  // yyyy
   strncpy( ts+12, c+11, 8 );  // hh:mm:ss
   strncpy( ts+21, tzname[localtime(&t)->tm_isdst], 3 );  // CST
 #endif
 
   strftime( ts, strlen(ts)+1, "%d-%b-%Y %H:%M:%S %Z", localtime(&t) );
                 // mf 4-9-04
 
 
   return ts;
 
 }  // formatTime()

bool edm::FreshErrorsExist ( )

Definition at line 24 of file LoggedErrorsSummary.cc.

References edm::MessageSender::freshError.

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

                         {
   return  MessageSender::freshError;
 }

Type edm::get_final_type ( Type t )

Definition at line 26 of file ReflexTools.cc.

References matplotRender::t.

Referenced by find_nested_type_named().

                               {
     while(t.IsTypedef()) t = t.ToType();
     return t;
   }

std::vector<BranchDescription const*> edm::getAllBranchDescriptions ( )

Definition at line 30 of file OutputModule.cc.

References edm::ConstProductRegistry::allBranchDescriptions().

Referenced by edm::OutputModule::selectProducts().

                              {
     Service<ConstProductRegistry> reg;
     return reg->allBranchDescriptions();
   }

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

Definition at line 35 of file OutputModule.cc.

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

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

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

void edm::getCodeTable ( edm::Exception::CodeMap *& setme )

Definition at line 40 of file EDMException.cc.

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

Referenced by edm::CodedException< Code >::codeToString(), and edm::Exception::codeToString().

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

std::string edm::getEnvironmentVariable	(	std::string const &	name,
		std::string const &	defaultValue = `std::string()`
	)

inline

Definition at line 9 of file GetEnvironmentVariable.h.

References L1TEmulatorMonitor_cff::p.

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

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

Definition at line 28 of file BufferArea.cc.

References b.

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

int edm::getFileFormatVersion ( )

Definition at line 4 of file GetFileFormatVersion.cc.

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

4 { return 17; }

MallocOptionSetter & edm::getGlobalOptionSetter ( )

Definition at line 217 of file MallocOpts.cc.

References global_malloc_options.

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

   {
     return global_malloc_options;
   }

std::string edm::getName ( Reflex::Type & cc )

Definition at line 18 of file ClassFiller.cc.

                                     {
     return cc.Name(Reflex::SCOPED);
   }

ParameterSet const & edm::getParameterSet ( ParameterSetID const & id )

Definition at line 865 of file ParameterSet.cc.

References edm::errors::Configuration, edm::hlt::Exception, edm::detail::ThreadSafeRegistry< KEY, T, E >::instance(), and query::result.

Referenced by HLTInfo::analyze(), EcalTrigPrimProducer::beginJob(), EcalSelectiveReadoutProducer::getBinOfMax(), edm::ParameterSet::getParameter(), edm::ParameterSetEntry::pset(), and edm::VParameterSetEntry::vpset().

                                             {
     ParameterSet const* result = 0;
     if(0 == (result = pset::Registry::instance()->getMapped(id))) {
       throw Exception(errors::Configuration, "MissingParameterSet:")
         << "Parameter Set ID '" << id << "' not found.";
     }
     return *result;
   }

std::string edm::getPassID ( )

inline

Definition at line 8 of file GetPassID.h.

Referenced by edm::ScheduleItems::initMisc().

                          {
     static std::string passID;
     // return empty string for now.
     return passID; 
   }

ParameterSet const & edm::getProcessParameterSet ( )

Definition at line 34 of file Registry.cc.

References edm::errors::EventCorruption, edm::hlt::Exception, edm::detail::ThreadSafeRegistry< KEY, T, E >::getMapped(), edm::pset::getProcessParameterSetID(), edm::detail::ThreadSafeRegistry< KEY, T, E >::instance(), and query::result.

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

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

template<typename T >

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

inline

Definition at line 37 of file RefCoreGet.h.

References edm::RefCore::isTransient(), edm::RefCore::nullPointerForTransientException(), L1TEmulatorMonitor_cff::p, and edm::RefCore::productPtr().

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

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

template<typename PROD >

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

inline

Definition at line 243 of file Principal.h.

References edm::InputTag::cachedOffset(), edm::InputTag::fillCount(), edm::Principal::getByLabel(), edm::InputTag::instance(), edm::InputTag::label(), edm::Principal::maybeFlushCache(), edm::InputTag::process(), and PROD.

                                                             {
     TypeID tid = TypeID(typeid(PROD));
     ep.maybeFlushCache(tid, tag);
     return boost::dynamic_pointer_cast<Wrapper<PROD> const>(ep.getByLabel(tid, tag.label(), tag.instance(), tag.process(), tag.cachedOffset(), tag.fillCount()).product());
   }

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

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

inline

Definition at line 41 of file RefItemGet.h.

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

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

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

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

inline

Definition at line 35 of file RefItemGet.h.

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

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

template<typename C >

helper::MatcherGetRef<C>::ref_type edm::getRef	(	const Handle< C > &	c,
		size_t	k
	)

Definition at line 28 of file getRef.h.

References edm::helper::MatcherGetRef< C >::getRef().

Referenced by edm::reftobase::Holder< T, REF >::isEqualTo(), edm::reftobase::RefHolder< REF >::isEqualTo(), reco::modules::MatcherBase< C1, C2, M >::produce(), and AssociatedVariableCollectionSelector< InputCollection, VarCollection, Selector, OutputCollection, StoreContainer, RefAdder >::select().

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

edm::ProductRegistry edm::getRegFromFile ( std::string const & filename )

Definition at line 206 of file Utilities.cc.

References edm::hlt::Exception, lut2db_cfg::filename, recoMuon::in, edm::StreamerInputSource::mergeIntoRegistry(), L1TEmulatorMonitor_cff::p, and readHeaderFromStream().

   {
     edm::ProductRegistry pr;
     ifstream ist(filename.c_str(), std::ios_base::binary | std::ios_base::in);
 
     if(!ist)
       {
     throw cms::Exception("ReadRegistry","getRegFromFile")
       << "cannot open file " << filename;
       }
 
     std::auto_ptr<SendJobHeader> p = readHeaderFromStream(ist);
     StreamerInputSource::mergeIntoRegistry(*p, pr, false);
     return pr;
   }

std::string edm::getReleaseVersion ( )

Definition at line 7 of file GetReleaseVersion.cc.

References STRINGIFY.

Referenced by BTagValidator::BTagValidator(), DQMEventInfo::DQMEventInfo(), edm::ScheduleItems::initMisc(), DQMProvInfo::makeProvInfo(), evf::FUEventProcessor::makeStaticInfo(), FUShmDQMOutputService::postEndLumi(), PrimaryVertexAnalyzer::PrimaryVertexAnalyzer(), PrimaryVertexAnalyzer4PU::PrimaryVertexAnalyzer4PU(), DQMFileSaver::saveForOffline(), edm::StreamerOutputModuleBase::serializeRegistry(), HLXMonitor::SetupEventInfo(), TauTagValidation::TauTagValidation(), TrackParameterAnalyzer::TrackParameterAnalyzer(), and XmasToDQMEventInfo::XmasToDQMEventInfo().

                                 {
     static std::string const releaseVersion(STRINGIFY(PROJECT_VERSION));
     return releaseVersion; 
   }

int edm::getSigNum ( )

Definition at line 46 of file UnixSignalHandlers.cc.

References signum_lock, and signum_value.

     {
       boost::mutex::scoped_lock sl(signum_lock);
       int rc = signum_value;
       ++signum_value;
       return rc;
     }

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

Definition at line 87 of file ClassFiller.cc.

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

                                             {
     Reflex::Type const typ = getReflectClass(ti);
     return getRootClass(typ.Name(Reflex::SCOPED));
   }

std::string edm::getUuid ( TTree * uuidTree )

Definition at line 98 of file CollUtil.cc.

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

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

std::string edm::glob2reg ( std::string const & pattern )

Definition at line 14 of file RegexMatch.cc.

References listBenchmarks::pattern.

Referenced by triggerExpression::L1Reader::init(), triggerExpression::L1TechReader::init(), HLTConfigProvider::matched(), and regexMatch().

                                                {
     std::string regexp = pattern;
     boost::replace_all(regexp, "*", ".*");
     boost::replace_all(regexp, "?", ".");
     return regexp;
   }

void edm::GroupLogStatistics ( std::string const & category )

Definition at line 115 of file MessageLogger.cc.

References edm::MessageLoggerQ::MLqGRP().

                                                     {
   std::string * cat_p = new std::string(category);
   edm::MessageLoggerQ::MLqGRP (cat_p); // Indicate a group summary category
   // Note that the scribe will be responsible for deleting cat_p
 }

void edm::HaltMessageLogging ( )

Definition at line 90 of file MessageLogger.cc.

References edm::MessageLoggerQ::MLqSHT().

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

HRTimeType edm::hrRealTime ( )

inline

Definition at line 74 of file HRRealTime.h.

                                  {
     return details::rdtsc();
   }

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

Definition at line 116 of file UnixSignalHandlers.cc.

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

Referenced by edm::EventProcessor::forkProcess(), edm::service::InitRootHandlers::InitRootHandlers(), and edm::service::UnixSignalService::UnixSignalService().

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

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

Definition at line 129 of file UnixSignalHandlers.cc.

References MUST_BE_ZERO, and NULL.

Referenced by installCustomHandler().

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

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

Definition at line 10 of file RegexMatch.cc.

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

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

bool edm::is_PtrVector	(	Reflex::Type const &	possible_ref_vector,
		Reflex::Type &	value_type
	)

Definition at line 63 of file ReflexTools.cc.

References find_nested_type_named().

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

                                        {
 
     static TypeTemplate ref_vector_template_id(TypeTemplate::ByName("edm::PtrVector", 1));
     static std::string member_type("member_type");
     static std::string val_type("value_type");
     TypeTemplate primary_template_id(possible_ref_vector.TemplateFamily());
     if(primary_template_id == ref_vector_template_id) {
       Reflex::Type ptrType;
       if(find_nested_type_named(val_type, possible_ref_vector, ptrType)) {
         return find_nested_type_named(val_type, ptrType, value_type);
       }
     }
     return false;
   }

bool edm::is_RefToBaseVector	(	Reflex::Type const &	possible_ref_vector,
		Reflex::Type &	value_type
	)

Definition at line 80 of file ReflexTools.cc.

References find_nested_type_named().

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

                                              {
 
     static TypeTemplate ref_vector_template_id(TypeTemplate::ByName("edm::RefToBaseVector", 1));
     static std::string member_type("member_type");
     TypeTemplate primary_template_id(possible_ref_vector.TemplateFamily());
     if(primary_template_id == ref_vector_template_id) {
       return find_nested_type_named(member_type, possible_ref_vector, value_type);
     }
     return false;
   }

bool edm::is_RefVector	(	Reflex::Type const &	possible_ref_vector,
		Reflex::Type &	value_type
	)

Definition at line 50 of file ReflexTools.cc.

References find_nested_type_named().

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

                                        {
 
     static TypeTemplate ref_vector_template_id(TypeTemplate::ByName("edm::RefVector", 3));
     static std::string member_type("member_type");
     TypeTemplate primary_template_id(possible_ref_vector.TemplateFamily());
     if(primary_template_id == ref_vector_template_id) {
       return find_nested_type_named(member_type, possible_ref_vector, value_type);
     }
     return false;
   }

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

Definition at line 46 of file ProcessHistory.cc.

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

Referenced by isDescendant().

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

bool edm::isDebugEnabled ( )

Definition at line 71 of file MessageLogger.cc.

References edm::MessageDrop::debugAlwaysSuppressed, and edm::MessageDrop::debugEnabled.

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

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

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

inline

Definition at line 103 of file ProcessHistory.h.

References isAncestor().

                                                                  {
     return isAncestor(b, a);
   }

bool edm::isErrorEnabled ( )

Definition at line 86 of file MessageLogger.cc.

References edm::MessageDrop::errorEnabled.

                       {
   return edm::MessageDrop::errorEnabled;                        // 7/6/11 fwyzard
 }

bool edm::isInfoEnabled ( )

Definition at line 76 of file MessageLogger.cc.

References edm::MessageDrop::infoAlwaysSuppressed, and edm::MessageDrop::infoEnabled.

Referenced by edm::InputSource::issueReports().

                      {
   return ((!edm::MessageDrop::infoAlwaysSuppressed)     // 9/27/10 mf
          && edm::MessageDrop::infoEnabled );
 }

bool edm::isMessageProcessingSetUp ( )

Definition at line 107 of file MessageLogger.cc.

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

                                 {               // 6/20/08 mf
 //  std::cerr << "isMessageProcessingSetUp: \n";
 //  std::cerr << "messageLoggerScribeIsRunning = "
 //            << (int)MessageDrop::instance()->messageLoggerScribeIsRunning << "\n";
   return (MessageDrop::instance()->messageLoggerScribeIsRunning ==
             MLSCRIBE_RUNNING_INDICATOR);
 }

bool edm::isnan ( float f )

inline

Definition at line 69 of file math.h.

References edm::detail::isnan().

Referenced by PrimaryVertexAnalyzer::analyze().

69 { return detail::isnan(f); }

edm::detail::isnan

bool isnan(float x)

Definition: math.h:13

f

double f[11][100]

Definition: MuScleFitUtils.cc:79

bool edm::isnan ( double d )

inline

Definition at line 71 of file math.h.

References equal_isnan().

71 { return equal_isnan(d); }

edm::equal_isnan

bool equal_isnan(FP x)

Definition: math.h:61

bool edm::isnan ( long double q )

inline

Definition at line 73 of file math.h.

References edm::detail::isnan().

73 { return detail::isnan(q); }

lumiQueryAPI.q

tuple q

Definition: lumiQueryAPI.py:1781

edm::detail::isnan

bool isnan(float x)

Definition: math.h:13

bool edm::isSameEvent	(	EventAuxiliary const &	a,
		EventAuxiliary const &	b
	)

Definition at line 17 of file EventAuxiliary.cc.

References edm::EventAuxiliary::bunchCrossing(), edm::EventAuxiliary::experimentType(), edm::EventAuxiliary::id(), edm::EventAuxiliary::isRealData(), edm::EventAuxiliary::luminosityBlock(), edm::EventAuxiliary::processGUID(), edm::EventAuxiliary::storeNumber(), and edm::EventAuxiliary::time().

Referenced by isSameEvent().

                                                                 {
     return
       a.id() == b.id() &&
       a.processGUID() == b.processGUID() &&
       a.luminosityBlock() == b.luminosityBlock() &&
       a.time() == b.time() &&
       a.isRealData() == b.isRealData() &&
       a.experimentType() == b.experimentType() &&
       a.bunchCrossing() == b.bunchCrossing() &&
       a.storeNumber() == b.storeNumber();
   }

bool edm::isSameEvent	(	EventPrincipal const &	a,
		EventPrincipal const &	b
	)

inline

Definition at line 166 of file EventPrincipal.h.

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

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

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

Definition at line 779 of file ParameterSet.cc.

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

Referenced by operator==().

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

bool edm::isWarningEnabled ( )

Definition at line 81 of file MessageLogger.cc.

References edm::MessageDrop::warningAlwaysSuppressed, and edm::MessageDrop::warningEnabled.

Referenced by L1GlobalTriggerPSB::receiveGctObjectData(), and L1GlobalTriggerPSB::receiveTechnicalTriggers().

                         {
   return ((!edm::MessageDrop::warningAlwaysSuppressed)      // 9/27/10 mf
          && edm::MessageDrop::warningEnabled );
 }

template<typename V , typename T >

bool edm::iterateTrieLeaves	(	V &	v,
		TrieNode< T > const &	n,
		std::string const &	label = `""`
	)

visits only leaf nodes

Definition at line 298 of file Trie.h.

References label, L1TEmulatorMonitor_cff::p, and v.

                                                                                      {
     typedef TrieNode<T> const node_base;
     typedef TrieNodeIter<T> node_iterator;
     node_iterator e;
     node_iterator p(&n);
     if (p==e) return true;
     for (; p!=e; ++p) {
       if (iterateTrieLeaves(v,*p,label+(char)p.label()) )
     v((*p).value(),label+(char)p.label());
     }
     return false;
   }

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

static

Referenced by edm::EDAnalyzer::baseType(), edm::EDProducer::baseType(), edm::EDFilter::baseType(), edm::OutputModule::baseType(), and edm::InputSource::baseType().

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

static

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

static

static std::string const edm::kBaseType ( "Source" )

static

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

static

static const TimeValue_t edm::kLowMask ( 0xFFFFFFFF )

static

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

Definition at line 70 of file LuminosityBlockRange.cc.

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

                                                                                 {
     return lh.endLumiID() < rh.startLumiID();
   }

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

Definition at line 67 of file EventRange.cc.

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

Referenced by distinct(), and edm::EventSkipperByID::skipIt().

                                                             {
     assert((lh.startLumi() == 0) == (rh.startLumi() == 0));
     return lh.endEventID() < rh.startEventID();
   }

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

Definition at line 59 of file EventRange.cc.

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

Referenced by edm::EventSkipperByID::skipIt().

                                                                    {
     // First, separate the ranges so that those with 0 lumiID go first.
     if ((lh.startLumi() == 0) != (rh.startLumi() == 0)) {
       return lh.startLumi() == 0;
     }
     return lh.endEventID() < rh.startEventID();
   }

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

Definition at line 22 of file ClassFiller.cc.

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

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

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

void edm::loadExtraClasses ( )

Definition at line 47 of file ClassFiller.cc.

References generateEDF::done, and loadCap().

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

                           {
     static bool done = false;
     if (done == false) {
     loadCap(std::string("edm::StreamedProduct"));
     loadCap(std::string("std::vector<edm::StreamedProduct>"));
     loadCap(std::string("edm::SendEvent"));
     loadCap(std::string("std::vector<edm::BranchDescription>"));
     loadCap(std::string("edm::SendJobHeader"));
     }
     G__SetCatchException(0);
     ROOT::Cintex::Cintex::Enable();
     done=true;
   }

static ELmap const& edm::loadMap ( )

static

Definition at line 62 of file ELseverityLevel.cc.

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

                           {
 
   static ELmap  m;
 
 
     m[ ELzeroSeverity.getSymbol()   ] = ELseverityLevel::ELsev_zeroSeverity
   , m[ ELzeroSeverity.getName()     ] = ELseverityLevel::ELsev_zeroSeverity
   , m[ ELzeroSeverity.getInputStr() ] = ELseverityLevel::ELsev_zeroSeverity
   , m[ ELzeroSeverity.getVarName()  ] = ELseverityLevel::ELsev_zeroSeverity
   ;
 
     m[ ELincidental.getSymbol()   ] = ELseverityLevel::ELsev_incidental
   , m[ ELincidental.getName()     ] = ELseverityLevel::ELsev_incidental
   , m[ ELincidental.getInputStr() ] = ELseverityLevel::ELsev_incidental
   , m[ ELincidental.getVarName()  ] = ELseverityLevel::ELsev_incidental
   ;
 
     m[ ELsuccess.getSymbol()   ] = ELseverityLevel::ELsev_success
   , m[ ELsuccess.getName()     ] = ELseverityLevel::ELsev_success
   , m[ ELsuccess.getInputStr() ] = ELseverityLevel::ELsev_success
   , m[ ELsuccess.getVarName()  ] = ELseverityLevel::ELsev_success
   ;
 
     m[ ELinfo.getSymbol()   ] = ELseverityLevel::ELsev_info
   , m[ ELinfo.getName()     ] = ELseverityLevel::ELsev_info
   , m[ ELinfo.getInputStr() ] = ELseverityLevel::ELsev_info
   , m[ ELinfo.getVarName()  ] = ELseverityLevel::ELsev_info
   ;
 
     m[ ELwarning.getSymbol()   ] = ELseverityLevel::ELsev_warning
   , m[ ELwarning.getName()     ] = ELseverityLevel::ELsev_warning
   , m[ ELwarning.getInputStr() ] = ELseverityLevel::ELsev_warning
   , m[ ELwarning.getVarName()  ] = ELseverityLevel::ELsev_warning
   ;
 
     m[ ELwarning2.getSymbol()   ] = ELseverityLevel::ELsev_warning2
   , m[ ELwarning2.getName()     ] = ELseverityLevel::ELsev_warning2
   , m[ ELwarning2.getInputStr() ] = ELseverityLevel::ELsev_warning2
   , m[ ELwarning2.getVarName()  ] = ELseverityLevel::ELsev_warning2
   ;
 
     m[ ELerror.getSymbol()   ] = ELseverityLevel::ELsev_error
   , m[ ELerror.getName()     ] = ELseverityLevel::ELsev_error
   , m[ ELerror.getInputStr() ] = ELseverityLevel::ELsev_error
   , m[ ELerror.getVarName()  ] = ELseverityLevel::ELsev_error
   ;
 
     m[ ELerror2.getSymbol()   ] = ELseverityLevel::ELsev_error2
   , m[ ELerror2.getName()     ] = ELseverityLevel::ELsev_error2
   , m[ ELerror2.getInputStr() ] = ELseverityLevel::ELsev_error2
   , m[ ELerror2.getVarName()  ] = ELseverityLevel::ELsev_error2
   ;
 
     m[ ELnextEvent.getSymbol()   ] = ELseverityLevel::ELsev_next
   , m[ ELnextEvent.getName()     ] = ELseverityLevel::ELsev_next
   , m[ ELnextEvent.getInputStr() ] = ELseverityLevel::ELsev_next
   , m[ ELnextEvent.getVarName()  ] = ELseverityLevel::ELsev_next
   ;
 
     m[ ELunspecified.getSymbol()   ] = ELseverityLevel::ELsev_unspecified
   , m[ ELunspecified.getName()     ] = ELseverityLevel::ELsev_unspecified
   , m[ ELunspecified.getInputStr() ] = ELseverityLevel::ELsev_unspecified
   , m[ ELunspecified.getVarName()  ] = ELseverityLevel::ELsev_unspecified
   ;
 
     m[ ELsevere.getSymbol()   ] = ELseverityLevel::ELsev_severe
   , m[ ELsevere.getName()     ] = ELseverityLevel::ELsev_severe
   , m[ ELsevere.getInputStr() ] = ELseverityLevel::ELsev_severe
   , m[ ELsevere.getVarName()  ] = ELseverityLevel::ELsev_severe
   ;
 
     m[ ELsevere2.getSymbol()   ] = ELseverityLevel::ELsev_severe2
   , m[ ELsevere2.getName()     ] = ELseverityLevel::ELsev_severe2
   , m[ ELsevere2.getInputStr() ] = ELseverityLevel::ELsev_severe2
   , m[ ELsevere2.getVarName()  ] = ELseverityLevel::ELsev_severe2
   ;
 
     m[ ELabort.getSymbol()   ] = ELseverityLevel::ELsev_abort
   , m[ ELabort.getName()     ] = ELseverityLevel::ELsev_abort
   , m[ ELabort.getInputStr() ] = ELseverityLevel::ELsev_abort
   , m[ ELabort.getVarName()  ] = ELseverityLevel::ELsev_abort
   ;
 
     m[ ELfatal.getSymbol()   ] = ELseverityLevel::ELsev_fatal
   , m[ ELfatal.getName()     ] = ELseverityLevel::ELsev_fatal
   , m[ ELfatal.getInputStr() ] = ELseverityLevel::ELsev_fatal
   , m[ ELfatal.getVarName()  ] = ELseverityLevel::ELsev_fatal
   ;
 
     m[ ELhighestSeverity.getSymbol()   ] = ELseverityLevel::ELsev_highestSeverity
   , m[ ELhighestSeverity.getName()     ] = ELseverityLevel::ELsev_highestSeverity
   , m[ ELhighestSeverity.getInputStr() ] = ELseverityLevel::ELsev_highestSeverity
   , m[ ELhighestSeverity.getVarName()  ] = ELseverityLevel::ELsev_highestSeverity
   ;
 
   return m;
 
 }

std::vector< ErrorSummaryEntry > edm::LoggedErrorsOnlySummary ( )

Definition at line 43 of file LoggedErrorsSummary.cc.

References begin, edm::ErrorSummaryEntry::count, ELerror, end, edm::MessageSender::errorSummaryMap, edm::MessageSender::freshError, i, edm::ErrorSummaryEntry::severity, and v.

                                                        {    //  ChangeLog 2
   std::vector<ErrorSummaryEntry> v;
   ErrorSummaryEntry e;
   ErrorSummaryMapIterator end = MessageSender::errorSummaryMap.end();
   for (ErrorSummaryMapIterator i = MessageSender::errorSummaryMap.begin();
     i != end; ++i) {
     e = i->first;    
     if (e.severity >= edm::ELerror) {
       e.count = (i->second); 
       v.push_back(e);
     }
   }
   MessageSender::freshError = false;
   MessageSender::errorSummaryMap.clear();
   return v;
 }

std::vector< ErrorSummaryEntry > edm::LoggedErrorsSummary ( )

Definition at line 28 of file LoggedErrorsSummary.cc.

References begin, edm::ErrorSummaryEntry::count, end, edm::MessageSender::errorSummaryMap, edm::MessageSender::freshError, i, and v.

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

                                                    {
   std::vector<ErrorSummaryEntry> v;
   ErrorSummaryEntry e;
   ErrorSummaryMapIterator end = MessageSender::errorSummaryMap.end();
   for (ErrorSummaryMapIterator i = MessageSender::errorSummaryMap.begin();
     i != end; ++i) {
     e       = i->first;    // sets category, module and severity ChangeLog 2
     e.count = (i->second); // count is 0 in key; set it to correct value
     v.push_back(e);
   }
   MessageSender::freshError = false;
   MessageSender::errorSummaryMap.clear();
   return v;
 }

void edm::LogStatistics ( )

Definition at line 67 of file MessageLogger.cc.

References edm::MessageLoggerQ::MLqSUM().

                      {
   edm::MessageLoggerQ::MLqSUM ( ); // trigger summary info
 }

void edm::longBranchPrint ( TTree * tr )

Definition at line 87 of file CollUtil.cc.

References gather_cfg::cout, and i.

                                   {
     if (tr != 0) {
       Long64_t nB = tr->GetListOfBranches()->GetEntries();
       for (Long64_t i = 0; i < nB; ++i) {
         tr->GetListOfBranches()->At(i)->Print();
       }
     } else {
       std::cout << "Missing Events tree?\n";
     }
   }

template<typename ForwardSequence , typename Datum >

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

inline

wrappers for std::lower_bound

Definition at line 91 of file Algorithms.h.

Referenced by edm::RootFile::fillHistory(), edm::FileIndex::findEventEntryPosition(), and edm::FileIndex::findPosition().

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

template<typename ForwardSequence , typename Datum >

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

inline

Definition at line 98 of file Algorithms.h.

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

template<typename ForwardSequence , typename Datum , typename Predicate >

ForwardSequence::const_iterator edm::lower_bound_all	(	ForwardSequence const &	s,
		Datum const &	d,
		Predicate	p
	)

inline

Definition at line 105 of file Algorithms.h.

References L1TEmulatorMonitor_cff::p.

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

template<typename ForwardSequence , typename Datum , typename Predicate >

ForwardSequence::iterator edm::lower_bound_all	(	ForwardSequence &	s,
		Datum const &	d,
		Predicate	p
	)

inline

Definition at line 112 of file Algorithms.h.

References L1TEmulatorMonitor_cff::p.

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

boost::shared_ptr<InputSource> edm::makeInput	(	ParameterSet &	params,
		CommonParams const &	common,
		ProductRegistry &	preg,
		PrincipalCache &	pCache,
		boost::shared_ptr< ActivityRegistry >	areg,
		boost::shared_ptr< ProcessConfiguration >	processConfiguration
	)

Definition at line 254 of file EventProcessor.cc.

References cms::Exception::append(), edm::Exception::categoryCode(), edm::errors::Configuration, SurfaceDeformationFactory::create(), edm::hlt::Exception, edm::InputSourceFactory::get(), reco::get(), edm::ParameterSet::getParameter(), edm::ParameterSet::getPSetForUpdate(), edm::ParameterSet::id(), collect_tpl::input, edm::InputSourceFactory::makeInputSource(), edm::CommonParams::maxEventsInput_, edm::CommonParams::maxLumisInput_, edm::ParameterSet::registerIt(), and edm::ConfigurationDescriptions::validate().

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

                                                                         {
     ParameterSet* main_input = params.getPSetForUpdate("@main_input");
     if(main_input == 0) {
       throw Exception(errors::Configuration, "FailedInputSource")
         << "Configuration of primary input source has failed\n";
     }
 
     std::string modtype;
     try {
       modtype = main_input->getParameter<std::string>("@module_type");
       std::auto_ptr<ParameterSetDescriptionFillerBase> filler(
         ParameterSetDescriptionFillerPluginFactory::get()->create(modtype));
       ConfigurationDescriptions descriptions(filler->baseType());
       filler->fill(descriptions);
       descriptions.validate(*main_input, std::string("source"));
     }
     catch (cms::Exception& iException) {
       Exception toThrow(errors::Configuration, "Failed validating primary input source configuration.");
       toThrow << "\nSource plugin name is \"" << modtype << "\"\n";
       toThrow.append(iException);
       throw toThrow;
     }
 
     main_input->registerIt();
 
     // Fill in "ModuleDescription", in case the input source produces
     // any EDproducts, which would be registered in the ProductRegistry.
     // Also fill in the process history item for this process.
     // There is no module label for the unnamed input source, so
     // just use "source".
     // Only the tracked parameters belong in the process configuration.
     ModuleDescription md(main_input->id(),
                          main_input->getParameter<std::string>("@module_type"),
                          "source",
                          processConfiguration);
 
     InputSourceDescription isdesc(md, preg, pCache, areg, common.maxEventsInput_, common.maxLumisInput_);
     areg->preSourceConstructionSignal_(md);
     boost::shared_ptr<InputSource> input;
     try {
       input = boost::shared_ptr<InputSource>(InputSourceFactory::get()->makeInputSource(*main_input, isdesc).release());
       areg->postSourceConstructionSignal_(md);
     }
     catch (Exception& iException) {
       areg->postSourceConstructionSignal_(md);
       //we want to keep the same category code so that cmsRun will return the proper return value
       Exception toThrow(iException.categoryCode(), "Error occured while constructing primary input source.");
       toThrow << "\nSource is of type \"" << modtype << "\"\n";
       toThrow.append(iException);
       throw toThrow;
     }
     catch (cms::Exception& iException) {
       areg->postSourceConstructionSignal_(md);
       Exception toThrow(errors::Configuration, "Error occured while constructing primary input source.");
       toThrow << "\nSource is of type \"" << modtype << "\"\n";
       toThrow.append(iException);
       throw toThrow;
     }
 
     return input;
   }

void edm::makeParameterSets	(	std::string const &	configtext,
		boost::shared_ptr< ParameterSet > &	main
	)

essentially the same as the previous method

Definition at line 54 of file MakeParameterSets.cc.

References PythonProcessDesc::parameterSet().

Referenced by edm::ServiceRegistry::createServicesFromConfig().

                                                        {
     PythonProcessDesc pythonProcessDesc(configtext);
     main = pythonProcessDesc.parameterSet();
   }

template<class HandleT >

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

Definition at line 465 of file DetSetVector.h.

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

Referenced by makeRefToDetSetVector().

                                                                           {
     typedef typename HandleT::element_type Vec;
     typename Vec::value_type::collection_type::size_type index=0;
     typename Vec::const_iterator itFound = iHandle->find(iDetID);
     if(itFound == iHandle->end()) {
       Exception::throwThis(errors::InvalidReference,
         "an edm::Ref to an edm::DetSetVector was given a DetId, ", iDetID, ", that is not in the DetSetVector");
     }
     index += (itIter- itFound->data.begin());
     if(index >= itFound->data.size()) {
       Exception::throwThis(errors::InvalidReference,
         "an edm::Ref to a edm::DetSetVector is being made with an interator that is not part of the edm::DetSet itself");
     }
     return Ref<typename HandleT::element_type,
            typename HandleT::element_type::value_type::value_type>
           (iHandle,std::make_pair(iDetID,index));
   }

template<class HandleT >

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

Definition at line 284 of file DetSetLazyVector.h.

References getHLTprescales::index.

Referenced by makeRefToDetSetLazyVector().

                                                                           {
       typedef typename HandleT::element_type Vec;
       typename Vec::value_type::collection_type::size_type index=0;
       typename Vec::const_iterator itFound = iHandle->find(iDetID);
       index += (itIter- itFound->data.begin());
       return    Ref< typename HandleT::element_type, typename HandleT::element_type::value_type::value_type> (iHandle,std::make_pair(iDetID,index));
    }

template<class HandleT >

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

Definition at line 296 of file DetSetLazyVector.h.

References makeRefToDetSetLazyVector().

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

template<class HandleT >

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

Definition at line 307 of file DetSetRefVector.h.

References getHLTprescales::index.

Referenced by makeRefToDetSetRefVector().

                                                                           {
       typedef typename HandleT::element_type Vec;
       typename Vec::value_type::collection_type::size_type index=0;
       typename Vec::const_iterator itFound = iHandle->find(iDetID);
       index += (itIter- itFound->data.begin());
       return    Ref< typename HandleT::element_type, typename HandleT::element_type::value_type::value_type> (iHandle,std::make_pair(iDetID,index));
    }

template<class HandleT >

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

Definition at line 319 of file DetSetRefVector.h.

References makeRefToDetSetRefVector().

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

template<class HandleT >

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

Definition at line 487 of file DetSetVector.h.

References makeRefTo().

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

template<typename T >

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

Definition at line 532 of file LazyGetter.h.

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

Referenced by TkStripMeasurementDet::fastMeasurements(), TkStripMeasurementDet::recHits(), SiStripRecHitConverterAlgorithm::run(), and TkStripMeasurementDet::simpleRecHits().

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

getHLTprescales.index

tuple index

Definition: getHLTprescales.py:79

patZpeak.handle

tuple handle

Definition: patZpeak.py:22

T

long double T

Definition: Basic3DVectorLD.h:57

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

inline

Definition at line 84 of file ConstBranchDescription.h.

References convertXMLtoSQLite_cfg::fileName, m, match(), and edm::ConstBranchDescription::me().

                                                   {
     return match(a.me(), b.me(), fileName, m);
   }

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

Definition at line 296 of file BranchDescription.cc.

References edm::BranchDescription::branchID(), edm::BranchDescription::branchName(), edm::BranchDescription::branchType(), edm::BranchDescription::dropped(), edm::BranchDescription::fullClassName(), edm::BranchDescription::parameterSetIDs(), and edm::BranchDescription::Strict.

Referenced by edm::RootOutputFile::beginInputFile(), edm::EventSelector::identical(), match(), ConversionTools::matchedConversion(), ConversionTools::matchedPromptElectron(), edm::ProductRegistry::merge(), reco::modules::MCMatchCandRefSelector::newEvent(), HLTTauRefCombiner::produce(), and CosmicMuonLinksProducer::sharedHits().

                                       {
     std::ostringstream differences;
     if (a.branchName() != b.branchName()) {
       differences << "Branch name '" << b.branchName() << "' does not match '" << a.branchName() << "'.\n";
       // Need not compare components of branch name individually.
       // (a.friendlyClassName() != b.friendlyClassName())
       // (a.moduleLabel() != b.moduleLabel())
       // (a.productInstanceName() != b.productInstanceName())
       // (a.processName() != b.processName())
     }
     if (a.branchType() != b.branchType()) {
       differences << "Branch '" << b.branchName() << "' is a(n) '" << b.branchType() << "' branch\n";
       differences << "    in file '" << fileName << "', but a(n) '" << a.branchType() << "' branch in previous files.\n";
     }
     if (a.branchID() != b.branchID()) {
       differences << "Branch '" << b.branchName() << "' has a branch ID of '" << b.branchID() << "'\n";
       differences << "    in file '" << fileName << "', but '" << a.branchID() << "' in previous files.\n";
     }
     if (a.fullClassName() != b.fullClassName()) {
       differences << "Products on branch '" << b.branchName() << "' have type '" << b.fullClassName() << "'\n";
       differences << "    in file '" << fileName << "', but '" << a.fullClassName() << "' in previous files.\n";
     }
     if (!b.dropped() && a.dropped()) {
       differences << "Branch '" << a.branchName() << "' was dropped in the first input file but is present in '" << fileName << "'.\n";
     }
     if (m == BranchDescription::Strict) {
         if (b.parameterSetIDs().size() > 1) {
           differences << "Branch '" << b.branchName() << "' uses more than one parameter set in file '" << fileName << "'.\n";
         } else if (a.parameterSetIDs().size() > 1) {
           differences << "Branch '" << a.branchName() << "' uses more than one parameter set in previous files.\n";
         } else if (a.parameterSetIDs() != b.parameterSetIDs()) {
           differences << "Branch '" << b.branchName() << "' uses different parameter sets in file '" << fileName << "'.\n";
           differences << "    than in previous files.\n";
         }
     }
     return differences.str();
   }

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

inline

Definition at line 136 of file LuminosityBlockID.h.

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

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

inline

Definition at line 137 of file EventID.h.

Referenced by edm::helper::Filler< Association< C > >::add(), cms::DiMuonSeedGeneratorHIC::barrelUpdateSeed(), DTTriggerEfficiencyTest::bookChambHistos(), DTLocalTriggerSynchTest::bookChambHistos(), TIBLayerBuilder::constructRings(), DTDigitizer::driftTimeFromParametrization(), merge(), and DTLocalTriggerBaseTest::phiRange().

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

const unsigned int edm::maxIDlength ( 200 )

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

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

Definition at line 78 of file LuminosityBlockRange.cc.

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

Referenced by sortAndRemoveOverlaps().

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

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

inline

Definition at line 131 of file LuminosityBlockID.h.

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

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

inline

Definition at line 132 of file EventID.h.

Referenced by cms::DiMuonSeedGeneratorHIC::barrelUpdateSeed(), DTTriggerEfficiencyTest::bookChambHistos(), DTLocalTriggerSynchTest::bookChambHistos(), merge(), and DTLocalTriggerBaseTest::phiRange().

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

StringSet & edm::missingTypes ( )

Definition at line 190 of file ReflexTools.cc.

Referenced by checkDictionaries(), and loadCap().

                             {
     static boost::thread_specific_ptr<StringSet> missingTypes_;
     if(0 == missingTypes_.get()) {
       missingTypes_.reset(new StringSet);
     }
     return *missingTypes_.get();
   }

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

Definition at line 75 of file EDProductGetter.cc.

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

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

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

Definition at line 50 of file CollUtil.cc.

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

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

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

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

Definition at line 24 of file CollUtil.cc.

References gather_cfg::cout, and cmsRelvalreport::exit.

                                              {
     TFile *hdl = TFile::Open(fname.c_str(), "read");
 
     if (0 == hdl) {
       std::cout << "ERR Could not open file " << fname.c_str() << std::endl;
       exit(1);
     }
     return hdl;
   }

template<class A >

boost::enable_if_c< has_match<A>::value, NotHelper<A> >::type edm::operator! ( A const & a )

Definition at line 261 of file Selector.h.

References a.

   {
     return NotHelper<A>(a);
   }

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

inline

Definition at line 28 of file FileID.h.

28 {return !(lh == rh);}

mathSSE::lh

bool int lh

Definition: SSEVec.h:37

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

inline

Definition at line 50 of file RunLumiEntryInfo.h.

References b.

50 { return !(a==b); }

b

double b

Definition: hdecay.h:120

a

double a

Definition: hdecay.h:121

template<typename KEY >

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

inline

Definition at line 52 of file RefItem.h.

                                                                {
     return !(lhs == rhs);
   }

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

inline

Definition at line 59 of file EventEntryDescription.h.

References b.

59 { return !(a==b); }

b

double b

Definition: hdecay.h:120

a

double a

Definition: hdecay.h:121

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

inline

Definition at line 59 of file EventEntryInfo.h.

References b.

59 { return !(a==b); }

b

double b

Definition: hdecay.h:120

a

double a

Definition: hdecay.h:121

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

inline

Definition at line 61 of file BranchKey.h.

References b.

                                                      {
     return !(a == b);
   }

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

inline

Definition at line 62 of file ProductID.h.

                                                             {
     return !(lh == rh);
   }

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

inline

Definition at line 65 of file TypeID.h.

References b.

                                                            {
     return !(a == b);
   }

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

inline

Definition at line 66 of file ProcessConfiguration.h.

References b.

                                                                            {
     return !(a == b);
   }

template<typename KEY >

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

Definition at line 68 of file RefBase.h.

                                                                {
     return !(lhs == rhs);
   }

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

inline

Definition at line 72 of file Parentage.h.

References b.

72 { return !(a==b); }

b

double b

Definition: hdecay.h:120

a

double a

Definition: hdecay.h:121

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

inline

Definition at line 75 of file TypeIDBase.h.

References b.

76 { return !(a==b); }

b

double b

Definition: hdecay.h:120

template<class X , class Y >

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

Definition at line 76 of file debugging_allocator.h.

76 { return false; }

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

inline

Definition at line 88 of file ProductProvenance.h.

References b.

88 { return !(a==b); }

b

double b

Definition: hdecay.h:120

a

double a

Definition: hdecay.h:121

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

inline

Definition at line 94 of file ProcessHistory.h.

References b.

                                                                {
     return !(a==b);
   }

template<typename KEY >

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

Inequality operator.

Definition at line 101 of file RefVectorBase.h.

                                                                            {
     return !(lhs == rhs);
   }

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

inline

Definition at line 105 of file RefCore.h.

                                                      {
     return !(lhs == rhs);
   }

template<typename T >

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

inline

Definition at line 149 of file FwdPtr.h.

                                                          {
     return !(lhs == rhs);
   }

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

inline

Definition at line 150 of file FileIndex.h.

References mathSSE::lh.

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

mathSSE::lh

bool int lh

Definition: SSEVec.h:37

template<typename T >

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

inline

Definition at line 396 of file View.h.

   {
     return !(lhs==rhs);
   }

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

inline

Definition at line 176 of file ProductRegistry.h.

References b.

                                                                  {
     return !(a == b);
   }

template<typename T , typename U >

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

Definition at line 192 of file value_ptr.h.

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

                                                          {
     lhs.this_type_does_not_support_comparisons();   
     return false;   
   }

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

inline

Definition at line 200 of file Entry.h.

References b.

                                              {
     return !(a == b);
   }

template<typename T >

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

inline

Definition at line 202 of file RefToBaseProd.h.

                                                                         {
     return !(lhs == rhs);
   }

template<typename T , typename U >

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

Definition at line 204 of file value_ptr.h.

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

                                                          {
     rhs.this_type_does_not_support_comparisons();   
     return false;   
   }

template<typename C , typename T , typename F >

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

inline

Definition at line 221 of file RefVector.h.

                                                                            {
     return !(lhs == rhs);
   }

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

template<typename C >

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

inline

Definition at line 228 of file RefProd.h.

                                                             {
     return !(lhs == rhs);
   }

template<typename T >

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

inline

Definition at line 253 of file Ptr.h.

                                                    {
     return !(lhs == rhs);
   }

template<typename C , typename T , typename F >

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

inline

Definition at line 293 of file FwdRef.h.

                                                                      {
     return !(lhs == rhs);
   }

template<typename C , typename T , typename F >

bool edm::operator!=	(	Ref< C, T, F > const &	lhs,
		FwdRef< C, T, F > const &	rhs
	)

inline

Definition at line 300 of file FwdRef.h.

                                                                   {
     return !(lhs == rhs);
   }

template<typename C , typename T , typename F >

bool edm::operator!=	(	FwdRef< C, T, F > const &	lhs,
		Ref< C, T, F > const &	rhs
	)

inline

Definition at line 307 of file FwdRef.h.

                                                                   {
     return !(lhs == rhs);
   }

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

inline

Definition at line 311 of file ParameterSet.h.

References b.

                                                            {
     return !(a == b);
   }

template<typename C , typename T , typename F >

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

inline

Definition at line 411 of file Ref.h.

                                                                {
     return !(lhs == rhs);
   }

template<class A , class B >

boost::enable_if_c< has_match<A>::value && has_match<B>::value, AndHelper<A,B> >::type edm::operator&&	(	A const &	a,
		B const &	b
	)

Definition at line 203 of file Selector.h.

References a, and b.

   {
     return AndHelper<A,B>(a,b);
   }

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

Definition at line 193 of file ParameterDescriptionNode.cc.

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

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

Definition at line 199 of file ParameterDescriptionNode.cc.

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

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

Definition at line 205 of file ParameterDescriptionNode.cc.

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

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

Definition at line 211 of file ParameterDescriptionNode.cc.

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

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

Definition at line 2346 of file ParameterSet.cc.

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

                                                      {
     if(a == ParameterSet::False || b == ParameterSet::False) {
       return ParameterSet::False;
     } else if(a == ParameterSet::Unknown || b == ParameterSet::Unknown) {
       return ParameterSet::Unknown;
     }
     return ParameterSet::True;
   }

template<typename C , typename T , typename F >

RefVectorIterator<C, T, F> edm::operator+	(	typename RefVectorIterator< C, T, F >::difference	n,
		RefVectorIterator< C, T, F > const &	iter
	)

inline

Definition at line 72 of file RefVectorIterator.h.

References n.

                                                                                                                                 {
     return iter + n;
   } 

template<typename C >

Association<C> edm::operator+	(	const Association< C > &	a1,
		const Association< C > &	a2
	)

inline

Definition at line 122 of file Association.h.

References a.

                                                    {
     Association<C> a = a1;
     a += a2;
     return a;
   }

template<typename T >

ValueMap<T> edm::operator+	(	const ValueMap< T > &	a1,
		const ValueMap< T > &	a2
	)

inline

Definition at line 241 of file ValueMap.h.

References a.

                                              {
     ValueMap<T> a = a1;
     a += a2;
     return a;
   }

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

inline

Definition at line 22 of file EventProcessHistoryID.h.

References edm::EventProcessHistoryID::eventID().

                                                                                    {
       return lh.eventID() < rh.eventID();
   }

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

inline

Definition at line 37 of file RunLumiEntryInfo.h.

References edm::RunLumiEntryInfo::branchID().

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

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

inline

Definition at line 41 of file BranchKey.h.

References edm::BranchKey::friendlyClassName_, edm::BranchKey::moduleLabel_, edm::BranchKey::processName_, and edm::BranchKey::productInstanceName_.

                                                     {
       return 
     a.friendlyClassName_ < b.friendlyClassName_ ? true :
     a.friendlyClassName_ > b.friendlyClassName_ ? false :
     a.moduleLabel_ < b.moduleLabel_ ? true :
     a.moduleLabel_ > b.moduleLabel_ ? false :
     a.productInstanceName_ < b.productInstanceName_ ? true :
     a.productInstanceName_ > b.productInstanceName_ ? false :
     a.processName_ < b.processName_ ? true :
     false;
   }

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

inline

Definition at line 46 of file EventEntryInfo.h.

References edm::EventEntryInfo::branchID().

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

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

Definition at line 73 of file ProcessConfiguration.cc.

References edm::ProcessConfiguration::parameterSetID(), edm::ProcessConfiguration::passID(), edm::ProcessConfiguration::processName(), and edm::ProcessConfiguration::releaseVersion().

                                                                                {
     if (a.processName() < b.processName()) return true;
     if (b.processName() < a.processName()) return false;
     if (a.parameterSetID() < b.parameterSetID()) return true;
     if (b.parameterSetID() < a.parameterSetID()) return false;
     if (a.releaseVersion() < b.releaseVersion()) return true;
     if (b.releaseVersion() < a.releaseVersion()) return false;
     if (a.passID() < b.passID()) return true;
     return false;
   }

template<typename KEY >

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

inline

Definition at line 59 of file RefItem.h.

References edm::RefItem< KEY >::key().

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

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

Definition at line 12 of file ProductID.cc.

References edm::ProductID::processIndex(), and edm::ProductID::productIndex().

                                                            {
     return lh.processIndex() < rh.processIndex() ||
       (lh.processIndex() == rh.processIndex() && lh.productIndex() < rh.productIndex());
   }

template<typename KEY >

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

Definition at line 74 of file RefBase.h.

                                                               {
     return (lhs.refCore() == rhs.refCore() ?  lhs.item() < rhs.item() : lhs.refCore() < rhs.refCore());
   }

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

inline

Definition at line 75 of file ProductProvenance.h.

References edm::ProductProvenance::branchID().

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

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

inline

Definition at line 74 of file ConstBranchDescription.h.

References edm::ConstBranchDescription::me().

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

template<class T >

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

inline

Definition at line 89 of file DetSet.h.

                                                      {
     return x.detId() < y.detId();
   }

template<class T >

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

inline

Definition at line 96 of file DetSet.h.

References x, and detailsBasic3DVector::y.

                                                 {
     return x.detId() < y;
   }

template<class T >

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

inline

Definition at line 103 of file DetSet.h.

References x, and detailsBasic3DVector::y.

                                                 {
     return x < y.detId();
   }

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

inline

Definition at line 111 of file RefCore.h.

References edm::RefCore::id(), edm::RefCore::isTransient(), and edm::RefCore::productPtr().

                                                     {
     return lhs.isTransient() ? (rhs.isTransient() ? lhs.productPtr() < rhs.productPtr() : false) : (rhs.isTransient() ? true : lhs.id() < rhs.id());
   }

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

Definition at line 176 of file FileIndex.cc.

References edm::FileIndex::Element::event_, edm::FileIndex::Element::lumi_, and edm::FileIndex::Element::run_.

                                                                          {
     if(lh.run_ == rh.run_) {
       if(lh.lumi_ == rh.lumi_) {
     return lh.event_ < rh.event_;
       }
       return lh.lumi_ < rh.lumi_;
     }
     return lh.run_ < rh.run_;
   }

template<typename T >

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

inline

The ordering of integer keys guarantees that the ordering of FwdPtrs within a collection will be identical to the ordering of the referenced objects in the collection.

Definition at line 156 of file FwdPtr.h.

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

template<typename T >

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

inline

Definition at line 404 of file View.h.

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

template<typename T >

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

inline

Definition at line 209 of file RefToBaseProd.h.

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

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

Definition at line 248 of file BranchDescription.cc.

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

                                                                     {
     if (a.processName() < b.processName()) return true;
     if (b.processName() < a.processName()) return false;
     if (a.fullClassName() < b.fullClassName()) return true;
     if (b.fullClassName() < a.fullClassName()) return false;
     if (a.friendlyClassName() < b.friendlyClassName()) return true;
     if (b.friendlyClassName() < a.friendlyClassName()) return false;
     if (a.productInstanceName() < b.productInstanceName()) return true;
     if (b.productInstanceName() < a.productInstanceName()) return false;
     if (a.moduleLabel() < b.moduleLabel()) return true;
     if (b.moduleLabel() < a.moduleLabel()) return false;
     if (a.branchType() < b.branchType()) return true;
     if (b.branchType() < a.branchType()) return false;
     if (a.branchID() < b.branchID()) return true;
     if (b.branchID() < a.branchID()) return false;
     if (a.parameterSetIDs() < b.parameterSetIDs()) return true;
     if (b.parameterSetIDs() < a.parameterSetIDs()) return false;
     if (a.moduleNames() < b.moduleNames()) return true;
     if (b.moduleNames() < a.moduleNames()) return false;
     if (a.branchAliases() < b.branchAliases()) return true;
     if (b.branchAliases() < a.branchAliases()) return false;
     if (a.present() < b.present()) return true;
     if (b.present() < a.present()) return false;
     return false;
   }

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

template<typename C >

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

inline

Definition at line 235 of file RefProd.h.

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

template<typename T >

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

inline

The ordering of integer keys guarantees that the ordering of Ptrs within a collection will be identical to the ordering of the referenced objects in the collection.

Definition at line 260 of file Ptr.h.

                                                   {
     return (lhs.refCore() == rhs.refCore() ? lhs.key() < rhs.key() : lhs.refCore() < rhs.refCore());
   }

template<typename C , typename T , typename F >

bool edm::operator<	(	FwdRef< C, T, F > const &	lhs,
		FwdRef< C, T, F > const &	rhs
	)

inline

for inequality operators, ONLY test the forward ref. the ordering of the backward ref is not relevant.

Definition at line 316 of file FwdRef.h.

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

template<typename C , typename T , typename F >

bool edm::operator<	(	Ref< C, T, F > const &	lhs,
		FwdRef< C, T, F > const &	rhs
	)

inline

Definition at line 323 of file FwdRef.h.

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

template<typename C , typename T , typename F >

bool edm::operator<	(	FwdRef< C, T, F > const &	lhs,
		Ref< C, T, F > const &	rhs
	)

inline

Definition at line 330 of file FwdRef.h.

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

template<typename C , typename T , typename F >

bool edm::operator<	(	Ref< C, T, F > const &	lhs,
		Ref< C, T, F > const &	rhs
	)

inline

the definition and use of compare_key<> guarantees that the ordering of Refs within

a collection will be identical to the ordering of the referenced objects in the collection.

Definition at line 418 of file Ref.h.

                                                               {
       return (lhs.refCore() == rhs.refCore() ? compare_key<C>(lhs.key(), rhs.key()) : lhs.refCore() < rhs.refCore());
   }

std::ostream & edm::operator<<	(	std::ostream &	os,
		TimeOfDay const &	tod
	)

Definition at line 28 of file TimeOfDay.cc.

References begin, min, listBenchmarks::pattern, and edm::TimeOfDay::tv_.

                                                    {
     std::ios::fmtflags oldflags = os.flags(); // Save stream formats so they can be left unchanged.
     struct tm timebuf;
     localtime_r(&tod.tv_.tv_sec, &timebuf);
     typedef std::ostreambuf_iterator<char, std::char_traits<char> > Iter;
     std::time_put<char, Iter> const& tp = std::use_facet<std::time_put<char, Iter> >(std::locale());
     int precision = os.precision();
     Iter begin(os);
     if (precision == 0) {
       char const pattern[] = "%d-%b-%Y %H:%M:%S %Z";
       tp.put(begin, os, ' ', &timebuf, pattern, pattern + sizeof(pattern) - 1);
     } else {
       char const pattern[] = "%d-%b-%Y %H:%M:%S.";
       tp.put(begin, os, ' ', &timebuf, pattern, pattern + sizeof(pattern) - 1);
       precision = std::min(precision, 6);
       os << std::setfill('0') << std::setw(precision) << tod.tv_.tv_usec/power[precision] << ' ';
       tp.put(begin, os, ' ', &timebuf, 'Z');
     }
     os.flags(oldflags);
     return os;
   }

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

Definition at line 6 of file ParameterSetBlob.cc.

References edm::ParameterSetBlob::pset().

                                                            {
     os << blob.pset();
     return os;
   }

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

Definition at line 6 of file FileID.cc.

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

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

Definition at line 6 of file BranchType.cc.

References BranchTypeToString().

                                                            {
     os << BranchTypeToString(branchType);
     return os;
   }

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

Definition at line 96 of file FileFormatVersion.cc.

References edm::FileFormatVersion::value().

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

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

Definition at line 14 of file BranchID.cc.

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

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

inline

Definition at line 43 of file RunLumiEntryInfo.h.

References edm::RunLumiEntryInfo::write().

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

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

Definition at line 81 of file GroupSelector.cc.

References edm::GroupSelector::print().

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

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

inline

Definition at line 52 of file EventEntryDescription.h.

References edm::EventEntryDescription::write().

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

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

inline

Definition at line 52 of file EventEntryInfo.h.

References edm::EventEntryInfo::write().

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

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

inline

Definition at line 54 of file EntryDescription.h.

References edm::EntryDescription::write().

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

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

Definition at line 87 of file InputTag.cc.

References edm::InputTag::instance(), edm::InputTag::label(), align_tpl::process, and edm::InputTag::process().

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

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

Definition at line 26 of file MallocOpts.cc.

References edm::MallocOpts::mmap_max_, edm::MallocOpts::mmap_thr_, edm::MallocOpts::top_pad_, and edm::MallocOpts::trim_thr_.

   {
     ost << "mmap_max=" << opts.mmap_max_
     << " trim_threshold=" << opts.trim_thr_
     << " top_padding=" << opts.top_pad_
     << " mmap_threshold=" << opts.mmap_thr_;
     return ost;
   }

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

inline

Definition at line 65 of file Parentage.h.

References edm::Parentage::write().

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

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

Definition at line 46 of file LuminosityBlockRange.cc.

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

                                                                              {
     oStream << "'" << r.startRun() << ":" << r.startLumi() << "-"
                    << r.endRun()   << ":" << r.endLumi()   << "'" ;
     return oStream;
   }

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

Definition at line 28 of file BranchKey.cc.

References edm::BranchKey::friendlyClassName_, edm::BranchKey::moduleLabel_, edm::BranchKey::processName_, and edm::BranchKey::productInstanceName_.

                                                   {
     os << "BranchKey("
        << bk.friendlyClassName_ << ", "
        << bk.moduleLabel_ << ", "
        << bk.productInstanceName_ << ", "
        << bk.processName_ << ')';
     return os;
   }

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

inline

Definition at line 67 of file RunAuxiliary.h.

References edm::RunAuxiliary::write().

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

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

inline

Definition at line 68 of file ConstBranchDescription.h.

References edm::ConstBranchDescription::me().

                                                               {
     os << p.me();
     return os;
   }

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

inline

Definition at line 68 of file LuminosityBlockAuxiliary.h.

References edm::LuminosityBlockAuxiliary::write().

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

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

Definition at line 7 of file ProductID.cc.

                                                   {
     os << id.processIndex() << ":" << id.productIndex();
     return os;
   }

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

Definition at line 120 of file TypeID.cc.

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

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

Definition at line 27 of file EventRange.cc.

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

                                                                    {
     if (r.startLumi() == 0) {
       oStream << "'" << r.startRun() << ":" << r.startEvent() << "-"
                      << r.endRun() << ":" << r.endEvent() << "'";
     } else {
       oStream << "'" << r.startRun() << ":" << r.startLumi() << ":" << r.startEvent() << "-"
                      << r.endRun() << ":" << r.endLumi() << ":" << r.endEvent() << "'";
     }
     return oStream;
   }

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

Definition at line 85 of file ProcessConfiguration.cc.

References edm::ProcessConfiguration::parameterSetID(), edm::ProcessConfiguration::passID(), edm::ProcessConfiguration::processName(), and edm::ProcessConfiguration::releaseVersion().

                                                               {
     os << pc.processName() << ' ' 
        << pc.parameterSetID() << ' '
        << pc.releaseVersion() << ' '
        << pc.passID();
     return os;
   }

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

inline

Definition at line 71 of file BranchMapper.h.

References edm::BranchMapper::write().

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

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

inline

Definition at line 81 of file ProductProvenance.h.

References edm::ProductProvenance::write().

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

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

inline

Definition at line 84 of file ModuleDescription.h.

References edm::ModuleDescription::write().

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

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

Definition at line 88 of file ParameterSetEntry.cc.

References edm::ParameterSetEntry::isTracked(), and edm::ParameterSetEntry::pset().

                                                                                {
      const char* trackiness = (psetEntry.isTracked()?"tracked":"untracked");
     os << "PSet "<<trackiness<<" = ("<< psetEntry.pset() << ")";
     return os;
   }

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

Definition at line 93 of file JobReport.cc.

References print().

                                                                        {
     return print(os,f);
   }

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

Definition at line 5 of file RunID.cc.

References edm::RunID::run().

                                                                 {
     oStream << "run: " << iID.run();
     return oStream;
   }

edm::MessageSender& edm::operator<<	(	edm::MessageSender &	os,
		JobReport::InputFile const &	f
	)

Definition at line 98 of file JobReport.cc.

References print().

                                                                                    {
     return print(os,f);
   }

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

inline

Definition at line 102 of file EventAuxiliary.h.

References edm::EventAuxiliary::write().

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

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

Definition at line 101 of file JobReport.cc.

References print().

                                                                                     {
     return print(os,f);
   }

std::ostream& edm::operator<<	(	std::ostream &	os,
		VParameterSetEntry const &	vpsetEntry
	)

Definition at line 104 of file VParameterSetEntry.cc.

References i, edm::VParameterSetEntry::isTracked(), and edm::VParameterSetEntry::vpset().

                                                                                {
     std::vector<ParameterSet> const& vps = vpsetEntry.vpset();
     os << "VPSet "<<(vpsetEntry.isTracked()?"tracked":"untracked")<<" = ({" << std::endl;
     std::string start;
     std::string const between(",\n");
     for(std::vector<ParameterSet>::const_iterator i = vps.begin(), e = vps.end(); i != e; ++i) {
       os << start << *i;
       start = between;
     }
     if (!vps.empty()) {
       os << std::endl;
     }
     os << "})";
     return os;
   }

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

Definition at line 104 of file JobReport.cc.

References print().

                                                                                    {
     return print(os,f);
   }

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

Definition at line 57 of file ProcessHistory.cc.

References copy_all().

                                                         {
     ost << "Process History = ";
     copy_all(ph, std::ostream_iterator<ProcessHistory::value_type>(ost,";"));
     return ost;
   }

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

inline

Definition at line 116 of file Provenance.h.

References edm::Provenance::write().

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

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

inline

Formatted printout of trigger tbale.

Definition at line 117 of file HLTGlobalStatus.h.

References i, n, edm::HLTGlobalStatus::size(), edm::HLTGlobalStatus::state(), and runonSM::text.

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

template<class T >

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

inline

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

Definition at line 25 of file LuminosityBlockID.cc.

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

                                                                             {
     oStream<< "run: " << iID.run() << " luminosityBlock: " << iID.luminosityBlock();
     return oStream;
   }

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

Definition at line 5 of file EventID.cc.

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

                                                                   {
     oStream << "run: " << iID.run() << " lumi: " << iID.luminosityBlock() << " event: " << iID.event();
     return oStream;
   }

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

Definition at line 274 of file ErrorObj.cc.

References edm::ErrorObj::opltlt().

                                                       {
   return e.opltlt(s);
 }

std::ostream& edm::operator<<	(	std::ostream &	os,
		const edm::FileInPath &	fip
	)

inline

Definition at line 144 of file FileInPath.h.

References edm::FileInPath::write().

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

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

Definition at line 205 of file FileIndex.cc.

References edm::FileIndex::begin(), edm::FileIndex::end(), edm::FileIndex::kEvent, edm::FileIndex::kLumi, and edm::FileIndex::kRun.

                                                          {
 
     os << "\nPrinting FileIndex contents.  This includes a list of all Runs, LuminosityBlocks\n"
        << "and Events stored in the root file.\n\n";
     os << std::setw(15) << "Run"
        << std::setw(15) << "Lumi"
        << std::setw(15) << "Event"
        << std::setw(15) << "TTree Entry"
        << "\n";
     for(std::vector<FileIndex::Element>::const_iterator it = fileIndex.begin(), itEnd = fileIndex.end(); it != itEnd; ++it) {
       if(it->getEntryType() == FileIndex::kEvent) {
         os << std::setw(15) << it->run_
            << std::setw(15) << it ->lumi_
            << std::setw(15) << it->event_
            << std::setw(15) << it->entry_
            << "\n";
       }
       else if(it->getEntryType() == FileIndex::kLumi) {
         os << std::setw(15) << it->run_
            << std::setw(15) << it ->lumi_
            << std::setw(15) << " "
            << std::setw(15) << it->entry_ << "  (LuminosityBlock)"
            << "\n";
       }
       else if(it->getEntryType() == FileIndex::kRun) {
         os << std::setw(15) << it->run_
            << std::setw(15) << " "
            << std::setw(15) << " "
            << std::setw(15) << it->entry_ << "  (Run)"
            << "\n";
       }
     }
     return os;
   }

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

inline

Definition at line 182 of file Group.h.

References edm::Group::write().

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

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

inline

Definition at line 182 of file ProductRegistry.h.

References edm::ProductRegistry::print().

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

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

inline

Definition at line 206 of file BranchDescription.h.

References edm::BranchDescription::write().

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

template<int I>

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

inline

Definition at line 217 of file Hash.h.

References h.

                                                {
     return h.print(os);
   }

template<typename PROD >

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

inline

Definition at line 244 of file PrincipalGetAdapter.h.

References h.

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

template<typename C , typename T , typename F >

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

Definition at line 249 of file RefVector.h.

References i, and csvReporter::r.

   {
     for (typename RefVector<C,T,F>::const_iterator
        i = r.begin(),
        e = r.end();
      i != e;
      ++i)
       {
     os << *i << '\n';
       }
     return os;
   }

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

Definition at line 316 of file ELseverityLevel.cc.

References edm::ELseverityLevel::getName().

                                                                          {
   return os << " -" << sev.getName() << "- ";
 }

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

Definition at line 86 of file JobReport.cc.

References print().

                                                                        {
     return print(os,f);
   }

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

Definition at line 89 of file JobReport.cc.

References print().

                                                                         {
     return print(os,f);
   }

std::ostream& edm::operator<<	(	std::ostream &	os,
		JobReport::LumiSectionReport const &	rep
	)

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

Definition at line 858 of file ParameterSet.cc.

References edm::ParameterSet::dump().

                                                                    {
     os << pset.dump();
     return os;
   }

std::ostream& edm::operator<<	(	std::ostream &	os,
		Entry const &	entry
	)

Definition at line 944 of file Entry.cc.

References edm::Entry::getInt32(), edm::Entry::getPSet(), edm::Entry::getString(), edm::Entry::getUInt32(), edm::Entry::getVESInputTag(), edm::Entry::getVInputTag(), edm::Entry::getVPSet(), edm::Entry::getVString(), i, edm::Entry::isTracked(), kTVESInputTag, edm::Entry::rep, sTypeTranslations, edm::pset::TypeTrans::table_, o2o::tags, and edm::Entry::typeCode().

                                                   {
     os << sTypeTranslations.table_[entry.typeCode()] << " "
        << (entry.isTracked() ? "tracked " : "untracked ") <<" = ";
 
     // now handle the difficult cases
     switch(entry.typeCode()) {
       case 'P': // ParameterSet
       {
         os << entry.getPSet();
         break;
       }
       case 'p': // vector<ParameterSet>
       {
         // Make sure we get the representation of each contained
         // ParameterSet including *only* tracked parameters
         std::vector<ParameterSet> whole = entry.getVPSet();
         std::vector<ParameterSet>::const_iterator i = whole.begin();
         std::vector<ParameterSet>::const_iterator e = whole.end();
         std::string start ="";
         std::string const between(",\n");
         os << "{"<<std::endl;
          for (; i != e; ++i) {
            os <<  start<< *i;
            start = between;
          }
          if (whole.size()) {
            os << std::endl;
          }
          os << "}";
          break;
       }
       case 'S':
       {
         os << "'" << entry.getString() << "'";
         break;
       }
       case 's':
       {
 
         os << "{";
         std::string start ="'";
         std::string const between(",'");
         std::vector<std::string> strings = entry.getVString();
         for(std::vector<std::string>::const_iterator it = strings.begin(), itEnd = strings.end();
             it != itEnd;
             ++it) {
           os << start << *it << "'";
           start = between;
         }
         os << "}";
         break;
       }
       case 'I':
       {
         os << entry.getInt32();
         break;
       }
       case 'U':
       {
         os << entry.getUInt32();
         break;
       }
       case 'v':
       {
         //VInputTag needs to be treated seperately because it is encode like
         // vector<string> rather than using the individual encodings of each InputTag
         os << "{";
         std::string start = "";
         std::string const between(",");
         std::vector<InputTag> tags = entry.getVInputTag();
         for(std::vector<InputTag>::const_iterator it = tags.begin(), itEnd = tags.end();
             it != itEnd;
             ++it) {
           os << start << it->encode();
           start = between;
         }
         os << "}";
         break;
       }
        case kTVESInputTag:
        {
           //VESInputTag needs to be treated seperately because it is encode like
           // vector<string> rather than using the individual encodings of each ESInputTag
           os << "{";
           std::string start = "";
           std::string const between(",");
           std::vector<ESInputTag> tags = entry.getVESInputTag();
           for(std::vector<ESInputTag>::const_iterator it = tags.begin(), itEnd = tags.end();
               it != itEnd;
               ++it) {
              os << start << it->encode();
              start = between;
           }
           os << "}";
           break;
        }
        default:
       {
         os << entry.rep;
         break;
       }
     }
 
     return os;
   }

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

inline

Definition at line 144 of file FileIndex.h.

References mathSSE::lh.

144 {return !(rh < lh);}

mathSSE::lh

bool int lh

Definition: SSEVec.h:37

template<typename T >

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

inline

Definition at line 414 of file View.h.

   {
     return !(rhs<lhs);
   }

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

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

inline

Definition at line 25 of file FileID.h.

References edm::FileID::fid().

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

mathSSE::lh

bool int lh

Definition: SSEVec.h:37

template<typename KEY >

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

inline

Definition at line 45 of file RefItem.h.

References edm::RefItem< KEY >::key().

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

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

Definition at line 23 of file RunLumiEntryInfo.cc.

References edm::RunLumiEntryInfo::branchID(), and edm::RunLumiEntryInfo::productStatus().

                                                                    {
     return
       a.branchID() == b.branchID()
       && a.productStatus() == b.productStatus();
   }

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

inline

Definition at line 55 of file BranchKey.h.

References a.

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

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

inline

Definition at line 57 of file ProcessConfiguration.h.

References edm::ProcessConfiguration::parameterSetID(), edm::ProcessConfiguration::passID(), edm::ProcessConfiguration::processName(), and edm::ProcessConfiguration::releaseVersion().

                                                                            {
     return a.processName() == b.processName() &&
     a.parameterSetID() == b.parameterSetID() &&
     a.releaseVersion() == b.releaseVersion() &&
     a.passID() == b.passID();
   }

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

Definition at line 43 of file EventEntryDescription.cc.

References edm::EventEntryDescription::parents().

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

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

Definition at line 27 of file EventEntryInfo.cc.

References edm::EventEntryInfo::branchID(), edm::EventEntryInfo::entryDescriptionID(), edm::EventEntryInfo::productID(), and edm::EventEntryInfo::productStatus().

                                                                {
     return
       a.branchID() == b.branchID()
       && a.productID() == b.productID()
       && a.productStatus() == b.productStatus()
       && a.entryDescriptionID() == b.entryDescriptionID();
   }

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

inline

Definition at line 58 of file ProductID.h.

References edm::ProductID::processIndex(), and edm::ProductID::productIndex().

                                                             {
     return lh.processIndex() == rh.processIndex() && lh.productIndex() == rh.productIndex();
   }

template<typename KEY >

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

Definition at line 62 of file RefBase.h.

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

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

Definition at line 49 of file Parentage.cc.

References edm::Parentage::parents().

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

template<class X , class Y >

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

Definition at line 73 of file debugging_allocator.h.

73 { return true; }

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

inline

Definition at line 79 of file ConstBranchDescription.h.

References edm::ConstBranchDescription::me().

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

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

Definition at line 110 of file ProductProvenance.cc.

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

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

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

inline

Definition at line 88 of file ProcessHistory.h.

References edm::ProcessHistory::data().

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

template<typename KEY >

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

Equality operator.

Definition at line 94 of file RefVectorBase.h.

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

template<class T >

bool edm::operator==	(	RefToBaseVector< T > const &	a,
		RefToBaseVector< T > const &	b
	)

inline

Definition at line 97 of file RefToBaseVector.h.

References edm::RefToBaseVector< T >::begin(), edm::RefToBaseVector< T >::end(), edm::RefToBaseVector< T >::isInvalid(), and edm::RefToBaseVector< T >::size().

   {
     if ( a.isInvalid() && b.isInvalid() ) return true;
     if ( a.isInvalid() || b.isInvalid() ) return false;
     return  a.size() == b.size() && std::equal(a.begin(), a.end(), b.begin());
   }

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

inline

Definition at line 99 of file RefCore.h.

References edm::RefCore::id(), edm::RefCore::isTransient(), and edm::RefCore::productPtr().

                                                      {
     return lhs.isTransient() == rhs.isTransient() && (lhs.isTransient() ? lhs.productPtr() == rhs.productPtr() : lhs.id() == rhs.id());
   }

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

Definition at line 96 of file Provenance.cc.

References edm::Provenance::product().

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

template<typename T >

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

inline

Definition at line 139 of file FwdPtr.h.

                                                          {
     return ( lhs.ptr() == rhs.ptr() ||
          lhs.backPtr() == rhs.ptr() ||
          lhs.ptr() == rhs.backPtr() ||
          lhs.backPtr() == rhs.backPtr() );
   }

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

inline

Definition at line 147 of file FileIndex.h.

References mathSSE::lh.

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

mathSSE::lh

bool int lh

Definition: SSEVec.h:37

template<typename T >

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

inline

Definition at line 386 of file View.h.

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

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

inline

Definition at line 158 of file FileInPath.h.

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

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

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

inline

Definition at line 170 of file ProductRegistry.h.

References edm::ProductRegistry::productList().

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

template<typename T , typename U >

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

Definition at line 186 of file value_ptr.h.

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

                                                          {
     lhs.this_type_does_not_support_comparisons();   
     return false;   
   }

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

inline

Definition at line 195 of file Entry.h.

References edm::Entry::toString().

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

template<typename T >

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

inline

Definition at line 195 of file RefToBaseProd.h.

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

template<typename T , typename U >

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

Definition at line 198 of file value_ptr.h.

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

                                                          {
     rhs.this_type_does_not_support_comparisons();   
     return false;   
   }

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

Definition at line 287 of file BranchDescription.cc.

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

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

template<typename C , typename T , typename F >

bool edm::operator==	(	RefVector< C, T, F > const &	lhs,
		RefVector< C, T, F > const &	rhs
	)

inline

Definition at line 214 of file RefVector.h.

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

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

template<typename C >

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

inline

Definition at line 221 of file RefProd.h.

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

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

template<typename T >

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

inline

Definition at line 246 of file Ptr.h.

References edm::Ptr< T >::key(), and edm::Ptr< T >::refCore().

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

template<typename C , typename T , typename F >

bool edm::operator==	(	FwdRef< C, T, F > const &	lhs,
		FwdRef< C, T, F > const &	rhs
	)

inline

for two FwdRefs to be equal, both the "forward" and the "backward" Refs must be the same

Definition at line 257 of file FwdRef.h.

References edm::FwdRef< C, T, F >::backRef(), and edm::FwdRef< C, T, F >::ref().

                                                                      {
     return 
     (lhs.ref() == rhs.ref() ) &&
     (lhs.backRef() == rhs.backRef() )
     ;
   }

template<typename C , typename T , typename F >

bool edm::operator==	(	Ref< C, T, F > const &	lhs,
		FwdRef< C, T, F > const &	rhs
	)

inline

for a FwdRef to equal a Ref, EITHER the "forward" or the "backward" Refs must equal to the test ref

Definition at line 269 of file FwdRef.h.

References edm::FwdRef< C, T, F >::backRef(), and edm::FwdRef< C, T, F >::ref().

                                                                   {
     return 
     (lhs == rhs.ref() )    ||
     (lhs == rhs.backRef() )
     ;
   }

template<typename C , typename T , typename F >

bool edm::operator==	(	FwdRef< C, T, F > const &	lhs,
		Ref< C, T, F > const &	rhs
	)

inline

for a FwdRef to equal a Ref, EITHER the "forward" or the "backward" Refs must equal to the test ref

Definition at line 281 of file FwdRef.h.

References edm::FwdRef< C, T, F >::backRef(), and edm::FwdRef< C, T, F >::ref().

                                                                   {
     return 
     (lhs.ref() == rhs )    ||
     (lhs.backRef() == rhs )
     ;
   }

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

Definition at line 772 of file ParameterSet.cc.

References edm::ParameterSet::id(), edm::ParameterSet::isRegistered(), isTransientEqual(), and edm::ParameterSet::trackedPart().

                                                                 {
     if(a.isRegistered() && b.isRegistered()) {
       return (a.id() == b.id());
     }
     return isTransientEqual(a.trackedPart(), b.trackedPart());
   }

template<typename C , typename T , typename F >

bool edm::operator==	(	Ref< C, T, F > const &	lhs,
		Ref< C, T, F > const &	rhs
	)

inline

Definition at line 404 of file Ref.h.

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

template<typename T , typename SORT , typename ALLOC >

bool edm::operator==	(	SortedCollection< T, SORT > const &	c,
		std::vector< T, ALLOC > const &	v
	)

inline

Definition at line 420 of file SortedCollection.h.

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

template<typename T , typename SORT >

bool edm::operator==	(	SortedCollection< T, SORT > const &	a,
		SortedCollection< T, SORT > const &	b
	)

inline

Definition at line 432 of file SortedCollection.h.

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

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

inline

Definition at line 61 of file TypeID.h.

References a.

                                                           {
     return b < a;
   }

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

inline

Definition at line 72 of file TypeIDBase.h.

References a.

73 { return b<a; }

a

double a

Definition: hdecay.h:121

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

inline

Definition at line 138 of file FileIndex.h.

References mathSSE::lh.

138 {return rh < lh;}

mathSSE::lh

bool int lh

Definition: SSEVec.h:37

template<typename T >

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

inline

Definition at line 421 of file View.h.

   {
     return rhs<lhs;
   }

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

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

inline

Definition at line 141 of file FileIndex.h.

141 {return !(lh < rh);}

mathSSE::lh

bool int lh

Definition: SSEVec.h:37

template<typename T >

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

inline

Definition at line 428 of file View.h.

   {
     return !(lhs<rhs);
   }

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

std::istream& edm::operator>>	(	std::istream &	is,
		FileInPath &	fip
	)

inline

Definition at line 151 of file FileInPath.h.

References edm::FileInPath::read().

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

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

Definition at line 134 of file ParameterDescriptionNode.cc.

References edm::ParameterDescriptionNode::clone().

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

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

Definition at line 141 of file ParameterDescriptionNode.cc.

References edm::ParameterDescriptionNode::clone().

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

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

Definition at line 148 of file ParameterDescriptionNode.cc.

References edm::ParameterDescriptionNode::clone().

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

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

Definition at line 155 of file ParameterDescriptionNode.cc.

References edm::ParameterDescriptionNode::clone().

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

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

Definition at line 162 of file ParameterDescriptionNode.cc.

References python.Node::node.

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

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

Definition at line 169 of file ParameterDescriptionNode.cc.

References python.Node::node.

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

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

Definition at line 176 of file ParameterDescriptionNode.cc.

References python.Node::node.

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

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

Definition at line 183 of file ParameterDescriptionNode.cc.

References python.Node::node.

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

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

Definition at line 245 of file ParameterDescriptionNode.cc.

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

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

Definition at line 251 of file ParameterDescriptionNode.cc.

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

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

Definition at line 257 of file ParameterDescriptionNode.cc.

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

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

Definition at line 263 of file ParameterDescriptionNode.cc.

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

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

Definition at line 8 of file ParameterDescriptionCases.cc.

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

                                                                   {
 
     std::auto_ptr<std::map<bool, edm::value_ptr<ParameterDescriptionNode> > > rightCases = right->caseMap();
     for (std::map<bool, edm::value_ptr<ParameterDescriptionNode> >::const_iterator iter = rightCases->begin(),
                                                                                iEnd = rightCases->end();
          iter != iEnd; ++iter) {
       bool caseValue = iter->first;
       std::auto_ptr<ParameterDescriptionNode> node(iter->second->clone());
       left->insert(caseValue, node);
     }
     return left;
   }

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

Definition at line 23 of file ParameterDescriptionCases.cc.

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

                                                                  {
 
     std::auto_ptr<std::map<int, edm::value_ptr<ParameterDescriptionNode> > > rightCases = right->caseMap();
     for (std::map<int, edm::value_ptr<ParameterDescriptionNode> >::const_iterator iter = rightCases->begin(),
                                                                               iEnd = rightCases->end();
          iter != iEnd; ++iter) {
       int caseValue = iter->first;
       std::auto_ptr<ParameterDescriptionNode> node(iter->second->clone());
       left->insert(caseValue, node);
     }
     return left;
   }

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

Definition at line 38 of file ParameterDescriptionCases.cc.

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

                                                                        {
 
     std::auto_ptr<std::map<std::string, edm::value_ptr<ParameterDescriptionNode> > > rightCases = right->caseMap();
     for (std::map<std::string, edm::value_ptr<ParameterDescriptionNode> >::const_iterator iter = rightCases->begin(),
                                                                             iEnd = rightCases->end();
          iter != iEnd; ++iter) {
       std::string caseValue = iter->first;
       std::auto_ptr<ParameterDescriptionNode> node(iter->second->clone());
       left->insert(caseValue, node);
     }
     return left;
   }

template<class A , class B >

boost::enable_if_c< has_match<A>::value && has_match<B>::value, OrHelper<A,B> >::type edm::operator\|\|	(	A const &	a,
		B const &	b
	)

Definition at line 235 of file Selector.h.

References a, and b.

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

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

Definition at line 219 of file ParameterDescriptionNode.cc.

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

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

Definition at line 225 of file ParameterDescriptionNode.cc.

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

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

Definition at line 231 of file ParameterDescriptionNode.cc.

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

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

Definition at line 237 of file ParameterDescriptionNode.cc.

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

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

Definition at line 66 of file LuminosityBlockRange.cc.

References distinct().

                                                                                 {
     return !distinct(lh, rh);
   }

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

Definition at line 54 of file EventRange.cc.

References distinct(), and edm::EventRange::startLumi().

Referenced by merge().

                                                             {
     assert((lh.startLumi() == 0) == (rh.startLumi() == 0));
     return !distinct(lh, rh);
   }

template<>

std::string edm::ParameterSet::getParameter< std::string > ( std::string const & name ) const

template<>

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

template<>

std::vector<double> edm::ParameterSet::getParameter< std::vector< double > > ( std::string const & name ) const

template<>

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

template<>

std::vector<ESInputTag> edm::ParameterSet::getParameter< std::vector< ESInputTag > > ( std::string const & name ) const

template<>

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

Definition at line 1664 of file ParameterSet.cc.

References mergeVDriftHistosByStation::name.

                                                                             {
       return retrieve(name).getVESInputTag();
    }

template<>

std::vector<EventID> edm::ParameterSet::getParameter< std::vector< EventID > > ( std::string const & name ) const

template<>

std::vector<EventID> edm::ParameterSet::getParameter< std::vector< EventID > > ( char const * name ) const

template<>

std::vector<EventRange> edm::ParameterSet::getParameter< std::vector< EventRange > > ( std::string const & name ) const

template<>

std::vector<EventRange> edm::ParameterSet::getParameter< std::vector< EventRange > > ( char const * name ) const

template<>

std::vector<InputTag> edm::ParameterSet::getParameter< std::vector< InputTag > > ( std::string const & name ) const

template<>

std::vector<InputTag> edm::ParameterSet::getParameter< std::vector< InputTag > > ( char const * name ) const

template<>

std::vector<int> edm::ParameterSet::getParameter< std::vector< int > > ( std::string const & name ) const

template<>

std::vector<int> edm::ParameterSet::getParameter< std::vector< int > > ( char const * name ) const

template<>

std::vector<long long> edm::ParameterSet::getParameter< std::vector< long long > > ( std::string const & name ) const

template<>

std::vector<long long> edm::ParameterSet::getParameter< std::vector< long long > > ( char const * name ) const

template<>

std::vector<LuminosityBlockID> edm::ParameterSet::getParameter< std::vector< LuminosityBlockID > > ( std::string const & name ) const

template<>

std::vector<LuminosityBlockID> edm::ParameterSet::getParameter< std::vector< LuminosityBlockID > > ( char const * name ) const

template<>

std::vector<LuminosityBlockRange> edm::ParameterSet::getParameter< std::vector< LuminosityBlockRange > > ( std::string const & name ) const

template<>

std::vector<LuminosityBlockRange> edm::ParameterSet::getParameter< std::vector< LuminosityBlockRange > > ( char const * name ) const

template<>

std::vector<PdtEntry> edm::ParameterSet::getParameter< std::vector< PdtEntry > > ( char const * name ) const

inline

Definition at line 110 of file PdtEntry.h.

References edm::pdtentry::getPdtEntryVector(), and mergeVDriftHistosByStation::name.

                                                                                                     {
     Entry const& e = retrieve(name);
     return pdtentry::getPdtEntryVector(e, name);
   }

template<>

std::vector<PdtEntry> edm::ParameterSet::getParameter< std::vector< PdtEntry > > ( std::string const & name ) const

inline

Definition at line 90 of file PdtEntry.h.

References edm::pdtentry::getPdtEntryVector(), and mergeVDriftHistosByStation::name.

                                                                                                          {
     Entry const& e = retrieve(name);
     return pdtentry::getPdtEntryVector(e, name.c_str());
   }

template<>

std::vector<std::string> edm::ParameterSet::getParameter< std::vector< std::string > > ( std::string const & name ) const

template<>

std::vector<std::string> edm::ParameterSet::getParameter< std::vector< std::string > > ( char const * name ) const

template<>

std::vector<unsigned int> edm::ParameterSet::getParameter< std::vector< unsigned int > > ( std::string const & name ) const

template<>

std::vector<unsigned int> edm::ParameterSet::getParameter< std::vector< unsigned int > > ( char const * name ) const

template<>

std::vector<unsigned long long> edm::ParameterSet::getParameter< std::vector< unsigned long long > > ( std::string const & name ) const

template<>

std::vector<unsigned long long> edm::ParameterSet::getParameter< std::vector< unsigned long long > > ( char const * name ) const

template<>

std::vector<std::string> edm::ParameterSet::getParameterNamesForType< std::vector< PdtEntry > > ( bool trackiness ) const

inline

Definition at line 138 of file PdtEntry.h.

References filterCSVwithJSON::copy.

                                                                                                                 {
     std::vector<std::string> ints = getParameterNamesForType<std::vector<int> >(trackiness);
     std::vector<std::string> strings = getParameterNamesForType<std::vector<std::string> >(trackiness);
     std::copy( strings.begin(), strings.end(), std::back_insert_iterator<std::vector<std::string> >( ints ) ); 
     return ints;
   }

template<>

std::string edm::ParameterSet::getUntrackedParameter< std::string >	(	std::string const &	name,
		std::string const &	defaultValue
	)		const

template<>

std::string edm::ParameterSet::getUntrackedParameter< std::string > ( std::string const & name ) const

template<>

std::string edm::ParameterSet::getUntrackedParameter< std::string >	(	char const *	name,
		std::string const &	defaultValue
	)		const

template<>

std::string edm::ParameterSet::getUntrackedParameter< std::string > ( char const * name ) const

template<>

std::vector<double> edm::ParameterSet::getUntrackedParameter< std::vector< double > >	(	std::string const &	name,
		std::vector< double > const &	defaultValue
	)		const

template<>

std::vector<double> edm::ParameterSet::getUntrackedParameter< std::vector< double > > ( std::string const & name ) const

template<>

std::vector<double> edm::ParameterSet::getUntrackedParameter< std::vector< double > >	(	char const *	name,
		std::vector< double > const &	defaultValue
	)		const

template<>

std::vector<double> edm::ParameterSet::getUntrackedParameter< std::vector< double > > ( char const * name ) const

template<>

std::vector<ESInputTag> edm::ParameterSet::getUntrackedParameter< std::vector< ESInputTag > >	(	std::string const &	name,
		std::vector< ESInputTag > const &	defaultValue
	)		const

Definition at line 1381 of file ParameterSet.cc.

References edm::Entry::getVESInputTag(), and mergeVDriftHistosByStation::name.

                                                                                                                 {
       Entry const* entryPtr = retrieveUntracked(name);
       return entryPtr == 0 ? defaultValue : entryPtr->getVESInputTag();
    }

template<>

std::vector<ESInputTag> edm::ParameterSet::getUntrackedParameter< std::vector< ESInputTag > > ( std::string const & name ) const

Definition at line 1389 of file ParameterSet.cc.

References mergeVDriftHistosByStation::name.

                                                                                           {
       return getEntryPointerOrThrow_(name)->getVESInputTag();
    }

template<>

std::vector<ESInputTag> edm::ParameterSet::getUntrackedParameter< std::vector< ESInputTag > > ( char const * name ) const

Definition at line 2019 of file ParameterSet.cc.

References mergeVDriftHistosByStation::name.

                                                                                      {
       return getEntryPointerOrThrow_(name)->getVESInputTag();
    }

template<>

std::vector<ESInputTag> edm::ParameterSet::getUntrackedParameter< std::vector< ESInputTag > >	(	char const *	name,
		std::vector< ESInputTag > const &	defaultValue
	)		const

Definition at line 2011 of file ParameterSet.cc.

References edm::Entry::getVESInputTag(), and mergeVDriftHistosByStation::name.

                                                                                                                 {
       Entry const* entryPtr = retrieveUntracked(name);
       return entryPtr == 0 ? defaultValue : entryPtr->getVESInputTag();
    }

template<>

std::vector<EventID> edm::ParameterSet::getUntrackedParameter< std::vector< EventID > >	(	std::string const &	name,
		std::vector< EventID > const &	defaultValue
	)		const

template<>

std::vector<EventID> edm::ParameterSet::getUntrackedParameter< std::vector< EventID > > ( std::string const & name ) const

template<>

std::vector<EventID> edm::ParameterSet::getUntrackedParameter< std::vector< EventID > > ( char const * name ) const

template<>

std::vector<EventID> edm::ParameterSet::getUntrackedParameter< std::vector< EventID > >	(	char const *	name,
		std::vector< EventID > const &	defaultValue
	)		const

template<>

std::vector<EventRange> edm::ParameterSet::getUntrackedParameter< std::vector< EventRange > > ( std::string const & name ) const

template<>

std::vector<EventRange> edm::ParameterSet::getUntrackedParameter< std::vector< EventRange > >	(	std::string const &	name,
		std::vector< EventRange > const &	defaultValue
	)		const

template<>

std::vector<EventRange> edm::ParameterSet::getUntrackedParameter< std::vector< EventRange > >	(	char const *	name,
		std::vector< EventRange > const &	defaultValue
	)		const

template<>

std::vector<EventRange> edm::ParameterSet::getUntrackedParameter< std::vector< EventRange > > ( char const * name ) const

template<>

std::vector<InputTag> edm::ParameterSet::getUntrackedParameter< std::vector< InputTag > >	(	std::string const &	name,
		std::vector< InputTag > const &	defaultValue
	)		const

template<>

std::vector<InputTag> edm::ParameterSet::getUntrackedParameter< std::vector< InputTag > > ( std::string const & name ) const

template<>

std::vector<InputTag> edm::ParameterSet::getUntrackedParameter< std::vector< InputTag > > ( char const * name ) const

template<>

std::vector<InputTag> edm::ParameterSet::getUntrackedParameter< std::vector< InputTag > >	(	char const *	name,
		std::vector< InputTag > const &	defaultValue
	)		const

template<>

std::vector<int> edm::ParameterSet::getUntrackedParameter< std::vector< int > >	(	std::string const &	name,
		std::vector< int > const &	defaultValue
	)		const

template<>

std::vector<int> edm::ParameterSet::getUntrackedParameter< std::vector< int > > ( std::string const & name ) const

template<>

std::vector<int> edm::ParameterSet::getUntrackedParameter< std::vector< int > >	(	char const *	name,
		std::vector< int > const &	defaultValue
	)		const

template<>

std::vector<int> edm::ParameterSet::getUntrackedParameter< std::vector< int > > ( char const * name ) const

template<>

std::vector<long long> edm::ParameterSet::getUntrackedParameter< std::vector< long long > >	(	std::string const &	name,
		std::vector< long long > const &	defaultValue
	)		const

template<>

std::vector<long long> edm::ParameterSet::getUntrackedParameter< std::vector< long long > > ( std::string const & name ) const

template<>

std::vector<long long> edm::ParameterSet::getUntrackedParameter< std::vector< long long > >	(	char const *	name,
		std::vector< long long > const &	defaultValue
	)		const

template<>

std::vector<long long> edm::ParameterSet::getUntrackedParameter< std::vector< long long > > ( char const * name ) const

template<>

std::vector<LuminosityBlockID> edm::ParameterSet::getUntrackedParameter< std::vector< LuminosityBlockID > >	(	std::string const &	name,
		std::vector< LuminosityBlockID > const &	defaultValue
	)		const

template<>

std::vector<LuminosityBlockID> edm::ParameterSet::getUntrackedParameter< std::vector< LuminosityBlockID > > ( std::string const & name ) const

template<>

std::vector<LuminosityBlockID> edm::ParameterSet::getUntrackedParameter< std::vector< LuminosityBlockID > >	(	char const *	name,
		std::vector< LuminosityBlockID > const &	defaultValue
	)		const

template<>

std::vector<LuminosityBlockID> edm::ParameterSet::getUntrackedParameter< std::vector< LuminosityBlockID > > ( char const * name ) const

template<>

std::vector<LuminosityBlockRange> edm::ParameterSet::getUntrackedParameter< std::vector< LuminosityBlockRange > > ( std::string const & name ) const

template<>

std::vector<LuminosityBlockRange> edm::ParameterSet::getUntrackedParameter< std::vector< LuminosityBlockRange > >	(	std::string const &	name,
		std::vector< LuminosityBlockRange > const &	defaultValue
	)		const

template<>

std::vector<LuminosityBlockRange> edm::ParameterSet::getUntrackedParameter< std::vector< LuminosityBlockRange > > ( char const * name ) const

template<>

std::vector<LuminosityBlockRange> edm::ParameterSet::getUntrackedParameter< std::vector< LuminosityBlockRange > >	(	char const *	name,
		std::vector< LuminosityBlockRange > const &	defaultValue
	)		const

template<>

std::vector<PdtEntry> edm::ParameterSet::getUntrackedParameter< std::vector< PdtEntry > >	(	char const *	name,
		std::vector< PdtEntry > const &	defaultValue
	)		const

inline

Definition at line 122 of file PdtEntry.h.

References edm::pdtentry::getPdtEntryVector(), and mergeVDriftHistosByStation::name.

                                                                                   {
     Entry const* e = retrieveUntracked(name);
     if (e == 0) return defaultValue;
     return pdtentry::getPdtEntryVector(*e, name);
   }

template<>

std::vector<PdtEntry> edm::ParameterSet::getUntrackedParameter< std::vector< PdtEntry > > ( std::string const & name ) const

inline

Definition at line 96 of file PdtEntry.h.

References edm::pdtentry::getPdtEntryVector(), and mergeVDriftHistosByStation::name.

                                                                                                                   {
     Entry const* e = getEntryPointerOrThrow_(name);
     return pdtentry::getPdtEntryVector(*e, name.c_str());
   }

template<>

std::vector<PdtEntry> edm::ParameterSet::getUntrackedParameter< std::vector< PdtEntry > >	(	std::string const &	name,
		std::vector< PdtEntry > const &	defaultValue
	)		const

inline

Definition at line 102 of file PdtEntry.h.

References edm::pdtentry::getPdtEntryVector(), and mergeVDriftHistosByStation::name.

                                                                                   {
     Entry const* e = retrieveUntracked(name);
     if (e == 0) return defaultValue;
     return pdtentry::getPdtEntryVector(*e, name.c_str());
   }

template<>

std::vector<PdtEntry> edm::ParameterSet::getUntrackedParameter< std::vector< PdtEntry > > ( char const * name ) const

inline

Definition at line 116 of file PdtEntry.h.

References edm::pdtentry::getPdtEntryVector(), and mergeVDriftHistosByStation::name.

                                                                                                              {
     Entry const* e = getEntryPointerOrThrow_(name);
     return pdtentry::getPdtEntryVector(*e, name);
   }

template<>

std::vector<std::string> edm::ParameterSet::getUntrackedParameter< std::vector< std::string > > ( std::string const & name ) const

template<>

std::vector<std::string> edm::ParameterSet::getUntrackedParameter< std::vector< std::string > >	(	std::string const &	name,
		std::vector< std::string > const &	defaultValue
	)		const

template<>

std::vector<std::string> edm::ParameterSet::getUntrackedParameter< std::vector< std::string > >	(	char const *	name,
		std::vector< std::string > const &	defaultValue
	)		const

template<>

std::vector<std::string> edm::ParameterSet::getUntrackedParameter< std::vector< std::string > > ( char const * name ) const

template<>

std::vector<unsigned int> edm::ParameterSet::getUntrackedParameter< std::vector< unsigned int > >	(	std::string const &	name,
		std::vector< unsigned int > const &	defaultValue
	)		const

template<>

std::vector<unsigned int> edm::ParameterSet::getUntrackedParameter< std::vector< unsigned int > > ( std::string const & name ) const

template<>

std::vector<unsigned int> edm::ParameterSet::getUntrackedParameter< std::vector< unsigned int > >	(	char const *	name,
		std::vector< unsigned int > const &	defaultValue
	)		const

template<>

std::vector<unsigned int> edm::ParameterSet::getUntrackedParameter< std::vector< unsigned int > > ( char const * name ) const

template<>

std::vector<unsigned long long> edm::ParameterSet::getUntrackedParameter< std::vector< unsigned long long > >	(	std::string const &	name,
		std::vector< unsigned long long > const &	defaultValue
	)		const

template<>

std::vector<unsigned long long> edm::ParameterSet::getUntrackedParameter< std::vector< unsigned long long > > ( std::string const & name ) const

template<>

std::vector<unsigned long long> edm::ParameterSet::getUntrackedParameter< std::vector< unsigned long long > >	(	char const *	name,
		std::vector< unsigned long long > const &	defaultValue
	)		const

template<>

std::vector<unsigned long long> edm::ParameterSet::getUntrackedParameter< std::vector< unsigned long long > > ( char const * name ) const

std::string edm::parameterTypeEnumToString ( ParameterTypes iType )

Definition at line 55 of file ParameterDescriptionNode.cc.

References TYPE_TO_NAME.

Referenced by edm::ParameterSwitchBase::insertAndCheckTypes(), edm::ParameterWildcardBase::print_(), edm::ParameterDescriptionBase::print_(), edm::ParameterSwitch< T >::print_(), edm::AllowedLabelsDescriptionBase::printNestedContentBase_(), edm::IfExistsDescription::throwIfDuplicateTypes(), edm::ORGroupDescription::throwIfDuplicateTypes(), edm::ANDGroupDescription::throwIfDuplicateTypes(), edm::ParameterWildcardBase::throwIfInvalidPattern(), edm::ParameterSetDescription::throwIfWildcardCollision(), edm::ParameterDescriptionBase::throwMissingRequiredNoDefault(), edm::ParameterDescriptionBase::throwParameterWrongTrackiness(), edm::ParameterDescriptionBase::throwParameterWrongType(), edm::ParameterWildcardBase::validateMatchingNames(), and edm::ParameterDescriptionBase::writeCfi_().

                                                             {
     switch(iType) {
       TYPE_TO_NAME(int32);
       TYPE_TO_NAME(vint32);
       TYPE_TO_NAME(uint32);
       TYPE_TO_NAME(vuint32);
       TYPE_TO_NAME(int64);
       TYPE_TO_NAME(vint64);
       TYPE_TO_NAME(uint64);
       TYPE_TO_NAME(vuint64);
       TYPE_TO_NAME(double);
       TYPE_TO_NAME(vdouble);
       TYPE_TO_NAME(bool);
       TYPE_TO_NAME(string);
       TYPE_TO_NAME(vstring);
       TYPE_TO_NAME(EventID);
       TYPE_TO_NAME(VEventID);
       TYPE_TO_NAME(LuminosityBlockID);
       TYPE_TO_NAME(VLuminosityBlockID);
       TYPE_TO_NAME(InputTag);
       TYPE_TO_NAME(VInputTag);
       TYPE_TO_NAME(FileInPath);
       TYPE_TO_NAME(PSet);
       TYPE_TO_NAME(VPSet);
       TYPE_TO_NAME(LuminosityBlockRange);
       TYPE_TO_NAME(VLuminosityBlockRange);
       TYPE_TO_NAME(EventRange);
       TYPE_TO_NAME(VEventRange);
     default:
       assert(false);
     }
     return "";
   }

std::auto_ptr< ParameterSet > edm::popSubProcessParameterSet ( ParameterSet & parameterSet )

Definition at line 306 of file SubProcess.cc.

References edm::ParameterSet::getUntrackedParameter(), and edm::ParameterSet::popParameterSet().

Referenced by edm::EventProcessor::init(), and edm::SubProcess::SubProcess().

                                                         {
     std::vector<std::string> subProcesses = parameterSet.getUntrackedParameter<std::vector<std::string> >("@all_subprocesses");
     if(!subProcesses.empty()) {
       assert(subProcesses.size() == 1U);
       assert(subProcesses[0] == "@sub_process");
       return parameterSet.popParameterSet(subProcesses[0]);
     }
     return std::auto_ptr<ParameterSet>(0);
   }

static void edm::postIndexIntoFilePrintEventLists	(	TFile *	tfl,
		FileFormatVersion const &	fileFormatVersion,
		TTree *	metaDataTree
	)

static

Definition at line 150 of file CollUtil.cc.

References edm::IndexIntoFile::begin(), gather_cfg::cout, edm::IndexIntoFile::end(), edm::EventID::event(), edm::poolNames::eventTreeName(), edm::IndexIntoFile::firstAppearanceOrder, edm::EventAuxiliary::id(), edm::poolNames::indexIntoFileBranchName(), edm::IndexIntoFile::iterationWillBeInEntryOrder(), edm::IndexIntoFile::kEvent, edm::IndexIntoFile::kLumi, edm::IndexIntoFile::kRun, and matplotRender::t.

Referenced by printEventLists().

                                                                                                                             {
     IndexIntoFile indexIntoFile;
     IndexIntoFile *findexPtr = &indexIntoFile;
     if (metaDataTree->FindBranch(poolNames::indexIntoFileBranchName().c_str()) != 0) {
       TBranch *fndx = metaDataTree->GetBranch(poolNames::indexIntoFileBranchName().c_str());
       fndx->SetAddress(&findexPtr);
       fndx->GetEntry(0);
     } else {
       std::cout << "IndexIntoFile not found.  If this input file was created with release 1_8_0 or later\n"
                    "this indicates a problem with the file.  This condition should be expected with\n"
                    "files created with earlier releases and printout of the event list will fail.\n";
       return;
     }
     //need to read event # from the EventAuxiliary branch
     TTree* eventsTree = dynamic_cast<TTree*>(tfl->Get(poolNames::eventTreeName().c_str()));
     TBranch* eventAuxBranch = 0;
     assert(0 != eventsTree);
     char const* const kEventAuxiliaryBranchName = "EventAuxiliary";
     if(eventsTree->FindBranch(kEventAuxiliaryBranchName) != 0){
       eventAuxBranch = eventsTree->GetBranch(kEventAuxiliaryBranchName);
     } else {
       std::cout << "Failed to find " << kEventAuxiliaryBranchName << " branch in Events TTree.  Something is wrong with this file." << std::endl;
       return;
     }
     EventAuxiliary eventAuxiliary;
     EventAuxiliary* eAPtr = &eventAuxiliary;
     eventAuxBranch->SetAddress(&eAPtr);
     std::cout << "\nPrinting IndexIntoFile contents.  This includes a list of all Runs, LuminosityBlocks\n"
        << "and Events stored in the root file.\n\n";
     std::cout << std::setw(15) << "Run"
        << std::setw(15) << "Lumi"
        << std::setw(15) << "Event"
        << std::setw(15) << "TTree Entry"
        << "\n";
 
     for(IndexIntoFile::IndexIntoFileItr it = indexIntoFile.begin(IndexIntoFile::firstAppearanceOrder),
                                         itEnd = indexIntoFile.end(IndexIntoFile::firstAppearanceOrder);
                                         it != itEnd; ++it) {
       IndexIntoFile::EntryType t = it.getEntryType();
       std::cout << std::setw(15) << it.run() << std::setw(15) << it.lumi();
       EventNumber_t eventNum = 0;
       std::string type;
       switch(t) {
         case IndexIntoFile::kRun:
           type = "(Run)";
         break;
         case IndexIntoFile::kLumi:
           type = "(Lumi)";
         break;
         case IndexIntoFile::kEvent:
           eventAuxBranch->GetEntry(it.entry());
           eventNum = eventAuxiliary.id().event();
         break;
         default:
         break;
       }
       std::cout << std::setw(15) << eventNum << std::setw(15) << it.entry() << " " << type << std::endl;
     }
 
     std::cout << "\nFileFormatVersion = " << fileFormatVersion << ".  ";
     if (fileFormatVersion.fastCopyPossible()) std::cout << "This version supports fast copy\n";
     else std::cout << "This version does not support fast copy\n";
 
     if (indexIntoFile.iterationWillBeInEntryOrder(IndexIntoFile::firstAppearanceOrder)) {
       std::cout << "Events are sorted such that fast copy is possible in the \"noEventSort = false\" mode\n";
     } else {
       std::cout << "Events are sorted such that fast copy is NOT possible in the \"noEventSort = false\" mode\n";
     }
 
     // This will not work unless the other nonpersistent parts of the Index are filled first
     // I did not have time to implement this yet.
     // if (indexIntoFile.iterationWillBeInEntryOrder(IndexIntoFile::numericalOrder)) {
     //   std::cout << "Events are sorted such that fast copy is possible in the \"noEventSort\" mode\n";
     // } else {
     //   std::cout << "Events are sorted such that fast copy is NOT possible in the \"noEventSort\" mode\n";
     // }
     std::cout << "(Note that other factors can prevent fast copy from occurring)\n\n";
   }

static void edm::preIndexIntoFilePrintEventLists	(	TFile *	tfl,
		FileFormatVersion const &	fileFormatVersion,
		TTree *	metaDataTree
	)

static

Definition at line 115 of file CollUtil.cc.

References gather_cfg::cout, and edm::poolNames::fileIndexBranchName().

Referenced by printEventLists().

                                                                                                                            {
     FileIndex fileIndex;
     FileIndex *findexPtr = &fileIndex;
     if (metaDataTree->FindBranch(poolNames::fileIndexBranchName().c_str()) != 0) {
       TBranch *fndx = metaDataTree->GetBranch(poolNames::fileIndexBranchName().c_str());
       fndx->SetAddress(&findexPtr);
       fndx->GetEntry(0);
     } else {
       std::cout << "FileIndex not found.  If this input file was created with release 1_8_0 or later\n"
                    "this indicates a problem with the file.  This condition should be expected with\n"
         "files created with earlier releases and printout of the event list will fail.\n";
       return;
     }
 
     std::cout << "\n" << fileIndex;
 
     std::cout << "\nFileFormatVersion = " << fileFormatVersion << ".  ";
     if (fileFormatVersion.fastCopyPossible()) std::cout << "This version supports fast copy\n";
     else std::cout << "This version does not support fast copy\n";
 
     if (fileIndex.allEventsInEntryOrder()) {
       std::cout << "Events are sorted such that fast copy is possible in the \"noEventSort = False\" mode\n";
     } else {
       std::cout << "Events are sorted such that fast copy is NOT possible in the \"noEventSort = False\" mode\n";
     }
 
     fileIndex.sortBy_Run_Lumi_EventEntry();
     if (fileIndex.allEventsInEntryOrder()) {
       std::cout << "Events are sorted such that fast copy is possible in the \"noEventSort\" mode\n";
     } else {
       std::cout << "Events are sorted such that fast copy is NOT possible in the \"noEventSort\" mode\n";
     }
     std::cout << "(Note that other factors can prevent fast copy from occurring)\n\n";
   }

template<typename S >

S& edm::print	(	S &	os,
		JobReport::InputFile const &	f
	)

Definition at line 38 of file JobReport.cc.

References formatFile(), edm::JobReport::InputFile::inputSourceClassName, edm::JobReport::InputFile::inputType, and edm::JobReport::InputFile::numEventsRead.

Referenced by operator<<(), and EcalDigiToRaw::produce().

                                               {
 
       os << "\n<InputFile>";
       formatFile(f, os);
       os << "\n<InputType>" << f.inputType << "</InputType>";
       os << "\n<InputSourceClass>" << TiXmlText(f.inputSourceClassName)
          << "</InputSourceClass>";
       os << "\n<EventsRead>" << f.numEventsRead << "</EventsRead>";
       return os;
     }

template<typename S >

S& edm::print	(	S &	os,
		JobReport::OutputFile const &	f
	)

Definition at line 51 of file JobReport.cc.

References edm::JobReport::OutputFile::branchHash, edm::JobReport::OutputFile::dataType, formatFile(), edm::JobReport::OutputFile::numEventsWritten, and edm::JobReport::OutputFile::outputModuleClassName.

                                                {
       formatFile(f, os);
       os << "\n<OutputModuleClass>"
                         << TiXmlText(f.outputModuleClassName)
                         << "</OutputModuleClass>";
       os << "\n<TotalEvents>"
                         << f.numEventsWritten
                         << "</TotalEvents>\n";
       os << "\n<DataType>"
                         << TiXmlText(f.dataType)
                         << "</DataType>\n";
       os << "\n<BranchHash>"
                         << TiXmlText(f.branchHash)
                         << "</BranchHash>\n";
 
       return os;
     }

template<typename S >

S& edm::print	(	S &	os,
		JobReport::RunReport const &	rep
	)

Definition at line 71 of file JobReport.cc.

References edm::JobReport::RunReport::lumiSections, and edm::JobReport::RunReport::runNumber.

                                           {
     os << "\n<Run ID=\""
        << rep.runNumber
        << "\">\n";
 
     typedef std::set<unsigned int>::iterator iterator;
     for (iterator il = rep.lumiSections.begin(), ilEnd = rep.lumiSections.end(); il != ilEnd; ++il) {
       os << "   <LumiSection ID=\"" << *il << "\"/>\n";
 
     }
     os << "</Run>\n";
     return os;
   }

template<typename RecordT >

void edm::print_eventsetup_record_dependencies	(	std::ostream &	oStream,
		std::string const &	iIndent = `std::string()`
	)

Definition at line 76 of file print_eventsetup_record_dependencies.h.

References edm::rec_dep::inherits_from_DependentRecordTag(), and mergeVDriftHistosByStation::name.

Referenced by print_eventsetup_record_dependencies(), and print_eventsetup_record_dependencies_recursive().

                                                                                             {
       oStream<<iIndent<<edm::eventsetup::EventSetupRecordKey::makeKey<RecordT>().name()<<std::endl;
       
       print_eventsetup_record_dependencies_recursive<RecordT>(oStream, iIndent, rec_dep::inherits_from_DependentRecordTag(static_cast<RecordT const*>(0)));
    }

template<typename T >

void edm::print_eventsetup_record_dependencies	(	std::ostream &	oStream,
		std::string	,
		T const *	,
		T const *
	)

Definition at line 41 of file print_eventsetup_record_dependencies.h.

44 { }

template<typename TFirst , typename TEnd >

void edm::print_eventsetup_record_dependencies	(	std::ostream &	oStream,
		std::string	iIndent,
		TFirst const *	,
		TEnd const *	iEnd
	)

Definition at line 47 of file print_eventsetup_record_dependencies.h.

References print_eventsetup_record_dependencies().

                                                                                {
       iIndent +=" ";
       print_eventsetup_record_dependencies<typename boost::mpl::deref<TFirst>::type>(oStream,iIndent);
       typename boost::mpl::next< TFirst >::type const* next(0);
       print_eventsetup_record_dependencies(oStream, iIndent, next, iEnd);
    }

template<typename RecordT >

void edm::print_eventsetup_record_dependencies_recursive	(	std::ostream &	oStream,
		std::string const &	iIndent,
		boost::mpl::true_
	)

Definition at line 62 of file print_eventsetup_record_dependencies.h.

References begin, end, and print_eventsetup_record_dependencies().

                                                                                                                      {
       typedef typename  RecordT::list_type list_type;
       
       typename boost::mpl::begin<list_type>::type const* begin(0);
       typename boost::mpl::end<list_type>::type const* end(0);
       print_eventsetup_record_dependencies(oStream, iIndent, begin, end);
    }

template<typename RecordT >

void edm::print_eventsetup_record_dependencies_recursive	(	std::ostream &	oStream,
		std::string const &	,
		boost::mpl::false_
	)

Definition at line 71 of file print_eventsetup_record_dependencies.h.

                                                                                                               {
       return;
    }

void edm::printBadAllocException	(	char const *	prog = `0`,
		edm::JobReport *	jobRep = `0`,
		int	rc = `-1`
	)

Definition at line 23 of file ExceptionMessages.cc.

References edm::JobReport::reportError().

                                                                                    {
     std::string programName(prog ? prog : "program");
     std::string shortDesc("std::bad_allocException");
     std::ostringstream longDesc;
     longDesc << "std::bad_alloc exception caught in "
          << programName
          << "\n"
          << "The job has probably exhausted the virtual memory available to the process.\n";
     edm::LogSystem(shortDesc) << longDesc.str() << "\n";
     if(jobRep) jobRep->reportError(shortDesc, longDesc.str(), rc);
   } catch(...) {
   }

void edm::printBranchNames ( TTree * tree )

Definition at line 73 of file CollUtil.cc.

References gather_cfg::cout, and i.

                                      {
     if (tree != 0) {
       Long64_t nB = tree->GetListOfBranches()->GetEntries();
       for (Long64_t i = 0; i < nB; ++i) {
         Long64_t size = 0LL;
         TBranch *btemp = (TBranch *)tree->GetListOfBranches()->At(i);
         addBranchSizes(btemp, size);
         std::cout << "Branch " << i << " of " << tree->GetName() << " tree: " << btemp->GetName() << " Total size = " << size << std::endl;
       }
     } else {
       std::cout << "Missing Events tree?\n";
     }
   }

void edm::printCmsException	(	cms::Exception &	e,
		char const *	prog = `0`,
		edm::JobReport *	jobRep = `0`,
		int	rc = `-1`
	)

Definition at line 10 of file ExceptionMessages.cc.

References cms::Exception::explainSelf(), and edm::JobReport::reportError().

                                                                                           {
     std::string programName(prog ? prog : "program");
     std::string shortDesc("CMSException");
     std::ostringstream longDesc;
     longDesc << "cms::Exception caught in " 
          << programName
          << "\n"
          << e.explainSelf();
     edm::LogSystem(shortDesc) << longDesc.str() << "\n";
     if(jobRep) jobRep->reportError(shortDesc, longDesc.str(), rc);
   } catch(...) {
   }

void edm::printEventLists ( TFile * tfl )

Definition at line 229 of file CollUtil.cc.

References edm::poolNames::fileFormatVersionBranchName(), edm::FileFormatVersion::hasIndexIntoFile(), edm::poolNames::metaDataTreeName(), postIndexIntoFilePrintEventLists(), and preIndexIntoFilePrintEventLists().

                                    {
     TTree *metaDataTree = dynamic_cast<TTree *>(tfl->Get(poolNames::metaDataTreeName().c_str()));
 
     FileFormatVersion fileFormatVersion;
     FileFormatVersion *fftPtr = &fileFormatVersion;
     if (metaDataTree->FindBranch(poolNames::fileFormatVersionBranchName().c_str()) != 0) {
       TBranch *fft = metaDataTree->GetBranch(poolNames::fileFormatVersionBranchName().c_str());
       fft->SetAddress(&fftPtr);
       fft->GetEntry(0);
     }
     if(fileFormatVersion.hasIndexIntoFile()) {
       postIndexIntoFilePrintEventLists(tfl, fileFormatVersion, metaDataTree);
     } else {
       preIndexIntoFilePrintEventLists(tfl, fileFormatVersion, metaDataTree);
     }
   }

void edm::printStdException	(	std::exception &	e,
		char const *	prog = `0`,
		edm::JobReport *	jobRep = `0`,
		int	rc = `-1`
	)

Definition at line 36 of file ExceptionMessages.cc.

References edm::JobReport::reportError().

                                                                                               {
     std::string programName(prog ? prog : "program");
     std::string shortDesc("StdLibException");
     std::ostringstream longDesc;
     longDesc << "Standard library exception caught in " 
          << programName
          << "\n"
          << e.what();
     edm::LogSystem(shortDesc) << longDesc.str() << "\n";
     if (jobRep) jobRep->reportError(shortDesc, longDesc.str(), rc);
   } catch(...) {
   }

void edm::printTrees ( TFile * hdl )

Definition at line 35 of file CollUtil.cc.

References combine::key, and VarParsing::obj.

                               {
     hdl->ls();
     TList *keylist = hdl->GetListOfKeys();
     TIterator *iter = keylist->MakeIterator();
     TKey *key = 0;
     while ((key = (TKey*)iter->Next())) {
       TObject *obj = hdl->Get(key->GetName());
       if (obj->IsA() == TTree::Class()) {
         obj->Print();
       }
     }
     return;
   }

void edm::printUnknownException	(	char const *	prog = `0`,
		edm::JobReport *	jobRep = `0`,
		int	rc = `-1`
	)

Definition at line 49 of file ExceptionMessages.cc.

References edm::JobReport::reportError().

                                                                                   {
     std::string programName(prog ? prog : "program");
     std::string shortDesc("UnknownException");
     std::ostringstream longDesc;
     longDesc << "Unknown exception caught in "
          << programName
          << "\n";
     edm::LogSystem(shortDesc) << longDesc.str() << "\n";
     if (jobRep) jobRep->reportError(shortDesc, longDesc.str(), rc);
   } catch(...) {
   }

void edm::printUuids ( TTree * uuidTree )

Definition at line 106 of file CollUtil.cc.

References gather_cfg::cout, edm::FileID::fid(), NewTree::fid, and edm::poolNames::fileIdentifierBranchName().

                                    {
     FileID fid;
     FileID *fidPtr = &fid;
     uuidTree->SetBranchAddress(poolNames::fileIdentifierBranchName().c_str(), &fidPtr);
     uuidTree->GetEntry(0);
 
     std::cout << "UUID: " << fid.fid() << std::endl;
   }

BranchID edm::productIDToBranchID	(	ProductID const &	pid,
		BranchIDLists const &	lists,
		BranchListIndexes const &	indexes
	)

Definition at line 12 of file ProductIDToBranchID.cc.

References cmsCodeRules.cppFunctionSkipper::exception, edm::ProductID::isValid(), edm::ProductID::processIndex(), and edm::ProductID::productIndex().

Referenced by edm::EventPrincipal::pidToBid(), fwlite::internal::BranchMapReaderStrategyV11::productToBranchID(), and fwlite::internal::BranchMapReaderStrategyV17::productToBranchID().

                                                                                                           {
     if (!pid.isValid()) {
       return BranchID();
     }
     BranchID::value_type bid = 0;
     try {
       BranchListIndex blix = indexes.at(pid.processIndex()-1);
       BranchIDList const& blist = lists.at(blix);
       bid = blist.at(pid.productIndex()-1);
     }
     catch (std::exception) {
       return BranchID();
     }
     return BranchID(bid);
   }

void edm::public_base_classes	(	Reflex::Type const &	type,
		std::vector< Reflex::Type > &	baseTypes
	)

Referenced by edm::ProductRegistry::initializeLookupTables(), and public_base_classes().

void edm::public_base_classes	(	Type const &	type,
		std::vector< Type > &	baseTypes
	)

Definition at line 208 of file ReflexTools.cc.

References CustomConfigs::Base(), newFWLiteAna::base, i, public_base_classes(), and search_all().

                                                        {
 
     if(type.IsClass() || type.IsStruct()) {
 
       int nBase = type.BaseSize();
       for(int i = 0; i < nBase; ++i) {
 
         Base base = type.BaseAt(i);
         if(base.IsPublic()) {
 
           Type baseType = type.BaseAt(i).ToType();
           if(bool(baseType)) {
 
             while(baseType.IsTypedef() == true) {
               baseType = baseType.ToType();
             }
 
             // Check to make sure this base appears only once in the
             // inheritance heirarchy.
             if(!search_all(baseTypes, baseType)) {
               // Save the type and recursive look for its base types
               baseTypes.push_back(baseType);
               public_base_classes(baseType, baseTypes);
             }
             // For now just ignore it if the class appears twice,
             // After some more testing we may decide to uncomment the following
             // exception.
             /*
             else {
               throw Exception(errors::UnimplementedFeature)
                 << "DataFormats/Common/src/ReflexTools.cc in function public_base_classes.\n"
                 << "Encountered class that has a public base class that appears\n"
                 << "multiple times in its inheritance heirarchy.\n"
                 << "Please contact the EDM Framework group with details about\n"
                 << "this exception. It was our hope that this complicated situation\n"
                 << "would not occur. There are three possible solutions. 1. Change\n"
                 << "the class design so the public base class does not appear multiple\n"
                 << "times in the inheritance heirarchy. In many cases, this is a\n"
                 << "sign of bad design. 2. Modify the code that supports Views to\n"
                 << "ignore these base classes, but not supply support for creating a\n"
                 << "View of this base class. 3. Improve the View infrastructure to\n"
                 << "deal with this case. Class name of base class: " << baseType.Name() << "\n\n";
             }
             */
           }
         }
       }
     }
   }

std::string edm::pythonFileToConfigure ( const std::string & iPythonFileName )

Definition at line 14 of file pythonFileToConfigure.cc.

References edmPickEvents::command, pythonToCppException(), and query::result.

 {
   std::string returnValue;
   std::string initCommand("import FWCore.ParameterSet.Config as cms\n"
                           "fileDict = dict()\n"
                           "execfile('");
   initCommand += iPythonFileName+"',fileDict)";
   
   Py_InitializeEx(0);
   using namespace boost::python;
   
   object main_module((
                       boost::python::handle<PyObject>(borrowed(PyImport_AddModule(const_cast<char *>("__main__"))))));
   object main_namespace = main_module.attr("__dict__");
   try {
     try {
       object result((boost::python::handle<>(PyRun_String(initCommand.c_str(),
                                                           Py_file_input,
                                                           main_namespace.ptr(),
                                                           main_namespace.ptr()))));
     } catch(error_already_set) {
       edm::pythonToCppException("Configuration");
     }
     try {
       std::string command("cms.findProcess(fileDict).dumpConfig()");
       object result((handle<>(PyRun_String(command.c_str(),
                                            Py_eval_input,
                                            main_namespace.ptr(),
                                            main_namespace.ptr()))));
       returnValue= extract<std::string>(result);
       
     }catch( error_already_set ) {
       edm::pythonToCppException("Configuration");
     }
   }catch(...) {
     Py_Finalize();
     throw;
   }
   Py_Finalize();
   return returnValue;
 }

void edm::pythonToCppException ( const std::string & iType )

Definition at line 6 of file PythonWrapper.cc.

References edm::hlt::Exception, NULL, and GsfMatrixTools::trace().

Referenced by pythonFileToConfigure(), PythonProcessDesc::read(), and FWPathsPopup::scheduleReloadEvent().

  {
   using namespace boost::python;
   PyObject *exc=NULL, *val=NULL, *trace=NULL;
   PyErr_Fetch(&exc,&val,&trace);
   PyErr_NormalizeException(&exc,&val,&trace);
   handle<> hExc(allow_null(exc));
   handle<> hVal(allow_null(val));
   handle<> hTrace(allow_null(trace));
  
   if(hTrace) {
     object oTrace(hTrace);
     handle<> hStringTr(PyObject_Str(oTrace.ptr()));
     object stringTr(hStringTr);
 //std::cout << "PR TR " << stringTr <<  " DONE "<<  std::endl;
   }
 
   if(hVal && hExc) {
     object oExc(hExc);
     object oVal(hVal);
     handle<> hStringVal(PyObject_Str(oVal.ptr()));
     object stringVal( hStringVal );
 
     handle<> hStringExc(PyObject_Str(oExc.ptr()));
     object stringExc( hStringExc);
 
     //PyErr_Print();
     throw cms::Exception(iType) <<"python encountered the error: "
                                 << PyString_AsString(stringExc.ptr())<<" "
                                 << PyString_AsString(stringVal.ptr())<<"\n";
   } else {
     throw cms::Exception(iType)<<" unknown python problem occurred.\n";
   }
 }

void edm::read_from_cin ( std::string & output )

Definition at line 27 of file Parse.cc.

References geometryCSVtoXML::line.

                                            {
       std::string line;
       while (getline(std::cin, line)) {
         output += line;
         output += '\n';
       }
     }

std::string edm::read_whole_file ( std::string const & filename )

only does the yacc interpretation

Definition at line 10 of file Parse.cc.

References edm::errors::Configuration, edm::hlt::Exception, lut2db_cfg::filename, collect_tpl::input, and query::result.

                                                           {
       std::string result;
       std::ifstream input(filename.c_str());
       if (!input) {
        throw edm::Exception(errors::Configuration,"MissingFile")
          << "Cannot read file " << filename;
       }
       std::string buffer;
       while (getline(input, buffer)) {
           // getline strips newlines; we have to put them back by hand.
           result += buffer;
           result += '\n';
       }
       return result; 
     }

boost::shared_ptr< ParameterSet > edm::readConfig ( std::string const & config )

Definition at line 42 of file MakeParameterSets.cc.

References PythonProcessDesc::parameterSet().

                                       {
     PythonProcessDesc pythonProcessDesc(config);
     return pythonProcessDesc.parameterSet();
   }

boost::shared_ptr< ParameterSet > edm::readConfig	(	std::string const &	config,
		int	argc,
		char *	argv[]
	)

same, but with arguments

Definition at line 48 of file MakeParameterSets.cc.

References PythonProcessDesc::parameterSet().

                                                               {
     PythonProcessDesc pythonProcessDesc(config, argc, argv);
     return pythonProcessDesc.parameterSet();
   }

std::auto_ptr<SendJobHeader> edm::readHeaderFromStream ( std::ifstream & ist )

Referenced by getRegFromFile().

std::auto_ptr<SendJobHeader> edm::readHeaderFromStream ( ifstream & ist )

Not an init message should return

Definition at line 164 of file Utilities.cc.

References HeaderView::code(), edm::StreamerInputSource::deserializeRegistry(), edm::hlt::Exception, Header::INIT, L1TEmulatorMonitor_cff::p, and HeaderView::size().

   {
     JobHeaderDecoder decoder;
     std::vector<char> regdata(1000*1000);
 
     //int len;
     //ist.read((char*)&len,sizeof(int));
     //regdata.resize(len);
     //ist.read(&regdata[0],len);
     ist.read(&regdata[0], sizeof(HeaderView));
 
     if (ist.eof() || (unsigned int)ist.gcount() < sizeof(HeaderView)  )
     {
           throw cms::Exception("ReadHeader","getRegFromFile")
                 << "No file exists or Empty file encountered:\n";
     }
 
     HeaderView head(&regdata[0]);
     uint32 code = head.code();
     if (code != Header::INIT) 
     {
       throw cms::Exception("ReadHeader","getRegFromFile")
                 << "Expecting an init Message at start of file\n";
     }
 
     uint32 headerSize = head.size();
     //Bring the pointer at start of Start Message/start of file
     ist.seekg(0, std::ios::beg);
     ist.read(&regdata[0], headerSize);
 
     //if(!ist)
     //  throw cms::Exception("ReadHeader","getRegFromFile")
     //  << "Could not read the registry information from the test\n"
     //  << "event stream file \n";
 
     //edm::InitMsg msg(&regdata[0],len);
     //std::auto_ptr<SendJobHeader> p = decoder.decodeJobHeader(msg);
     InitMsgView initView(&regdata[0]);
     std::auto_ptr<SendJobHeader> p = StreamerInputSource::deserializeRegistry(initView);
     return p;
   }

boost::shared_ptr< ParameterSet > edm::readPSetsFrom ( std::string const & fileOrString )

finds all the PSets used in the top level module referred as a file or as a string containing python commands. These PSets are bundled into a top level PSet from which they can be retrieved

Definition at line 61 of file MakeParameterSets.cc.

References edm::python::initializeModule(), makePSetsFromFile(), makePSetsFromString(), dbtoconf::object, PythonParameterSet::pset(), pythonToCppException(), and edm::ParameterSet::swap().

Referenced by main().

                                          {
     python::initializeModule();
 
     boost::python::object mainModule = object(handle<>(borrowed(PyImport_AddModule(const_cast<char*>("__main__")))));
 
     boost::python::object mainNamespace = mainModule.attr("__dict__");
     PythonParameterSet theProcessPSet;
     mainNamespace["topPSet"] = ptr(&theProcessPSet);
 
     try {
       // if it ends with py, it's a file
       if(module.substr(module.size()-3) == ".py") {
         makePSetsFromFile(module,mainNamespace);
       } else {
         makePSetsFromString(module,mainNamespace);
       }
     }
     catch( error_already_set ) {
       pythonToCppException("Configuration");
       Py_Finalize();
     }
     boost::shared_ptr<ParameterSet> returnValue(new ParameterSet);
     theProcessPSet.pset().swap(*returnValue);
     return returnValue;
   }

void edm::reenableSigs ( sigset_t * oldset )

Definition at line 91 of file UnixSignalHandlers.cc.

References MUST_BE_ZERO.

Referenced by installCustomHandler(), and MulticoreRunLumiEventChecker::postForkReacquireResources().

     {
       // reenable the signals
       MUST_BE_ZERO(pthread_sigmask(SIG_SETMASK,oldset,0));
     }

template<class T >

T const* edm::reflex_cast	(	void *	raw,
		Reflex::Type const &	dynamicType
	)

Try to convert the un-typed pointer raw (which we promise is a pointer to an object whose dynamic type is denoted by dynamicType) to a pointer of type T. This is like the dynamic_cast operator, in that it can do pointer adjustment (in cases of multiple inheritance), and will return 0 if T is neither the same type as nor a public base of the C++ type denoted by dynamicType.

Definition at line 75 of file ReflexTools.h.

References compareJSON::const, and VarParsing::obj.

                                                         {
     static Reflex::Type const
       toType(Reflex::Type::ByTypeInfo(typeid(T)));
 
     Reflex::Object obj(dynamicType, raw);
     return static_cast<T const*>(obj.CastObject(toType).Address());
 
     // This alternative implementation of reflex_cast would allow us
     // to remove the compile-time depenency on Reflex/Type.h and
     // Reflex/Object.h, at the cost of some speed.
     //
     //     return static_cast<T const*>(reflex_pointer_adjust(raw,
     //                             dynamicType,
     //                             typeid(T)));
   }

void const* edm::reflex_pointer_adjust	(	void *	raw,
		Reflex::Type const &	dynamicType,
		std::type_info const &	toType
	)

Take an un-typed pointer raw (which we promise is a pointer to an object whose dynamic type is denoted by dynamicType), and return a raw pointer that is appropriate for referring to an object whose type is denoted by toType. This performs any pointer adjustment needed for dealing with base class sub-objects, and returns 0 if the type denoted by toType is neither the same as, nor a public base of, the type denoted by dynamicType.

void const* edm::reflex_pointer_adjust	(	void *	raw,
		Type const &	dynamicType,
		std::type_info const &	toType
	)

Definition at line 260 of file ReflexTools.cc.

References VarParsing::obj.

                                                     {
     Object obj(dynamicType, raw);
     return obj.CastObject(Type::ByTypeInfo(toType)).Address();
   }

template<typename C >

Ptr<typename C::value_type> edm::refToPtr ( Ref< C, typename C::value_type, refhelper::FindUsingAdvance< C, typename C::value_type > > const & ref )

Definition at line 18 of file RefToPtr.h.

Referenced by TauGenJetProducer::produce(), PFRootEventManager::reconstructGenJets(), and reco::PFTau::sourceCandidatePtr().

                                                                                                   {
     typedef typename C::value_type T;
     if (ref.isTransient()) {
       return Ptr<T>(ref.product(), ref.key());
     } else if (not ref.hasProductCache()) {
       return Ptr<T>(ref.id(), ref.key(), ref.productGetter());
     }
     return Ptr<T>(ref.id(), ref.get(), ref.key());
   }

std::vector< std::vector< std::string >::const_iterator > edm::regexMatch	(	std::vector< std::string > const &	strings,
		boost::regex const &	regexp
	)

Definition at line 22 of file RegexMatch.cc.

References i.

Referenced by triggerExpression::HLTReader::init(), HLTHighLevel::init(), edm::EventSelector::init(), regexMatch(), and stor::TriggerSelector::TreeElement::TreeElement().

                                                                             {
     std::vector< std::vector<std::string>::const_iterator> matches;
     for (std::vector<std::string>::const_iterator i = strings.begin(), iEnd = strings.end(); i != iEnd; ++i) {
       if (boost::regex_match((*i), regexp)) {
         matches.push_back(i);
       }
     }
     return matches;
   }

std::vector< std::vector< std::string >::const_iterator > edm::regexMatch	(	std::vector< std::string > const &	strings,
		std::string const &	pattern
	)

Definition at line 33 of file RegexMatch.cc.

References glob2reg(), and regexMatch().

                                                                             {
     boost::regex regexp(glob2reg(pattern));
     return regexMatch(strings, regexp);
   }

bool edm::registryIsSubset	(	SendJobHeader const &	sd,
		ProductRegistry const &	reg
	)

Definition at line 85 of file Utilities.cc.

References edm::SendJobHeader::descs(), edm::hlt::Exception, FDEBUG, i, combine::key, and edm::ProductRegistry::productList().

Referenced by edmtestp::TestFileReader::TestFileReader().

   {
     bool rc = true;
     SendDescs::const_iterator i(sd.descs().begin()),e(sd.descs().end());
 
     // the next line seems to be not good.  what if the productdesc is
     // already there? it looks like I replace it.  maybe that it correct
 
     FDEBUG(6) << "registryIsSubset: Product List: " << std::endl;
     for(;i != e; ++i) {
     typedef edm::ProductRegistry::ProductList plist;
     // the new products must be contained in the old registry
     // form a branchkey from the *i branchdescription,
     // use the productlist from the product registry to locate
     // the branchkey.  If not found, then error in this state
     BranchKey key(*i);
     if(reg.productList().find(key)==reg.productList().end()) {
       rc = false;
       break;
 #if 0
       throw cms::Exception("InconsistentRegistry","EventStreamer")
         << "A new product registry was received during the "
         << "running state with entries that were not present "
         << "in the original registry.\n"
         << "The new type is " << i->className() << "\n";
 #endif
       FDEBUG(6) << "Inconsistent Registry: new type is "
             << i->className() << "\n";
     }
     }
 
     return rc;
   }

bool edm::registryIsSubset	(	SendJobHeader const &	sd,
		SendJobHeader const &	ref
	)

Definition at line 120 of file Utilities.cc.

References edm::SendJobHeader::descs(), edm::hlt::Exception, FDEBUG, newFWLiteAna::found, i, and combine::key.

   {
     bool rc = true;
     SendDescs::const_iterator i(sd.descs().begin()),e(sd.descs().end());
 
     FDEBUG(6) << "registryIsSubset: Product List: " << std::endl;
     for(;i != e; ++i) {
     // the new products must be contained in the old registry
     // form a branchkey from the *i branchdescription,
     // use the productlist from the product registry to locate
     // the branchkey.  If not found, then error in this state
     BranchKey key(*i);
         // look for matching in ref
     FDEBUG(9) << "Looking for " << i->className() << "\n";
         SendDescs::const_iterator iref(ref.descs().begin()),eref(ref.descs().end());
         bool found = false;
         for(; iref != eref; ++iref) {
       FDEBUG(9) << "testing against " << iref->className() << "\n";
           BranchKey refkey(*iref);
           if(key == refkey) {
             found = true;
         FDEBUG(9) << "found!" << "\n";
             break;
           }
         }
     if(!found) {
       rc = false;
       break;
 #if 0
       throw cms::Exception("InconsistentRegistry","EventStreamer")
         << "A new product registry was received during the "
         << "running state with entries that were not present "
         << "in the original registry.\n"
         << "The new type is " << i->className() << "\n";
 #endif
       FDEBUG(6) << "Inconsistent Registry: new type is "
             << i->className() << "\n";
     }
     }
 
     return rc;
   }

template<typename ForwardSequence , typename Datum >

bool edm::search_all	(	ForwardSequence const &	s,
		Datum const &	d
	)

inline

Definition at line 46 of file Algorithms.h.

References spr::find().

Referenced by edm::eventsetup::EventSetupRecordProvider::add(), edm::Schedule::addToAllWorkers(), edm::service::MessageLoggerScribe::configure_statistics(), edm::Schedule::fillWorkers(), edm::service::TriggerNamesService::getTrigPaths(), edm::Schedule::limitOutput(), edm::MainParameterSet::MainParameterSet(), and public_base_classes().

                                                        {
     return std::find(s.begin(), s.end(), d) != s.end();
   }

template<typename ForwardSequence , typename Predicate >

bool edm::search_if_in_all	(	ForwardSequence const &	s,
		Predicate const &	p
	)

inline

Definition at line 68 of file Algorithms.h.

References L1TEmulatorMonitor_cff::p.

                                                                  {
     return std::find_if(s.begin(), s.end(), p) != s.end();
   }

template<typename T , typename U >

U edm::second ( std::pair< T, U > const & p )

Definition at line 203 of file ParameterSet.cc.

Referenced by FilterOR::accept(), TkTrackingRegionsMargin< float >::add(), edm::eventsetup::EventSetupRecord::add(), pos::PixelConfigFile::addAlias(), evf::WebGUI::addCountersToParams(), HcalHardwareXml::addHardware(), FWConvTrackHitsDetailView::addModules(), FWTrackHitsDetailView::addModules(), Hector::addPartToHepMC(), SurveyInputTrackerFromDB::addSurveyInfo(), SurveyMisalignmentInput::addSurveyInfo(), EcalPreshowerGeometry::alignmentTransformIndexLocal(), BlockWipedPool::allocator(), PFCandConnector::analyseNuclearWPrim(), PFCandConnector::analyseNuclearWSec(), SiStripThresholdBuilder::analyze(), BxTiming::analyze(), RPCGeometryServTest::analyze(), LHEAnalyzer::analyze(), DTPreCalibrationTask::analyze(), HcalQIEDataCheck::analyze(), DTNoiseCalibration::analyze(), HcalPedestalWidthsCheck::analyze(), DTNoiseTask::analyze(), cms::HcalConstantsASCIIWriter::analyze(), HeavyFlavorValidation::analyze(), DTTestPulsesTask::analyze(), DTAlbertoBenvenutiTask::analyze(), EcalTPGParamBuilder::analyze(), DTDigiTask::analyze(), L1TRPCTPG::analyze(), DQMHcalIsoTrackHLT::analyze(), HLTScalers::analyze(), SiStripBadAPVAlgorithmFromClusterOccupancy::AnalyzeOccupancy(), SiStripBadAPVandHotStripAlgorithmFromClusterOccupancy::AnalyzeOccupancy(), SurveyDataConverter::applyFineSurveyInfo(), TrackerHitAssociator::associateHit(), BxTiming::beginJob(), ShallowTree::beginJob(), Tracker_OldtoNewConverter::beginJob(), HLTSeedL1LogicScalers::beginRun(), FourVectorHLTOnline::beginRun(), TrigResRateMon::beginRun(), FourVectorHLTOffline::beginRun(), ora::RelationalDeleter::build(), CSCGeometryParsFromDD::build(), SeedFromGenericPairOrTriplet::buildSeed(), CocoaUnitDefinition::BuildUnitsTable(), ALIUnitDefinition::BuildUnitsTable(), JetPartonMatching::calculate(), ClusterShapeAlgo::Calculate_Covariances(), ClusterShapeAlgo::Calculate_e3x2(), ClusterShapeAlgo::Calculate_e3x3(), ClusterShapeAlgo::Calculate_e4x4(), ClusterShapeAlgo::Calculate_e5x5(), MultipleAlgoIterator::calculatePedestal(), PileUpSubtractor::calculatePedestal(), edm::Principal::checkUniquenessAndType(), TrackCleaner::cleanTracks(), SimTrackManager::cleanTracksWithHistory(), BlockWipedPool::clear(), PixelHitMatcher::compatibleSeeds(), GsfBetheHeitlerUpdator::compute(), GaussianSumUtilities1D::computeMode(), SiStripFecCabling::connections(), DDHCalBarrelAlgo::constructGeneralVolume(), DDHCalEndcapAlgo::constructGeneralVolume(), DDHCalBarrelAlgo::constructInsideDetectors(), DDHCalBarrelAlgo::constructInsideLayers(), DDHCalEndcapAlgo::constructInsideModule(), DDHCalEndcapAlgo::constructInsideModule0(), DDHCalBarrelAlgo::constructInsideSector(), DDHCalEndcapAlgo::constructInsideSector(), DDHCalBarrelAlgo::constructMidLayer(), DDHCalEndcapAlgo::constructScintLayer(), DDHCalBarrelAlgo::constructSideLayer(), CaloTowersCreationAlgo::convert(), GctFormatTranslateV35::convertBlock(), GctFormatTranslateMCLegacy::convertBlock(), GctFormatTranslateV38::convertBlock(), popcon::PopConSourceHandler< CastorPedestals >::convertFromOld(), copyObject(), TauJetCorrector::correction(), JetPartonCorrector::correction(), FourVectorHLTOnline::countHLTGroupBXHitsEndLumiBlock(), TrigResRateMon::countHLTGroupBXHitsEndLumiBlock(), FourVectorHLTOffline::countHLTGroupBXHitsEndLumiBlock(), LatencyHistosUsingDb::create(), Histograms::declareHistograms(), evf::ExceptionGenerator::defaultWebPage(), edm::DaqSource::defaultWebPage(), GeomDetTypeIdToEnum::detId(), PFRecoTauDiscriminationByInvMass::discriminate(), SurveyPxbDicer::doDice(), DTSC::DTSectCollsort2(), MuScleFit::duringFastLoop(), ZeeCalibration::duringLoop(), EcalClusterTools::e2nd(), EcalClusterTools::eMax(), edm::ELlog4cplus::emit(), edm::service::ELoutput::emitToken(), TowerBlockFormatter::EndEvent(), DuplicationChecker::endJob(), AlcaBeamMonitor::endLuminosityBlock(), DTtTrigCalibrationTest::endLuminosityBlock(), DTNoiseTest::endLuminosityBlock(), AlcaBeamMonitorClient::endRun(), DDTIDModulePosAlgo::execute(), DDHCalForwardAlgo::execute(), DDHCalTBCableAlgo::execute(), DDHCalTBZposAlgo::execute(), DDTIBLayerAlgo_MTCC::execute(), DDTIBRadCableAlgo_MTCC::execute(), DDPixBarLayerAlgo::execute(), DDTECCoolAlgo::execute(), DDTECOptoHybAlgo::execute(), DDTIBLayerAlgo::execute(), DDTIDModuleAlgo::execute(), DDTOBAxCableAlgo::execute(), DDTOBRadCableAlgo::execute(), DDTOBRodAlgo::execute(), DDTrackerLinear::execute(), DDTrackerLinearXY::execute(), DDTrackerXYZPosAlgo::execute(), DDTrackerZPosAlgo::execute(), DDHCalFibreBundle::execute(), DDHCalLinearXY::execute(), DDTECAxialCableAlgo::execute(), DDTECModuleAlgo::execute(), DDTECPhiAltAlgo::execute(), DDTECPhiAlgo::execute(), DDTIDAxialCableAlgo::execute(), DDTIDRingAlgo::execute(), DDTrackerAngular::execute(), DDTrackerPhiAlgo::execute(), DDTrackerPhiAltAlgo::execute(), DDPixFwdBlades::execute(), CommissioningHistograms::extractHistograms(), PatZToMuMuAnalyzer::fill(), PatJetAnalyzer::fill(), TopSingleLepton::MonitorEnsemble::fill(), TopDiLeptonOffline::MonitorEnsemble::fill(), OutInConversionSeedFinder::fillClusterSeeds(), GenParticleProducer::fillDaughters(), TrigResRateMon::fillHltMatrix(), FourVectorHLTOffline::fillHltMatrix(), edm::RootFile::fillIndexIntoFile(), EcalTrigPrimFunctionalAlgo::fillMap(), SiStripCMMonitorPlugin::fillMaps(), SiStripNoisesDQM::fillMEsForLayer(), SiStripLorentzAngleDQM::fillMEsForLayer(), SiStripPedestalsDQM::fillMEsForLayer(), SiStripThresholdDQM::fillMEsForLayer(), SiStripApvGainsDQM::fillMEsForLayer(), SiStripQualityDQM::fillMEsForLayer(), SiPixelUtility::fillPaveText(), Histograms::fillRecHistograms(), HLTEgammaDoubleLegCombFilter::filter(), HLTEgammaEtFilterPairs::filter(), ProbeTreeProducer::filter(), HLTJetTag::filter(), CSCDigiValidator::filter(), Hector::filterD1(), Hector::filterFP420(), Hector::filterZDC(), DisplayManager::findBlock(), pftools::SpaceManager::findCalibrator(), EcalTBCrystalMap::findCrystalAngles(), SymmetryFit::findUsableMinMax(), GsfTrajectoryFitter::fit(), CosmicMuonSmoother::fit(), KFTrajectoryFitter::fit(), alpgen::fixEventHiggsTTbar(), alpgen::fixEventSingleTop(), alpgen::fixEventTTbar(), NuclearTester::fwdEstimate(), DTTPGParameters::get(), DTLVStatus::get(), edm::RangeMap< det_id_type, edm::OwnVector< double_binary > >::get(), DTHVStatus::get(), edm::helper::IndexRangeAssociation::get(), DTRangeT0::get(), DTTtrig::get(), DTDeadFlag::get(), DTPerformance::get(), DTStatusFlag::get(), DTMtime::get(), GctFormatTranslateBase::getBlockDescription(), CalibrationInterface< CategoryT, CalibDataT >::getCalibData(), CaloGeometryHelper::getClosestCell(), egHLT::ComCodes::getCodeName(), egHLT::TrigCodes::TrigBitSetMap::getCodeName(), SiStripPsuDetIdMap::getDcuId(), HICMeasurementEstimator::getDetectorCode(), SiStripPsuDetIdMap::getDetectorLocation(), egHLT::trigTools::getFiltersPassed(), LMFCorrCoefDat::getFlag(), metsig::SignAlgoResolutions::getfunc(), IO::GetLineData(), pftools::IO::GetLineData(), EcalElectronicsMapping::getLMNumber(), PileUpSubtractor::getMeanAtTower(), IO::GetNextLineData(), pftools::IO::GetNextLineData(), trigger::TriggerEventWithRefs::getObjects(), PileUpSubtractor::getPileUpAtTower(), DTT0::getRandom(), LMFCorrCoefDat::getSeqID(), LMFCorrCoefDat::getSequence(), PileUpSubtractor::getSigmaAtTower(), DTT0::getSorted(), RPCSeedPattern::getSpecialAlgorithmErrorMatrix(), SiStripBaseCondObjDQM::getSummaryMEs(), ZIterativeAlgorithmWithFit::getWeight(), SimTrackManager::giveMotherNeeded(), MuonRoadTrajectoryBuilder::flippingPair< A >::head(), PixelTripletLargeTipGenerator::hitTriplets(), SimTrackManager::idSavedTrack(), CombinedHitTripletGenerator::init(), L1MuGMTLUT::Init(), init_filter(), PixelRecoRange< float >::inside(), egammaisolation::EgammaRange< float >::inside(), muonisolation::Range< float >::inside(), TRange< int >::inside(), EcalTBDaqFormatter::interpretRawData(), EcalTB07DaqFormatter::interpretRawData(), TtGenEvent::isFullLeptonic(), RPCFw::isMajor(), CSCDDUMap::item(), CSCChamberMap::item(), CSCCrateMap::item(), TtEvent::jetLeptonCombination(), MuonTkNavigationSchool::linkEndcapLayers(), G4SimEvent::load(), CalorimetryManager::loadFromEcalBarrel(), CalorimetryManager::loadFromEcalEndcap(), CalorimetryManager::loadFromHcal(), pos::PixelConfigFile::makeKey(), SiStripHitEffFromCalibTree::makeTKMap(), match(), JetPartonMatching::matchingPtOrderedMinDist(), PixelRecoRange< float >::max(), egammaisolation::EgammaRange< float >::max(), muonisolation::Range< float >::max(), TRange< int >::max(), PixelRecoRange< float >::mean(), egammaisolation::EgammaRange< float >::mean(), muonisolation::Range< float >::mean(), TRange< int >::mean(), MultipleAlgoIterator::offsetCorrectJets(), PileUpSubtractor::offsetCorrectJets(), OnDemandMeasurementTracker::OnDemandMeasurementTracker(), DDValuePair::operator const double &(), DDValuePair::operator double &(), PhysicsTools::AtomicId::operator!=(), ddsvaluesCmp::operator()(), CastorDbASCIIIO::DetIdLess::operator()(), reco::tau::RecoTauDiscriminantFromDiscriminator::operator()(), reco::tau::RecoTauPiZeroStripPlugin::operator()(), L1MuGMTExtendedCand::Rank::operator()(), SimpleL1MuGMTCand::Rank::operator()(), PhysicsTools::AtomicId::operator<(), operator<<(), PhysicsTools::AtomicId::operator<=(), PhysicsTools::AtomicId::operator==(), PhysicsTools::AtomicId::operator>(), PhysicsTools::AtomicId::operator>=(), EnergyLossPlain::optimal(), ClusterClusterMapping::overlap(), MomentumDependentPedeLabeler::parameterLabel(), DDLParser::parseFile(), DDLParser::parseOneFile(), reco::modules::TrackerTrackHitFilter::parseStoN(), PartitionGenerator::partitions(), L1MuDTAssignmentUnit::PhiAU(), PhiBorderFinder::PhiBorderFinder(), cond::PayLoadInspector< DataT >::plot(), SiStripRegionCabling::position(), HLTConfigProvider::prescaleValues(), TtFullLeptonicEvent::print(), egHLT::TrigCodes::TrigBitSetMap::printCodes(), hcalCalib::Process(), PFAlgoTestBenchElectrons::processBlock(), PFAlgo::processBlock(), cscdqm::EventProcessor::processCSC(), DDLSpecPar::processElement(), DDLString::processElement(), DDLNumeric::processElement(), EnergyLossProducer::produce(), CandOneToManyDeltaRMatcher::produce(), TtFullLepKinSolutionProducer::produce(), PFTrackProducer::produce(), DTFakeT0ESProducer::produce(), L1ExtraParticleMapProd::produce(), pat::PATPhotonProducer::produce(), pat::PATGenericParticleProducer::produce(), pat::PATMuonProducer::produce(), pat::PATTauProducer::produce(), reco::modules::TrackMultiSelector::produce(), JetPlusTrackProducerAA::produce(), pat::PATElectronProducer::produce(), RunManager::produce(), reco::PhysObjectMatcher< C1, C2, S, D, Q >::produce(), NuclearTrackCorrector::produce(), cms::HITrackVertexMaker::produceTracks(), edm::eventsetup::EventSetupProvider::proxyProviderDescriptions(), RBorderFinder::RBorderFinder(), RunSummaryRead::readData(), L1TriggerScalerRead::readData(), SiStripDetVOffBuilder::readLastValueFromFile(), evf::FUEventProcessor::receivingAndMonitor(), CSCEfficiency::recHitSegment_Efficiencies(), CSCEfficiency::recSimHitEfficiency(), SiStripDetVOffBuilder::reduce(), SiStripDetVOffBuilder::reduction(), edm::ESProxyFactoryProducer::registerFactoryWithKey(), pftools::CaloWindow::relativePosition(), SiPixelHistoricInfoEDAClient::retrieveMEs(), TkTrackingRegionsMargin< float >::right(), reco::modules::TrackerTrackHitFilter::Rule::Rule(), DTTSS::run(), RoadSearchTrackCandidateMakerAlgorithm::run(), DTTSM::run(), DTSC::run(), EcalTrigPrimFunctionalAlgo::run_part2(), DTLocalTriggerLutTest::runClientDiagnostic(), SortCollectionSelector< InputCollection, Comparator, OutputCollection, StoreContainer, RefAdder >::select(), FWTableView::selectCollection(), MuScleFit::selectMuons(), DTLVStatus::set(), DTTPGParameters::set(), DTHVStatus::set(), DTRangeT0::set(), DTT0::set(), DTTtrig::set(), DTPerformance::set(), DTStatusFlag::set(), DTDeadFlag::set(), DTMtime::set(), PFElectronAlgo::SetActive(), HICMeasurementEstimator::setCuts(), egHLT::trigTools::setFiltersObjPasses(), FWEventItemsManager::setFrom(), TauJetCorrector::setParameters(), JetPartonCorrector::setParameters(), DDLSolid::setReference(), ConvBremSeedProducer::sharedHits(), ora::Sequences::sinchronize(), ora::Sequences::sinchronizeAll(), SiStripGainESProducerTemplate< TDependentRecord, TInputRecord >::SiStripGainNormalizationFunction(), muonisolation::Range< float >::sort(), egammaisolation::EgammaRange< float >::sort(), PixelRecoRange< float >::sort(), TRange< int >::sort(), edm::OneToManyWithQualityGeneric< TrackingParticleCollection, edm::View< reco::Track >, double >::sort(), DTTSM::sortTSM2(), DTTSS::sortTSS2(), CombinationGenerator< T >::splitInTwoCollections(), SiStripZeroSuppression::storeCMN(), L1MuGMTLUT::PortDecoder::str(), RPCDigiL1Link::strip(), StripCPE::StripCPE(), cond::PayLoadInspector< DataT >::summary(), MagGeoBuilderFromDDD::summary(), MuonRoadTrajectoryBuilder::flippingPair< A >::tail(), CompositeLogicalTrajectoryFilter::TBC(), L3MuonTrajectoryBuilder::trajectories(), GsfTrajectorySmoother::trajectories(), TwoBodyDecayTrajectoryFactory::trajectories(), GeomDetTypeIdToEnum::type(), MonopoleSteppingAction::update(), LatencyHistosUsingDb::update(), SiTrackerMultiRecHitUpdator::update(), SiTrackerMultiRecHitUpdatorMTF::update(), TauJetCorrector::ParametrizationTauJet::value(), viewNameFrom(), BlockWipedPool::visit(), and BlockWipedPool::wipe().

                                                                     {
     return p.second;
   }

void edm::setCacheStreamers ( )

Definition at line 30 of file CacheStreamers.cc.

Referenced by AutoLibraryLoader::enable(), and edm::service::InitRootHandlers::InitRootHandlers().

                            {
 #if 0    
     TClass *cl = gROOT->GetClass("edm::BoolCache");
     if (cl->GetStreamer() == 0) {
       cl->AdoptStreamer(new BoolCacheStreamer());
     /*} else {
       std::cout <<"ERROR: no edm::BoolCache found"<<std::endl;*/
     }
 
     cl = gROOT->GetClass("edm::ConstPtrCache");
     if (cl->GetStreamer() == 0) {
       cl->AdoptStreamer(new ConstPtrCacheStreamer());
     /*} else {
       std::cout <<"ERROR: no edm::ConstPtrCache found"<<std::endl;*/
     }
 #endif    
   }

template<typename T >

void edm::SetCustomStreamer ( )

Definition at line 41 of file CustomStreamer.h.

References className().

                       {
     TClass *cl = gROOT->GetClass(TypeID(typeid(T)).className().c_str());
     if (cl->GetStreamer() == 0) {
       cl->AdoptStreamer(new CustomStreamer<T>());
     }
   }

template<typename T >

void edm::SetCustomStreamer ( T const & )

Definition at line 50 of file CustomStreamer.h.

References className().

                               {
     TClass *cl = gROOT->GetClass(TypeID(typeid(T)).className().c_str());
     if (cl->GetStreamer() == 0) {
       cl->AdoptStreamer(new CustomStreamer<T>());
     }
   }

template<typename T , typename A >

void edm::setPtr	(	std::vector< T, A > const &	obj,
		std::type_info const &	iToType,
		unsigned long	iIndex,
		void const *&	oPtr
	)

Definition at line 84 of file setPtr.h.

References edm::detail::reallySetPtr().

Referenced by edm::helpers::PtrSetter< T >::set().

                             {
     detail::reallySetPtr(obj, iToType, iIndex, oPtr);
   }

template<typename T , typename A >

void edm::setPtr	(	std::list< T, A > const &	obj,
		std::type_info const &	iToType,
		unsigned long	iIndex,
		void const *&	oPtr
	)

Definition at line 93 of file setPtr.h.

References edm::detail::reallySetPtr().

                             {
     detail::reallySetPtr(obj, iToType, iIndex, oPtr);
   }

template<typename T , typename A >

void edm::setPtr	(	std::deque< T, A > const &	obj,
		std::type_info const &	iToType,
		unsigned long	iIndex,
		void const *&	oPtr
	)

Definition at line 102 of file setPtr.h.

References edm::detail::reallySetPtr().

                             {
     detail::reallySetPtr(obj, iToType, iIndex, oPtr);
   }

template<typename T , typename A , typename Comp >

void edm::setPtr	(	std::set< T, A, Comp > const &	obj,
		std::type_info const &	iToType,
		unsigned long	iIndex,
		void const *&	oPtr
	)

Definition at line 111 of file setPtr.h.

References edm::detail::reallySetPtr().

                             {
     detail::reallySetPtr(obj, iToType, iIndex, oPtr);
   }

template<typename T , typename SORT >

void edm::setPtr	(	SortedCollection< T, SORT > const &	obj,
		std::type_info const &	toType,
		unsigned long	index,
		void const *&	ptr
	)

inline

Definition at line 455 of file SortedCollection.h.

                            {
     obj.setPtr(toType, index, ptr);
   }

template<typename T , typename P >

void edm::setPtr	(	OwnVector< T, P > const &	obj,
		std::type_info const &	toType,
		unsigned long	index,
		void const *&	ptr
	)

inline

Definition at line 505 of file OwnVector.h.

References edm::OwnVector< T, P >::setPtr().

                            {
     obj.setPtr(toType, index, ptr);
   }

void edm::setRefCoreStreamer ( bool resetAll = false )

Definition at line 85 of file RefCoreStreamer.cc.

References edm::EDProductGetter::switchProductGetter().

Referenced by edm::StreamerInputSource::deserializeEvent(), edm::RootDelayedReader::getProduct_(), edm::service::InitRootHandlers::InitRootHandlers(), edm::BranchMapperWithReader::readProvenance_(), edm::RootFile::RootFile(), and edm::RootOutputTree::writeTTree().

                                          {
     
     {
       TClass *cl = gROOT->GetClass("edm::RefCore::CheckTransientOnWrite");
       TClassStreamer *st = cl->GetStreamer();
       if (st == 0) {
         cl->AdoptStreamer(new RefCoreCheckTransientOnWriteStreamer());
       } 
     }
     EDProductGetter::switchProductGetter(0);
     if (resetAll) {
       TClass *cl = gROOT->GetClass("edm::RefCore");
       if (cl->GetStreamer() != 0) {
         cl->AdoptStreamer(0);
       }
     }
     if (resetAll) {
       TClass *cl = gROOT->GetClass("edm::ProductID");
       if (cl->GetStreamer() != 0) {
         cl->AdoptStreamer(0);
       }
     }
   }

EDProductGetter const * edm::setRefCoreStreamer	(	EDProductGetter const *	ep,
		bool	oldFormat = `false`,
		bool	productIDwasLong = `false`
	)

Definition at line 109 of file RefCoreStreamer.cc.

References edm::RefCoreStreamer::setProductGetter(), edm::ProductIDStreamer::setProductGetter(), and edm::EDProductGetter::switchProductGetter().

                                                                                                               {
     EDProductGetter const* returnValue=0;
     if (ep != 0) {
       if (oldFormat) {
         TClass *cl = gROOT->GetClass("edm::RefCore");
         RefCoreStreamer *st = static_cast<RefCoreStreamer *>(cl->GetStreamer());
         if (st == 0) {
           cl->AdoptStreamer(new RefCoreStreamer(ep));
         } else {          
           returnValue = st->setProductGetter(ep);
         }
       } else {
         TClass *cl = gROOT->GetClass("edm::RefCore::CheckTransientOnWrite");
         TClassStreamer *st = cl->GetStreamer();
         if (st == 0) {
           cl->AdoptStreamer(new RefCoreCheckTransientOnWriteStreamer());
         } 
         returnValue = edm::EDProductGetter::switchProductGetter(ep);
       }
     }
     if (oldFormat) {
       TClass *cl = gROOT->GetClass("edm::ProductID");
       ProductIDStreamer *st = static_cast<ProductIDStreamer *>(cl->GetStreamer());
       if (st == 0) {
         cl->AdoptStreamer(new ProductIDStreamer(ep, productIDwasLong));
       } else {
         st->setProductGetter(ep);
       }
     }
     return returnValue;
   }

void edm::setStandAloneMessageThreshold ( std::string const & severity )

Definition at line 142 of file MessageLogger.cc.

References edm::MessageLoggerQ::standAloneThreshold().

                                                                {
   edm::MessageLoggerQ::standAloneThreshold(severity);
 }

template<typename T >

void edm::SetTransientStreamer ( )

Definition at line 44 of file TransientStreamer.h.

References className().

                          {
     TClass *cl = gROOT->GetClass(TypeID(typeid(T)).className().c_str());
     if (cl->GetStreamer() == 0) {
       cl->AdoptStreamer(new TransientStreamer<T>());
     }
   }

template<typename T >

void edm::SetTransientStreamer ( T const & )

Definition at line 53 of file TransientStreamer.h.

References className().

                                  {
     TClass *cl = gROOT->GetClass(TypeID(typeid(T)).className().c_str());
     if (cl->GetStreamer() == 0) {
       cl->AdoptStreamer(new TransientStreamer<T>());
     }
   }

void edm::setTransientStreamers ( )

Definition at line 12 of file TransientStreamer.cc.

Referenced by edm::service::InitRootHandlers::InitRootHandlers().

                                {
     SetTransientStreamer<Transient<BranchDescription::Transients> >();
     SetTransientStreamer<Transient<ProductProvenance::Transients> >();
     SetTransientStreamer<Transient<IndexIntoFile::Transients> >();
     SetTransientStreamer<Transient<Parentage::Transients> >();
     SetTransientStreamer<Transient<ProcessConfiguration::Transients> >();
     SetTransientStreamer<Transient<ProcessHistory::Transients> >();
     SetTransientStreamer<Transient<ProductRegistry::Transients> >();
   }

void edm::sigInventory ( )

Definition at line 160 of file UnixSignalHandlers.cc.

References benchmark_cfg::cerr, gen::k, and MUST_BE_ZERO.

     {
       sigset_t tmpset, oldset;
 //    Make a full house set of signals, except for SIGKILL = 9
 //    and SIGSTOP = 19 which cannot be blocked
       MUST_BE_ZERO(sigfillset(&tmpset));
       MUST_BE_ZERO(sigdelset(&tmpset, SIGKILL));
       MUST_BE_ZERO(sigdelset(&tmpset, SIGSTOP));
 //    Swap it with the current sigset_t
       MUST_BE_ZERO(pthread_sigmask( SIG_SETMASK, &tmpset, &oldset ));
 //    Now see what's included in the set
       for(int k=1; k<NSIG; ++k) {
         std::cerr << "sigismember is " << sigismember( &tmpset, k )
                   << " for signal " << std::setw(2) << k
 #if defined(__linux__)
                   << " (" << strsignal(k) << ")"
 #endif
                   << std::endl;
       }
 //    Finally put the original sigset_t back
       MUST_BE_ZERO(pthread_sigmask( SIG_SETMASK, &oldset, &tmpset));
     }

void edm::snapshotMessageLog ( )

Definition at line 100 of file MessageLogger.cc.

References edm::MessageDrop::instance(), and edm::MessageDrop::snapshot().

                           {                 // 11/30/10 mf
   // Capture module name and label strings.
   // Use if module objects are about to disappear due to exception,
   // but a message will then be issued.
   MessageDrop::instance()->snapshot();
 }

template<typename RandomAccessSequence >

void edm::sort_all ( RandomAccessSequence & s )

inline

wrappers for std::sort

Definition at line 120 of file Algorithms.h.

References python.multivaluedict::sort().

Referenced by edm::EventContentAnalyzer::EventContentAnalyzer(), CaloVNoiseSignalGenerator::fillDetIds(), edm::PoolOutputModule::fillSelectedItemList(), edm::GroupSelector::initialize(), edm::MixingModule::MixingModule(), edm::RootOutputFile::RootOutputFile(), edm::StreamSerializer::serializeRegistry(), sortAndRemoveOverlaps(), ProvenanceDumper::work_(), edmplugin::CacheParser::write(), and edm::RootOutputFile::writeProcessConfigurationRegistry().

                                      {
     std::sort(s.begin(), s.end());
   }

template<typename RandomAccessSequence , typename Predicate >

void edm::sort_all	(	RandomAccessSequence &	s,
		Predicate	p
	)

inline

Definition at line 127 of file Algorithms.h.

References L1TEmulatorMonitor_cff::p, and python.multivaluedict::sort().

                                                   {
     std::sort(s.begin(), s.end(), p);
   }

std::vector< LuminosityBlockRange > & edm::sortAndRemoveOverlaps ( std::vector< LuminosityBlockRange > & lumiRange )

Definition at line 96 of file LuminosityBlockRange.cc.

References i, merge(), and sort_all().

                                                                     {
     if (lumiRange.size() <= 1U) return lumiRange;
     sort_all(lumiRange, sortByStartLuminosityBlockID);
     for (std::vector<LuminosityBlockRange>::iterator i = lumiRange.begin() + 1, e = lumiRange.end();
         i != e; ++i) {
       std::vector<LuminosityBlockRange>::iterator iprev = i - 1;
       if (merge(*iprev, *i)) {
         i = lumiRange.erase(iprev);
         e = lumiRange.end();
       }
     }
     return lumiRange;
   }

std::vector< EventRange > & edm::sortAndRemoveOverlaps ( std::vector< EventRange > & eventRange )

Definition at line 102 of file EventRange.cc.

References i, and sort_all().

Referenced by edm::EventSkipperByID::EventSkipperByID().

                                                            {
     if (eventRange.size() <= 1U) return eventRange;
     sort_all(eventRange, sortByStartEventIDSpecial);
     for (std::vector<EventRange>::iterator i = eventRange.begin() + 1, e = eventRange.end();
         i != e; ++i) {
       std::vector<EventRange>::iterator iprev = i - 1;
       if (mergeSpecial(*iprev, *i)) {
         i = eventRange.erase(iprev);
         e = eventRange.end();
       }
     }
     return eventRange;
   }

template<class OutIter >

bool edm::split	(	OutIter	result,
		std::string const &	string_to_split,
		char	first,
		char	sep,
		char	last
	)

Definition at line 88 of file split.h.

References b, contextual_find(), and contextual_find_not().

Referenced by edm::ParameterSetConverter::convertParameterSets(), decode(), edm::ParameterSet::fromString(), and edm::VParameterSetEntry::VParameterSetEntry().

 {
   typedef  std::string::const_iterator  str_c_iter;
   str_c_iter  b = s.begin()
            ,  e = s.end();
 
   if(static_cast<unsigned int>(e - b) < 2u)  return false;
 
   if(*b == first)  ++b;
   else               return false;
 
   if(*--e != last)  return false;
 
   // invariant:  we've found all items in [b..boi)
   for(str_c_iter  //boi = std::find_if(b, e, is_not_a(sep))
                    boi = contextual_find_not(b, e, first, sep, last)
                 ,  eoi
      ; boi != e
      //; boi = std::find_if(eoi, e, is_not_a(sep))
      ; boi = contextual_find_not(eoi, e, first, sep, last))
   {
     // find end of current item:
     //eoi = std::find_if(boi, e, is_a(sep));
     eoi = contextual_find(boi, e, first, sep, last);
 
     // copy the item formed from characters in [boi..eoi):
     *dest++ = std::string(boi, eoi);
   }  // for
 
   return true;
 }  // split< >()

void edm::squelchStandAloneMessageCategory ( std::string const & category )

Definition at line 145 of file MessageLogger.cc.

References edm::MessageLoggerQ::squelch().

                                                                  {
   edm::MessageLoggerQ::squelch(category);
 }

template<typename RandomAccessSequence >

void edm::stable_sort_all ( RandomAccessSequence & s )

inline

wrappers for std::stable_sort

Definition at line 135 of file Algorithms.h.

Referenced by edm::RootFile::fillIndexIntoFile(), edm::IndexIntoFile::fillRunOrLumiIndexes(), edm::FileIndex::sortBy_Run_Lumi_Event(), edm::FileIndex::sortBy_Run_Lumi_EventEntry(), and edm::IndexIntoFile::sortVector_Run_Or_Lumi_Entries().

                                             {
     std::stable_sort(s.begin(), s.end());
   }

template<typename RandomAccessSequence , typename Predicate >

void edm::stable_sort_all	(	RandomAccessSequence &	s,
		Predicate	p
	)

inline

Definition at line 142 of file Algorithms.h.

References L1TEmulatorMonitor_cff::p.

                                                          {
     std::stable_sort(s.begin(), s.end(), p);
   }

std::string edm::stripLeadingDirectoryTree ( const std::string & file )

void edm::swap	(	ProductID &	a,
		ProductID &	b
	)

inline

Definition at line 53 of file ProductID.h.

References edm::ProductID::swap().

                                         {
     a.swap(b);
   }

void edm::swap	(	GroupData &	a,
		GroupData &	b
	)

inline

Definition at line 58 of file Group.h.

References edm::GroupData::swap().

                                                {
     a.swap(b);
   }

void edm::swap	(	Parentage &	a,
		Parentage &	b
	)

inline

Definition at line 59 of file Parentage.h.

References edm::Parentage::swap().

                                    {
     a.swap(b);
   }

template<class T , class P >

void edm::swap	(	CloningPtr< T, P > &	a,
		CloningPtr< T, P > &	b
	)

inline

Definition at line 66 of file CloningPtr.h.

References edm::CloningPtr< T, P >::swap().

   {
     a.swap(b);
   }

void edm::swap	(	ESHandleBase &	a,
		ESHandleBase &	b
	)

inline

Definition at line 76 of file ESHandle.h.

References edm::ESHandleBase::swap().

   {
     a.swap(b);
   }

void edm::swap	(	OrphanHandleBase &	a,
		OrphanHandleBase &	b
	)

inline

Definition at line 77 of file OrphanHandleBase.h.

References edm::OrphanHandleBase::swap().

                                                  {
     a.swap(b);
   }

void edm::swap	(	ProcessHistory &	a,
		ProcessHistory &	b
	)

inline

Definition at line 82 of file ProcessHistory.h.

References edm::ProcessHistory::swap().

                                              {
     a.swap(b);
   }

template<class T >

void edm::swap	(	RefToBaseVector< T > &	a,
		RefToBaseVector< T > &	b
	)

inline

Definition at line 90 of file RefToBaseVector.h.

References edm::RefToBaseVector< T >::swap().

                                                      {
     a.swap(b);
   }

void edm::swap	(	TriggerResults &	lhs,
		TriggerResults &	rhs
	)

inline

Definition at line 100 of file TriggerResults.h.

References edm::TriggerResults::swap().

                                                  {
     lhs.swap(rhs);
   }

void edm::swap	(	HandleBase &	a,
		HandleBase &	b
	)

inline

Definition at line 107 of file HandleBase.h.

References edm::HandleBase::swap().

                                      {
     a.swap(b);
   }

template<typename KEY >

void edm::swap	(	RefVectorBase< KEY > &	a,
		RefVectorBase< KEY > &	b
	)

inline

swap two vectors

Definition at line 109 of file RefVectorBase.h.

                                                        {
     a.swap(b);
   }

void edm::swap	(	HLTGlobalStatus &	lhs,
		HLTGlobalStatus &	rhs
	)

inline

Free swap function.

Definition at line 112 of file HLTGlobalStatus.h.

References edm::HLTGlobalStatus::swap().

                                                    {
     lhs.swap(rhs);
   }

void edm::swap	(	BasicHandle &	a,
		BasicHandle &	b
	)

inline

Definition at line 115 of file BasicHandle.h.

References edm::BasicHandle::swap().

                                        {
     a.swap(b);
   }

template<typename C >

void edm::swap	(	Association< C > &	lhs,
		Association< C > &	rhs
	)

inline

template<class T >

void edm::swap	(	DetSet< T > &	a,
		DetSet< T > &	b
	)

inline

Definition at line 118 of file DetSet.h.

References edm::DetSet< T >::swap().

                                      {
     a.swap(b);
   }

void edm::swap	(	OutputHandle &	a,
		OutputHandle &	b
	)

inline

Definition at line 119 of file OutputHandle.h.

References edm::OutputHandle::swap().

                                          {
     a.swap(b);
   }

void edm::swap	(	edm::RefCore &	lhs,
		edm::RefCore &	rhs
	)

inline

Definition at line 125 of file RefCore.h.

References edm::RefCore::swap().

                                                        {
     lhs.swap(rhs);
   }

void edm::swap	(	FileInPath &	a,
		FileInPath &	b
	)

inline

Definition at line 138 of file FileInPath.h.

References edm::FileInPath::swap().

   {
     a.swap(b);
   }

template<typename K , typename T >

void edm::swap	(	MapOfVectors< K, T > &	lhs,
		MapOfVectors< K, T > &	rhs
	)

inline

Definition at line 160 of file MapOfVectors.h.

References edm::MapOfVectors< K, T >::swap().

                                                          {
     lhs.swap(rhs);
   }

template<class T >

void edm::swap	(	EDCollection< T > &	a,
		EDCollection< T > &	b
	)

inline

Definition at line 162 of file EDCollection.h.

References edm::EDCollection< T >::swap().

   {
     a.swap(b);
   }

template<typename C , typename T , typename F >

void edm::swap	(	RefVector< C, T, F > &	a,
		RefVector< C, T, F > &	b
	)

inline

Definition at line 168 of file RefVector.h.

                                                        {
     a.swap(b);
   }

template<typename T >

void edm::swap	(	value_ptr< T > &	vp1,
		value_ptr< T > &	vp2
	)

inline

Definition at line 178 of file value_ptr.h.

References edm::value_ptr< T >::swap().

178 { vp1.swap(vp2); }

template<class T >

void edm::swap	(	RefGetter< T > &	a,
		RefGetter< T > &	b
	)

inline

Definition at line 178 of file RefGetter.h.

References edm::RefGetter< T >::swap().

     {
       a.swap(b);
     }

template<typename ID , typename C , typename P >

void edm::swap	(	IDVectorMap< ID, C, P > &	a,
		IDVectorMap< ID, C, P > &	b
	)

inline

Definition at line 193 of file IDVectorMap.h.

References edm::IDVectorMap< ID, C, P >::swap().

                                                              {
     a.swap(b);
   }

template<typename T >

void edm::swap	(	PtrVector< T > &	lhs,
		PtrVector< T > &	rhs
	)

inline

Definition at line 206 of file PtrVector.h.

References edm::PtrVector< T >::swap().

                                              {
     lhs.swap(rhs);
   }

template<int I>

void edm::swap	(	Hash< I > &	a,
		Hash< I > &	b
	)

inline

Definition at line 210 of file Hash.h.

References edm::Hash< I >::swap().

                                {
     a.swap(b);
   }

void edm::swap	(	DataFrameContainer &	lhs,
		DataFrameContainer &	rhs
	)

inline

Definition at line 211 of file DataFrameContainer.h.

References edm::DataFrameContainer::swap().

                                                          {
     lhs.swap(rhs);
   }

template<typename T >

void edm::swap	(	edm::RefToBaseProd< T > const &	lhs,
		edm::RefToBaseProd< T > const &	rhs
	)

inline

Definition at line 214 of file RefToBaseProd.h.

References edm::RefToBaseProd< T >::swap().

                                                                                    {
     lhs.swap(rhs);
   }

void edm::swap	(	InputGroup &	a,
		InputGroup &	b
	)

inline

Definition at line 222 of file Group.h.

References edm::Group::swap().

                                                  {
     a.swap(b);
   }

template<typename KeyRefProd , typename CVal , typename KeyRef , typename SizeType , typename KeyReferenceHelper >

void edm::swap	(	AssociationVector< KeyRefProd, CVal, KeyRef, SizeType, KeyReferenceHelper > &	a,
		AssociationVector< KeyRefProd, CVal, KeyRef, SizeType, KeyReferenceHelper > &	b
	)

inline

Definition at line 224 of file AssociationVector.h.

References edm::AssociationVector< KeyRefProd, CVal, KeyRef, SizeType, KeyReferenceHelper >::swap().

                                                                                          {
     a.swap(b);
   }

template<typename ID , typename C , typename P >

void edm::swap	(	RangeMap< ID, C, P > &	a,
		RangeMap< ID, C, P > &	b
	)

inline

Definition at line 226 of file RangeMap.h.

References edm::RangeMap< ID, C, P >::swap().

                                                        {
     a.swap(b);
   }

template<typename C >

void edm::swap	(	edm::RefProd< C > const &	lhs,
		edm::RefProd< C > const &	rhs
	)

inline

Definition at line 241 of file RefProd.h.

References edm::RefProd< T >::swap().

                                                                  {
     lhs.swap(rhs);
   }

template<typename T >

void edm::swap	(	Vector< T > &	a,
		Vector< T > &	b
	)

inline

Definition at line 244 of file Vector.h.

References edm::Vector< T >::swap().

                                                {
     a.swap(b);
   }

template<typename T >

void edm::swap	(	ValueMap< T > &	lhs,
		ValueMap< T > &	rhs
	)

inline

Definition at line 251 of file ValueMap.h.

References edm::ValueMap< T >::swap().

                                                 {
     lhs.swap(rhs);
   }

template<class T >

void edm::swap	(	DetSetLazyVector< T > &	a,
		DetSetLazyVector< T > &	b
	)

inline

Definition at line 258 of file DetSetLazyVector.h.

   {
     a.swap(b);
   }

void edm::swap	(	ScheduledGroup &	a,
		ScheduledGroup &	b
	)

inline

Definition at line 278 of file Group.h.

References edm::Group::swap().

                                                          {
     a.swap(b);
   }

template<typename T , typename C >

void edm::swap	(	DetSetRefVector< T, C > &	a,
		DetSetRefVector< T, C > &	b
	)

inline

Definition at line 282 of file DetSetRefVector.h.

                                                            {
     a.swap(b);
   }

template<typename C >

void edm::swap	(	MultiAssociation< C > &	lhs,
		MultiAssociation< C > &	rhs
	)

inline

Definition at line 292 of file MultiAssociation.h.

292 { lhs.swap(rhs); }

void edm::swap	(	ParameterSet &	a,
		ParameterSet &	b
	)

inline

Definition at line 301 of file ParameterSet.h.

References edm::ParameterSet::swap().

                                                {
     a.swap(b);
   }

void edm::swap	(	UnscheduledGroup &	a,
		UnscheduledGroup &	b
	)

inline

Definition at line 303 of file Group.h.

References edm::Group::swap().

                                                              {
     a.swap(b);
   }

void edm::swap	(	SourceGroup &	a,
		SourceGroup &	b
	)

inline

Definition at line 328 of file Group.h.

References edm::Group::swap().

                                                    {
     a.swap(b);
   }

template<class T >

void edm::swap	(	RefToBase< T > &	a,
		RefToBase< T > &	b
	)

inline

Definition at line 354 of file RefToBase.h.

References edm::RefToBase< T >::swap().

   {
     a.swap(b);
   }

template<typename T , typename SORT >

void edm::swap	(	SortedCollection< T, SORT > &	a,
		SortedCollection< T, SORT > &	b
	)

inline

Definition at line 395 of file SortedCollection.h.

                                                                    {
     a.swap(b);
   }

template<class T >

void edm::swap	(	DetSetVector< T > &	a,
		DetSetVector< T > &	b
	)

inline

Definition at line 434 of file DetSetVector.h.

   {
     a.swap(b);
   }

template<typename T >

void edm::swap	(	View< T > &	lhs,
		View< T > &	rhs
	)

inline

Definition at line 436 of file View.h.

                                         {
     lhs.swap(rhs);
   }

template<typename T , typename P >

void edm::swap	(	OwnVector< T, P > &	a,
		OwnVector< T, P > &	b
	)

inline

Definition at line 466 of file OwnVector.h.

References edm::OwnVector< T, P >::swap().

                                                            {
     a.swap(b);
   }

template<class T >

void edm::swap	(	LazyGetter< T > &	a,
		LazyGetter< T > &	b
	)

inline

Definition at line 506 of file LazyGetter.h.

References edm::LazyGetter< T >::swap().

     {
       a.swap(b);
     }

void edm::throwExceptionWithText ( char const * txt )

Definition at line 211 of file BranchDescription.cc.

References edm::errors::LogicError.

Referenced by edm::BranchDescription::throwIfInvalid_().

                                                {
     Exception e(errors::LogicError);
     e << "Problem using an incomplete BranchDescription\n"
       << txt
       << "\nPlease report this error to the FWCore developers";
     throw e;
   }

std::vector< std::string > edm::tokenize	(	std::string const &	input,
		std::string const &	separator
	)

breaks the input string into tokens, delimited by the separator

Definition at line 57 of file Parse.cc.

References copy_all(), query::result, and EcalElecEmulTccFlatFileProducerFromTPG_cfg::tokens.

Referenced by MomentumDependentPedeLabeler::buildMomentumDependencyMap(), RunRangeDependentPedeLabeler::buildRunRangeDependencyMap(), decode(), editESInputTag(), editInputTag(), editVInputTag(), edm::ESInputTag::ESInputTag(), edm::FileInPath::initialize_(), edm::InputTag::InputTag(), AlignmentProducer::makeNonOverlappingRunRanges(), and PasswordReader::readPassword().

                                                                   {
       typedef boost::char_separator<char>   separator_t;
       typedef boost::tokenizer<separator_t> tokenizer_t;
 
       std::vector<std::string> result;
       separator_t  sep(separator.c_str(), "", boost::keep_empty_tokens); // separator for elements in path
       tokenizer_t  tokens(input, sep);
       copy_all(tokens, std::back_inserter<std::vector<std::string> >(result));
       return result;
     }

template<typename T >

boost::python::list edm::toPythonList ( const std::vector< T > & v )

Definition at line 16 of file PythonWrapper.h.

References i, list(), and query::result.

Referenced by PythonParameterSet::getParameters().

                                                        {
     boost::python::list result;
     for(unsigned i = 0; i < v.size(); ++i) {
        result.append(v[i]);
     }
     return result;
   }

template<typename T >

std::vector<T> edm::toVector ( boost::python::list & l )

Definition at line 28 of file PythonWrapper.h.

References i, n, VarParsing::obj, dbtoconf::object, and query::result.

   {
     std::vector<T> result;
     unsigned n = PyList_Size(l.ptr());
     boost::python::object iter_obj(boost::python::handle<>(PyObject_GetIter(l.ptr())));
     for(unsigned i = 0; i < n; ++i)
     {
       boost::python::object obj = boost::python::extract<boost::python::object>(iter_obj.attr("next")());
       result.push_back(boost::python::extract<T>(obj)); 
     }
     return result;
   }

void edm::typeDemangle	(	char const *	mangledName,
		std::string &	demangledName
	)

Definition at line 86 of file TypeDemangler.cc.

References edm::hlt::Exception, and ntuplemaker::status.

Referenced by edm::serviceregistry::ServicesManager::ServicesManager().

                                                            {
     int status = 0;
     size_t* const nullSize = 0;
     char* const null = 0;
     demangledName += abi::__cxa_demangle(name, null, nullSize, &status);
     if (status != 0) {
       throw cms::Exception("Demangling error") << " '" << name << "'\n";
     } 
     // We must use the same conventions used by REFLEX.
     noSpaceAfterComma(demangledName);
     // Strip default allocator
     std::string const allocator(",std::allocator<");
     removeParameter(demangledName, allocator);
     // Strip default comparator
     std::string const comparator(",std::less<");
     removeParameter(demangledName, comparator);
     // Put const qualifier before identifier.
     constBeforeIdentifier(demangledName);
   }

bool edm::value_type_of	(	Reflex::Type const &	t,
		Reflex::Type &	found_type
	)

inline

Definition at line 31 of file ReflexTools.h.

References find_nested_type_named().

Referenced by edm::ProductRegistry::initializeLookupTables().

                                                              {
     return find_nested_type_named("value_type", t, found_type);
   }

template<typename V , typename T >

void edm::walkTrie	(	V &	v,
		TrieNode< T > const &	n,
		std::string const &	label = `""`
	)

visit each node of the trie

Definition at line 284 of file Trie.h.

References label, L1TEmulatorMonitor_cff::p, and v.

                                                                             {
     typedef TrieNode<T> const node_base;
     typedef TrieNodeIter<T> node_iterator;
     node_iterator e;
     for (node_iterator p(&n); p!=e; ++p) {
       v((*p).value(),label+(char)p.label());
       walkTrie(v,*p,label+(char)p.label());
     }
   }

std::string edm::withoutQuotes ( std::string const & from )

Definition at line 36 of file Parse.cc.

References Capri::details::from(), and query::result.

                                                    {
       std::string result = from;
       if(!result.empty()) {
       // get rid of leading quotes
         if(result[0] == '"' || result[0] == '\'') {
           result.erase(0,1);
         }
       }
 
       if(!result.empty()) {
        // and trailing quotes
         int lastpos = result.size()-1;
         if(result[lastpos] == '"' || result[lastpos] == '\'') {
           result.erase(lastpos, 1);
         }
       }
      return result;
     }

std::string edm::wrappedClassName ( std::string const & iFullName )

Definition at line 5 of file WrappedClassName.cc.

References className().

Referenced by edm::StreamerInputSource::buildClassCache(), stor::HLTInfo::buildClassCache(), BareRootProductGetter::createNewBuffer(), edm::StreamerInputSource::declareStreamers(), stor::HLTInfo::declareStreamers(), fwlite::DataGetterHelper::getByProductID(), edm::root::FWLiteDelayedReader::getProduct_(), edm::BranchDescription::initFromDictionary(), and edm::Event::put().

                                                {
     std::string const wrapperBegin("edm::Wrapper<");
     std::string const wrapperEnd1(">");
     std::string const wrapperEnd2(" >");
     std::string const& wrapperEnd = (className[className.size()-1] == '>' ? wrapperEnd2 : wrapperEnd1);
     std::string wrapped;
     wrapped.reserve(wrapperBegin.size() + className.size() + wrapperEnd.size());
     wrapped += wrapperBegin;
     wrapped += className;
     wrapped += wrapperEnd;
     return wrapped;
   }

bool edm::wrapper_type_of	(	Reflex::Type const &	possible_wrapper,
		Reflex::Type &	found_wrapped_type
	)

inline

Definition at line 38 of file ReflexTools.h.

References find_nested_type_named().

                                           {
     return find_nested_type_named("wrapped_type",
                   possible_wrapper,
                   found_wrapped_type);
   }

Variable Documentation

debugvalue edm::debugit

Definition at line 13 of file DebugMacros.cc.

Referenced by edm::ActionTable::addDefaults(), edm::RootDebug::RootDebug(), and edm::RootDebug::~RootDebug().

LogDebug_ edm::dummyLogDebugObject_

LogTrace_ edm::dummyLogTraceObject_

ELslProxy< ELabortGen > const edm::ELabort

Definition at line 402 of file ELseverityLevel.cc.

Referenced by loadMap().

ELslGen edm::ELabortGen

ELslProxy< ELerrorGen > const edm::ELerror

Definition at line 366 of file ELseverityLevel.cc.

Referenced by loadMap(), and LoggedErrorsOnlySummary().

ELslProxy< ELerror2Gen > const edm::ELerror2

Definition at line 372 of file ELseverityLevel.cc.

Referenced by edm::service::ELrecv(), and loadMap().

ELslGen edm::ELerror2Gen

ELslGen edm::ELerrorGen

ELslProxy< ELfatalGen > const edm::ELfatal

Definition at line 408 of file ELseverityLevel.cc.

Referenced by loadMap(), and edm::ErrorObj::setSeverity().

ELslGen edm::ELfatalGen

ELslProxy< ELhighestSeverityGen > const edm::ELhighestSeverity

Definition at line 414 of file ELseverityLevel.cc.

Referenced by edm::service::MessageLoggerScribe::configure_ordinary_destinations(), edm::service::ELtsErrorLog::dispatch(), loadMap(), edm::service::ELadministrator::resetSeverityCount(), and edm::ErrorObj::setSeverity().

ELslGen edm::ELhighestSeverityGen

ELslProxy< ELincidentalGen > const edm::ELincidental

Definition at line 336 of file ELseverityLevel.cc.

Referenced by loadMap(), and edm::ErrorObj::setSeverity().

ELslGen edm::ELincidentalGen

ELslProxy< ELinfoGen > const edm::ELinfo

Definition at line 348 of file ELseverityLevel.cc.

Referenced by loadMap().

ELslGen edm::ELinfoGen

ELslProxy< ELnextEventGen > const edm::ELnextEvent

Definition at line 378 of file ELseverityLevel.cc.

Referenced by loadMap().

ELslGen edm::ELnextEventGen

ELslProxy< ELsevereGen > const edm::ELsevere

Definition at line 390 of file ELseverityLevel.cc.

Referenced by loadMap(), and edm::service::ELoutput::log().

ELslProxy< ELsevere2Gen > const edm::ELsevere2

Definition at line 396 of file ELseverityLevel.cc.

Referenced by loadMap().

ELslGen edm::ELsevere2Gen

ELslGen edm::ELsevereGen

ELslProxy< ELsuccessGen > const edm::ELsuccess

Definition at line 342 of file ELseverityLevel.cc.

Referenced by loadMap(), and edm::service::ELoutput::log().

ELslGen edm::ELsuccessGen

ELslProxy< ELunspecifiedGen > const edm::ELunspecified

Definition at line 384 of file ELseverityLevel.cc.

Referenced by edm::ELextendedID::clear(), edm::service::ErrorLog::emitToken(), edm::service::ELtsErrorLog::item(), and loadMap().

ELslGen edm::ELunspecifiedGen

ELslProxy< ELwarningGen > const edm::ELwarning

Definition at line 354 of file ELseverityLevel.cc.

Referenced by loadMap(), and edm::MessageSender::~MessageSender().

ELslProxy< ELwarning2Gen > const edm::ELwarning2

Definition at line 360 of file ELseverityLevel.cc.

Referenced by edm::service::ELdestination::changeFile(), edm::service::ELdestination::clearSummary(), edm::service::ELdestination::flush(), loadMap(), edm::service::ELdestination::summarization(), and edm::service::ELdestination::summary().

ELslGen edm::ELwarning2Gen

ELslGen edm::ELwarningGen

ELslProxy< ELzeroSeverityGen > const edm::ELzeroSeverity

Definition at line 330 of file ELseverityLevel.cc.

Referenced by edm::service::ELadministrator::checkSeverity(), edm::service::MessageLoggerScribe::configure_ordinary_destinations(), loadMap(), edm::service::ELadministrator::resetSeverityCount(), and edm::ErrorObj::setSeverity().

ELslGen edm::ELzeroSeverityGen

char const* edm::fmt_Guid

static

Initial value:

=

"%08lX-%04hX-%04hX-%02hhX%02hhX-%02hhX%02hhX%02hhX%02hhX%02hhX%02hhX"

Definition at line 18 of file Guid.cc.

Referenced by edm::Guid::fromString(), and edm::Guid::toString().

MallocOptionSetter edm::global_malloc_options

Definition at line 215 of file MallocOpts.cc.

Referenced by getGlobalOptionSetter().

const int edm::init_size = 1024*1024

Definition at line 21 of file StreamDQMSerializer.cc.

unsigned int const edm::kAveEventPerSec = 200U

static

Definition at line 18 of file ConfigurableInputSource.cc.

Referenced by edm::ConfigurableInputSource::fillDescription().

unsigned int const edm::kNanoSecPerSec = 1000000000U

static

Definition at line 17 of file ConfigurableInputSource.cc.

Referenced by edm::ConfigurableInputSource::fillDescription().

const unsigned char edm::MLSCRIBE_RUNNING_INDICATOR = 29

static

Definition at line 116 of file MessageDrop.h.

Referenced by FlushMessageLog(), isMessageProcessingSetUp(), edm::service::MessageLoggerScribe::run(), run_app(), and edm::service::SingleThreadMSPresence::SingleThreadMSPresence().

TriggerNamesMap::const_iterator edm::previousTriggerName

static

Definition at line 31 of file EventBase.cc.

Referenced by edm::EventBase::triggerNames_().

EDProductGetter const* edm::s_productGetter =0

static

Definition at line 84 of file EDProductGetter.cc.

Referenced by edm::EDProductGetter::assignEDProductGetter(), and edm::EDProductGetter::switchProductGetter().

unsigned int const edm::shift = 8 * sizeof(unsigned int)

static

Definition at line 9 of file LuminosityBlockID.cc.

Referenced by HcalTriggerPrimitiveAlgo::analyze(), L1TCSCTF::analyze(), EcalTPGParamBuilder::analyze(), HcalTriggerPrimitiveAlgo::analyzeHF(), RigidBodyAlignmentParameters::apply(), BeamSpotAlignmentParameters::apply(), TwoBowedSurfacesAlignmentParameters::apply(), KalmanAlignmentAlgorithm::applyAlignmentParameters(), MuScleFitUtils::applyScale(), CSCTFTrackBuilder::buildTracks(), TOBLayer::calculatePhiWindow(), PixelBarrelLayer::calculatePhiWindow(), SiStripMonitorMuonHLT::createMEs(), DEutils< T >::DEDigi(), OptOSensor2D::fastTraversesLightRay(), OptOPlateSplitter::fastTraversesLightRay(), OptOMirror::fastTraversesLightRay(), RPCTBMuon::PACOut::fromBits(), RPCTBMuon::TBOut::fromBits(), RPCTBMuon::TCOut::fromBits(), RPCTBMuon::HSBOut::fromBits(), RPCTBMuon::FSBOut::fromBits(), OptOModifiedRhomboidPrism::getRotatedPlate(), HcalNumberingFromDDD::getShift(), cond::EcalDQMChannelStatusHelper::getValues(), cond::EcalDQMTowerStatusHelper::getValues(), cond::EcalTPGCrystalStatusHelper::getValues(), cond::EcalDCSTowerStatusHelper::getValues(), RigidBodyAlignmentParameters::globalParameters(), BeamSpotAlignmentParameters::globalParameters(), HcalNumberingFromDDD::HcalCellTypes(), PixelTripletNoTipGenerator::hitTriplets(), L1MuDTPtaLut::load(), HcalTTPDigiProducer::produce(), DistortedMuonProducerFromDB::produce(), CSCTFSectorProcessor::run(), CSCTFSPCoreLogic::run(), BackgroundHandler::setParameters(), DTTracoChip::storeCorr(), DTTracoChip::storeUncorr(), RPCTBMuon::PACOut::toBits(), RPCTBMuon::TBOut::toBits(), RPCTBMuon::TCOut::toBits(), RPCTBMuon::HSBOut::toBits(), RPCTBMuon::FSBOut::toBits(), RigidBodyAlignmentParameters::translation(), BeamSpotAlignmentParameters::translation(), DCCEEEventBlock::unpack(), CSCTFEvent::unpack(), DCCEBEventBlock::unpack(), LatencyHistosUsingDb::update(), edm::LuminosityBlockID::value(), and CastorCORData::wasMarkAndPassZS().

volatile bool edm::shutdown_flag = false

Definition at line 24 of file UnixSignalHandlers.cc.

Referenced by ep_sigusr2(), edm::EventProcessor::forkProcess(), stor::EventServerProxy< RegInfo >::getInitMsg(), edm::EventProcessor::runCommon(), smproxy::DataManager::start(), and smproxy::DataManager::stop().

boost::mutex edm::signum_lock

Definition at line 36 of file UnixSignalHandlers.cc.

Referenced by getSigNum().

volatile int edm::signum_value

Initial value:

= 
    0

Definition at line 37 of file UnixSignalHandlers.cc.

Referenced by getSigNum().

pset::TypeTrans const edm::sTypeTranslations

static

Definition at line 77 of file Entry.cc.

Referenced by edm::Entry::Entry(), operator<<(), and edm::Entry::throwValueError().

TransEntry edm::table[]

Definition at line 190 of file EventProcessor.cc.

Referenced by edm::EventProcessor::changeState().

TriggerNamesMap edm::triggerNamesMap

static

Definition at line 30 of file EventBase.cc.

Referenced by edm::EventBase::triggerNames_().

boost::mutex edm::usr2_lock

Definition at line 20 of file UnixSignalHandlers.cc.

Referenced by edm::EventProcessor::runCommon().

Namespaces
	actions

	clonehelper

	daqsource

	detail

	details

	detailsTrie

	dslv

	dslvdetail

	dsrvdetail

	edmmltest

	errors

	es

	event_processor

	eventsetup

	evtSel

	extensioncord

	fillDetails

	friendlyname

	handleimpl

	hash_detail

	helper

	helpers

	hlt

	lazydetail

	math_private

	messagedrop

	multicore

	pdtentry

	poolNames

	principal_get_adapter_detail

	productstatus

	pset

	python

	rec_dep

	refcore

	refhelper

	refitem

	reftobase

	root

	rootfix

	roottree

	service

	serviceregistry

	test

	typelookup

	writeParameterValue

Namespaces

Classes

Typedefs

Enumerations

Functions

Variables

Detailed Description

-------------------------------------------------------------------—

Typedef Documentation

Enumeration Type Documentation

Function Documentation

Variable Documentation