edm Namespace Reference

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

Classes

class ActionTable

struct ActivityRegistry

class AlpgenInfoProduct

class AlpgenProducer

class AlpgenSource

class AlpWgtFileInfoProduct

class AndHelper

class ArbitraryType

class AsciiOutputModule

class AssertHandler

class Association

class AssociationMap

one-to-many or one-to-one associative map using EDM references More...

class AssociationVector

class AssociativeIterator

class BaseFlatGunSource

class BasicHandle

class BeamHaloSource

class BMixingModule

class BoolCache

class BoolCacheStreamer

class BranchChildren

struct BranchDescription

struct BranchEntryDescription

class BranchID

struct BranchKey

class BranchMapper

class BranchMapperWithReader

struct ClonePolicy

class CloningPtr

class CodedException

class Compare_Run_Lumi_EventEntry

struct CompareRefDetSet

class ComphepProducer

class ComphepSource

class ComposedSelectorWrapper

class ConfigurableInputSource

struct ConfigurationHandshake

class ConstBranchDescription

class ConstProductRegistry

class ConstPtrCache

class ConstPtrCacheStreamer

struct CopyPolicy

class CosMuoGenSource

class CountAndLimit

class CPUTimer

class CurrentProcessingContext

class CustomStreamer

class DaqSource

class DataFrame

class DataFrameContainer

an optitimized container that linearized a "vector of vector". More...

class DataMixingEMWorker

class DataMixingHcalWorker

class DataMixingModule

class DataMixingMuonWorker

class DataMixingSiPixelWorker

class DataMixingSiStripWorker

class DataViewImpl

class debugging_allocator

struct debugvalue

class DelayedReader

struct deleter

struct DetSet

class DetSetLazyVector

class DetSetRefVector

class DetSetVector

struct DoAssign

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

class Entry

class EntryDescription

class ErrorObj

struct ErrorSummaryEntry

class ESHandle

class ESOutlet

class ESProducer

class ESProducerLooper

struct ESProducts

class ESProxyFactoryProducer

class ESWatcher

class Event

struct EventAux

struct EventAuxiliary

class EventAuxiliaryHistoryProducer

class EventBuffer

class EventEntryDescription

class EventEntryInfo

class EventExtractor

class EventID

class EventMsg

class EventOutputService

class EventPrincipal

struct EventProcessHistoryID

class EventProcessor

class EventSelector

class EventSetup

class EventSetupRecordDataGetter

class EventSetupRecordIntervalFinder

class EventStreamHttpReader

class EventStreamService

struct EventSummary

class EventTime

class ExceptionCollector

class ExhumeSource

class ExpoRandomPtGunSource

class ExtensionCord

class ExternalInputSource

class Factory

class FileBlock

class FileCatalog

class FileCatalogItem

struct FileFormatVersion

class FileID

class FileIndex

class FileInPath

class FileRecord

struct FindRegion

struct FindValue

class FixedPUGenerator

class FlatEGunASCIIWriter

class FlatRandomEGunSource

class FlatRandomPtGunSource

class FRDOutputService

class FRDStreamService

class FUShmOutputModule

class GeneratedInputSource

struct GenericObject

This class is just a 'tag' used to allow a specialization of edm::Handle. More...

class GenericObjectOwner

class GenHIEvent

class GenInfoProduct

class Group

class GroupSelector

class GroupSelectorRules

class Guid

Description:. More...

class H2RootNtplSource

class Handle

class Handle< GenericObject >

struct has_fillView

struct has_fillView< edm::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< 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 template has_match. More...

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

class Herwig6Producer

class Herwig6Source

class History

class HLTGlobalStatus

The HLT global status, summarising the status of the individual HLT triggers, is implemented as a vector of HLTPathStatus objects. More...

class HLTPathStatus

The status of a single HLT trigger (single trigger path consisting of modules on the path). More...

class HydjetProducer

class HydjetSource

class IDVectorMap

class IEventProcessor

class InitMsg

class InputFileCatalog

class InputSource

struct InputSourceDescription

class InputSourceFactory

class InputTag

class InputTagSelector

class IOVSyncValue

struct IsMergeable

struct IsNotMergeable

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 LogImportant

class LogInfo

class LogPrint

class LogProblem

class LogSystem

class LogTrace_

class LogVerbatim

class LogWarning

class LumiKey

class LuminosityBlock

struct LuminosityBlockAux

struct LuminosityBlockAuxiliary

class LuminosityBlockID

class LuminosityBlockPrincipal

class MadGraphProducer

class MadGraphSource

class Maker

class MallocOptionSetter

struct MallocOpts

class MapOfVectors

class MatchAllSelector

Class MatchAllSelector. More...

class MCatNLOProducer

class MCatNLOSource

class MCFileSource

struct MessageDrop

class MessageLoggerQ

class MessageSender

class MixingModule

class MixingWorker

class MixingWorkerBase

struct ModuleDescription

struct ModuleInPathSummary

class ModuleLabelSelector

Class ModuleLabelSelector. More...

class ModuleTime

class MsgCode

class MultiAssociation

class MultiParticleInConeGunSource

struct NewPolicy

class NoDelayedReader

class NotHelper

class OccurrenceTraits< EventPrincipal, BranchActionBegin >

class OccurrenceTraits< LuminosityBlockPrincipal, BranchActionBegin >

class OccurrenceTraits< LuminosityBlockPrincipal, BranchActionEnd >

class OccurrenceTraits< RunPrincipal, BranchActionBegin >

class OccurrenceTraits< RunPrincipal, BranchActionEnd >

class OneToMany

class OneToManyWithQuality

class OneToManyWithQualityGeneric

class OneToOne

class OneToOneGeneric

class OneToValue

class OnlineHttpReader

class OrHelper

class OrphanHandle

class OrphanHandle< GenericObjectOwner >

struct Other

class OutletBase

class OutputHandle

class OutputModule

struct OutputModuleDescription

class OutputService

class OutputWorker

class OwnVector

class ParameterDescription

class ParameterDescriptionTemplate

class ParameterSet

struct ParameterSetBlob

class ParameterSetDescription

class ParameterSetDescriptionFiller

class ParameterSetDescriptionFillerBase

struct ParameterTypeToEnum

class Path

struct PathSummary

class PileUp

class PoissonPUGenerator

class PomwigProducer

class PomwigSource

struct PoolCatalog

class PoolOutputModule

class PoolSource

class Prescaler

class Presence

class PresenceFactory

class Principal

class PrincipalCache

class ProblemTracker

struct ProcessConfiguration

class ProcessDesc

class ProcessHistory

class ProcessNameSelector

Class ProcessNameSelector. More...

class ProcessOneOccurrence

class ProducerBase

struct ProductID

class ProductInstanceNameSelector

Class ProductInstanceNameSelector. More...

class ProductRegistry

author Stefano ARGIRO author Bill Tanenbaum More...

class ProductRegistryHelper

class Provenance

class ProvenanceCheckerOutputModule

class Ptr

Description: Persistent 'pointer' to an item in a collection where the collection is in the edm::Event. More...

class PtrHolder

class PtrVector

class PtrVectorBase

class PtrVectorItr

class PtYDistributor

class PUGenerator

class PyquenProducer

class PyquenSource

class Pythia8Source

class PythiaMuEnrichSource

class PythiaProducer

class PythiaSource

class RandomFilter

class RandomNumberGenerator

class RangeMap

class RawInputSource

struct RecordInParentfull

struct RecordInParentless

class Ref

class RefBase

class RefCore

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 RootHandlers

class RootInputFileSequence

class RootOutputFile

class RootOutputTree

class RootServiceChecker

class RootTree

class Run

struct RunAux

struct RunAuxiliary

class RunID

class RunLumiEntryInfo

class RunPrincipal

class RunStopwatch

class Schedule

class ScheduleValidator

Incapsulates the machinery to validate a schedule. More...

class Selector

class SelectorBase

class SendEvent

class SendJobHeader

class Service

class ServiceManager

class ServiceRegistry

class ServiceToken

class SherpaSource

class SignallingProductRegistry

class SimpleOutlet

class SingleConsumerQ

class SiteLocalConfig

class SortedCollection

class StatsCount

class STLesHouchesMixerSource

class StreamDQMDeserializer

class StreamDQMSerializer

class StreamedProduct

class StreamerFileReader

class StreamerFileWriter

class StreamerInputModule

class StreamerInputSource

class StreamerOutputModule

class StreamerOutputModuleBase

class StreamSerializer

class StreamService

struct StrictWeakOrdering

class SubEvent

class Suppress_LogDebug_

class TauolaInterface

class TestHandle

class TestMix

class Timestamp

class ToprexProducer

class ToprexSource

class TRandomAdaptor

struct TransEntry

class Transient

class TransientDataFrame

class TransientStreamer

class Trie

Implement a trie in memory with the smallest structure as possible (use few RAM as possible). More...

class TrieFactory

The goal of this class is to allocate Trie node by paquet of X element in order to reduce heap-admin size. More...

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 TriggerReport

class TriggerResultInserter

class TriggerResults

Original Authors: Jim Kowalkowski 13-01-06 Martin Grunewald
Id
TriggerResults.h,v 1.12 2008/09/05 20:02:40 wdd Exp
. More...

class TypeID

class TypeIDBase

class UnknownModuleException

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

class UnscheduledCallProducer

class UnscheduledHandler

class UpdateGetterAdapter

class ValidityInterval

class value_ptr

struct value_ptr_traits

class ValueHolderECGetter

class ValueMap

class Vector

class VectorInputSource

class VectorInputSourceFactory

class View

Class template View<T>. More...

class ViewBase

class Worker

class WorkerInPath

class WorkerMaker

struct WorkerParams

class WorkerRegistry

struct WorkerSummary

class WorkerT

class Wrapper

class XMLOutputModule

Namespaces

namespace actions

namespace clonehelper

namespace daqsource

namespace detail

namespace details

namespace detailsTrie

namespace dslv

namespace dslvdetail

namespace dsrvdetail

namespace errors

namespace es

namespace event_processor

namespace eventsetup

namespace evtSel

namespace extensioncord

namespace friendlyname

namespace helper

namespace helpers

namespace hlt

namespace input

namespace lazydetail

namespace math_private

namespace poolNames

namespace productstatus

namespace pset

namespace python

namespace refcore

namespace refhelper

namespace refitem

namespace reftobase

namespace root

namespace rootfix

namespace service

namespace serviceregistry

namespace test

Typedefs

typedef Handle< ArbitraryType > ArbitraryHandle

typedef Wrapper< ArbitraryType > ArbitraryWrapper

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 std::pair< std::string,
std::string > ErrorSummaryMapKey

typedef std::vector
< EventEntryInfo > EventEntryInfoVector

typedef unsigned int EventNumber_t

typedef ParameterSetID EventSelectionID

typedef std::vector
< EventSelectionID > EventSelectionIDVector

typedef edm::CodedException
< edm::errors::ErrorCodes > Exception

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

typedef unsigned int LuminosityBlockNumber_t

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

typedef Hash
< ModuleDescriptionType > ModuleDescriptionID

typedef
ModuleDescriptionRegistry::collection_type ModuleDescriptionMap

typedef
edm::detail::ThreadSafeRegistry
< edm::ModuleDescriptionID,
edm::ModuleDescription > ModuleDescriptionRegistry

typedef std::map
< boost::shared_ptr
< FileRecord >,
boost::shared_ptr
< OutputService > > OutputMap

typedef std::map
< boost::shared_ptr
< FileRecord >,
boost::shared_ptr
< OutputService > >::iterator OutputMapIterator

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

typedef Hash< ParameterSetType > ParameterSetID

typedef std::string PassID

typedef std::vector< PCaloHit > PCaloHitContainer

typedef
Pointer_to_new_exception_on_heap * Place_for_passing_exception_ptr

typedef 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 Hash< ProcessHistoryType > ProcessHistoryID

typedef
ProcessHistoryRegistry::collection_type ProcessHistoryMap

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

typedef std::string ProcessingTask

typedef byte_t ProductStatus

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::vector
< boost::shared_ptr
< StreamService > > Streams

typedef std::vector
< boost::shared_ptr
< StreamService > >::iterator StreamsIterator

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

typedef unsigned long long TimeValue_t

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

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

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

typedef
edmplugin::PluginFactory
< ISVecFunc > VectorInputSourcePluginFactory

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

typedef boost::shared_ptr
< pset::WrapperNode > WrapperNodePtr

Enumerations

enum BranchActionType { BranchActionBegin = 0, BranchActionEnd = 1 }

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

enum HashedTypes {
 ModuleDescriptionType, ParameterSetType, ProcessHistoryType, ProcessConfigurationType,
 EntryDescriptionType
}

enum JobMode { GridJobMode, ReleaseValidationJobMode, AnalysisJobMode, NilJobMode }

enum ParameterTypes {
 k_uint32, k_vuint32, k_int32, k_vint32,
 k_uint64, k_vuint64, k_int64, k_vint64,
 k_string, k_vstring, k_bool, k_vbool,
 k_double, k_vdouble, k_PSet, k_VPSet,
 k_FileInPath, k_InputTag, k_VInputTag, k_EventID,
 k_VEventID, k_LuminosityBlockID, k_VLuminosityBlockID, k_numParameterTypes
}

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

Functions

static void addWrapperOfVectorOfBuiltin (std::map< std::string, std::string > &iMap, const char *iBuiltin)

static int ALL_AutoLoadCallback (char *c, char *l)

template<class FP>

bool asm_isnan (FP x)

template<typename ForwardSequence, typename Datum>

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

wrapper for std::binary_search

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)

void checkAllDictionaries ()

void checkConsistency (RunPrincipal const &primary, RunPrincipal const &secondary)

void checkConsistency (LuminosityBlockPrincipal const &primary, LuminosityBlockPrincipal const &secondary)

void checkConsistency (EventPrincipal const &primary, EventPrincipal const &secondary)

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

void checkDicts (BranchDescription const &productDesc)

void checkHistoryConsistency (Principal const &primary, Principal const &secondary)

void checkType (Type t, bool noComponents=false)

static std::map< std::string,
std::string > & cintToReflexSpecialCasesMap ()

static std::string classNameForRoot (const std::string &iCapName)

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

static const Guid clid_null (std::string("00000000-0000-0000-0000-000000000000"))

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

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 (RunAux const &from, RunAuxiliary &to)

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

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

template<>

void convert_handle (const BasicHandle &basic, ArbitraryHandle &result)

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

specialize this function for GenericHandle

template<class T>

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

template<typename ForwardSequence, typename Func>

Func copy_all (ForwardSequence &s, Func f)

wrappers for copy

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

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

std::string createGlobalIdentifier ()

template<typename T>

boost::shared_ptr< T > createSharedPtrToStatic (T *ptr)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

unsigned int decodeInt (unsigned char *v)

void disableAllSigs (sigset_t *oldset)

bool DisableLoggedErrorsSummary ()

void disableRTSigs ()

void disableSignal (sigset_t *newset, int signum)

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

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

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

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

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

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

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

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

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

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

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

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

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

bool encode (std::string &, double)

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

bool encode (std::string &, boost::uint64_t)

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

bool encode (std::string &, boost::int64_t)

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

bool encode (std::string &, unsigned)

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

bool encode (std::string &, bool)

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)

template<typename T>

cms::Exception & exceptionContext (ModuleDescription const &iMD, T const &ip, cms::Exception &iEx)

template<class FROM, class TO, class FUNC>

void fill_summary (FROM const &from, TO &to, FUNC func)

void fillEventSetupProvider (edm::eventsetup::EventSetupProvider &cp, ParameterSet const &params, EventProcessor::CommonParams const &common)

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

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

void fillModuleInPathSummary (Path const &, ModuleInPathSummary &)

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

template<class T, class SORT>

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

template<class T, class A, class Comp>

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

template<class T, class A>

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

template<class T, class A>

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

template<class T, class A>

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

template<typename T>

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

template<class T, class SORT>

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

template<typename C, typename T, typename F>

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

template<typename T>

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

template<typename T, typename P>

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

template<class T, class A, class Comp>

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

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

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::vector< T, A > const &obj, ProductID const &id, std::vector< void const * > &ptrs, helper_vector &helpers)

template<class T>

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

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

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

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

template<typename ForwardSequence, typename Datum>

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

template<typename ForwardSequence, typename Datum>

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

wrappers for std::find

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

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

template<class T, class U>

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

void FlushMessageLog ()

template<typename ForwardSequence, typename Func>

Func for_all (ForwardSequence &s, Func f)

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

template<typename S, typename T>

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

static char * formatTime (const time_t t)

bool FreshErrorsExist ()

cpu_type get_cpu_type ()

Type get_final_type (Type t)

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

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

TBranch * getAuxiliaryBranch (TTree *tree, BranchType const &branchType)

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)

TBranch * getEventEntryInfoBranch (TTree *tree, BranchType const &branchType)

int getFileFormatVersion ()

MallocOptionSetter & getGlobalOptionSetter ()

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

ParameterSet getParameterSet (ParameterSetID const &id)

std::string getPassID ()

ParameterSet getProcessParameterSet ()

template<typename T>

T const * getProduct (RefCore const &ref)

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

T const * getPtr (RefCore const &product, RefItem< KEY > const &item)

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

T const * getPtr_ (RefCore const &product, RefItem< KEY > const &item)

template<typename C>

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

ROOT::Reflex::Type const getReflectClass (std::type_info const &ti)

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

std::string getReleaseVersion ()

TClass * getRootClass (std::string const &name)

int getSigNum ()

TBranch * getStatusBranch (TTree *tree, BranchType const &branchType)

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

template<class T>

TClass * getTClassFor ()

void GroupLogStatistics (std::string const &category)

void HaltMessageLogging ()

bool hasCintDictionary (std::string const &name)

HRTimeType hrRealTime ()

bool if_edm_ref_get_value_type (Type const &possible_ref, Type &result)

bool if_edm_ref_get_value_type (ROOT::Reflex::Type const &possible_ref, ROOT::Reflex::Type &value_type)

bool if_edm_refToBase_get_value_type (Type const &possible_ref, Type &result)

bool if_edm_refToBase_get_value_type (ROOT::Reflex::Type const &possible_ref, ROOT::Reflex::Type &value_type)

void install (actions::ActionCodes code, ActionTable::ActionMap &out, const ParameterSet &pset)

void installCustomHandler (int signum, CFUNC func)

void installSig (int signum, CFUNC func)

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

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

bool is_sequence_wrapper (Type const &possible_sequence_wrapper, Type &found_sequence_value_type)

bool is_sequence_wrapper (ROOT::Reflex::Type const &possible_sequence_wrapper, ROOT::Reflex::Type &found_sequence_value_type)

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

bool isDebugEnabled ()

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

bool isInfoEnabled ()

bool isMessageProcessingSetUp ()

bool isnan (long double q)

bool isnan (double d)

bool isnan (float f)

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

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

bool isWarningEnabled ()

template<typename V, typename T>

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

visits only leaf nodes

static const TimeValue_t kLowMask (0xFFFFFFFF)

void loadCap (const std::string &name)

void loadExtraClasses ()

void loadextrastuff ()

static bool loadLibraryForClass (const char *classname)

static ELmap const & loadMap ()

std::vector< ErrorSummaryEntry > LoggedErrorsSummary ()

void LogStatistics ()

void longBranchPrint (TTree *tr)

template<typename ForwardSequence, typename Datum, typename Predicate>

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

template<typename ForwardSequence, typename Datum, typename Predicate>

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

template<typename ForwardSequence, typename Datum>

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

template<typename ForwardSequence, typename Datum>

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

wrappers for std::lower_bound

static std::auto_ptr
< eventsetup::EventSetupProvider > makeEventSetupProvider (ParameterSet const &params)

void makeFileAppender ()

shared_ptr< InputSource > makeInput (ParameterSet const &params, EventProcessor::CommonParams const &common, ProductRegistry &preg, boost::shared_ptr< ActivityRegistry > areg)

Schedule::WorkerPtr makeInserter (ParameterSet const &proc_pset, ParameterSet const &trig_pset, std::string const &proc_name, ProductRegistry &preg, ActionTable &actions, boost::shared_ptr< ActivityRegistry > areg, Schedule::TrigResPtr trptr)

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

essentially the same as the previous method

template<class HandleT>

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

template<class HandleT>

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

template<class HandleT>

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

template<class HandleT>

Ref< typename
HandleT::element_type,
typename
HandleT::element_type::value_type::value_type > makeRefToDetSetRefVector (const HandleT &iHandle, det_id_type iDetID, typename HandleT::element_type::value_type::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 > 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)

static void markAncestors (const EventEntryInfo &iInfo, const BranchMapper &iMapper, std::map< BranchID, bool > &oMap, std::set< BranchID > &oMapperMissing)

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)

const unsigned int maxIDlength (200)

StringSet & missingTypes ()

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

LuminosityBlock * newLumi (EventPrincipal &ep, ModuleDescription const &md)

Run * newRun (LuminosityBlockPrincipal &lbp, ModuleDescription const &md)

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

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

template<class A, class B>

boost::enable_if_c< has_match
< A >::value &&has_match
::value, AndHelper< A, B >
>::type operator && (A const &a, B const &b)

template<class A>

boost::enable_if_c< has_match
< A >::value, NotHelper< A >
>::type operator! (A const &a)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

template<typename T>

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

template<typename KEY>

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

Inequality operator.

template<typename C, typename T, typename F>

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

template<typename T>

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

template<typename C>

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

template<typename KEY>

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

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

template<typename KEY>

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

template<typename C, typename T, typename F>

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

template<typename T>

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

template<class X, class Y>

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

template<typename T>

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

template<typename C, typename T, typename F>

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

template<typename C>

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

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

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

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

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

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

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

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

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

template<typename T>

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

template<typename T>

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

template<typename C>

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

template<typename KEY>

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

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

template<typename KEY>

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

template<typename C, typename T, typename F>

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

template<typename T>

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

template<class T>

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

template<class T>

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

template<class T>

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

template<class T>

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

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

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

template<typename PROD>

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

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

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

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

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

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

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

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

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

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

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

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

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

template<int I>

std::ostream & operator<< (std::ostream &os, Hash const &h)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

template<typename C, typename T, typename F>

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

std::ostream & operator<< (std::ostream &ost, const HLTGlobalStatus &hlt)

Formatted printout of trigger tbale.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

template<typename T>

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

template<class T, class SORT>

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

template<class T, class SORT, class ALLOC>

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

template<typename KEY>

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

Equality operator.

template<typename C, typename T, typename F>

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

template<class T>

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

template<typename T>

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

template<typename C>

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

template<typename KEY>

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

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

template<typename KEY>

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

template<typename C, typename T, typename F>

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

template<typename T>

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

template<class X, class Y>

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

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

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)

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

template<typename T>

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

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

template<class A, class B>

boost::enable_if_c< has_match
< A >::value &&has_match
::value, OrHelper< A, B >
>::type operator|| (A const &a, B const &b)

template<>

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

template<>

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

template<>

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

template<>

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

template<>

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

template<>

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

template<>

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

template<>

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

template<>

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

template<>

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

template<>

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

template<>

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

template<>

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

template<>

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

template<>

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

template<>

std::vector< int > ParameterSet::getParameter< std::vector< int > > (std::string 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< unsigned int > ParameterSet::getParameter< std::vector< unsigned int > > (std::string const &name) const

template<>

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

template<>

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

template<>

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

template<>

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

template<>

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

template<>

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

template<>

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

template<>

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

template<>

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

template<>

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

template<>

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

template<>

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

template<>

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

template<>

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

template<>

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

template<>

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

template<>

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

template<>

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

template<>

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

template<>

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

template<>

std::vector< boost::uint64_t > ParameterSet::getUntrackedParameter< std::vector< boost::uint64_t > > (std::string const &name, std::vector< boost::uint64_t > 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 > > (std::string const &name, std::vector< double > const &defaultValue) const

template<>

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

template<>

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

template<>

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

template<>

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

template<>

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

template<>

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

template<>

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

template<>

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

template<>

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

template<>

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

template<>

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

template<>

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

template<>

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

template<>

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

template<>

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

template<>

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

std::string parameterTypeEnumToString (ParameterTypes)

bool partial_match (const boost::regex &regularExpression, const std::string &branchstring)

template<typename S>

S & print (S &os, JobReport::RunReport const &rep)

template<typename S>

S & print (S &os, JobReport::OutputFile const &f)

template<typename S>

S & print (S &os, JobReport::InputFile const &f)

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)

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

void public_base_classes (const ROOT::Reflex::Type &type, std::vector< ROOT::Reflex::Type > &baseTypes)

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

void pythonToCppException (const std::string &iType)

void read_from_cin (std::string &output)

std::string read_whole_file (std::string const &filename)

only does the yacc interpretation

boost::shared_ptr
< edm::ProcessDesc > readConfig (const std::string &config, int argc, char *argv[])

same, but with arguments

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

boost::shared_ptr
< edm::ProcessDesc > readConfigFile (const std::string &fileName)

std::auto_ptr< SendJobHeader > readHeaderFromStream (ifstream &ist)

std::auto_ptr< SendJobHeader > readHeaderFromStream (std::ifstream &ist)

void reenableSigs (sigset_t *oldset)

template<class T>

T const * reflex_cast (void *raw, ROOT::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.

void const * reflex_pointer_adjust (void *raw, Type const &dynamicType, std::type_info const &toType)

void const * reflex_pointer_adjust (void *raw, ROOT::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.

template<typename C>

Ptr< typename C::value_type > refToPtr (Ref< C, typename C::value_type, refhelper::FindUsingAdvance< C, typename C::value_type > > const &ref)

static void registerTypes ()

bool registryIsSubset (SendJobHeader const &sd, SendJobHeader const &ref)

bool registryIsSubset (SendJobHeader const &, ProductRegistry const &reg)

template<typename ForwardSequence, typename Datum>

bool search_all (ForwardSequence const &s, Datum const &d)

template<class T, class U>

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

void setCacheStreamers ()

template<typename T>

void SetCustomStreamer (T const &)

template<typename T>

void SetCustomStreamer ()

template<class T, class SORT>

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

template<class T, class A, class Comp>

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

template<class T, class A>

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

template<class T, class A>

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

template<class T, class A>

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

void setRefCoreStreamer (EDProductGetter const *ep)

void setRefCoreStreamer ()

template<typename T>

void SetTransientStreamer (T const &)

template<typename T>

void SetTransientStreamer ()

void setTransientStreamers ()

void sigInventory ()

template<typename RandomAccessSequence, typename Predicate>

void sort_all (RandomAccessSequence &s, Predicate p)

template<typename RandomAccessSequence>

void sort_all (RandomAccessSequence &s)

wrappers for std::sort

bool sorterForJobReportHash (BranchDescription const *lh, BranchDescription const *rh)

template<class OutIter>

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

template<typename RandomAccessSequence, typename Predicate>

void stable_sort_all (RandomAccessSequence &s, Predicate p)

template<typename RandomAccessSequence>

void stable_sort_all (RandomAccessSequence &s)

wrappers for std::stable_sort

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

std::string const & suffix (int count)

template<class T>

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

void swap (FileInPath &a, FileInPath &b)

void swap (Group &a, Group &b)

template<class T>

void swap (ESHandle< T > &a, ESHandle< T > &b)

void swap (ProcessHistory &a, ProcessHistory &b)

template<int I>

void swap (Hash &a, Hash &b)

template<typename T>

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

template<typename T>

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

template<typename T>

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

void swap (TriggerResults &lhs, TriggerResults &rhs)

template<class T>

void swap (TestHandle< T > &a, TestHandle< T > &b)

template<class T, class SORT>

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

template<typename KEY>

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

swap two vectors

template<typename C, typename T, typename F>

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

template<class T>

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

template<typename T>

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

template<class T>

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

template<typename C>

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

template<class T>

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

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

template<typename ID, typename C, typename P>

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

template<typename T>

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

template<typename T, typename P>

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

template<typename T>

void swap (OutputHandle< T > &a, OutputHandle< T > &b)

template<class T>

void swap (OrphanHandle< T > &a, OrphanHandle< T > &b)

template<typename C>

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

template<typename K, typename T>

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

template<class T>

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

template<typename ID, typename C, typename P>

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

void swap (HLTGlobalStatus &lhs, HLTGlobalStatus &rhs)

Free swap function.

template<class T>

void swap (Handle< T > &a, Handle< T > &b)

template<class T>

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

template<class T>

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

template<typename T, typename C>

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

template<class T>

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

template<class T>

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

void swap (DataFrameContainer &lhs, DataFrameContainer &rhs)

template<class T, class P>

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

void swap (BasicHandle &a, BasicHandle &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 C>

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

void throwExceptionWithText (const char *txt)

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

breaks the input string into tokens, delimited by the separator

template<typename T>

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

template<typename T>

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

template<class InputIterator, class ForwardIterator, class Func>

void transform_into (InputIterator begin, InputIterator end, ForwardIterator out, Func func)

static std::string typeToClassName (const std::type_info &iType)

bool value_type_of (ROOT::Reflex::Type const &t, ROOT::Reflex::Type &found_type)

template<typename V, typename T>

void walkTrie (V &v, TrieNode< T > const &n, std::string const &label="")

visit each node of the trie

std::string withoutQuotes (std::string const &from)

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

bool wrapper_type_of (ROOT::Reflex::Type const &possible_wrapper, ROOT::Reflex::Type &found_wrapped_type)

Variables

const MallocOpts amd_opts (0, 8388608, 131072, 10485760)

std::string const aux = "Aux"

std::string const auxiliary = "Auxiliary"

std::string const branchEntryInfo = "BranchEntryInfo"

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

std::string const entryDescriptionBranch = "Description"

std::string const entryDescriptionIDBranch = "Hash"

std::string const entryDescriptionTree = "EntryDescription"

std::string const event = "Event"

std::string const eventAux = event + aux

std::string const eventAuxiliary = event + auxiliary

std::string const eventBranchMapper = "EventBranchMapper"

std::string const eventEventEntryInfo = event + branchEntryInfo

std::string const eventHistory = "EventHistory"

std::string const eventInfo = event + "StatusInformation"

std::string const eventMajorIndex = eventAuxiliary + majorIndex

std::string const eventMeta = event + metaData

std::string const eventMinorIndex = eventAuxiliary + ".id_.event_"

std::string const eventProductStatus = event + productStatus

std::string const events = event + 's'

std::string const fileFormatVersion = "FileFormatVersion"

std::string const fileIdentifier = "FileIdentifier"

std::string const fileIndex = "FileIndex"

static const char * fmt_Guid

MallocOptionSetter global_malloc_options

BufHolder holder

int const improbable = -65783927

const int init_size = 1024*1024

const MallocOpts intel_opts (262144, 524288, 5242880, 131072)

static const unsigned int kAveEventPerSec = 200U

static const unsigned int kNanoSecPerSec = 1000000000U

std::string const lumi = "LuminosityBlock"

std::string const lumiAux = lumi + aux

std::string const lumiAuxiliary = lumi + auxiliary

std::string const lumiEventEntryInfo = lumi + branchEntryInfo

std::string const lumiInfo = lumi + "StatusInformation"

std::string const lumiMajorIndex = lumiAuxiliary + majorIndex

std::string const lumiMeta = lumi + metaData

std::string const lumiMinorIndex = lumiAuxiliary + ".id_.luminosityBlock_"

std::string const lumiProductStatus = lumi + productStatus

std::string const lumis = lumi + 's'

std::string const majorIndex = ".id_.run_"

std::string const metaData = "MetaData"

std::string const metaDataTree = "MetaData"

static const unsigned char MLSCRIBE_RUNNING_INDICATOR = 29

std::string const moduleDescriptionMap = "ModuleDescriptionMap"

char const * msgNames []

std::string const oneParam [oneParamArraySize]

int const oneParamArraySize = 6

std::string const parameterSetMap = "ParameterSetMap"

std::string const processConfigurationMap = "ProcessConfigurationMap"

std::string const processHistoryMap = "ProcessHistoryMap"

std::string const productDependencies = "ProductDependencies"

std::string const productRegistry = "ProductRegistry"

std::string const productStatus = "ProductStatus"

std::string const run = "Run"

std::string const runAux = run + aux

std::string const runAuxiliary = run + auxiliary

std::string const runEventEntryInfo = run + branchEntryInfo

std::string const runInfo = run + "StatusInformation"

std::string const runMajorIndex = runAuxiliary + majorIndex

std::string const runMeta = run + metaData

std::string const runMinorIndex

std::string const runProductStatus = run + productStatus

std::string const runs = run + 's'

volatile bool shutdown_flag = false

boost::mutex signum_lock

volatile int signum_value

char const * stateNames []

static const edm::pset::TypeTrans sTypeTranslations

TransEntry table []

std::string const twoParam [twoParamArraySize]

int const twoParamArraySize = 3

boost::mutex usr2_lock

Detailed Description

A PluginFactory for concrete instances of class KalmanAlignmentMetricsUpdator.

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

jet parton energy corrections

classes declaration

classes declarations

StreamSerializer.cc.

StreamDQMSerializer.cc.

StreamDQMDeserializer.cc.

A ThreadSafeRegistry is used to keep track of the instances of some type 'mapped_typed'.

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.

This is the basic exception that is thrown by the framework code.

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

A singleton for managing the plugin feedback function and assert hook function.

----------------------------------------- VEntries hold: vint32, vuint32, vdouble, vstring

IncludeNodes which are immediately renamed, so they aren't subject to restrictions on multiple inclusion.

Applies preprocessing to a ParseResults object.

IncludeNodes contain a FileInPath for the file to be included.

Resolves where to look for include files, by looking up the module using the EdmPluginManager.

this type of node accepts a class name and a label, and tries to find the correct include file

Id: FileInPath.h,v 1.9 2007/06/14 04:55:59 wmtan Exp

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

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

CurrentProcessingContext is a class that carries information about the current event processing context.

Parameters used in the hadron fast simulation.

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

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.

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.

An input source for DQM consumers using cmsRun that connect to the StorageManager or SMProxyServer to get DQM data.

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

HLT enums.

A PluginFactory for updators for the KalmanAlignmentAlgorithm.

Definition of common HLT enums

Date: 2007/12/21 22:42:30

Revision: 1.3

Author:: Martin Grunewald

Id: DQMHttpSource.h,v 1.8 2008/06/03 17:04:44 biery Exp

Author:: Patrick Janot

Date:: : 25-Jan-2004

Author:: Patrick Janot

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.

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

Find a non-event-data file, given a relative path. 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.

They are resolved through a second pass through the parser

Designed to implement nodes for modifications such as copy, modify, and rename

Rick Wilkinson

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.

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>

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

This is the initial version of the framework/edm error and action codes. Should the error/action lists be completely dynamic? Should they have this fixed part and allow for dynamic expansion? The answer is not clear right now and this will suffice for the first version.

Will ErrorCodes be used as return codes? Unknown at this time.

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.

These objects are each associated with a given 'key_type' object, which must be retrievable from the mapped_type object, and which must uniquely identify the mapped_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 'mapped_type const&', the expression

key_type k = m.id();

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

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

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

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

Typedef Documentation

typedef Handle<ArbitraryType> edm::ArbitraryHandle

Definition at line 9 of file ArbitraryType.h.

typedef Wrapper<ArbitraryType> edm::ArbitraryWrapper

Definition at line 10 of file ArbitraryType.h.

typedef unsigned char edm::byte_t

Definition at line 15 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 18 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 58 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 21 of file MessageSender.h.

typedef std::pair<std::string, std::string> edm::ErrorSummaryMapKey

Definition at line 19 of file MessageSender.h.

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

Definition at line 112 of file EventEntryInfo.h.

typedef unsigned int edm::EventNumber_t

Definition at line 31 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 edm::CodedException<edm::errors::ErrorCodes> edm::Exception

Definition at line 69 of file EDMException.h.

typedef Handle<GenericObject> edm::GenericHandle

Definition at line 151 of file GenericHandle.h.

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

Definition at line 44 of file EDProductfwd.h.

typedef reftobase::RefVectorHolderBase edm::helper_vector

Definition at line 45 of file EDProductfwd.h.

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

Definition at line 46 of file EDProductfwd.h.

typedef long long int edm::HRTimeDiffType

Definition at line 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 RunLumiEntryInfo edm::LumiEntryInfo

Definition at line 83 of file RunLumiEntryInfo.h.

typedef unsigned int edm::LuminosityBlockNumber_t

Definition at line 30 of file LuminosityBlockID.h.

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

Definition at line 15 of file Factory.h.

typedef Hash<ModuleDescriptionType> edm::ModuleDescriptionID

Definition at line 9 of file ModuleDescriptionID.h.

typedef ModuleDescriptionRegistry::collection_type edm::ModuleDescriptionMap

Definition at line 11 of file ModuleDescriptionRegistry.h.

typedef edm::detail::ThreadSafeRegistry<edm::ModuleDescriptionID, edm::ModuleDescription> edm::ModuleDescriptionRegistry

Definition at line 10 of file ModuleDescriptionRegistry.h.

typedef std::map<boost::shared_ptr<FileRecord>, boost::shared_ptr<OutputService> > edm::OutputMap

Definition at line 21 of file StreamService.h.

typedef std::map<boost::shared_ptr<FileRecord>, boost::shared_ptr<OutputService> >::iterator edm::OutputMapIterator

Definition at line 22 of file StreamService.h.

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

Definition at line 31 of file ParameterSetDescriptionFillerPluginFactory.h.

typedef Hash<ParameterSetType> edm::ParameterSetID

Definition at line 23 of file ParameterSetID.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 Pointer_to_new_exception_on_heap* edm::Place_for_passing_exception_ptr

Definition at line 14 of file ConfigurationHandshake.h.

typedef edm::Exception* edm::Pointer_to_new_exception_on_heap

Definition at line 11 of file ConfigurationHandshake.h.

typedef PoolSource edm::PoolRASource

Definition at line 61 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 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 std::string edm::ProcessingTask

Definition at line 8 of file ProcessingTask.h.

typedef byte_t edm::ProductStatus

Definition at line 16 of file ProductStatus.h.

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

Definition at line 11 of file PSimHitContainer.h.

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

Definition at line 29 of file ESProxyFactoryProducer.cc.

typedef std::string edm::ReleaseVersion

Definition at line 7 of file ReleaseVersion.h.

typedef RunLumiEntryInfo edm::RunEntryInfo

Definition at line 84 of file RunLumiEntryInfo.h.

typedef unsigned int edm::RunNumber_t

Definition at line 28 of file RunID.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 96 of file StreamedProducts.h.

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

Definition at line 75 of file StreamedProducts.h.

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

Definition at line 12 of file SimTrackContainer.h.

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

Definition at line 13 of file SimVertexContainer.h.

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

Definition at line 14 of file SimVertexContainer.h.

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

Definition at line 15 of file SimVertexContainer.h.

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

Definition at line 16 of file SimVertexContainer.h.

typedef std::vector<boost::shared_ptr<StreamService> > edm::Streams

Definition at line 25 of file ServiceManager.h.

typedef std::vector<boost::shared_ptr<StreamService> >::iterator edm::StreamsIterator

Definition at line 26 of file ServiceManager.h.

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

Definition at line 36 of file ReflexTools.h.

typedef unsigned long long edm::TimeValue_t

Definition at line 27 of file Timestamp.h.

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

Definition at line 33 of file OutputModule.h.

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

Definition at line 72 of file Entry.cc.

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

Definition at line 21 of file GroupSelector.cc.

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

Definition at line 15 of file VectorInputSourceFactory.h.

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

Definition at line 90 of file Schedule.cc.

typedef boost::shared_ptr<pset::WrapperNode> edm::WrapperNodePtr

Definition at line 11 of file ProcessDesc.h.

Enumeration Type Documentation

enum edm::BranchActionType

Enumerator:

BranchActionBegin
BranchActionEnd

Definition at line 12 of file BranchActionType.h.

00012                         {
00013     BranchActionBegin = 0,
00014     BranchActionEnd = 1
00015   };

enum edm::BranchType

Enumerator:

InEvent
InLumi
InRun
NumBranchTypes

Definition at line 13 of file BranchType.h.

00013                   {
00014     InEvent = 0,
00015     InLumi = 1,
00016     InRun = 2,
00017     NumBranchTypes
00018   };

enum edm::HashedTypes

Enumerator:

ModuleDescriptionType
ParameterSetType
ProcessHistoryType
ProcessConfigurationType
EntryDescriptionType

Definition at line 10 of file HashedTypes.h.

00010                    {
00011       ModuleDescriptionType,
00012       ParameterSetType,
00013       ProcessHistoryType,
00014       ProcessConfigurationType,
00015       EntryDescriptionType
00016   };

enum edm::JobMode

Enumerator:

GridJobMode
ReleaseValidationJobMode
AnalysisJobMode
NilJobMode

Definition at line 15 of file JobMode.h.

00015                {
00016          GridJobMode
00017        , ReleaseValidationJobMode
00018        , AnalysisJobMode
00019        , NilJobMode
00020   };

enum edm::ParameterTypes

Enumerator:

k_uint32
k_vuint32
k_int32
k_vint32
k_uint64
k_vuint64
k_int64
k_vint64
k_string
k_vstring
k_bool
k_vbool
k_double
k_vdouble
k_PSet
k_VPSet
k_FileInPath
k_InputTag
k_VInputTag
k_EventID
k_VEventID
k_LuminosityBlockID
k_VLuminosityBlockID
k_numParameterTypes

Definition at line 31 of file ParameterDescription.h.

00031                       {
00032     k_uint32,    k_vuint32,
00033     k_int32,     k_vint32,
00034     k_uint64,    k_vuint64,
00035     k_int64,     k_vint64,
00036     k_string,    k_vstring,
00037     k_bool,      k_vbool,
00038     k_double,    k_vdouble,
00039     k_PSet,      k_VPSet,
00040     k_FileInPath,
00041     k_InputTag,  k_VInputTag,
00042     k_EventID,   k_VEventID,
00043     k_LuminosityBlockID,   k_VLuminosityBlockID,
00044     k_numParameterTypes
00045   };

enum edm::Verbosity

Enumerator:

Silent
Concise
Normal
Detailed

Definition at line 5 of file Verbosity.h.

00005                  {
00006     Silent=0,
00007     Concise=2,
00008     Normal=5,
00009     Detailed=10
00010   };

Function Documentation

static void edm::addWrapperOfVectorOfBuiltin	(	std::map< std::string, std::string > &	iMap,
		const char *	iBuiltin
	)			`[static]`

Definition at line 93 of file RootAutoLibraryLoader.cc.

Referenced by edm::RootAutoLibraryLoader::RootAutoLibraryLoader().

00094 {
00095    static std::string sReflexPrefix("edm::Wrapper<std::vector<");
00096    static std::string sReflexPostfix("> >");
00097 
00098    //Wrapper<vector<float,allocator<float> > >
00099    static std::string sCintPrefix("Wrapper<vector<");
00100    static std::string sCintMiddle(",allocator<");
00101    static std::string sCintPostfix("> > >");
00102 
00103    std::string type(iBuiltin);
00104    iMap.insert(make_pair(sCintPrefix+type+sCintMiddle+type+sCintPostfix,
00105                          sReflexPrefix+type+sReflexPostfix));
00106 }

static int edm::ALL_AutoLoadCallback	(	char *	c,
		char *	l
	)			`[static]`

Definition at line 160 of file RootAutoLibraryLoader.cc.

References gPrevious, kDummyLibName, loadLibraryForClass(), and HLT_VtxMuL3::result.

Referenced by edm::RootAutoLibraryLoader::RootAutoLibraryLoader().

00160                                                   {
00161   //NOTE: if the library (i.e. 'l') is an empty string this means we are dealing with a namespace
00162   // These checks appear to avoid a crash of ROOT during shutdown of the application
00163   if(0==c || 0==l || l[0]==0) {
00164     return 0;
00165   }
00166   ULong_t varp = G__getgvp();
00167   G__setgvp(G__PVOID);
00168   int result = loadLibraryForClass(c) ? 1:0;
00169   G__setgvp(varp);
00170   //NOTE: the check for the library is done since we can have a failure
00171   // if a CMS library has an incomplete set of Reflex dictionaries where
00172   // the remaining dictionaries can be found by Cint.  If the library with
00173   // the Reflex dictionaries is loaded first, then the Cint library then any
00174   // requests for a Reflex::Type from the Reflex library will fail because for
00175   // some reason the loading of the Cint library causes Reflex to forget about
00176   // what types it already loaded from the Reflex library.  This problem was
00177   // seen for libDataFormatsMath and libMathCore.  I do not print an error message
00178   // since the dictionaries are actually loaded so things work fine.
00179   if(!result && 0 != strcmp(l,kDummyLibName) && gPrevious) {
00180     result = gPrevious(c,l);
00181   }
00182   return result;
00183 }

template<class FP>

bool edm::asm_isnan ( FP x ) [inline]

Definition at line 43 of file math.h.

References flags.

00044   {
00045     // I do not know of a preprocessor symbol used to identify the
00046     // presence of an x87 floating-point processor.
00047 #if defined(__i386__)||defined(__x86_64)
00048     u_int16_t flags;
00049     __asm__("fxam\n\t"
00050             "fstsw %%ax"
00051             : "=a" (flags) /* output */
00052             : "t"  (x)     /* input */
00053             :              /* clobbered */
00054             );
00055     return (flags & 0x4500)==0x0100;
00056 #else
00057     #error No asm_isnan for this architecture.
00058 #endif    
00059   }

template<typename ForwardSequence, typename Datum>

bool edm::binary_search_all	(	ForwardSequence const &	s,
		Datum const &	d
	)			`[inline]`

wrapper for std::binary_search

Definition at line 54 of file Algorithms.h.

Referenced by EventContentAnalyzer::analyze(), edm::RootFile::getNextEntryTypeWanted(), and edm::GroupSelector::selected().

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

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

Definition at line 93 of file BranchType.cc.

References eventAux, InEvent, InRun, lumiAux, and runAux.

Referenced by fwlite::Event::Event(), and getAuxiliaryBranch().

00093                                                                            {
00094     return ((branchType == InEvent) ? eventAux : ((branchType == InRun) ? runAux : lumiAux));
00095   }

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

Definition at line 89 of file BranchType.cc.

References eventAuxiliary, InEvent, InRun, lumiAuxiliary, and runAuxiliary.

Referenced by fwlite::Event::Event(), getAuxiliaryBranch(), TFWLiteSelectorBasic::Process(), and edm::RootOutputTree::RootOutputTree().

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

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

Definition at line 101 of file BranchType.cc.

References eventEventEntryInfo, InEvent, InRun, lumiEventEntryInfo, and runEventEntryInfo.

Referenced by getEventEntryInfoBranch(), edm::RootOutputTree::RootOutputTree(), and fwlite::internal::BranchMapReaderStrategyV8::updateFile().

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

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

Definition at line 85 of file BranchType.cc.

References eventInfo, InEvent, InRun, lumiInfo, and runInfo.

00085                                                                           {
00086     return ((branchType == InEvent) ? eventInfo : ((branchType == InRun) ? runInfo : lumiInfo));
00087   }

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

Definition at line 105 of file BranchType.cc.

References eventMajorIndex, InEvent, InRun, lumiMajorIndex, and runMajorIndex.

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

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

Definition at line 81 of file BranchType.cc.

References eventMeta, InEvent, InRun, lumiMeta, and runMeta.

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

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

Definition at line 109 of file BranchType.cc.

References eventMinorIndex, InEvent, InRun, lumiMinorIndex, and runMinorIndex.

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

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

Definition at line 97 of file BranchType.cc.

References eventProductStatus, InEvent, InRun, lumiProductStatus, and runProductStatus.

Referenced by getStatusBranch().

00097                                                                                      {
00098     return ((branchType == InEvent) ? eventProductStatus : ((branchType == InRun) ? runProductStatus : lumiProductStatus));
00099   }

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

Definition at line 77 of file BranchType.cc.

References events, InEvent, InRun, lumis, and runs.

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

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

Definition at line 73 of file BranchType.cc.

References event, InEvent, InRun, lumi, and run.

Referenced by operator<<().

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

void edm::checkAllDictionaries ( )

Definition at line 255 of file ReflexTools.cc.

References begin, edm::errors::DictionaryNotFound, empty, end, it, and missingTypes().

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

00255                               {
00256     if (!missingTypes().empty()) {
00257       std::ostringstream ostr;
00258       for (StringSet::const_iterator it = missingTypes().begin(), itEnd = missingTypes().end(); 
00259            it != itEnd; ++it) {
00260         ostr << *it << "\n\n";
00261       }
00262       throw edm::Exception(edm::errors::DictionaryNotFound)
00263         << "No REFLEX data dictionary found for the following classes:\n\n"
00264         << ostr.str()
00265         << "Most likely each dictionary was never generated,\n"
00266         << "but it may be that it was generated in the wrong package.\n"
00267         << "Please add (or move) the specification\n"
00268         << "<class name=\"whatever\"/>\n"
00269         << "to the appropriate classes_def.xml file.\n"
00270         << "If the class is a template instance, you may need\n"
00271         << "to define a dummy variable of this type in classes.h.\n"
00272         << "Also, if this class has any transient members,\n"
00273         << "you need to specify them in classes_def.xml.";
00274     }
00275   }

void edm::@9934::checkConsistency	(	RunPrincipal const &	primary,
		RunPrincipal const &	secondary
	)			`[static]`

Definition at line 41 of file PoolSource.cc.

References checkHistoryConsistency(), edm::RunPrincipal::id(), and edm::errors::MismatchedInputFiles.

00041                                                                                       {
00042       if (primary.id() != secondary.id()) {
00043         throw edm::Exception(errors::MismatchedInputFiles, "PoolSource::checkConsistency") <<
00044           primary.id() << " has inconsistent RunAuxiliary data in the primary and secondary file\n";
00045       }
00046       checkHistoryConsistency(primary, secondary);
00047     }

void edm::@9934::checkConsistency	(	LuminosityBlockPrincipal const &	primary,
		LuminosityBlockPrincipal const &	secondary
	)			`[static]`

Definition at line 34 of file PoolSource.cc.

References checkHistoryConsistency(), edm::LuminosityBlockPrincipal::id(), and edm::errors::MismatchedInputFiles.

00034                                                                                                               {
00035       if (primary.id() != secondary.id()) {
00036         throw edm::Exception(errors::MismatchedInputFiles, "PoolSource::checkConsistency") <<
00037           primary.id() << " has inconsistent LuminosityBlockAuxiliary data in the primary and secondary file\n";
00038       }
00039       checkHistoryConsistency(primary, secondary);
00040     }

void edm::@9934::checkConsistency	(	EventPrincipal const &	primary,
		EventPrincipal const &	secondary
	)			`[static]`

Definition at line 27 of file PoolSource.cc.

References checkHistoryConsistency(), edm::EventPrincipal::id(), isSameEvent(), and edm::errors::MismatchedInputFiles.

Referenced by edm::PoolSource::readEvent_(), edm::PoolSource::readIt(), edm::PoolSource::readLuminosityBlock_(), and edm::PoolSource::readRun_().

00027                                                                                           {
00028       if (!isSameEvent(primary, secondary)) {
00029         throw edm::Exception(errors::MismatchedInputFiles, "PoolSource::checkConsistency") <<
00030           primary.id() << " has inconsistent EventAuxiliary data in the primary and secondary file\n";
00031       }
00032       checkHistoryConsistency(primary, secondary);
00033     }

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

Definition at line 245 of file ReflexTools.cc.

References checkType(), missingTypes(), and t.

Referenced by checkDicts(), and loadCap().

00245                                                                    {
00246     Type null;
00247     Type t = Type::ByName(name);
00248     if (t == null) {
00249       missingTypes().insert(name);
00250       return;
00251     }
00252     checkType(Type::ByName(name), noComponents);
00253   }

void edm::@4425::checkDicts ( BranchDescription const & productDesc ) [static]

Definition at line 22 of file ProductRegistry.cc.

References checkDictionaries(), edm::BranchDescription::fullClassName(), edm::BranchDescription::transient(), and wrappedClassName().

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

00022                                                           {
00023       if (productDesc.transient()) {
00024         checkDictionaries(productDesc.fullClassName(), true);
00025       } else {
00026         checkDictionaries(wrappedClassName(productDesc.fullClassName()), false);
00027       }
00028     }

void edm::@9934::checkHistoryConsistency	(	Principal const &	primary,
		Principal const &	secondary
	)			`[static]`

Definition at line 19 of file PoolSource.cc.

References isAncestor(), edm::errors::MismatchedInputFiles, and edm::Principal::processHistory().

Referenced by checkConsistency().

00019                                                                                        {
00020       ProcessHistory const& ph1 = primary.processHistory();
00021       ProcessHistory const& ph2 = secondary.processHistory();
00022       if (ph1 != ph2 && !isAncestor(ph2, ph1)) {
00023         throw edm::Exception(errors::MismatchedInputFiles, "PoolSource::checkConsistency") <<
00024           "The secondary file is not an ancestor of the primary file\n";
00025       }
00026     }

void edm::@7818::checkType	(	Type	t,
		bool	noComponents = `false`
	)			`[static]`

Definition at line 173 of file ReflexTools.cc.

References find(), hasCintDictionary(), i, m, missingTypes(), n, name, and x.

Referenced by checkDictionaries().

00173                                                  {
00174 
00175       // The only purpose of this cache is to stop infinite recursion.
00176       // Reflex maintains its own internal cache.
00177       static boost::thread_specific_ptr<StringSet> s_types;
00178       if (0 == s_types.get()) {
00179         s_types.reset(new StringSet);
00180       }
00181   
00182       // ToType strips const, volatile, array, pointer, reference, etc.,
00183       // and also translates typedefs.
00184       // To be safe, we do this recursively until we either get a null type
00185       // or the same type.
00186       Type null;
00187       for (Type x = t.ToType(); x != null && x != t; t = x, x = t.ToType()) {}
00188   
00189       std::string name = t.Name(SCOPED);
00190   
00191       if (s_types->end() != s_types->find(name)) {
00192         // Already been processed.  Prevents infinite loop.
00193         return;
00194       }
00195       s_types->insert(name);
00196   
00197       if (name.empty()) return;
00198       if (t.IsFundamental()) return;
00199       if (t.IsEnum()) return;
00200 
00201       if (!bool(t)) {
00202         if (!hasCintDictionary(name)) {
00203           missingTypes().insert(name);
00204         }
00205         return;
00206       }
00207       if (noComponents) return;
00208   
00209       if (name.find("std::") == 0) {
00210         if (t.IsTemplateInstance()) {
00211           std::string::size_type n = name.find('<');
00212           int cnt = 0;
00213           if (std::find(oneParam, oneParam + oneParamArraySize, name.substr(5, n - 5)) != oneParam + oneParamArraySize) {
00214             cnt = 1;
00215           } else if (std::find(twoParam, twoParam + twoParamArraySize, name.substr(5, n - 5)) != twoParam + twoParamArraySize) {
00216             cnt = 2;
00217           } 
00218           for(int i = 0; i < cnt; ++i) {
00219             checkType(t.TemplateArgumentAt(i));
00220           }
00221         }
00222       } else {
00223         int mcnt = t.DataMemberSize();
00224         for(int i = 0; i < mcnt; ++i) {
00225           Member m = t.DataMemberAt(i);
00226           if(m.IsTransient() || m.IsStatic()) continue;
00227           checkType(m.TypeOf());
00228         }
00229         int cnt = t.BaseSize();
00230         for(int i = 0; i < cnt; ++i) {
00231           checkType(t.BaseAt(i).ToType());
00232         }
00233       }
00234     }

static std::map<std::string,std::string>& edm::cintToReflexSpecialCasesMap ( ) [static]

Definition at line 85 of file RootAutoLibraryLoader.cc.

Referenced by registerTypes(), and edm::RootAutoLibraryLoader::RootAutoLibraryLoader().

00086 {
00087    static std::map<std::string,std::string> s_map;
00088    return s_map;
00089 }

static std::string edm::classNameForRoot ( const std::string & iCapName ) [static]

Definition at line 186 of file RootAutoLibraryLoader.cc.

Referenced by registerTypes().

00187 {
00188   //need to remove any 'std::' since ROOT ignores it
00189   static const boost::regex ex("std::");
00190   const std::string to("");
00191 
00192   return regex_replace(iCapName, ex, to, boost::match_default | boost::format_sed);
00193 
00194   return iCapName;
00195 }

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

Definition at line 12 of file Factory.cc.

Referenced by edm::Factory::~Factory().

00013   {
00014     delete v.second;
00015   }

static const Guid 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 280 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==().

00280                                                                      {
00281     return
00282     (a.branchType() == b.branchType()) &&
00283     (a.processName() == b.processName()) &&
00284     (a.fullClassName() == b.fullClassName()) &&
00285     (a.friendlyClassName() == b.friendlyClassName()) &&
00286     (a.productInstanceName() == b.productInstanceName()) &&
00287     (a.moduleLabel() == b.moduleLabel()) &&
00288     (a.branchID() == b.branchID());
00289   }

template<class FwdIter>

FwdIter edm::contextual_find	(	FwdIter	b,
		FwdIter	e,
		char	first,
		char	sep,
		char	last
	)			`[inline]`

Definition at line 50 of file split.h.

Referenced by split().

00052 {
00053   for(int  nested = 0;  b != e;  ++b)  {
00054     if(*b == first)
00055       ++nested;
00056     else if(*b == last)
00057       --nested;
00058     else if(*b == sep  &&  nested == 0)
00059       return b;
00060   }
00061 
00062   return e;
00063 
00064 }  // contextual_find()

template<class FwdIter>

FwdIter edm::contextual_find_not	(	FwdIter	b,
		FwdIter	e,
		char	first,
		char	sep,
		char	last
	)			`[inline]`

Definition at line 72 of file split.h.

Referenced by split().

00074 {
00075   for(;  b != e;  ++b)  {
00076     if(*b != sep)
00077       return b;
00078   }
00079 
00080   return e;
00081 
00082 }  // contextual_find_not()

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

Definition at line 12 of file RunAux.cc.

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

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

00012                                                          {
00013     to.processHistoryID_ = from.processHistoryID_;
00014     to.id_ = RunID(from.id_);
00015     to.beginTime_ = to.endTime_ = Timestamp::invalidTimestamp(); 
00016   }

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

Definition at line 12 of file LuminosityBlockAux.cc.

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

00012                                                                                  {
00013     to.processHistoryID_ = from.processHistoryID_;
00014     to.id_ = LuminosityBlockID(from.runID_, from.id_);
00015     to.beginTime_ = to.endTime_ = Timestamp::invalidTimestamp();
00016   }

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

Definition at line 11 of file EventAux.cc.

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

Referenced by edm::RootFile::fillEventAuxiliary(), edm::RootFile::fillLumiAuxiliary(), and edm::RootFile::fillRunAuxiliary().

00011                                                              {
00012     to.processHistoryID_ = from.processHistoryID_;
00013     to.id_ = from.id_;
00014     to.time_ = from.time_;
00015     to.luminosityBlock_ = from.luminosityBlockID_;
00016   }

template<>

void edm::convert_handle	(	const BasicHandle &	basic,
		ArbitraryHandle &	result
	)			`[inline]`

Definition at line 13 of file ArbitraryType.h.

References edm::BasicHandle::failedToGet(), edm::BasicHandle::id(), edm::Wrapper< T >::product(), edm::errors::ProductNotFound, edm::BasicHandle::provenance(), edm::Handle< T >::swap(), edm::BasicHandle::whyFailed(), edm::BasicHandle::wrapper(), and wrapper.

Referenced by edm::DataViewImpl::get(), edm::Event::get(), edm::DataViewImpl::getByLabel(), edm::DataViewImpl::getByType(), edm::DataViewImpl::getMany(), and edm::DataViewImpl::getManyByType().

00014   {
00015     if (basic.failedToGet()) {
00016       ArbitraryHandle handle(basic.whyFailed());
00017       handle.swap(result);
00018       return;
00019     }
00020     
00021     const ArbitraryWrapper * wrapper = static_cast<const ArbitraryWrapper *>(basic.wrapper());
00022     if (wrapper == 0 or wrapper->product() == 0) {
00023       boost::shared_ptr<cms::Exception> whyFailed( new edm::Exception(edm::errors::ProductNotFound, "InvalidID") );
00024       *whyFailed << "get by product ID: no product with given id: " << basic.id() << "\n";
00025       ArbitraryHandle handle(whyFailed);
00026       handle.swap(result);
00027       return;
00028     }
00029     
00030     ArbitraryHandle handle(wrapper->product(), basic.provenance());
00031     handle.swap(result);
00032   }

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

specialize this function for GenericHandle

Definition at line 20 of file GenericHandle.cc.

References edm::BasicHandle::failedToGet(), h, edm::errors::InvalidReference, edm::errors::LogicError, edm::BasicHandle::provenance(), edm::BasicHandle::whyFailed(), wrap(), and edm::BasicHandle::wrapper().

00022 {
00023   using namespace ROOT::Reflex;
00024   if(orig.failedToGet()) {
00025     result.setWhyFailed(orig.whyFailed());
00026     return;
00027   }
00028   EDProduct const* originalWrap = orig.wrapper();
00029   if (originalWrap == 0)
00030     throw edm::Exception(edm::errors::InvalidReference,"NullPointer")
00031       << "edm::BasicHandle has null pointer to Wrapper";
00032   
00033   //Since a pointer to an EDProduct is not necessarily the same as a pointer to the actual type
00034   // (compilers are allowed to offset the two) we must get our object via a two step process
00035   Object edproductObject(Type::ByTypeInfo(typeid(EDProduct)), const_cast<EDProduct*>(originalWrap));
00036   assert(edproductObject != Object());
00037   
00038   Object wrap(edproductObject.CastObject(edproductObject.DynamicType()));
00039   assert(wrap != Object());
00040   
00041   Object product(wrap.Get("obj"));
00042   if(!product){
00043     throw edm::Exception(edm::errors::LogicError)<<"GenericObject could not find 'obj' member";
00044   }
00045   if(product.TypeOf().IsTypedef()){
00046     //For a 'Reflex::Typedef' the 'ToType' method returns the actual type
00047     // this is needed since you are now allowed to 'invoke' methods of a 'Typedef'
00048     // only for a 'real' class
00049     product = Object(product.TypeOf().ToType(), product.Address());
00050     assert(!product.TypeOf().IsTypedef());
00051   }
00052   //NOTE: comparing on type doesn't seem to always work! The problem appears to be if we have a typedef
00053   if(product.TypeOf()!=result.type() &&
00054      !product.TypeOf().IsEquivalentTo(result.type()) &&
00055      product.TypeOf().TypeInfo()!= result.type().TypeInfo()){
00056     throw edm::Exception(edm::errors::LogicError)<<"GenericObject asked for "<<result.type().Name()
00057     <<" but was given a "<<product.TypeOf().Name();
00058   }
00059   
00060   Handle<GenericObject> h(product, orig.provenance());
00061   h.swap(result);
00062 }

template<class T>

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

Definition at line 222 of file Handle.h.

References edm::BasicHandle::failedToGet(), h, edm::errors::InvalidReference, edm::errors::LogicError, edm::Wrapper< T >::product(), edm::BasicHandle::provenance(), edm::BasicHandle::whyFailed(), wrap(), and edm::BasicHandle::wrapper().

00224   {
00225     if(orig.failedToGet()) {
00226       Handle<T> h(orig.whyFailed());
00227       h.swap(result);
00228       return;
00229     }
00230     EDProduct const* originalWrap = orig.wrapper();
00231     if (originalWrap == 0)
00232       throw edm::Exception(edm::errors::InvalidReference,"NullPointer")
00233       << "edm::BasicHandle has null pointer to Wrapper";
00234     Wrapper<T> const* wrap = dynamic_cast<Wrapper<T> const*>(originalWrap);
00235     if (wrap == 0)
00236       throw edm::Exception(edm::errors::LogicError,"ConvertType")
00237       << "edm::Wrapper converting from EDProduct to "
00238       << typeid(*originalWrap).name();
00239 
00240     Handle<T> h(wrap->product(), orig.provenance());
00241     h.swap(result);
00242   }

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 edmNew::copy().

Referenced by edm::service::MessageLoggerScribe::configure_dest(), edm::ScheduleValidator::dependencies(), dumpEventHeader(), dumpInitHeader(), MsgTools::fillNames(), edm::ProcessDesc::fillPaths(), edm::es::Label::operator()(), operator<<(), edm::GroupSelector::print(), edm::Hash::print(), tokenize(), edm::ScheduleValidator::validateDependencies(), and edm::ScheduleValidator::validatePath().

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

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

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

Definition at line 199 of file ESProducts.h.

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

00200                                {
00201        iFrom.assignTo(iTo);
00202      }

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

00006                            {
00007     Guid guid;
00008     Guid::create(guid);
00009     return guid.toString();
00010   }

template<typename T>

boost::shared_ptr<T> edm::@7381::createSharedPtrToStatic ( T * ptr ) [inline, static]

Definition at line 44 of file InputSource.cc.

00044                                                             {
00045           return  boost::shared_ptr<T>(ptr, do_nothing_deleter());
00046         }

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

Definition at line 697 of file types.cc.

References decode().

00698 {
00699   std::vector<std::string> strings;
00700   decode(strings, from);
00701 
00702   for(std::vector<std::string>::const_iterator stringItr = strings.begin(), stringItrEnd = strings.end();
00703       stringItr != stringItrEnd; ++stringItr)
00704   {
00705     to.push_back(InputTag(*stringItr));
00706   }
00707   return true;
00708 }  // decode to VInputTag

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

Definition at line 1046 of file types.cc.

References decode(), e, and split().

01047 {
01048   std::vector<std::string> temp;
01049   if(! split(std::back_inserter(temp), from, '{', ',', '}'))
01050     return false;
01051 
01052   to.clear();
01053   for(std::vector<std::string>::const_iterator  b = temp.begin()
01054                                               ,  e = temp.end()
01055       ; b != e ; ++b)
01056   {
01057     ParameterSet val;
01058     if(! decode(val, *b))
01059       return false;
01060     to.push_back(val);
01061   }
01062 
01063   return true;
01064 }  // decode to vector<ParameterSet>

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

Definition at line 1025 of file types.cc.

01026 {
01027   to = ParameterSet(from);
01028   return true;
01029 }  // decode to ParameterSet

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

Definition at line 826 of file types.cc.

References decode().

00827 {
00828   std::vector<std::string> strings;
00829   decode(strings, from);
00830 
00831   for(std::vector<std::string>::const_iterator stringItr = strings.begin(), stringItrEnd = strings.end();
00832       stringItr != stringItrEnd; ++stringItr)
00833   {
00834     edm::LuminosityBlockID lumiID;
00835     decode(lumiID, *stringItr);
00836     to.push_back(lumiID);
00837   }
00838   return true;
00839 }  // decode to VInputTag

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

Definition at line 799 of file types.cc.

References lumi, run, tokenize(), and cmsScimarkStop::tokens.

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

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

Definition at line 759 of file types.cc.

References decode().

00760 {
00761   std::vector<std::string> strings;
00762   decode(strings, from);
00763 
00764   for(std::vector<std::string>::const_iterator stringItr = strings.begin(), stringItrEnd = strings.end();
00765       stringItr != stringItrEnd; ++stringItr)
00766   {
00767     edm::EventID eventID;
00768     decode(eventID, *stringItr);
00769     to.push_back(eventID);
00770   }
00771   return true;
00772 }  // decode to VInputTag

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

Definition at line 732 of file types.cc.

References event, run, tokenize(), and cmsScimarkStop::tokens.

00733 {
00734   std::vector<std::string> tokens = edm::tokenize(from, ":");
00735   assert(tokens.size() == 2);
00736   unsigned int run = strtoul(tokens[0].c_str(), 0, 0);
00737   unsigned int event = strtoul(tokens[1].c_str(), 0, 0);
00738   to = edm::EventID(run, event);
00739   return true;
00740 }  // decode to EventID

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

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

Definition at line 676 of file types.cc.

00677 {
00678   to = InputTag(from);
00679   return true;
00680 }  // decode to InputTag

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

Definition at line 648 of file types.cc.

00649 {
00650   std::istringstream is(from);
00651   FileInPath temp;
00652   is >> temp;
00653   if (!is) return false;
00654   to = temp;
00655   return true;
00656 }  // decode to FileInPath

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

Definition at line 975 of file types.cc.

References decode(), e, and split().

00976 {
00977   std::vector<std::string> temp;
00978   if(! split(std::back_inserter(temp), from, '{', ',', '}'))
00979     return false;
00980 
00981   to.clear();
00982   for(std::vector<std::string>::const_iterator  b = temp.begin()
00983                                              ,  e = temp.end()
00984       ; b != e ; ++b)
00985   {
00986     std::string  val;
00987     if(! decode(val, *b))
00988       return false;
00989     to.push_back(val);
00990   }
00991 
00992   return true;
00993 }  // decode to vector<string>

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

Definition at line 601 of file types.cc.

References c, e, and from_hex().

00602 {
00603   /*std::cerr << "Decoding: " << from << '\n'; //DEBUG*/
00604   std::string::const_iterator  b = from.begin()
00605                             ,  e = from.end();
00606 
00607   to = "";
00608   to.reserve((e-b)/2);
00609   char  c = '\0';
00610   for(bool  even_pos = true
00611      ;  b != e ; ++b, even_pos = ! even_pos)
00612   {
00613     if(even_pos)  {
00614       /*std::cerr << "Even: |"
00615                 << *b
00616                 << "|   giving "
00617                 << from_hex(*b)
00618                 << "\n"; //DEBUG*/
00619       c = static_cast<char>(from_hex(*b));
00620     }
00621     else  {
00622       /*std::cerr << "Odd:  |"
00623                 << *b
00624                 << "|   giving "
00625                 << from_hex(*b)
00626                 << "\n"; //DEBUG*/
00627       c = static_cast<char>(c * 16 + from_hex(*b));
00628       //      if(std::isalnum(c))  {
00629         /*std::cerr << "Ans:  |" << c << "|\n"; //DEBUG*/
00630         to += c;
00631         //}
00632         //else  {  // keep all special chars encoded
00633         //to += "\\x";
00634         //to += to_hex_rep(c);
00635         //}
00636     }
00637   }
00638   /*std::cerr << "Decoded: " << to << '\n'; //DEBUG*/
00639   return true;
00640 }  // decode to String

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

Definition at line 551 of file types.cc.

References decode(), e, and split().

00552 {
00553   std::vector<std::string> temp;
00554   if(! split(std::back_inserter(temp), from, '{', ',', '}'))
00555     return false;
00556 
00557   to.clear();
00558   for(std::vector<std::string>::const_iterator  b = temp.begin()
00559                                              ,  e = temp.end()
00560       ; b != e ; ++b)
00561   {
00562     double  val;
00563     if(! decode(val, *b))
00564       return false;
00565     to.push_back(val);
00566   }
00567 
00568   return true;
00569 }  // decode to vector<double>

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

Definition at line 500 of file types.cc.

References infinity, and max.

00501 {
00502   if(from == "NaN")
00503     to = std::numeric_limits<double>::quiet_NaN();
00504 
00505   else if(from == "+inf" || from == "inf")
00506   {
00507     to = std::numeric_limits<double>::has_infinity
00508        ? std::numeric_limits<double>::infinity()
00509        : std::numeric_limits<double>::max();
00510   }
00511   else if(from == "-inf")
00512   {
00513     to = std::numeric_limits<double>::has_infinity
00514        ? -std::numeric_limits<double>::infinity()
00515        : -std::numeric_limits<double>::max();
00516   }  
00517 
00518   else  {
00519     try  {
00520       // std::cerr << "from:" << from << std::endl;
00521       to = boost::lexical_cast<double>(from);
00522       // std::cerr << "to:" << to << std::endl;
00523     }
00524     catch(boost::bad_lexical_cast &)  {
00525       return false;
00526     }
00527   }
00528 
00529   return true;
00530 }

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

Definition at line 450 of file types.cc.

References decode(), e, and split().

00451 {
00452   std::vector<std::string> temp;
00453   if(! split(std::back_inserter(temp), from, '{', ',', '}'))
00454     return false;
00455 
00456   to.clear();
00457   for(std::vector<std::string>::const_iterator  b = temp.begin()
00458                                              ,  e = temp.end()
00459       ; b != e ; ++b)
00460   {
00461     boost::uint64_t val;
00462     if(! decode(val, *b))
00463       return false;
00464     to.push_back(val);
00465   }
00466 
00467   return true;
00468 }  // decode to vector<unsigned>

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

Definition at line 365 of file types.cc.

References e.

00366 {
00367   std::string::const_iterator  b = from.begin()
00368                             ,  e = from.end();
00369 
00370   to = 0u;
00371   for(; b != e; ++b)  {
00372     if(*b == 'u' || *b == 'U')
00373       return true;
00374     if(! std::isdigit(*b))
00375       return false;
00376     to = 10u * to + (*b - '0');
00377   }
00378 
00379   return true;
00380 }  // decode to unsigned

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

Definition at line 280 of file types.cc.

References decode(), e, and split().

00281 {
00282   std::vector<std::string> temp;
00283   if(! split(std::back_inserter(temp), from, '{', ',', '}'))
00284     return false;
00285 
00286   to.clear();
00287   for(std::vector<std::string>::const_iterator  b = temp.begin()
00288                                              ,  e = temp.end()
00289       ; b != e ; ++b)
00290   {
00291     boost::int64_t val;
00292     if(! decode(val, *b))
00293       return false;
00294     to.push_back(val);
00295   }
00296 
00297   return true;
00298 }  // decode to vector<int>

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

Definition at line 187 of file types.cc.

References e.

00188 {
00189   std::string::const_iterator  b = from.begin()
00190                             ,  e = from.end();
00191 
00192   if(*b != '+' && *b != '-')
00193     return false;
00194   int  sign = (*b == '+') ? +1 : -1;
00195 
00196   to = 0;
00197   while(++b != e)  {
00198     if(! std::isdigit(*b))
00199       return false;
00200     to = 10 * to + (*b - '0');
00201   }
00202   to *= sign;
00203 
00204   return true;
00205 }  // decode to int

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

Definition at line 401 of file types.cc.

References decode(), e, and split().

00402 {
00403   std::vector<std::string> temp;
00404   if(! split(std::back_inserter(temp), from, '{', ',', '}'))
00405     return false;
00406 
00407   to.clear();
00408   for(std::vector<std::string>::const_iterator  b = temp.begin()
00409                                              ,  e = temp.end()
00410       ; b != e ; ++b)
00411   {
00412     unsigned  val;
00413     if(! decode(val, *b))
00414       return false;
00415     to.push_back(val);
00416   }
00417 
00418   return true;
00419 }  // decode to vector<unsigned>

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

Definition at line 329 of file types.cc.

References e.

00330 {
00331   std::string::const_iterator  b = from.begin()
00332                             ,  e = from.end();
00333 
00334   to = 0u;
00335   for(; b != e; ++b)  {
00336     if(*b == 'u' || *b == 'U')
00337       return true;
00338     if(! std::isdigit(*b))
00339       return false;
00340     to = 10u * to + (*b - '0');
00341   }
00342 
00343   return true;
00344 }  // decode to unsigned

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

Definition at line 93 of file types.cc.

References b, decode(), e, split(), and pyDBSRunClass::temp.

00094 {
00095   std::vector<std::string> temp;
00096   if(! split(std::back_inserter(temp), from, '{', ',', '}'))
00097     return false;
00098 
00099   to.clear();
00100   for(std::vector<std::string>::const_iterator  b = temp.begin()
00101                                              ,  e = temp.end()
00102       ; b != e ; ++b)
00103   {
00104     bool  val;
00105     if(! decode(val, *b))
00106       return false;
00107     to.push_back(val);
00108   }
00109 
00110   return true;
00111 }  // decode to vector<bool>

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

Definition at line 71 of file types.cc.

References true.

Referenced by decode(), edm::pset::VEntryNode::makeEntry(), and edm::pset::EntryNode::makeEntry().

00072 {
00073   if     (from == "true")  { to = true ; return true; }
00074   else if(from == "false")  { to = false; return true; }
00075   else                        return false;
00076 }  // decode to bool

unsigned int edm::decodeInt ( unsigned char * v ) [inline]

Definition at line 33 of file Messages.h.

References a, b, c, and d.

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

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

void edm::disableAllSigs ( sigset_t * oldset )

Definition at line 49 of file UnixSignalHandlers.cc.

References MUST_BE_ZERO, and sigfillset.

Referenced by installCustomHandler(), and runMessageLoggerScribe().

00050     {
00051       sigset_t myset;
00052       // all blocked for now
00053       MUST_BE_ZERO(sigfillset(&myset));
00054       MUST_BE_ZERO(pthread_sigmask(SIG_SETMASK,&myset,oldset));
00055     }

bool edm::DisableLoggedErrorsSummary ( )

Definition at line 18 of file LoggedErrorsSummary.cc.

References edm::MessageSender::errorSummaryIsBeingKept.

00018                                  {
00019   bool ret = MessageSender::errorSummaryIsBeingKept;
00020   MessageSender::errorSummaryIsBeingKept = false;
00021   return ret;
00022 }

void edm::disableRTSigs ( )

Definition at line 59 of file UnixSignalHandlers.cc.

References MUST_BE_ZERO, NULL, funct::num(), sigaction, sigaddset, and sigemptyset.

Referenced by installCustomHandler().

00060     {
00061 #if defined(__linux__)
00062       // ignore all the RT signals
00063       sigset_t myset;
00064       MUST_BE_ZERO(sigemptyset(&myset));
00065       
00066       struct sigaction tmpact;
00067       memset(&tmpact,0,sizeof(tmpact));
00068       tmpact.sa_handler = SIG_IGN;
00069 
00070       for(int num = SIGRTMIN; num < SIGRTMAX; ++num) {
00071           MUST_BE_ZERO(sigaddset(&myset,num));
00072           MUST_BE_ZERO(sigaction(num,&tmpact,NULL));
00073       }
00074       
00075       MUST_BE_ZERO(pthread_sigmask(SIG_BLOCK,&myset,0));
00076 #endif
00077     }

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

Definition at line 98 of file UnixSignalHandlers.cc.

References MUST_BE_ZERO, and sigdelset.

00099     {
00100       // disable the specified signal
00101       MUST_BE_ZERO(sigdelset(newset, signum));
00102     }

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

Definition at line 34 of file ClassFiller.cc.

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

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

00034                                               {
00035     FDEBUG(3) << "doing BuildRealData for " << name << "\n";
00036     ROOT::Reflex::Type cc = ROOT::Reflex::Type::ByName(name);
00037     TClass* ttest = TClass::GetClass(getName(cc).c_str());
00038     if (ttest != 0) {
00039       ttest->BuildRealData();
00040     } else {
00041       throw edm::Exception(errors::Configuration)
00042                         << "Could not find TClass for " << name << "\n";
00043     }
00044   }

ELseverityLevel const edm::ELabortGen ( )

Definition at line 397 of file ELseverityLevel.cc.

References e, and edm::ELseverityLevel::ELsev_abort.

00397                                      {
00398   static ELseverityLevel const  e( ELseverityLevel::ELsev_abort );
00399   return e;
00400 }

ELseverityLevel const edm::ELerror2Gen ( )

Definition at line 367 of file ELseverityLevel.cc.

References e, and edm::ELseverityLevel::ELsev_error2.

00367                                       {
00368   static ELseverityLevel const  e( ELseverityLevel::ELsev_error2 );
00369   return e;
00370 }

ELseverityLevel const edm::ELerrorGen ( )

Definition at line 361 of file ELseverityLevel.cc.

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

00361                                      {
00362   static ELseverityLevel const  e( ELseverityLevel::ELsev_error );
00363   return e;
00364 }

ELseverityLevel const edm::ELfatalGen ( )

Definition at line 403 of file ELseverityLevel.cc.

References e, and edm::ELseverityLevel::ELsev_fatal.

00403                                      {
00404   static ELseverityLevel const  e( ELseverityLevel::ELsev_fatal );
00405   return e;
00406 }

ELseverityLevel const edm::ELhighestSeverityGen ( )

Definition at line 409 of file ELseverityLevel.cc.

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

00409                                                {
00410   static ELseverityLevel const  e( ELseverityLevel::ELsev_highestSeverity );
00411   return e;
00412 }

ELseverityLevel const edm::ELincidentalGen ( )

Definition at line 331 of file ELseverityLevel.cc.

References e, and edm::ELseverityLevel::ELsev_incidental.

00331                                           {
00332   static ELseverityLevel const  e( ELseverityLevel::ELsev_incidental );
00333   return e;
00334 }

ELseverityLevel const edm::ELinfoGen ( )

Definition at line 343 of file ELseverityLevel.cc.

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

00343                                     {
00344   static ELseverityLevel const  e( ELseverityLevel::ELsev_info );
00345   return e;
00346 }

ELseverityLevel const edm::ELnextEventGen ( )

Definition at line 373 of file ELseverityLevel.cc.

References e, and edm::ELseverityLevel::ELsev_next.

00373                                          {
00374   static ELseverityLevel const  e( ELseverityLevel::ELsev_next );
00375   return e;
00376 }

ELseverityLevel const edm::ELsevere2Gen ( )

Definition at line 391 of file ELseverityLevel.cc.

References e, and edm::ELseverityLevel::ELsev_severe2.

00391                                        {
00392   static ELseverityLevel const  e( ELseverityLevel::ELsev_severe2 );
00393   return e;
00394 }

ELseverityLevel const edm::ELsevereGen ( )

Definition at line 385 of file ELseverityLevel.cc.

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

00385                                       {
00386   static ELseverityLevel const  e( ELseverityLevel::ELsev_severe );
00387   return e;
00388 }

ELseverityLevel const edm::ELsuccessGen ( )

Definition at line 337 of file ELseverityLevel.cc.

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

00337                                        {
00338   static ELseverityLevel const  e( ELseverityLevel::ELsev_success );
00339   return e;
00340 }

ELseverityLevel const edm::ELunspecifiedGen ( )

Definition at line 379 of file ELseverityLevel.cc.

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

00379                                            {
00380   static ELseverityLevel const  e( ELseverityLevel::ELsev_unspecified );
00381   return e;
00382 }

ELseverityLevel const edm::ELwarning2Gen ( )

Definition at line 355 of file ELseverityLevel.cc.

References e, and edm::ELseverityLevel::ELsev_warning2.

00355                                         {
00356   static ELseverityLevel const  e( ELseverityLevel::ELsev_warning2 );
00357   return e;
00358 }

ELseverityLevel const edm::ELwarningGen ( )

Definition at line 349 of file ELseverityLevel.cc.

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

00349                                        {
00350   static ELseverityLevel const  e( ELseverityLevel::ELsev_warning );
00351   return e;
00352 }

ELseverityLevel const edm::ELzeroSeverityGen ( )

Definition at line 325 of file ELseverityLevel.cc.

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

00325                                             {
00326   static ELseverityLevel const  e( ELseverityLevel::ELsev_zeroSeverity );
00327   return e;
00328 }

bool edm::EnableLoggedErrorsSummary ( )

Definition at line 12 of file LoggedErrorsSummary.cc.

References edm::MessageSender::errorSummaryIsBeingKept.

00012                                  {
00013   bool ret = MessageSender::errorSummaryIsBeingKept;
00014   MessageSender::errorSummaryIsBeingKept = true;
00015   return ret;
00016 }

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

Definition at line 89 of file UnixSignalHandlers.cc.

References MUST_BE_ZERO, and sigaddset.

00090     {
00091       // enable the specified signal
00092       MUST_BE_ZERO(sigaddset(newset, signum));
00093     }

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

Definition at line 713 of file types.cc.

References encode().

00714 {
00715   std::vector<std::string> strings;
00716   for(std::vector<InputTag>::const_iterator tagItr = from.begin(), tagItrEnd = from.end();
00717        tagItr != tagItrEnd; ++tagItr)
00718   {
00719     strings.push_back(tagItr->encode());
00720   }
00721   encode(to, strings);
00722   return true;
00723 }

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

Definition at line 1069 of file types.cc.

References e, and encode().

01070 {
01071   to = "{";
01072 
01073   std::string  converted;
01074   for(std::vector<ParameterSet>::const_iterator b = from.begin()
01075                                        , e = from.end()
01076      ; b != e ; ++b)
01077   {
01078     if(! encode(converted, *b))
01079       return false;
01080 
01081     if(b != from.begin()) 
01082       to += ",";
01083     to += converted;
01084   }
01085 
01086   to += '}';
01087   return true;
01088 }  // encode from vector<ParameterSet>

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

Definition at line 1034 of file types.cc.

References edm::ParameterSet::toString().

01035 {
01036   to = from.toString();
01037   return true;
01038 }  // encode from ParameterSet

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

Definition at line 844 of file types.cc.

References encode().

00845 {
00846   std::vector<std::string> strings;
00847   for(std::vector<edm::LuminosityBlockID>::const_iterator idItr = from.begin(), idItrEnd = from.end();
00848       idItr != idItrEnd; ++idItr)
00849   {
00850     std::string encodedLuminosityBlockID;
00851     encode(encodedLuminosityBlockID, *idItr);
00852     strings.push_back(encodedLuminosityBlockID);
00853   }
00854   encode(to, strings);
00855   return true;
00856 }

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

Definition at line 812 of file types.cc.

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

00813 {
00814   std::ostringstream os;
00815   os << from.run() << ":" << from.luminosityBlock();
00816   to = os.str();
00817   return true;
00818 }

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

Definition at line 777 of file types.cc.

References encode().

00778 {
00779   std::vector<std::string> strings;
00780   for(std::vector<edm::EventID>::const_iterator idItr = from.begin(), idItrEnd = from.end();
00781       idItr != idItrEnd; ++idItr)
00782   {
00783     std::string encodedEventID;
00784     encode(encodedEventID, *idItr);
00785     strings.push_back(encodedEventID);
00786   }
00787   encode(to, strings);
00788   return true;
00789 }

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

Definition at line 745 of file types.cc.

References edm::EventID::event(), and edm::EventID::run().

00746 {
00747   std::ostringstream os;
00748   os << from.run() << ":" << from.event();
00749   to = os.str();
00750   return true;
00751 }

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

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

Definition at line 685 of file types.cc.

References edm::InputTag::encode().

00686 {
00687   to = from.encode();
00688   return true;
00689 }

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

Definition at line 661 of file types.cc.

00662 {
00663   std::ostringstream ost;
00664   ost << from;
00665   if (!ost) return false;
00666   to = ost.str();
00667   return true;
00668 }

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

Definition at line 998 of file types.cc.

References e, and encode().

00999 {
01000   to = "{";
01001 
01002   std::string  converted;
01003   for(std::vector<std::string>::const_iterator b = from.begin()
01004                                               , e = from.end()
01005      ; b != e ; ++b)
01006   {
01007     if(! encode(converted, *b))
01008       return false;
01009 
01010     if(b != from.begin()) 
01011       to += ",";
01012     to += converted;
01013   }
01014 
01015   to += '}';
01016   return true;
01017 }  // encode from vector<string>

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

Definition at line 864 of file types.cc.

References code, e, from_hex(), HEX, NONE, state, and to_hex_rep().

00865 {
00866   std::string::const_iterator  b = from.begin()
00867                             ,  e = from.end();
00868 
00869   enum escape_state { NONE
00870                     , BACKSLASH
00871                     , HEX, HEX1
00872                     , OCT1, OCT2
00873                     };
00874 
00875   escape_state  state = NONE;
00876   int code = 0;
00877   to = "";
00878   for(; b != e; ++b)  {
00879     /*std::cerr << "State: " << state << "; char = " << *b << '\n'; //DEBUG*/
00880     switch(state)  {
00881       case NONE:  {
00882         if(*b == '\\')  state = BACKSLASH;
00883         else              to += to_hex_rep(*b);
00884         /*std::cerr << "To: |" << to << "|\n"; //DEBUG*/
00885         break;
00886       }
00887       case BACKSLASH:  {
00888         code = 0;
00889         switch(*b)  {
00890           case 'x': case 'X':  {
00891             state = HEX;
00892             break;
00893           }
00894           case '0': case '1': case '2': case '3':
00895           case '4': case '5': case '6': case '7':  {
00896             code = 8 * code + from_hex(*b);
00897             state = OCT1;
00898             break;
00899           }
00900           case 'n':  {
00901             to += to_hex_rep(10);
00902             state = NONE;
00903             break;
00904           }
00905           case 't':  {
00906             to += to_hex_rep(9);
00907             state = NONE;
00908             break;
00909           }
00910           default:  {
00911             to += to_hex_rep(*b);
00912             state = NONE;
00913             break;
00914           }
00915         }
00916         break;
00917       }
00918       case HEX:  {
00919         to += *b;
00920         state = HEX1;
00921         break;
00922       }
00923       case HEX1:  {
00924         to += *b;
00925         state = NONE;
00926         break;
00927       }
00928       case OCT1:  {
00929         switch(*b)  {
00930           case '0': case '1': case '2': case '3':
00931           case '4': case '5': case '6': case '7':  {
00932             code = 8 * code + from_hex(*b);
00933             state = OCT2;
00934             break;
00935           }
00936           default:  {
00937             to += to_hex_rep(code);
00938             state = NONE;
00939             break;
00940           }
00941         }
00942         break;
00943       }
00944       case OCT2:  {
00945         switch(*b)  {
00946           case '0': case '1': case '2': case '3':
00947           case '4': case '5': case '6': case '7':  {
00948             code = 8 * code + from_hex(*b);
00949             break;
00950           }
00951           default:  {
00952             to += to_hex_rep(code);
00953             break;
00954           }
00955         }
00956         state = NONE;
00957         break;
00958       }
00959       default:  {
00960         throw std::logic_error("can't happen");
00961         break;
00962       }
00963     }
00964   }  // for
00965 
00966   return true;
00967 }  // encode from String

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

Definition at line 574 of file types.cc.

References e, and encode().

00575 {
00576   to = "{";
00577 
00578   std::string  converted;
00579   for(std::vector<double>::const_iterator b = from.begin()
00580                                          , e = from.end()
00581      ; b != e ; ++b)
00582   {
00583     if(! encode(converted, *b))
00584       return false;
00585 
00586     if(b != from.begin()) 
00587       to += ",";
00588     to += converted;
00589   }
00590 
00591   to += '}';
00592   return true;
00593 }  // encode from vector<double>

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

Definition at line 535 of file types.cc.

00536 {
00537   std::ostringstream ost;
00538   ost.precision(std::numeric_limits<double>::digits10+1);
00539   ost << from;
00540   if(!ost) return false;
00541   to=ost.str();
00542   return true;
00543 }

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

Definition at line 473 of file types.cc.

References e, and encode().

00474 {
00475   to = "{";
00476 
00477   std::string  converted;
00478   for(std::vector<boost::uint64_t>::const_iterator b = from.begin()
00479                                            , e = from.end()
00480      ; b != e ; ++b)
00481   {
00482     if(! encode(converted, *b))
00483       return false;
00484 
00485     if(b != from.begin())
00486       to += ",";
00487     to += converted;
00488   }
00489 
00490   to += '}';
00491   return true;
00492 }  // encode from vector<unsigned>

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

Definition at line 385 of file types.cc.

00386 {
00387   to.clear();
00388   do  {
00389     to = static_cast<char>(from % 10 + '0') + to;
00390     from /= 10u;
00391   }  while(from > 0u);
00392 
00393   return true;
00394 }  // encode from unsigned

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

Definition at line 303 of file types.cc.

References e, and encode().

00304 {
00305   to = "{";
00306 
00307   std::string  converted;
00308   for(std::vector<boost::int64_t>::const_iterator b = from.begin()
00309                                       , e = from.end()
00310      ; b != e ; ++b)
00311   {
00312     if(! encode(converted, *b))
00313       return false;
00314 
00315     if(b != from.begin())
00316       to += ",";
00317     to += converted;
00318   }
00319 
00320   to += '}';
00321   return true;
00322 }  // encode from vector<int>

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

Definition at line 210 of file types.cc.

00211 {
00212   bool is_negative = (from < 0);
00213   if(is_negative)
00214     from = - from;  // TODO: work around this for most negative integer
00215 
00216   to.clear();
00217   do  {
00218     to = static_cast<char>(from % 10 + '0') + to;
00219     from /= 10;
00220   }  while(from > 0);
00221   to = (is_negative ? '-' : '+') + to;
00222 
00223   return true;
00224 }  // encode from int

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

Definition at line 424 of file types.cc.

References e, and encode().

00425 {
00426   to = "{";
00427 
00428   std::string  converted;
00429   for(std::vector<unsigned>::const_iterator b = from.begin()
00430                                            , e = from.end()
00431      ; b != e ; ++b)
00432   {
00433     if(! encode(converted, *b))
00434       return false;
00435 
00436     if(b != from.begin()) 
00437       to += ",";
00438     to += converted;
00439   }
00440 
00441   to += '}';
00442   return true;
00443 }  // encode from vector<unsigned>

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

Definition at line 349 of file types.cc.

00350 {
00351   to.clear();
00352   do  {
00353     to = static_cast<char>(from % 10 + '0') + to;
00354     from /= 10u;
00355   }  while(from > 0u);
00356 
00357   return true;
00358 }  // encode from unsigned

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

Definition at line 116 of file types.cc.

References b, e, and encode().

00117 {
00118   to = "{";
00119 
00120   std::string  converted;
00121   for(std::vector<bool>::const_iterator b = from.begin()
00122                                        , e = from.end()
00123      ; b != e ; ++b)
00124   {
00125     if(! encode(converted, *b))
00126       return false;
00127 
00128     if(b != from.begin()) 
00129       to += ",";
00130     to += converted;
00131   }
00132 
00133   to += '}';
00134   return true;
00135 }  // encode from vector<bool>

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

Definition at line 81 of file types.cc.

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

00082 {
00083   to = from ? "true" : "false";
00084   return true;
00085 }  // encode from bool

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

00042   {
00043     v[0]=i&0xff;
00044     v[1]=(i>>8)&0xff;
00045     v[2]=(i>>16)&0xff;
00046     v[3]=(i>>24)&0xff;
00047   }

void edm::endmsg ( ErrorLog & )

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

Definition at line 17 of file UnixSignalHandlers.cc.

References FDEBUG, and shutdown_flag.

Referenced by installCustomHandler(), and edm::service::UnixSignalService::UnixSignalService().

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

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

Definition at line 42 of file ELstring.cc.

Referenced by DEutils< T >::DEDigi(), KinematicConstrainedVertexFitter::fit(), edm::service::ELstatistics::formSummary(), HelixBarrelCylinderCrossing::HelixBarrelCylinderCrossing(), StraightLineBarrelCylinderCrossing::pathLength(), StraightLineCylinderCrossing::pathLength(), loopername::produce(), prodname::produce(), HcalTB04Analysis::qieAnalysis(), and HcalTB04Analysis::xtalAnalysis().

00042                                                     {
00043 
00044   return  s1 == s2;
00045 
00046 }  // eq()

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

Definition at line 24 of file ELstring.cc.

References p1, and p2.

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

00024                                                          {
00025   using std::toupper;
00026 
00027   if (s1.length() != strlen(s2) ) return false;
00028 
00029   ELstring::const_iterator  p1;
00030   const char             *  p2;
00031 
00032   for ( p1 = s1.begin(), p2 = s2;  *p2 != '\0';  ++p1, ++p2 )  {
00033     if ( toupper(*p1) != toupper(*p2) )  {
00034       return false;
00035     }
00036   }
00037   return true;
00038 
00039 }  // eq_nocase()

template<class FP>

bool edm::equal_isnan ( FP x ) [inline]

Definition at line 61 of file math.h.

Referenced by isnan().

00062     {
00063       return x !=x;
00064     }

template<typename T>

cms::Exception& edm::@7418::exceptionContext	(	ModuleDescription const &	iMD,
		T const &	ip,
		cms::Exception &	iEx
	)			`[inline, static]`

Definition at line 140 of file Worker.h.

References edm::ModuleDescription::moduleLabel_, and edm::ModuleDescription::moduleName_.

Referenced by edm::Worker::doWork().

00142                                                         {
00143       iEx << iMD.moduleName_ << "/" << iMD.moduleLabel_ 
00144         << " " << ip.id() << "\n";
00145       return iEx;
00146     }

template<class FROM, class TO, class FUNC>

void edm::@7406::fill_summary	(	FROM const &	from,
		TO &	to,
		FUNC	func
	)			`[inline, static]`

Definition at line 50 of file Schedule.cc.

References pyDBSRunClass::temp, and transform_into().

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

00050                                                       {
00051       TO temp(from.size());
00052       transform_into(from.begin(), from.end(), temp.begin(), func);
00053       to.swap(temp);
00054     }

void edm::fillEventSetupProvider	(	edm::eventsetup::EventSetupProvider &	cp,
		ParameterSet const &	params,
		EventProcessor::CommonParams const &	common
	)

Definition at line 341 of file EventProcessor.cc.

References DBSPlugin::get(), edm::ParameterSet::getParameter(), edm::EventProcessor::CommonParams::passID_, edm::EventProcessor::CommonParams::processName_, and edm::EventProcessor::CommonParams::releaseVersion_.

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

00344   {
00345     using namespace edm::eventsetup;
00346     std::vector<std::string> providers =
00347       params.getParameter<std::vector<std::string> >("@all_esmodules");
00348 
00349     for(std::vector<std::string>::iterator itName = providers.begin(), itNameEnd = providers.end();
00350         itName != itNameEnd;
00351         ++itName) 
00352       {
00353         ParameterSet providerPSet = params.getParameter<ParameterSet>(*itName);
00354         ModuleFactory::get()->addTo(cp, 
00355                                     providerPSet, 
00356                                     common.processName_, 
00357                                     common.releaseVersion_, 
00358                                     common.passID_);
00359       }
00360     
00361     std::vector<std::string> sources = 
00362       params.getParameter<std::vector<std::string> >("@all_essources");
00363 
00364     for(std::vector<std::string>::iterator itName = sources.begin(), itNameEnd = sources.end();
00365         itName != itNameEnd;
00366         ++itName) 
00367       {
00368         ParameterSet providerPSet = params.getParameter<ParameterSet>(*itName);
00369         SourceFactory::get()->addTo(cp, 
00370                                     providerPSet, 
00371                                     common.processName_, 
00372                                     common.releaseVersion_, 
00373                                     common.passID_);
00374     }
00375   }

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

Definition at line 379 of file EventProcessor.cc.

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

00382   {
00383     using namespace edm::eventsetup;
00384     boost::shared_ptr<edm::EDLooper> vLooper;
00385     
00386     std::vector<std::string> loopers =
00387       params.getParameter<std::vector<std::string> >("@all_loopers");
00388 
00389     if(loopers.size() == 0) {
00390        return vLooper;
00391     }
00392    
00393     assert(1 == loopers.size());
00394 
00395     for(std::vector<std::string>::iterator itName = loopers.begin(), itNameEnd = loopers.end();
00396         itName != itNameEnd;
00397         ++itName) 
00398       {
00399         ParameterSet providerPSet = params.getParameter<ParameterSet>(*itName);
00400         vLooper = LooperFactory::get()->addTo(cp, 
00401                                     providerPSet, 
00402                                     common.processName_, 
00403                                     common.releaseVersion_, 
00404                                     common.passID_);
00405       }
00406       return vLooper;
00407     
00408   }

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

Definition at line 826 of file Schedule.cc.

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

00828                                                     {
00829     sum.timesVisited = path.timesVisited(which);
00830     sum.timesPassed  = path.timesPassed(which);
00831     sum.timesFailed  = path.timesFailed(which);
00832     sum.timesExcept  = path.timesExcept(which);
00833     sum.moduleLabel  = 
00834       path.getWorker(which)->description().moduleLabel_;
00835   }

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

Definition at line 820 of file Schedule.cc.

Referenced by fillPathSummary().

00821                                                 {
00822   }

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

Definition at line 838 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(), pyDBSRunClass::temp, edm::PathSummary::timesExcept, edm::Path::timesExcept(), edm::Path::timesFailed(), edm::PathSummary::timesFailed, edm::Path::timesPassed(), edm::PathSummary::timesPassed, edm::PathSummary::timesRun, and edm::Path::timesRun().

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

00838                                                       {
00839     sum.name        = path.name();
00840     sum.bitPosition = path.bitPosition();
00841     sum.timesRun    = path.timesRun();
00842     sum.timesPassed = path.timesPassed();
00843     sum.timesFailed = path.timesFailed();
00844     sum.timesExcept = path.timesExcept();
00845 
00846     Path::size_type sz = path.size();
00847     std::vector<ModuleInPathSummary> temp(sz);
00848     for (size_t i = 0; i != sz; ++i) {
00849       fillModuleInPathSummary(path, i, temp[i]);
00850     }
00851     sum.moduleInPathSummaries.swap(temp);
00852   }

template<class T, class SORT>

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

Definition at line 483 of file SortedCollection.h.

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

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

template<class T, class A, class Comp>

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

Definition at line 118 of file fillPtrVector.h.

References edm::detail::reallyfillPtrVector().

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

template<class T, class A>

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

Definition at line 109 of file fillPtrVector.h.

References edm::detail::reallyfillPtrVector().

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

template<class T, class A>

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

Definition at line 100 of file fillPtrVector.h.

References edm::detail::reallyfillPtrVector().

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

template<class T, class A>

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

Definition at line 91 of file fillPtrVector.h.

References edm::detail::reallyfillPtrVector().

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

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 261 of file Vector.h.

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

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

template<class T, class SORT>

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

Definition at line 460 of file SortedCollection.h.

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

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

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

References edm::RefVector< C, T, F >::fillView().

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

template<typename T>

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

Definition at line 245 of file RefToBaseVector.h.

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

00246                                                          {
00247     obj.fillView(pointers);
00248   }

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

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

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

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
	)			`[inline]`

Definition at line 111 of file FillView.h.

References edm::detail::reallyFillView().

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

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
	)			`[inline]`

Definition at line 101 of file FillView.h.

References edm::detail::reallyFillView().

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

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
	)			`[inline]`

Definition at line 91 of file FillView.h.

References edm::detail::reallyFillView().

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

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
	)			`[inline]`

Definition at line 81 of file FillView.h.

References edm::detail::reallyFillView().

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

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 418 of file DetSetVector.h.

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

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

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

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

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

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

Definition at line 865 of file Schedule.cc.

References fillWorkerSummaryAux().

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

00865                                                           {
00866     fillWorkerSummaryAux(*pw, sum);
00867   }

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

Definition at line 855 of file Schedule.cc.

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

Referenced by fillWorkerSummary().

00855                                                             {
00856     sum.timesVisited = w.timesVisited();
00857     sum.timesRun     = w.timesRun();
00858     sum.timesPassed  = w.timesPassed();
00859     sum.timesFailed  = w.timesFailed();
00860     sum.timesExcept  = w.timesExcept();
00861     sum.moduleLabel  = w.description().moduleLabel_;
00862   }

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

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

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

Referenced by edm::ParameterSet::fromString(), and edm::EventPrincipal::unscheduledFill().

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

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

Definition at line 49 of file ReflexTools.cc.

References e, get_final_type(), and i.

00052   {
00053     // Look for a sub-type named 'nested_type'
00054     for (Type_Iterator
00055            i = type_to_search.SubType_Begin(),
00056            e = type_to_search.SubType_End();
00057          i != e;
00058          ++i)
00059       {
00060         if (i->Name() == nested_type)
00061           {
00062             found_type = get_final_type(*i);
00063             return true;
00064           }
00065       }
00066     return false;
00067   }

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

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

template<class T, class U>

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

Definition at line 103 of file ParameterSet.cc.

Referenced by edm::TestMix::analyze(), edm::pset::PythonFormWriter::doSchedule(), edm::service::ELoutput::emit(), edm::ELlog4cplus::emit(), edm::pset::explode(), edm::PythiaMuEnrichSource::initdc(), LoggedErrorsSummary(), edm::PythiaSource::produce(), edm::TypeID::stripTemplate(), edm::TrieNode< T >::subNodeByLabel(), edm::pset::PythonFormWriter::visitVEntry(), and edm::pset::PythonFormWriter::writeCommaSeparated().

00104   { return p.first; }

void edm::FlushMessageLog ( )

Definition at line 43 of file MessageLogger.cc.

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

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

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

template<typename ForwardSequence, typename Func>

Func edm::for_all	(	ForwardSequence &	s,
		Func	f
	)			`[inline]`

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

wrapper for std::for_each

Definition at line 16 of file Algorithms.h.

Referenced by edm::Schedule::beginJob(), edm::detail::CachedProducts::clear(), edm::Schedule::clearCounters(), edm::Path::clearCounters(), edm::Schedule::closeOutputFiles(), copySlotsToFrom(), copySlotsToFromReverse(), edm::Schedule::fillEndPath(), edm::Schedule::fillTrigPath(), edm::RootOutputTree::fillTTree(), install(), loadCap(), main(), edm::Schedule::openNewOutputFilesIfNeeded(), edm::Schedule::openOutputFiles(), edm::EDLooper::prepareForNextLoop(), edm::eventsetup::EventSetupProvider::proxyProviderDescriptions(), edm::Schedule::resetAll(), edm::eventsetup::EventSetupRecordProvider::resetProxies(), edm::eventsetup::EventSetupProvider::resetRecordPlusDependentRecords(), edm::Schedule::respondToCloseInputFile(), edm::Schedule::respondToCloseOutputFiles(), edm::Schedule::respondToOpenInputFile(), edm::Schedule::respondToOpenOutputFiles(), edm::Schedule::runEndPaths(), edm::Schedule::runTriggerPaths(), edm::eventsetup::DependentEventSetupRecordProvider::setDependentProviders(), edm::eventsetup::EventSetupRecordProvider::usePreferred(), edm::Schedule::writeLumi(), edm::Schedule::writeRun(), edm::DataViewImpl::~DataViewImpl(), and edm::Factory::~Factory().

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

template<typename S, typename T>

S& edm::formatFile	(	const T &	f,
		S &	os
	)			`[inline]`

Definition at line 479 of file JobReport.h.

Referenced by print().

00479                                    {
00480 
00481     if (f.fileHasBeenClosed) {
00482       os << "\n<State  Value=\"closed\"/>";
00483     } else {
00484       os << "\n<State  Value=\"open\"/>";
00485     }
00486     os << "\n<LFN>" << f.logicalFileName << "</LFN>";
00487     os << "\n<PFN>" << f.physicalFileName << "</PFN>";
00488     os << "\n<Catalog>" << f.catalog << "</Catalog>";
00489     os << "\n<ModuleLabel>" << f.moduleLabel << "</ModuleLabel>";
00490     os << "\n<GUID>" << f.guid << "</GUID>";
00491     os << "\n<Branches>";
00492     std::vector<std::string>::const_iterator iBranch;
00493     for (iBranch = f.branchNames.begin(); 
00494         iBranch != f.branchNames.end(); 
00495         iBranch++) {
00496       os << "\n  <Branch>" << *iBranch << "</Branch>";
00497     }
00498     os << "\n</Branches>";
00499     return os;
00500   }

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

Definition at line 56 of file ELlog4cplus.cc.

References c.

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

00056                                             {
00057 
00058 static char ts[] = "dd-Mon-yyyy hh:mm:ss XYZ";
00059 
00060 
00061 #ifdef ANALTERNATIVE
00062   char * c  = ctime( &t );                      // 6/14/99 mf Can't be static!
00063   strncpy( ts+ 0, c+ 8, 2 );  // dd
00064   strncpy( ts+ 3, c+ 4, 3 );  // Mon
00065   strncpy( ts+ 7, c+20, 4 );  // yyyy
00066   strncpy( ts+12, c+11, 8 );  // hh:mm:ss
00067   strncpy( ts+21, tzname[localtime(&t)->tm_isdst], 3 );  // CST
00068 #endif
00069 
00070   strftime( ts, strlen(ts)+1, "%d-%b-%Y %H:%M:%S %Z", localtime(&t) );
00071                 // mf 4-9-04
00072 
00073 
00074   return ts;
00075 
00076 }  // formatTime()

bool edm::FreshErrorsExist ( )

Definition at line 24 of file LoggedErrorsSummary.cc.

References edm::MessageSender::freshError.

00024                         {
00025   return  MessageSender::freshError;
00026 }

cpu_type edm::@7814::get_cpu_type ( ) [static]

Definition at line 36 of file MallocOpts.cc.

References a, AMD_CPU, INTEL_CPU, and UNKNOWN_CPU.

Referenced by edm::MallocOptionSetter::retrieveFromCpuType().

00037     {
00038       // issue: these need to be static.  The asm instruction combined
00039       // with optimization on the 64 bit platform moves the stack data
00040       // member around in such a way that the =m directive misses the
00041       // the location.   Of course this means that this routine is not
00042       // multithread safe.
00043       static volatile int op=0,a;
00044       static volatile int ans[4];
00045 
00046 // Still some problem on x86_64, so only i386 for now    
00047 #if defined(__x86_64__)
00048 
00049       __asm__ __volatile__ ("pushq %%rdx;\
00050  pushq %%rcx;                            \
00051  pushq %%rsi;                            \
00052  pushq %%rbx;                            \
00053  cpuid;                                  \
00054  movq  %%rbx,%%rsi;                      \
00055  popq  %%rbx;                            \
00056  movl  %%ecx,%0;                         \
00057  movl  %%edx,%1;                         \
00058  movl  %%esi,%2;                         \
00059  movl  %%eax,%3;                         \
00060  popq  %%rsi;                            \
00061  popq  %%rcx;                            \
00062  popq  %%rdx;"
00063                             : "=m"(ans[2]), "=m"(ans[1]), "=m"(ans[0]), "=m"(a)
00064                             : "a"(op)
00065                             );
00066 
00067 #elif defined(__i386__)
00068 
00069 
00070       __asm__ __volatile__ ("pushl %%edx;\
00071  pushl %%ecx;                            \
00072  pushl %%esi;                            \
00073  pushl %%ebx;                            \
00074  cpuid;                                  \
00075  movl  %%ebx,%%esi;                      \
00076  popl  %%ebx;                            \
00077  movl  %%ecx,%0;                         \
00078  movl  %%edx,%1;                         \
00079  movl  %%esi,%2;                         \
00080  movl  %%eax,%3;                         \
00081  popl  %%esi;                            \
00082  popl  %%ecx;                            \
00083  popl  %%edx;"
00084                             : "=m"(ans[2]), "=m"(ans[1]), "=m"(ans[0]), "=m"(a)
00085                             : "a"(op)
00086                             );
00087 
00088     
00089 #else
00090       const char* unknown_str = "Unknown";
00091       // int unknown_sz = strlen(unknown_str);
00092       strcpy((char*)&ans[0],unknown_str);
00093 #endif
00094       
00095       const char* amd_str = "AuthenticAMD";
00096       int amd_sz = strlen(amd_str);
00097       const char* intel_str = "GenuineIntel";
00098       int intel_sz = strlen(intel_str);
00099     
00100       char* str = (char*)&ans[0];
00101       ans[3]=0;
00102 
00103       return strncmp(str,amd_str,amd_sz)==0?AMD_CPU:
00104         strncmp(str,intel_str,intel_sz)==0?INTEL_CPU:UNKNOWN_CPU;
00105     }

Type edm::get_final_type ( Type t )

Definition at line 42 of file ReflexTools.cc.

Referenced by find_nested_type_named().

00043   {
00044     while (t.IsTypedef()) t = t.ToType();
00045     return t;
00046   }

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

Definition at line 32 of file OutputModule.cc.

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

00032                              {
00033     edm::Service<edm::ConstProductRegistry> reg;
00034     return reg->allBranchDescriptions();
00035   }

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

Definition at line 37 of file OutputModule.cc.

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

00037                                                 {
00038     edm::Service<edm::service::TriggerNamesService> tns;
00039     return tns->getTrigPaths();
00040   }

TBranch* edm::@9942::getAuxiliaryBranch	(	TTree *	tree,
		BranchType const &	branchType
	)			`[static]`

Definition at line 18 of file RootTree.cc.

References BranchTypeToAuxBranchName(), and BranchTypeToAuxiliaryBranchName().

00018                                                                              {
00019       TBranch *branch = tree->GetBranch(BranchTypeToAuxiliaryBranchName(branchType).c_str());
00020       if (branch == 0) {
00021         branch = tree->GetBranch(BranchTypeToAuxBranchName(branchType).c_str());
00022       }
00023       return branch;
00024     }

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

00040                                                  {
00041     static errors::FilledMap fm;
00042     setme = &fm.trans_;
00043   }

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

Definition at line 9 of file GetEnvironmentVariable.h.

References p.

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

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

Definition at line 28 of file BufferArea.cc.

References b, and holder.

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

TBranch* edm::@9942::getEventEntryInfoBranch	(	TTree *	tree,
		BranchType const &	branchType
	)			`[static]`

Definition at line 25 of file RootTree.cc.

References BranchTypeToBranchEntryInfoBranchName().

00025                                                                                   {
00026       TBranch *branch = tree->GetBranch(BranchTypeToBranchEntryInfoBranchName(branchType).c_str());
00027       return branch;
00028     }

int edm::getFileFormatVersion ( )

Definition at line 5 of file GetFileFormatVersion.cc.

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

00005 { return 10; }

MallocOptionSetter & edm::getGlobalOptionSetter ( )

Definition at line 206 of file MallocOpts.cc.

References global_malloc_options.

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

00207   {
00208     return global_malloc_options;
00209   }

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

Definition at line 18 of file ClassFiller.cc.

00018                                         {
00019     return cc.Name(ROOT::Reflex::SCOPED);
00020   }

ParameterSet edm::getParameterSet ( ParameterSetID const & id )

Definition at line 469 of file ParameterSet.cc.

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

Referenced by EcalTrigPrimProducer::beginJob(), and EcalSelectiveReadoutProducer::getBinOfMax().

00469                                             {
00470     ParameterSet result;
00471     if(!pset::Registry::instance()->getMapped(id, result)) {
00472         throw edm::Exception(errors::Configuration,"MissingParameterSet:")
00473           << "Parameter Set ID '" << id
00474           << "' not found.";
00475     }
00476     return result;
00477   }

std::string edm::getPassID ( ) [inline]

Definition at line 8 of file GetPassID.h.

Referenced by edm::BMixingModule::BMixingModule(), edm::Schedule::fillWorkers(), edm::EventProcessor::init(), makeInput(), makeInserter(), and edm::Schedule::Schedule().

00008                          {
00009     static std::string passID;
00010     // return empty string for now.
00011     return passID; 
00012   }

edm::ParameterSet edm::getProcessParameterSet ( )

Definition at line 48 of file Registry.cc.

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

Referenced by edm::service::PrescaleService::reconfigure().

00049   {
00050     edm::pset::Registry* reg = edm::pset::Registry::instance();
00051     edm::ParameterSetID id = edm::pset::getProcessParameterSetID(reg);
00052 
00053     edm::ParameterSet result;
00054     if (!reg->getMapped(id, result))
00055       throw edm::Exception(errors::EventCorruption, "Uknown ParameterSetID")
00056         << "Unable to find the ParameterSet for id: "
00057         << id
00058         << ";\nthis was supposed to be the process ParameterSet\n";
00059 
00060     return result;
00061   }

template<typename T>

T const * edm::getProduct ( RefCore const & ref ) [inline]

Definition at line 53 of file RefCoreGet.h.

References edm::RefCore::isTransient(), name, p, edm::errors::ProductNotFound, and edm::RefCore::productPtr().

00053                                   {
00054     T const* p = static_cast<T const *>(ref.productPtr());
00055     if (p != 0) return p;
00056     if (ref.isTransient()) {
00057         throw edm::Exception(errors::ProductNotFound)
00058           << "RefCore: A request to resolve a transient reference to a product of type: "
00059           << typeid(T).name()
00060           << "\ncan not be satisfied because the pointer to the product is null.\n";
00061     }
00062     return refcore::getProductPtr_<T>(ref);
00063   }

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

T const* edm::getPtr	(	RefCore const &	product,
		RefItem< KEY > const &	item
	)			`[inline]`

Definition at line 42 of file RefItemGet.h.

References p, edm::RefItem< KEY >::ptr(), and edm::RefItem< KEY >::setPtr().

00042                                                                     {
00043     T const* p = static_cast<T const *>(item.ptr());
00044     if(0==p){
00045       p=getPtr_<C, T, F>(product,item);
00046       item.setPtr(p);
00047     }
00048     return p;
00049   }

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

T const* edm::getPtr_	(	RefCore const &	product,
		RefItem< KEY > const &	item
	)			`[inline]`

Definition at line 36 of file RefItemGet.h.

00036                                                                      {
00037     return refitem::GetPtrImpl<C, T, F, KEY>::getPtr_(product, item);
00038   }

template<typename C>

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

Definition at line 28 of file getRef.h.

Referenced by reco::modules::MatcherBase< C1, C2, M >::produce(), and AssociatedVariableCollectionSelector< InputCollection, VarCollection, Selector, OutputCollection, StoreContainer, RefAdder >::select().

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

ROOT::Reflex::Type const edm::@9991::getReflectClass ( std::type_info const & ti ) [static]

Definition at line 62 of file ClassFiller.cc.

Referenced by getTClass().

00062                                                                  {
00063       ROOT::Reflex::Type const typ = ROOT::Reflex::Type::ByTypeInfo(ti);
00064       return typ;
00065     }

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

Definition at line 206 of file Utilities.cc.

References Exception, in, edm::StreamerInputSource::mergeIntoRegistry(), p, and readHeaderFromStream().

00207   {
00208     edm::ProductRegistry pr;
00209     ifstream ist(filename.c_str(), std::ios_base::binary | std::ios_base::in);
00210 
00211     if(!ist)
00212       {
00213         throw cms::Exception("ReadRegistry","getRegFromFile")
00214           << "cannot open file " << filename;
00215       }
00216 
00217     std::auto_ptr<SendJobHeader> p = readHeaderFromStream(ist);
00218     StreamerInputSource::mergeIntoRegistry(*p, pr, false);
00219     return pr;
00220   }

std::string edm::getReleaseVersion ( )

Definition at line 7 of file GetReleaseVersion.cc.

References STRINGIFY.

Referenced by edm::BMixingModule::BMixingModule(), BTagValidator::BTagValidator(), CaloTauTagVal::CaloTauTagVal(), DQMEventInfo::DQMEventInfo(), DQMFileSaver::endJob(), MEtoEDMConverter::endRun(), edm::Schedule::fillWorkers(), edm::EventProcessor::init(), makeInput(), makeInserter(), PFTauTagVal::PFTauTagVal(), FUShmDQMOutputService::postEventProcessing(), PrimaryVertexAnalyzer::PrimaryVertexAnalyzer(), DQMStore::save(), edm::Schedule::Schedule(), edm::StreamerOutputModuleBase::serializeRegistry(), TauTagVal::TauTagVal(), TrackParameterAnalyzer::TrackParameterAnalyzer(), and XmasToDQMEventInfo::XmasToDQMEventInfo().

00007                                 {
00008     static std::string const releaseVersion(STRINGIFY(PROJECT_VERSION));
00009     return releaseVersion; 
00010   }

TClass* edm::@9991::getRootClass ( std::string const & name ) [static]

Definition at line 67 of file ClassFiller.cc.

References edm::errors::Configuration, and tc.

Referenced by getTClass().

00067                                                 {
00068       TClass* tc = TClass::GetClass(name.c_str());    
00069       
00070       // get ROOT TClass for this product
00071       // CINT::Type* cint_type = CINT::Type::get(typ_ref);
00072       // tc_ = cint_type->rootClass();
00073       // TClass* tc = TClass::GetClass(typeid(se));
00074       // tc_ = TClass::GetClass("edm::SendEvent");
00075       
00076       if(tc == 0) {
00077         throw edm::Exception(errors::Configuration,"getRootClass")
00078           << "could not find TClass for " << name
00079           << "\n";
00080       }
00081       
00082       return tc;
00083     }

int edm::getSigNum ( )

Definition at line 36 of file UnixSignalHandlers.cc.

References signum_lock, signum_value, and sl.

00037     {
00038       boost::mutex::scoped_lock sl(signum_lock);
00039       int rc = signum_value;
00040       ++signum_value;
00041       return rc;
00042     }

TBranch* edm::@9942::getStatusBranch	(	TTree *	tree,
		BranchType const &	branchType
	)			`[static]`

Definition at line 29 of file RootTree.cc.

References BranchTypeToProductStatusBranchName().

00029                                                                           {
00030       TBranch *branch = tree->GetBranch(BranchTypeToProductStatusBranchName(branchType).c_str());
00031       return branch;
00032     }

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

Definition at line 87 of file ClassFiller.cc.

References getReflectClass(), and getRootClass().

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

00087                                             {
00088     ROOT::Reflex::Type const typ = getReflectClass(ti);
00089     return getRootClass(typ.Name(ROOT::Reflex::SCOPED));
00090   }

template<class T>

TClass* edm::@10025::getTClassFor ( ) [inline, static]

Definition at line 32 of file Utilities.cc.

References Exception, getTClass(), loadextrastuff(), and name.

00033     {
00034       static TClass* ans = 0;
00035       loadextrastuff();
00036       if(!ans) {
00037         if((ans = getTClass(typeid(T)))==0) {
00038           throw cms::Exception("gettclass")
00039             << "Could not get the TClass for "
00040             << typeid(T).name() << "\n";
00041         }
00042       }
00043       return ans;
00044     }

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

Definition at line 57 of file MessageLogger.cc.

References edm::MessageLoggerQ::MLqGRP().

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

void edm::HaltMessageLogging ( )

Definition at line 39 of file MessageLogger.cc.

References edm::MessageLoggerQ::MLqSHT().

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

bool edm::@7818::hasCintDictionary ( std::string const & name ) [static]

Definition at line 164 of file ReflexTools.cc.

Referenced by checkType().

00164                                              {
00165       std::auto_ptr<G__ClassInfo> ci(new G__ClassInfo(name.c_str()));
00166         return (ci.get() && ci->IsLoaded());
00167     }

HRTimeType edm::hrRealTime ( ) [inline]

Definition at line 74 of file HRRealTime.h.

00074                                  {
00075     return details::rdtsc();
00076   }

bool edm::if_edm_ref_get_value_type	(	Type const &	possible_ref,
		Type &	result
	)

Definition at line 70 of file ReflexTools.cc.

References value_type_of(), and void.

00072   {
00073     TypeTemplate primary_template_id(possible_ref.TemplateFamily());
00074     if (primary_template_id == TypeTemplate::ByName("edm::Ref", 3)) {
00075       (void)value_type_of(possible_ref, result);
00076       return true;
00077     } else {
00078       result = possible_ref;    
00079       return false;
00080     }
00081   }

bool edm::if_edm_ref_get_value_type	(	ROOT::Reflex::Type const &	possible_ref,
		ROOT::Reflex::Type &	value_type
	)

Referenced by is_sequence_wrapper().

bool edm::if_edm_refToBase_get_value_type	(	Type const &	possible_ref,
		Type &	result
	)

Definition at line 84 of file ReflexTools.cc.

References value_type_of(), and void.

00086   {
00087     TypeTemplate primary_template_id(possible_ref.TemplateFamily());
00088     if (primary_template_id == TypeTemplate::ByName("edm::RefToBase", 1)) {
00089       (void)value_type_of(possible_ref, result);
00090       return true;
00091     } else {
00092       result = possible_ref;    
00093       return false;
00094     }
00095   }

bool edm::if_edm_refToBase_get_value_type	(	ROOT::Reflex::Type const &	possible_ref,
		ROOT::Reflex::Type &	value_type
	)

Referenced by is_sequence_wrapper().

void edm::@7335::install	(	actions::ActionCodes	code,
		ActionTable::ActionMap &	out,
		const ParameterSet &	pset
	)			`[inline, static]`

Definition at line 44 of file Actions.cc.

References edm::actions::actionName(), for_all(), edm::ParameterSet::getUntrackedParameter(), bookConverter::opts, and v.

Referenced by edm::ActionTable::ActionTable().

00047     {
00048       using namespace boost::lambda;
00049       typedef std::vector<std::string> vstring;
00050 
00051       // we cannot have parameters in the main process section so look
00052       // for an untrakced (optional) ParameterSet called "options" for
00053       // now.  Notice that all exceptions (most actally) throw
00054       // edm::Exception with the configuration category.  This
00055       // category should probably be more specific or a derived
00056       // exception type should be used so the catch can be more
00057       // specific.
00058 
00059 //      cerr << pset.toString() << std::endl;
00060 
00061       ParameterSet defopts;
00062       ParameterSet opts = 
00063         pset.getUntrackedParameter<ParameterSet>("options", defopts);
00064       //cerr << "looking for " << actionName(code) << std::endl;
00065       vstring v = 
00066         opts.getUntrackedParameter(actionName(code),vstring());
00067       for_all(v, var(out)[_1] = code);      
00068 
00069     }

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

Definition at line 106 of file UnixSignalHandlers.cc.

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

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

00107     {
00108       sigset_t oldset;
00109       edm::disableAllSigs(&oldset);
00110 #if defined(__linux__)
00111       edm::disableRTSigs();
00112 #endif
00113       edm::installSig(signum,edm::ep_sigusr2);
00114       edm::reenableSigs(&oldset);
00115     }

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

Definition at line 119 of file UnixSignalHandlers.cc.

References MUST_BE_ZERO, NULL, sigaction, sigaddset, and sigemptyset.

Referenced by installCustomHandler().

00120     {
00121       // set up my RT signal now
00122       struct sigaction act;
00123       memset(&act,0,sizeof(act));
00124       act.sa_sigaction = func;
00125       act.sa_flags = SA_RESTART;
00126       
00127       // get my signal number
00128       int mysig = signum;
00129       if( mysig == SIGKILL ) {
00130         perror("Cannot install handler for KILL signal");
00131         return;
00132       } else if( mysig == SIGSTOP ) {
00133          perror("Cannot install handler for STOP signal");
00134         return;
00135       }
00136       
00137       if(sigaction(mysig,&act,NULL) != 0) {
00138           perror("sigaction failed");
00139           abort();
00140       }
00141       
00142       sigset_t newset;
00143       MUST_BE_ZERO(sigemptyset(&newset));
00144       MUST_BE_ZERO(sigaddset(&newset,mysig));
00145       MUST_BE_ZERO(pthread_sigmask(SIG_UNBLOCK,&newset,0));
00146     }

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

Definition at line 132 of file ReflexTools.cc.

References find_nested_type_named().

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

00134   {
00135 
00136     static TypeTemplate ref_vector_template_id(TypeTemplate::ByName("edm::RefToBaseVector", 1));
00137     static std::string member_type("member_type");
00138     TypeTemplate primary_template_id(possible_ref_vector.TemplateFamily());
00139     if ( primary_template_id == ref_vector_template_id )
00140       return find_nested_type_named(member_type, possible_ref_vector, value_type);
00141     return false;    
00142   }

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

Definition at line 119 of file ReflexTools.cc.

References find_nested_type_named().

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

00121   {
00122 
00123     static TypeTemplate ref_vector_template_id(TypeTemplate::ByName("edm::RefVector", 3));
00124     static std::string member_type("member_type");
00125     TypeTemplate primary_template_id(possible_ref_vector.TemplateFamily());
00126     if ( primary_template_id == ref_vector_template_id )
00127       return find_nested_type_named(member_type, possible_ref_vector, value_type);
00128     return false;    
00129   }

bool edm::is_sequence_wrapper	(	Type const &	possible_sequence_wrapper,
		Type &	found_sequence_value_type
	)

Definition at line 98 of file ReflexTools.cc.

References if_edm_ref_get_value_type(), if_edm_refToBase_get_value_type(), value_type_of(), and wrapper_type_of().

00100   {
00101     Type possible_sequence;
00102     if (!edm::wrapper_type_of(possible_sequence_wrapper, possible_sequence))
00103       return false;
00104 
00105     Type outer_value_type;
00106     if (!edm::value_type_of(possible_sequence, outer_value_type))
00107       return false;
00108 
00109     if (!if_edm_ref_get_value_type(outer_value_type,
00110                                    found_sequence_value_type)) {
00111 
00112       if_edm_refToBase_get_value_type(outer_value_type,
00113                                       found_sequence_value_type);
00114     }
00115     return true;
00116   }

bool edm::is_sequence_wrapper	(	ROOT::Reflex::Type const &	possible_sequence_wrapper,
		ROOT::Reflex::Type &	found_sequence_value_type
	)

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 checkHistoryConsistency(), and isDescendant().

00046                                                                {
00047     if (a.size() >= b.size()) return false;
00048     typedef ProcessHistory::collection_type::const_iterator const_iterator;
00049     for (const_iterator itA = a.data().begin(), itB = b.data().begin(),
00050          itAEnd = a.data().end(); itA != itAEnd; ++itA, ++itB) {
00051       if (*itA != *itB) return false;
00052     }
00053     return true;
00054   }

bool edm::isDebugEnabled ( )

Definition at line 27 of file MessageLogger.cc.

References edm::MessageDrop::instance().

00027                       {
00028   return ( edm::MessageDrop::instance()->debugEnabled );
00029 }

bool edm::isDescendant	(	ProcessHistory const &	a,
		ProcessHistory const &	b
	)			`[inline]`

Definition at line 107 of file ProcessHistory.h.

References isAncestor().

00107                                                                  {
00108     return isAncestor(b, a);
00109   }

bool edm::isInfoEnabled ( )

Definition at line 31 of file MessageLogger.cc.

References edm::MessageDrop::instance().

00031                      {
00032   return( edm::MessageDrop::instance()->infoEnabled );
00033 }

bool edm::isMessageProcessingSetUp ( )

Definition at line 49 of file MessageLogger.cc.

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

00049                                 {                               // 6/20/08 mf
00050 //  std::cerr << "isMessageProcessingSetUp: \n";
00051 //  std::cerr << "messageLoggerScribeIsRunning = "
00052 //          << (int)MessageDrop::instance()->messageLoggerScribeIsRunning << "\n";
00053   return (MessageDrop::instance()->messageLoggerScribeIsRunning == 
00054                         MLSCRIBE_RUNNING_INDICATOR); 
00055 }

bool edm::isnan ( long double q ) [inline]

Definition at line 73 of file math.h.

Referenced by CaloHitResponse::add(), ElectronCalibrationUniv::analyze(), PrimaryVertexAnalyzer::analyze(), ElectronCalibration::analyze(), DetIdAssociator::buildMap(), GsfVertexWeightCalculator::calculate(), TwoBodyDecayEstimator::checkValues(), SiPixelGainCalibrationAnalysis::doFits(), MagGeometry::fieldInTesla(), AlignmentExtendedCorrelationsStore::fillCovariance(), AlignmentExtendedCorrelationsStore::fillCovarianceT(), BSFitter::Fit(), CaloDetIdAssociator::getDetIdPoints(), PixelErrorParametrization::getError(), sim::Field::GetFieldValue(), SequentialVertexFitter< 5 >::hasNan(), ConversionFastHelix::helixStateAtVertex(), RoadSearchTrackCandidateMakerAlgorithm::initialTrajectoryFromTriplet(), isnan(), OptOCOPS::makeMeasurement(), SensitiveDetector::NaNTrap(), TtHadLRSignalSelObservables::operator()(), EcalUncalibRecHitFixedAlphaBetaAlgo< C >::PerformAnalyticFit(), CaloRecoTauDiscriminationAgainstElectron::produce(), SimpleCosmicBONSeeder::seeds(), SeedGeneratorForCosmics::seeds(), ConversionFastHelix::straightLineStateAtVertex(), PrimaryVertexMonitor::vertexPlots(), CSCCrossTalkAnalyzer::~CSCCrossTalkAnalyzer(), CSCGainAnalyzer::~CSCGainAnalyzer(), CSCOldCrossTalkAnalyzer::~CSCOldCrossTalkAnalyzer(), and CSCOldGainAnalyzer::~CSCOldGainAnalyzer().

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

bool edm::isnan ( double d ) [inline]

Definition at line 71 of file math.h.

References equal_isnan().

00071 { return equal_isnan(d); }

bool edm::isnan ( float f ) [inline]

Definition at line 69 of file math.h.

References isnan().

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

bool edm::isSameEvent	(	EventPrincipal const &	a,
		EventPrincipal const &	b
	)			`[inline]`

Definition at line 165 of file EventPrincipal.h.

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

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

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

Definition at line 20 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 checkConsistency(), and isSameEvent().

00020                                                                 {
00021     return
00022       a.id_ == b.id_ &&
00023       a.processGUID_ == b.processGUID_ &&
00024       a.luminosityBlock_ == b.luminosityBlock_ &&
00025       a.time_ == b.time_ &&
00026       a.isRealData_ == b.isRealData_ &&
00027       a.experimentType_ == b.experimentType_ &&
00028       a.bunchCrossing_ == b.bunchCrossing_ &&
00029       a.storeNumber_ == b.storeNumber_;
00030   }

bool edm::isWarningEnabled ( )

Definition at line 35 of file MessageLogger.cc.

References edm::MessageDrop::instance().

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

00035                         {
00036   return( edm::MessageDrop::instance()->warningEnabled );
00037 }

template<typename V, typename T>

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

visits only leaf nodes

Definition at line 298 of file Trie.h.

References e, label, p, and v.

00298                                                                                      {
00299     typedef TrieNode<T> const node_base;
00300     typedef TrieNodeIter<T> node_iterator;
00301     node_iterator e;
00302     node_iterator p(&n);
00303     if (p==e) return true;
00304     for (; p!=e; ++p) {
00305       if (iterateTrieLeaves(v,*p,label+(char)p.label()) )
00306         v((*p).value(),label+(char)p.label());
00307     }
00308     return false;
00309   }

static const TimeValue_t edm::kLowMask ( 0xFFFFFFFF ) [static]

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

Definition at line 22 of file ClassFiller.cc.

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

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

00022                                       {
00023     static std::string const fname("LCGReflex/");
00024     FDEBUG(1) << "Loading dictionary for " << name << "\n";
00025     edmplugin::PluginCapabilities::get()->load(fname + name);
00026     checkDictionaries(name);
00027     if (!missingTypes().empty()) {
00028       StringSet missing = missingTypes();
00029       missingTypes().clear();
00030       for_all(missing, loadCap);
00031     }
00032   }

void edm::loadExtraClasses ( )

Definition at line 47 of file ClassFiller.cc.

References loadCap().

Referenced by loadextrastuff(), and edm::StreamerInputSource::mergeIntoRegistry().

00047                           {
00048     static bool done = false;
00049     if (done == false) {
00050         loadCap(std::string("edm::StreamedProduct"));
00051         loadCap(std::string("std::vector<edm::StreamedProduct>"));
00052         loadCap(std::string("edm::SendEvent"));
00053         loadCap(std::string("std::vector<edm::BranchDescription>"));
00054         loadCap(std::string("edm::SendJobHeader"));
00055     }
00056     G__SetCatchException(0);
00057     ROOT::Cintex::Cintex::Enable();
00058     done=true;
00059   }

void edm::@10025::loadextrastuff ( ) [static]

Definition at line 21 of file Utilities.cc.

References loadExtraClasses().

Referenced by getTClassFor().

00022     {
00023       static bool loaded = false;
00024       if(loaded==false)
00025         {
00026           loadExtraClasses();
00027           loaded=true;
00028         }
00029     }

static bool edm::loadLibraryForClass ( const char * classname ) [static]

Definition at line 109 of file RootAutoLibraryLoader.cc.

References e, edmplugin::PluginCapabilities::get(), name, edm::root::stdNamespaceAdder(), and t.

Referenced by ALL_AutoLoadCallback(), and edm::RootAutoLibraryLoader::GetClass().

00110 {
00111   //std::cout <<"loadLibaryForClass"<<std::endl;
00112   if(0 == classname) {
00113     return false;
00114   }
00115   //std::cout <<"asking to find "<<classname<<std::endl;
00116   static const std::string cPrefix("LCGReflex/");
00117   //std::cout <<"asking to find "<<cPrefix+classname<<std::endl;
00118   try {
00119     //give ROOT a name for the file we are loading
00120     RootLoadFileSentry sentry;
00121     if(edmplugin::PluginCapabilities::get()->tryToLoad(cPrefix+classname)) {
00122       ROOT::Reflex::Type t = ROOT::Reflex::Type::ByName(classname);
00123       if (ROOT::Reflex::Type() == t) {
00124         //would be nice to issue a warning here
00125         return false;
00126       }
00127       if(!t.IsComplete()) {
00128         //would be nice to issue a warning here.  Not sure the remainder of this comment is correct.
00129         // this message happens too often (too many false positives) to be useful plus ROOT will complain about a missing dictionary
00130         //std::cerr <<"Warning: Reflex knows about type '"<<classname<<"' but has no dictionary for it."<<std::endl;
00131         return false;
00132       }
00133     } else {
00134       //see if adding a std namespace helps
00135       std::string name = root::stdNamespaceAdder(classname);
00136       //std::cout <<"see if std helps"<<std::endl;
00137       if (not edmplugin::PluginCapabilities::get()->tryToLoad(cPrefix+name)) {
00138         // Too many false positives on built-in types here.
00139         return false;
00140       }
00141       ROOT::Reflex::Type t = ROOT::Reflex::Type::ByName(name);
00142       if (ROOT::Reflex::Type() == t) {
00143         t = ROOT::Reflex::Type::ByName(classname);
00144         if (ROOT::Reflex::Type() == t) {
00145           //would be nice to issue a warning here
00146           return false;
00147         }
00148       }
00149     }
00150   } catch(cms::Exception& e) {
00151     //would be nice to issue a warning here
00152     return false;
00153   }
00154   //std::cout <<"loaded "<<classname<<std::endl;
00155   return true;
00156 }

static ELmap const& edm::loadMap ( ) [static]

Definition at line 61 of file ELseverityLevel.cc.

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

00061                           {
00062 
00063   static ELmap  m;
00064 
00065 
00066     m[ ELzeroSeverity.getSymbol()   ] = ELseverityLevel::ELsev_zeroSeverity
00067   , m[ ELzeroSeverity.getName()     ] = ELseverityLevel::ELsev_zeroSeverity
00068   , m[ ELzeroSeverity.getInputStr() ] = ELseverityLevel::ELsev_zeroSeverity
00069   , m[ ELzeroSeverity.getVarName()  ] = ELseverityLevel::ELsev_zeroSeverity
00070   ;
00071 
00072     m[ ELincidental.getSymbol()   ] = ELseverityLevel::ELsev_incidental
00073   , m[ ELincidental.getName()     ] = ELseverityLevel::ELsev_incidental
00074   , m[ ELincidental.getInputStr() ] = ELseverityLevel::ELsev_incidental
00075   , m[ ELincidental.getVarName()  ] = ELseverityLevel::ELsev_incidental
00076   ;
00077 
00078     m[ ELsuccess.getSymbol()   ] = ELseverityLevel::ELsev_success
00079   , m[ ELsuccess.getName()     ] = ELseverityLevel::ELsev_success
00080   , m[ ELsuccess.getInputStr() ] = ELseverityLevel::ELsev_success
00081   , m[ ELsuccess.getVarName()  ] = ELseverityLevel::ELsev_success
00082   ;
00083 
00084     m[ ELinfo.getSymbol()   ] = ELseverityLevel::ELsev_info
00085   , m[ ELinfo.getName()     ] = ELseverityLevel::ELsev_info
00086   , m[ ELinfo.getInputStr() ] = ELseverityLevel::ELsev_info
00087   , m[ ELinfo.getVarName()  ] = ELseverityLevel::ELsev_info
00088   ;
00089 
00090     m[ ELwarning.getSymbol()   ] = ELseverityLevel::ELsev_warning
00091   , m[ ELwarning.getName()     ] = ELseverityLevel::ELsev_warning
00092   , m[ ELwarning.getInputStr() ] = ELseverityLevel::ELsev_warning
00093   , m[ ELwarning.getVarName()  ] = ELseverityLevel::ELsev_warning
00094   ;
00095 
00096     m[ ELwarning2.getSymbol()   ] = ELseverityLevel::ELsev_warning2
00097   , m[ ELwarning2.getName()     ] = ELseverityLevel::ELsev_warning2
00098   , m[ ELwarning2.getInputStr() ] = ELseverityLevel::ELsev_warning2
00099   , m[ ELwarning2.getVarName()  ] = ELseverityLevel::ELsev_warning2
00100   ;
00101 
00102     m[ ELerror.getSymbol()   ] = ELseverityLevel::ELsev_error
00103   , m[ ELerror.getName()     ] = ELseverityLevel::ELsev_error
00104   , m[ ELerror.getInputStr() ] = ELseverityLevel::ELsev_error
00105   , m[ ELerror.getVarName()  ] = ELseverityLevel::ELsev_error
00106   ;
00107 
00108     m[ ELerror2.getSymbol()   ] = ELseverityLevel::ELsev_error2
00109   , m[ ELerror2.getName()     ] = ELseverityLevel::ELsev_error2
00110   , m[ ELerror2.getInputStr() ] = ELseverityLevel::ELsev_error2
00111   , m[ ELerror2.getVarName()  ] = ELseverityLevel::ELsev_error2
00112   ;
00113 
00114     m[ ELnextEvent.getSymbol()   ] = ELseverityLevel::ELsev_next
00115   , m[ ELnextEvent.getName()     ] = ELseverityLevel::ELsev_next
00116   , m[ ELnextEvent.getInputStr() ] = ELseverityLevel::ELsev_next
00117   , m[ ELnextEvent.getVarName()  ] = ELseverityLevel::ELsev_next
00118   ;
00119 
00120     m[ ELunspecified.getSymbol()   ] = ELseverityLevel::ELsev_unspecified
00121   , m[ ELunspecified.getName()     ] = ELseverityLevel::ELsev_unspecified
00122   , m[ ELunspecified.getInputStr() ] = ELseverityLevel::ELsev_unspecified
00123   , m[ ELunspecified.getVarName()  ] = ELseverityLevel::ELsev_unspecified
00124   ;
00125 
00126     m[ ELsevere.getSymbol()   ] = ELseverityLevel::ELsev_severe
00127   , m[ ELsevere.getName()     ] = ELseverityLevel::ELsev_severe
00128   , m[ ELsevere.getInputStr() ] = ELseverityLevel::ELsev_severe
00129   , m[ ELsevere.getVarName()  ] = ELseverityLevel::ELsev_severe
00130   ;
00131 
00132     m[ ELsevere2.getSymbol()   ] = ELseverityLevel::ELsev_severe2
00133   , m[ ELsevere2.getName()     ] = ELseverityLevel::ELsev_severe2
00134   , m[ ELsevere2.getInputStr() ] = ELseverityLevel::ELsev_severe2
00135   , m[ ELsevere2.getVarName()  ] = ELseverityLevel::ELsev_severe2
00136   ;
00137 
00138     m[ ELabort.getSymbol()   ] = ELseverityLevel::ELsev_abort
00139   , m[ ELabort.getName()     ] = ELseverityLevel::ELsev_abort
00140   , m[ ELabort.getInputStr() ] = ELseverityLevel::ELsev_abort
00141   , m[ ELabort.getVarName()  ] = ELseverityLevel::ELsev_abort
00142   ;
00143 
00144     m[ ELfatal.getSymbol()   ] = ELseverityLevel::ELsev_fatal
00145   , m[ ELfatal.getName()     ] = ELseverityLevel::ELsev_fatal
00146   , m[ ELfatal.getInputStr() ] = ELseverityLevel::ELsev_fatal
00147   , m[ ELfatal.getVarName()  ] = ELseverityLevel::ELsev_fatal
00148   ;
00149 
00150     m[ ELhighestSeverity.getSymbol()   ] = ELseverityLevel::ELsev_highestSeverity
00151   , m[ ELhighestSeverity.getName()     ] = ELseverityLevel::ELsev_highestSeverity
00152   , m[ ELhighestSeverity.getInputStr() ] = ELseverityLevel::ELsev_highestSeverity
00153   , m[ ELhighestSeverity.getVarName()  ] = ELseverityLevel::ELsev_highestSeverity
00154   ;
00155 
00156   return m;
00157 
00158 }

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

Definition at line 28 of file LoggedErrorsSummary.cc.

References begin, edm::ErrorSummaryEntry::category, edm::ErrorSummaryEntry::count, e, end, edm::MessageSender::errorSummaryMap, first(), edm::MessageSender::freshError, i, edm::ErrorSummaryEntry::module, second(), and v.

00028                                                    {
00029   std::vector<ErrorSummaryEntry> v;
00030   ErrorSummaryEntry e;
00031   ErrorSummaryMapIterator end = MessageSender::errorSummaryMap.end();
00032   for (ErrorSummaryMapIterator i = MessageSender::errorSummaryMap.begin();
00033         i != end; ++i) {
00034     e.category = (i->first).first;
00035     e.module   = (i->first).second;
00036     e.count    = (i->second);
00037     v.push_back(e);
00038   }
00039   MessageSender::freshError = false;
00040   MessageSender::errorSummaryMap.clear();
00041   return v;
00042 }

void edm::LogStatistics ( )

Definition at line 23 of file MessageLogger.cc.

References edm::MessageLoggerQ::MLqSUM().

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

void edm::longBranchPrint ( TTree * tr )

Definition at line 77 of file CollUtil.cc.

References GenMuonPlsPt100GeV_cfg::cout, and i.

00077                                    {
00078 
00079     if ( tr != 0 ) {
00080       Long64_t nB=tr->GetListOfBranches()->GetEntries();
00081       for ( Long64_t i=0; i<nB; ++i) {    
00082         tr->GetListOfBranches()->At(i)->Print();
00083       }
00084     }
00085     else{
00086       std::cout << "Missing Events tree?\n";
00087     }
00088     
00089   }

template<typename ForwardSequence, typename Datum, typename Predicate>

ForwardSequence::iterator edm::lower_bound_all	(	ForwardSequence &	s,
		Datum const &	d,
		Predicate	p
	)			`[inline]`

Definition at line 83 of file Algorithms.h.

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

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

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

template<typename ForwardSequence, typename Datum>

ForwardSequence::iterator edm::lower_bound_all	(	ForwardSequence &	s,
		Datum const &	d
	)			`[inline]`

Definition at line 69 of file Algorithms.h.

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

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

Referenced by edm::RootFile::fillHistory(), edm::FileIndex::findLumiOrRunPosition(), edm::FileIndex::findLumiPosition(), edm::FileIndex::findPosition(), and edm::FileIndex::findRunPosition().

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

static std::auto_ptr<eventsetup::EventSetupProvider> edm::makeEventSetupProvider ( ParameterSet const & params ) [static]

Definition at line 259 of file EventProcessor.cc.

References cms::Exception::append(), edm::errors::Configuration, edm::ParameterSet::getParameter(), and edm::ParameterSet::getParameterNames().

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

00260   {
00261     using namespace edm::eventsetup;
00262     std::vector<std::string> prefers =
00263       params.getParameter<std::vector<std::string> >("@all_esprefers");
00264 
00265     if(prefers.empty()) {
00266       return std::auto_ptr<EventSetupProvider>(new EventSetupProvider());
00267     }
00268 
00269     EventSetupProvider::PreferredProviderInfo preferInfo;
00270     EventSetupProvider::RecordToDataMap recordToData;
00271 
00272     //recordToData.insert(std::make_pair(std::string("DummyRecord"),
00273     //      std::make_pair(std::string("DummyData"),std::string())));
00274     //preferInfo[ComponentDescription("DummyProxyProvider","",false)]=
00275     //      recordToData;
00276 
00277     for(std::vector<std::string>::iterator itName = prefers.begin(), itNameEnd = prefers.end();
00278         itName != itNameEnd;
00279         ++itName) 
00280       {
00281         recordToData.clear();
00282         ParameterSet preferPSet = params.getParameter<ParameterSet>(*itName);
00283         std::vector<std::string> recordNames = preferPSet.getParameterNames();
00284         for(std::vector<std::string>::iterator itRecordName = recordNames.begin(),
00285             itRecordNameEnd = recordNames.end();
00286             itRecordName != itRecordNameEnd;
00287             ++itRecordName) {
00288 
00289           if((*itRecordName)[0] == '@') {
00290             //this is a 'hidden parameter' so skip it
00291             continue;
00292           }
00293 
00294           //this should be a record name with its info
00295           try {
00296             std::vector<std::string> dataInfo =
00297               preferPSet.getParameter<std::vector<std::string> >(*itRecordName);
00298             
00299             if(dataInfo.empty()) {
00300               //FUTURE: empty should just mean all data
00301               throw edm::Exception(errors::Configuration)
00302                 << "The record named "
00303                 << *itRecordName << " specifies no data items";
00304             }
00305             //FUTURE: 'any' should be a special name
00306             for(std::vector<std::string>::iterator itDatum = dataInfo.begin(),
00307                 itDatumEnd = dataInfo.end();
00308                 itDatum != itDatumEnd;
00309                 ++itDatum){
00310               std::string datumName(*itDatum, 0, itDatum->find_first_of("/"));
00311               std::string labelName;
00312 
00313               if(itDatum->size() != datumName.size()) {
00314                 labelName = std::string(*itDatum, datumName.size()+1);
00315               }
00316               recordToData.insert(std::make_pair(std::string(*itRecordName),
00317                                                  std::make_pair(datumName,
00318                                                                 labelName)));
00319             }
00320           } catch(cms::Exception const& iException) {
00321             cms::Exception theError("ESPreferConfigurationError");
00322             theError << "While parsing the es_prefer statement for type="
00323                      << preferPSet.getParameter<std::string>("@module_type")
00324                      << " label=\""
00325                      << preferPSet.getParameter<std::string>("@module_label")
00326                      << "\" an error occurred.";
00327             theError.append(iException);
00328             throw theError;
00329           }
00330         }
00331         preferInfo[ComponentDescription(preferPSet.getParameter<std::string>("@module_type"),
00332                                         preferPSet.getParameter<std::string>("@module_label"),
00333                                         false)]
00334           = recordToData;
00335       }
00336     return std::auto_ptr<EventSetupProvider>(new EventSetupProvider(&preferInfo));
00337   }

void edm::@6706::makeFileAppender ( ) [static]

Definition at line 35 of file ELlog4cplus.cc.

References python::SiStripOnlineP5_cfg::log4cplus.

00036   {
00037     static bool iscalled = false;
00038     if(iscalled) return;
00039     iscalled=true;
00040 
00041     using namespace log4cplus;
00042     using namespace log4cplus::helpers;
00043 
00044     SharedAppenderPtr ap(new FileAppender("log4cplus.output"));
00045     ap->setName("Main");
00046     ap->setLayout(std::auto_ptr<Layout>(new log4cplus::TTCCLayout()) );
00047     Logger::getRoot().addAppender(ap);
00048   }

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

Definition at line 211 of file EventProcessor.cc.

References edm::CodedException< Code >::categoryCode(), edm::errors::Configuration, edm::InputSourceFactory::get(), edm::ParameterSet::getParameter(), getPassID(), getReleaseVersion(), edm::ParameterSet::id(), iggi_31X_cfg::input, edm::EventProcessor::CommonParams::maxEventsInput_, edm::EventProcessor::CommonParams::maxLumisInput_, edm::EventProcessor::CommonParams::processName_, and release().

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

00215   {
00216     // find single source
00217     bool sourceSpecified = false;
00218     try {
00219       ParameterSet main_input =
00220         params.getParameter<ParameterSet>("@main_input");
00221       
00222       // Fill in "ModuleDescription", in case the input source produces
00223       // any EDproducts,which would be registered in the ProductRegistry.
00224       // Also fill in the process history item for this process.
00225       ModuleDescription md;
00226       md.parameterSetID_ = main_input.id();
00227       md.moduleName_ =
00228         main_input.getParameter<std::string>("@module_type");
00229       // There is no module label for the unnamed input source, so 
00230       // just use "source".
00231       md.moduleLabel_ = "source";
00232       md.processConfiguration_ = ProcessConfiguration(common.processName_,
00233                                 params.id(), getReleaseVersion(), getPassID());
00234 
00235       sourceSpecified = true;
00236       InputSourceDescription isdesc(md, preg, areg, common.maxEventsInput_, common.maxLumisInput_);
00237       areg->preSourceConstructionSignal_(md);
00238       shared_ptr<InputSource> input(InputSourceFactory::get()->makeInputSource(main_input, isdesc).release());
00239       areg->postSourceConstructionSignal_(md);
00240       
00241       return input;
00242     } 
00243     catch(edm::Exception const& iException) {
00244         if(sourceSpecified == false && 
00245            errors::Configuration == iException.categoryCode()) {
00246             throw edm::Exception(errors::Configuration, "FailedInputSource")
00247               << "Configuration of main input source has failed\n"
00248               << iException;
00249         } else {
00250             throw;
00251         }
00252     }
00253     return shared_ptr<InputSource>();
00254   }

Schedule::WorkerPtr edm::@7406::makeInserter	(	ParameterSet const &	proc_pset,
		ParameterSet const &	trig_pset,
		std::string const &	proc_name,
		ProductRegistry &	preg,
		ActionTable &	actions,
		boost::shared_ptr< ActivityRegistry >	areg,
		Schedule::TrigResPtr	trptr
	)			`[static]`

Definition at line 62 of file Schedule.cc.

References getPassID(), getReleaseVersion(), edm::ParameterSet::id(), edm::ModuleDescription::moduleLabel_, edm::ModuleDescription::moduleName_, edm::ModuleDescription::parameterSetID_, edm::ModuleDescription::processConfiguration_, reco_calib_source_client_cfg::producer, and ptr.

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

00068                                            {
00069 
00070       WorkerParams work_args(proc_pset,trig_pset,preg,actions,proc_name);
00071       ModuleDescription md;
00072       md.parameterSetID_ = trig_pset.id();
00073       md.moduleName_ = "TriggerResultInserter";
00074       md.moduleLabel_ = "TriggerResults";
00075       md.processConfiguration_ = ProcessConfiguration(proc_name, proc_pset.id(), getReleaseVersion(), getPassID());
00076 
00077       areg->preModuleConstructionSignal_(md);
00078       std::auto_ptr<EDProducer> producer(new TriggerResultInserter(trig_pset,trptr));
00079       areg->postModuleConstructionSignal_(md);
00080 
00081       Schedule::WorkerPtr ptr(new WorkerT<EDProducer>(producer, md, work_args));
00082       ptr->setActivityRegistry(areg);
00083       return ptr;
00084     }

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

essentially the same as the previous method

Definition at line 22 of file MakeParameterSets.cc.

References PythonProcessDesc::processDesc().

Referenced by edm::ServiceRegistry::createServicesFromConfig(), and cond::FWIncantation::FWIncantation().

00025   {
00026     PythonProcessDesc pythonProcessDesc(configtext);
00027     boost::shared_ptr<edm::ProcessDesc> processDesc = pythonProcessDesc.processDesc();
00028     main = processDesc->getProcessPSet();
00029     serviceparams = processDesc->getServicesPSets();
00030   }

template<class HandleT>

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

Definition at line 467 of file DetSetVector.h.

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

Referenced by makeRefToDetSetVector().

00469                                                                           {
00470     typedef typename HandleT::element_type Vec;
00471     typename Vec::value_type::collection_type::size_type index=0;
00472     typename Vec::const_iterator itFound = iHandle->find(iDetID);
00473     if(itFound == iHandle->end()) {
00474       throw edm::Exception(errors::InvalidReference) 
00475       <<"an edm::Ref to an edm::DetSetVector was given a DetId, "<<iDetID<<", that is not in the DetSetVector";
00476     }
00477     index += (itIter- itFound->data.begin());
00478     if(index >= itFound->data.size()) {
00479       throw edm::Exception(errors::InvalidReference) 
00480       <<"an edm::Ref to a edm::DetSetVector is being made with an interator that is not part of the edm::DetSet itself";
00481     }
00482     return Ref<typename HandleT::element_type,
00483                typename HandleT::element_type::value_type::value_type>
00484               (iHandle,std::make_pair(iDetID,index));
00485   }

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
	)			`[inline]`

Definition at line 299 of file DetSetLazyVector.h.

References makeRefToDetSetLazyVector().

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

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
	)			`[inline]`

Definition at line 287 of file DetSetLazyVector.h.

References index.

Referenced by makeRefToDetSetLazyVector().

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

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
	)			`[inline]`

Definition at line 318 of file DetSetRefVector.h.

References makeRefToDetSetRefVector().

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

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
	)			`[inline]`

Definition at line 306 of file DetSetRefVector.h.

References index.

Referenced by makeRefToDetSetRefVector().

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

template<class HandleT>

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

Definition at line 489 of file DetSetVector.h.

References makeRefTo().

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

template<typename T>

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

Definition at line 526 of file LazyGetter.h.

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

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

static void edm::markAncestors	(	const EventEntryInfo &	iInfo,
		const BranchMapper &	iMapper,
		std::map< BranchID, bool > &	oMap,
		std::set< BranchID > &	oMapperMissing
	)			`[static]`

Definition at line 80 of file ProvenanceCheckerOutputModule.cc.

References edm::BranchMapper::branchToEntryInfo(), edm::EventEntryInfo::entryDescription(), it, and edm::EventEntryDescription::parents().

Referenced by edm::ProvenanceCheckerOutputModule::write().

00083                                                                {
00084       for(std::vector<BranchID>::const_iterator it = iInfo.entryDescription().parents().begin(),
00085           itEnd = iInfo.entryDescription().parents().end();
00086           it != itEnd;
00087           ++it) {
00088          //Don't look for parents if we've previously looked at the parents
00089          if(oMap.find(*it) == oMap.end()) {
00090             //use side effect of calling operator[] which is if the item isn't there it will add it as 'false'
00091             oMap[*it];
00092             boost::shared_ptr<EventEntryInfo> pInfo = iMapper.branchToEntryInfo(*it);
00093             if(pInfo.get()) {
00094                markAncestors(*pInfo,iMapper,oMap,oMapperMissing);
00095             } else {
00096                oMapperMissing.insert(*it);
00097             }
00098          }
00099       }
00100    }

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

Definition at line 85 of file ConstBranchDescription.h.

References match(), and edm::ConstBranchDescription::me().

Referenced by ZHistogrammer::analyze(), HLTMuonGenericRate::analyze(), SiPixelTrackResidualSource::analyze(), DebugZMCTruth::analyze(), VertexAssociatorByTracks::associateRecoToSim(), VertexAssociatorByTracks::associateSimToReco(), JetPartonMatching::calculate(), checkHLTMatch(), MuonTrajectoryCleaner::clean(), TrajectoryCleanerMerger::clean(), L1Comparator::compareCollections(), DEcompare< T >::CompareCollections(), L1Comparator::CompareCollections(), VisG4TwigOps::doApplyFilter(), GtPsbTextToDigi::endJob(), L1GctLut< NAddressBits, NDataBits >::equalityCheck(), FlavouredJetPlots::fill(), StringMap::find(), pat::GenericOverlapFinder< Distance >::find(), pat::PATObject< ObjectType >::getKinResolution(), TrackDetectorAssociator::getTAMuonChamberMatches(), pat::PATObject< ObjectType >::hasKinResolution(), edm::EventSelector::identical(), HLTHighLevel::init(), IsoDepositVetoFactory::make(), PFBenchmarkAlgo::matchByDeltaEt(), PFBenchmarkAlgo::matchByDeltaR(), JetAnalyzer::MatchEmHadClusters(), JetPartonMatching::matchingPtOrderedMinDist(), JetPartonMatching::matchingTotalMinDist(), JetPartonMatching::matchingUnambiguousOnly(), AlignmentGlobalTrackSelector::matchTracks(), JetPartonMatching::minSumDist_recursion(), reco::modules::MCMatchCandRefSelector::newEvent(), Ig3DBaseBrowser::onDeselect(), Ig3DBaseBrowser::onPick(), Ig3DBaseBrowser::onSelect(), lat::MultiMethod_1_0< R, V1 >::operator()(), lat::MultiMethod_3_2< R, V1, V2, V3, T1, T2 >::operator()(), lat::MultiMethod_2_1< R, V1, V2, T1 >::operator()(), lat::MultiMethod_1_2< R, V1, T1, T2 >::operator()(), lat::MultiMethod_1_1< R, V1, T1 >::operator()(), lat::MultiMethod_3_0< R, V1, V2, V3 >::operator()(), lat::MultiMethod_2_0< R, V1, V2 >::operator()(), lat::MultiMethod_2_2< R, V1, V2, T1, T2 >::operator()(), lat::MultiMethod_3_1< R, V1, V2, V3, T1 >::operator()(), StringMap::operator[](), MuonIdProducer::overlap(), pat::PATObject< ObjectType >::overlaps(), CandOneToManyDeltaRMatcher::produce(), cms::SimpleTrackListMerger::produce(), MCTrackMatcher::produce(), reco::modules::TrackMultiSelector::produce(), pat::PATJetProducer::produce(), TtSemiLepHypothesis::produce(), reco::modules::AnalyticalTrackSelector::produce(), reco::PhysObjectMatcher< C1, C2, S, D, Q >::produce(), reco::modules::TrackFullCloneSelectorBase< Selector >::produce(), reco::modules::MatcherBase< C1, C2, M >::produce(), reco::modulesNew::Matcher< C1, C2, S, D >::produce(), GenTrackMatcher::produce(), reco::modulesNew::MCTruthCompositeMatcher::produce(), TtJetPartonMatch< C >::produce(), pat::PATTriggerMatchEmbedder< PATObjectType, RecoObjectType >::produce(), TtSemiLepKinFitProducer< LeptonCollection >::produce(), MCTruthCompositeMatcher< C1, C2 >::produce(), reco::modules::TrackerTrackHitFilter::Rule::Rule(), IgModuleCache::scanModules(), pat::PATObject< ObjectType >::setKinResolution(), pat::PATObject< ObjectType >::setOverlaps(), CosmicMuonLinksProducer::sharedHits(), DEcompare< T >::SortCollections(), and reco::parser::ExpressionVar::trueDelete().

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

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

Definition at line 301 of file BranchDescription.cc.

References edm::BranchDescription::branchID(), edm::BranchDescription::branchName(), edm::BranchDescription::branchType(), edm::BranchDescription::fullClassName(), edm::BranchDescription::present(), edm::BranchDescription::processConfigurationIDs(), edm::BranchDescription::psetIDs(), and edm::BranchDescription::Strict.

Referenced by edm::pset::EntryNode::locate(), edm::pset::VEntryNode::locate(), match(), and edm::ProductRegistry::merge().

00303                                       {
00304     std::ostringstream differences;
00305     if (a.branchName() != b.branchName()) {
00306       differences << "Branch name '" << b.branchName() << "' does not match '" << a.branchName() << "'.\n";
00307       // Need not compare components of branch name individually.
00308       // (a.friendlyClassName() != b.friendlyClassName())
00309       // (a.moduleLabel() != b.moduleLabel())
00310       // (a.productInstanceName() != b.productInstanceName())
00311       // (a.processName() != b.processName())
00312     }
00313     if (a.branchType() != b.branchType()) {
00314       differences << "Branch '" << b.branchName() << "' is a(n) '" << b.branchType() << "' branch\n";
00315       differences << "    in file '" << fileName << "', but a(n) '" << a.branchType() << "' branch in previous files.\n";
00316     }
00317     if (a.branchID() != b.branchID()) {
00318       differences << "Branch '" << b.branchName() << "' has a branch ID of '" << b.branchID() << "'\n";
00319       differences << "    in file '" << fileName << "', but '" << a.branchID() << "' in previous files.\n";
00320     }
00321     if (a.fullClassName() != b.fullClassName()) {
00322       differences << "Products on branch '" << b.branchName() << "' have type '" << b.fullClassName() << "'\n";
00323       differences << "    in file '" << fileName << "', but '" << a.fullClassName() << "' in previous files.\n";
00324     }
00325     if (b.present() && !a.present()) {
00326       differences << "Branch '" << a.branchName() << "' was dropped in previous files but is present in '" << fileName << "'.\n";
00327     }
00328     if (m == BranchDescription::Strict) {
00329         if (b.psetIDs().size() > 1) {
00330           differences << "Branch '" << b.branchName() << "' uses more than one parameter set in file '" << fileName << "'.\n";
00331         } else if (a.psetIDs().size() > 1) {
00332           differences << "Branch '" << a.branchName() << "' uses more than one parameter set in previous files.\n";
00333         } else if (a.psetIDs() != b.psetIDs()) {
00334           differences << "Branch '" << b.branchName() << "' uses different parameter sets in file '" << fileName << "'.\n";
00335           differences << "    than in previous files.\n";
00336         }
00337 
00338         if (b.processConfigurationIDs().size() > 1) {
00339           differences << "Branch '" << b.branchName() << "' uses more than one process configuration in file '" << fileName << "'.\n";
00340         } else if (a.processConfigurationIDs().size() > 1) {
00341           differences << "Branch '" << a.branchName() << "' uses more than one process configuration in previous files.\n";
00342         } else if (a.processConfigurationIDs() != b.processConfigurationIDs()) {
00343           differences << "Branch '" << b.branchName() << "' uses different process configurations in file '" << fileName << "'.\n";
00344           differences << "    than in previous files.\n";
00345         }
00346     }
00347     return differences.str();
00348   }

const unsigned int edm::maxIDlength ( 200 )

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

StringSet & edm::missingTypes ( )

Definition at line 237 of file ReflexTools.cc.

Referenced by checkAllDictionaries(), checkDictionaries(), checkType(), and loadCap().

00237                              {
00238     static boost::thread_specific_ptr<StringSet> missingTypes_;
00239     if (0 == missingTypes_.get()) {
00240       missingTypes_.reset(new StringSet);
00241     }
00242     return *missingTypes_.get();
00243   }

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

Definition at line 98 of file EDProductGetter.cc.

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

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

LuminosityBlock* edm::@7360::newLumi	(	EventPrincipal &	ep,
		ModuleDescription const &	md
	)			`[static]`

Definition at line 12 of file Event.cc.

References edm::EventPrincipal::luminosityBlockPrincipal(), and edm::EventPrincipal::luminosityBlockPrincipalSharedPtr().

00012                                                                                {
00013       return (ep.luminosityBlockPrincipalSharedPtr() ? new LuminosityBlock(ep.luminosityBlockPrincipal(), md) : 0);
00014     }

Run* edm::@7388::newRun	(	LuminosityBlockPrincipal &	lbp,
		ModuleDescription const &	md
	)			`[static]`

Definition at line 10 of file LuminosityBlock.cc.

References edm::LuminosityBlockPrincipal::runPrincipal(), and edm::LuminosityBlockPrincipal::runPrincipalSharedPtr().

00010                                                                        {
00011       return (lbp.runPrincipalSharedPtr() ? new Run(lbp.runPrincipal(), md) : 0);
00012     }

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

Definition at line 49 of file CollUtil.cc.

References GenMuonPlsPt100GeV_cfg::cout, lat::endl(), and tree.

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

00049                                                            {
00050 
00051     TTree *tree= (TTree*)hdl->Get(trname.c_str());
00052     if ( tree ) {
00053       return tree->GetEntries();
00054     } else {
00055       std::cout << "ERR cannot find a TTree named \"" << trname << "\"" 
00056                 << std::endl;
00057       return -1;
00058     }
00059   }

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

Definition at line 21 of file CollUtil.cc.

References GenMuonPlsPt100GeV_cfg::cout, lat::endl(), and cmsRelvalreport::exit.

00021                                              {
00022     
00023     TFile *hdl= TFile::Open(fname.c_str(),"read");
00024 
00025     if ( 0== hdl ) {
00026       std::cout << "ERR Could not open file " << fname.c_str() << std::endl;
00027       exit(1);
00028     }
00029     return hdl;
00030   }

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
	)			`[inline]`

Definition at line 205 of file Selector.h.

00206   {
00207     return AndHelper<A,B>(a,b);
00208   }

template<class A>

boost::enable_if_c< has_match<A>::value, NotHelper<A> >::type edm::operator! ( A const & a ) [inline]

Definition at line 263 of file Selector.h.

00264   {
00265     return NotHelper<A>(a);
00266   }

bool edm::operator!=	(	const TypeIDBase &	a,
		const TypeIDBase &	b
	)			`[inline]`

Definition at line 75 of file TypeIDBase.h.

00076    { return !(a==b); }

bool edm::operator!=	(	ParameterSet const &	a,
		ParameterSet const &	b
	)			`[inline]`

Definition at line 187 of file ParameterSet.h.

00187                                                            {
00188     return !(a == b);
00189   }

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

bool edm::operator!=	(	RunLumiEntryInfo const &	a,
		RunLumiEntryInfo const &	b
	)			`[inline]`

Definition at line 81 of file RunLumiEntryInfo.h.

00081 { return !(a==b); }

bool edm::operator!=	(	ProductRegistry const &	a,
		ProductRegistry const &	b
	)			`[inline]`

Definition at line 160 of file ProductRegistry.h.

00160                                                                  {
00161     return !(a == b);
00162   }

bool edm::operator!=	(	ProcessHistory const &	a,
		ProcessHistory const &	b
	)			`[inline]`

Definition at line 98 of file ProcessHistory.h.

00098                                                                {
00099     return !(a==b);
00100   }

bool edm::operator!=	(	ProcessConfiguration const &	a,
		ProcessConfiguration const &	b
	)			`[inline]`

Definition at line 47 of file ProcessConfiguration.h.

00047                                                                            {
00048     return !(a == b);
00049   }

bool edm::operator!=	(	FileIndex::Element const &	lh,
		FileIndex::Element const &	rh
	)			`[inline]`

Definition at line 141 of file FileIndex.h.

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

bool edm::operator!=	(	FileID const &	lh,
		FileID const &	rh
	)			`[inline]`

Definition at line 28 of file FileID.h.

00028 {return !(lh == rh);}

bool edm::operator!=	(	FileFormatVersion const &	a,
		FileFormatVersion const &	b
	)			`[inline]`

Definition at line 26 of file FileFormatVersion.h.

00027   {
00028     return !(a==b);
00029   }

bool edm::operator!=	(	EventEntryInfo const &	a,
		EventEntryInfo const &	b
	)			`[inline]`

Definition at line 111 of file EventEntryInfo.h.

00111 { return !(a==b); }

bool edm::operator!=	(	EventEntryDescription const &	a,
		EventEntryDescription const &	b
	)			`[inline]`

Definition at line 93 of file EventEntryDescription.h.

00093 { return !(a==b); }

bool edm::operator!=	(	EntryDescription const &	a,
		EntryDescription const &	b
	)			`[inline]`

Definition at line 67 of file EntryDescription.h.

00067 { return !(a==b); }

bool edm::operator!=	(	BranchKey const &	a,
		BranchKey const &	b
	)			`[inline]`

Definition at line 63 of file BranchKey.h.

00063                                                      {
00064     return !(a == b);
00065   }

template<typename T>

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

Definition at line 396 of file View.h.

00397   {
00398     return !(lhs==rhs);
00399   }

template<typename KEY>

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

Inequality operator.

Definition at line 97 of file RefVectorBase.h.

00097                                                                            {
00098     return !(lhs == rhs);
00099   }

template<typename C, typename T, typename F>

bool edm::operator!=	(	RefVector< C, T, F > const &	lhs,
		RefVector< C, T, F > const &	rhs
	)			`[inline]`

Definition at line 220 of file RefVector.h.

00220                                                                            {
00221     return !(lhs == rhs);
00222   }

template<typename T>

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

Definition at line 197 of file RefToBaseProd.h.

00197                                                                         {
00198     return !(lhs == rhs);
00199   }

template<typename C>

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

Definition at line 224 of file RefProd.h.

00224                                                             {
00225     return !(lhs == rhs);
00226   }

template<typename KEY>

bool edm::operator!=	(	RefItem< KEY > const &	lhs,
		RefItem< KEY > const &	rhs
	)			`[inline]`

Definition at line 50 of file RefItem.h.

00050                                                                {
00051     return !(lhs == rhs);
00052   }

bool edm::operator!=	(	RefCore const &	lhs,
		RefCore const &	rhs
	)			`[inline]`

Definition at line 82 of file RefCore.h.

00082                                                      {
00083     return !(lhs == rhs);
00084   }

template<typename KEY>

bool edm::operator!=	(	RefBase< KEY > const &	lhs,
		RefBase< KEY > const &	rhs
	)			`[inline]`

Definition at line 65 of file RefBase.h.

00065                                                                {
00066     return !(lhs == rhs);
00067   }

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

00413                                                                {
00414     return !(lhs == rhs);
00415   }

template<typename T>

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

Definition at line 253 of file Ptr.h.

00253                                                    {
00254     return !(lhs == rhs);
00255   }

template<class X, class Y>

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

Definition at line 76 of file debugging_allocator.h.

00076 { return false; }

template<typename T>

ValueMap<T> edm::operator+	(	const ValueMap< T > &	a1,
		const ValueMap< T > &	a2
	)			`[inline]`

Definition at line 236 of file ValueMap.h.

References a.

00237                                                              {
00238     ValueMap<T> a = a1;
00239     a += a2;
00240     return a;
00241   }

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

00073                                                                                                                                 {
00074     return iter + n;
00075   }

template<typename C>

Association<C> edm::operator+	(	const Association< C > &	a1,
		const Association< C > &	a2
	)			`[inline]`

Definition at line 119 of file Association.h.

References a.

00120                                                                    {
00121     Association<C> a = a1;
00122     a += a2;
00123     return a;
00124   }

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

bool edm::operator<	(	RunLumiEntryInfo const &	a,
		RunLumiEntryInfo const &	b
	)			`[inline]`

Definition at line 68 of file RunLumiEntryInfo.h.

References edm::RunLumiEntryInfo::branchID().

00068                                                                     {
00069     return a.branchID() < b.branchID();
00070   }

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

Definition at line 187 of file FileIndex.cc.

References edm::FileIndex::Element::event_, edm::FileIndex::Element::lumi_, and edm::FileIndex::Element::run_.

00187                                                                          {
00188     if(lh.run_ == rh.run_) {
00189       if(lh.lumi_ == rh.lumi_) {
00190         return lh.event_ < rh.event_;
00191       }
00192       return lh.lumi_ < rh.lumi_;
00193     }
00194     return lh.run_ < rh.run_;
00195   }

bool edm::operator<	(	EventProcessHistoryID const &	lh,
		EventProcessHistoryID const &	rh
	)			`[inline]`

Definition at line 16 of file EventProcessHistoryID.h.

References edm::EventProcessHistoryID::eventID_.

00016                                                                                    {
00017       return lh.eventID_ < rh.eventID_;
00018   }

bool edm::operator<	(	EventEntryInfo const &	a,
		EventEntryInfo const &	b
	)			`[inline]`

Definition at line 98 of file EventEntryInfo.h.

References edm::EventEntryInfo::branchID().

00098                                                                 {
00099     return a.branchID() < b.branchID();
00100   }

bool edm::operator<	(	ConstBranchDescription const &	a,
		ConstBranchDescription const &	b
	)			`[inline]`

Definition at line 75 of file ConstBranchDescription.h.

References edm::ConstBranchDescription::me().

00075                                                                                    {
00076     return a.me() < b.me();
00077   }

bool edm::operator<	(	BranchKey const &	a,
		BranchKey const &	b
	)			`[inline]`

Definition at line 43 of file BranchKey.h.

References edm::BranchKey::friendlyClassName_, edm::BranchKey::moduleLabel_, edm::BranchKey::processName_, and edm::BranchKey::productInstanceName_.

00043                                                     {
00044       return 
00045         a.friendlyClassName_ < b.friendlyClassName_ ? true :
00046         a.friendlyClassName_ > b.friendlyClassName_ ? false :
00047         a.moduleLabel_ < b.moduleLabel_ ? true :
00048         a.moduleLabel_ > b.moduleLabel_ ? false :
00049         a.productInstanceName_ < b.productInstanceName_ ? true :
00050         a.productInstanceName_ > b.productInstanceName_ ? false :
00051         a.processName_ < b.processName_ ? true :
00052         false;
00053   }

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

Definition at line 253 of file BranchDescription.cc.

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

00253                                                                     {
00254     if (a.processName() < b.processName()) return true;
00255     if (b.processName() < a.processName()) return false;
00256     if (a.fullClassName() < b.fullClassName()) return true;
00257     if (b.fullClassName() < a.fullClassName()) return false;
00258     if (a.friendlyClassName() < b.friendlyClassName()) return true;
00259     if (b.friendlyClassName() < a.friendlyClassName()) return false;
00260     if (a.productInstanceName() < b.productInstanceName()) return true;
00261     if (b.productInstanceName() < a.productInstanceName()) return false;
00262     if (a.moduleLabel() < b.moduleLabel()) return true;
00263     if (b.moduleLabel() < a.moduleLabel()) return false;
00264     if (a.branchType() < b.branchType()) return true;
00265     if (b.branchType() < a.branchType()) return false;
00266     if (a.branchID() < b.branchID()) return true;
00267     if (b.branchID() < a.branchID()) return false;
00268     if (a.psetIDs() < b.psetIDs()) return true;
00269     if (b.psetIDs() < a.psetIDs()) return false;
00270     if (a.processConfigurationIDs() < b.processConfigurationIDs()) return true;
00271     if (b.processConfigurationIDs() < a.processConfigurationIDs()) return false;
00272     if (a.branchAliases() < b.branchAliases()) return true;
00273     if (b.branchAliases() < a.branchAliases()) return false;
00274     if (a.present() < b.present()) return true;
00275     if (b.present() < a.present()) return false;
00276     return false;
00277   }

template<typename T>

bool edm::operator<	(	View< T > const &	lhs,
		View< T > const &	rhs
	)			`[inline]`

Definition at line 404 of file View.h.

00405   {
00406     return 
00407       std::lexicographical_compare(lhs.begin(), lhs.end(),
00408                                    rhs.begin(), rhs.end());
00409   }

template<typename T>

bool edm::operator<	(	RefToBaseProd< T > const &	lhs,
		RefToBaseProd< T > const &	rhs
	)			`[inline]`

Definition at line 204 of file RefToBaseProd.h.

00204                                                                        {
00205     return (lhs.refCore() < rhs.refCore());
00206   }

template<typename C>

bool edm::operator<	(	RefProd< C > const &	lhs,
		RefProd< C > const &	rhs
	)			`[inline]`

Definition at line 231 of file RefProd.h.

00231                                                            {
00232     return (lhs.refCore() < rhs.refCore());
00233   }

template<typename KEY>

bool edm::operator<	(	RefItem< KEY > const &	lhs,
		RefItem< KEY > const &	rhs
	)			`[inline]`

Definition at line 57 of file RefItem.h.

00057                                                               {
00058     return lhs.key() < rhs.key();
00059   }

bool edm::operator<	(	RefCore const &	lhs,
		RefCore const &	rhs
	)			`[inline]`

Definition at line 88 of file RefCore.h.

References false, edm::RefCore::id(), edm::RefCore::isTransient(), and edm::RefCore::productPtr().

00088                                                     {
00089     return lhs.isTransient() ? (rhs.isTransient() ? lhs.productPtr() < rhs.productPtr() : false ) : (rhs.isTransient() ? true : lhs.id() < rhs.id());
00090   }

template<typename KEY>

bool edm::operator<	(	RefBase< KEY > const &	lhs,
		RefBase< KEY > const &	rhs
	)			`[inline]`

Definition at line 71 of file RefBase.h.

00071                                                               {
00072     return (lhs.refCore() == rhs.refCore() ?  lhs.item() < rhs.item() : lhs.refCore() < rhs.refCore());
00073   }

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

00420                                                               {
00423       return (lhs.ref().refCore() == rhs.ref().refCore() ? compare_key<C>(lhs.key(), rhs.key()) : lhs.ref().refCore() < rhs.ref().refCore());
00424   }

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.

00260                                                   {
00263     return (lhs.refCore() == rhs.refCore() ? lhs.key() < rhs.key() : lhs.refCore() < rhs.refCore());
00264   }

template<class T>

bool edm::operator<	(	det_id_type	x,
		DetSet< T > const &	y
	)			`[inline]`

Definition at line 80 of file DetSet.h.

References x, and y.

00080                                                 {
00081     return x < y.detId();
00082   }

template<class T>

bool edm::operator<	(	DetSet< T > const &	x,
		det_id_type	y
	)			`[inline]`

Definition at line 73 of file DetSet.h.

References x, and y.

00073                                                 {
00074     return x.detId() < y;
00075   }

template<class T>

bool edm::operator<	(	DetSet< T > const &	x,
		DetSet< T > const &	y
	)			`[inline]`

Definition at line 66 of file DetSet.h.

References x, and y.

00066                                                      {
00067     return x.detId() < y.detId();
00068   }

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

Definition at line 99 of file TypeID.cc.

00099                                                {
00100     id.print(os);
00101     return os;
00102   }

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

Definition at line 23 of file MallocOpts.cc.

References edm::MallocOpts::mmap_max_, edm::MallocOpts::mmap_thr_, edm::MallocOpts::top_pad_, and edm::MallocOpts::trim_thr_.

00024   {
00025     ost << "mmap_max=" << opts.mmap_max_
00026         << " trim_threshold=" << opts.trim_thr_
00027         << " top_padding=" << opts.top_pad_
00028         << " mmap_threshold=" << opts.mmap_thr_;
00029     return ost;
00030   }

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

Definition at line 62 of file InputTag.cc.

References edm::InputTag::instance(), edm::InputTag::label(), and edm::InputTag::process().

00062                                                                   {
00063     static std::string const process(", process = ");
00064     ost << "InputTag:  label = " << tag.label() << ", instance = " << tag.instance()
00065     <<(tag.process().empty()?std::string():(process+tag.process()));
00066     return ost;
00067   }

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

Definition at line 381 of file ParameterSet.cc.

References edm::ParameterSet::dump().

00382   {
00383     os << pset.dump();
00384     return os;
00385   }

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

Definition at line 903 of file Entry.cc.

References e, lat::endl(), edm::Entry::getInt32(), edm::Entry::getPSet(), edm::Entry::getString(), edm::Entry::getUInt32(), edm::Entry::getVInputTag(), edm::Entry::getVPSet(), edm::Entry::getVString(), i, edm::Entry::isTracked(), it, edm::Entry::rep, sTypeTranslations, edm::pset::TypeTrans::table_, and edm::Entry::typeCode().

00904   {
00905     os << sTypeTranslations.table_[entry.typeCode()] << " " 
00906        << (entry.isTracked() ? "tracked " : "untracked ") <<" = "; 
00907 
00908     // now handle the difficult cases
00909     switch(entry.typeCode())
00910     {
00911       case 'P': // ParameterSet
00912       {
00913         os << entry.getPSet();
00914         break;
00915       }
00916       case 'p': // vector<ParameterSet>
00917       {
00918         // Make sure we get the representation of each contained
00919         // ParameterSet including *only* tracked parameters
00920         std::vector<ParameterSet> whole = entry.getVPSet();
00921         std::vector<ParameterSet>::const_iterator i = whole.begin();
00922         std::vector<ParameterSet>::const_iterator e = whole.end();
00923         std::string start ="";
00924         const std::string between(",\n");
00925         os << "{"<<std::endl;
00926          for ( ; i != e; ++i )
00927          {
00928            os <<  start<< *i;
00929            start = between;
00930          }
00931          if (whole.size()) {
00932            os << std::endl;
00933          }
00934          os << "}";
00935          break;
00936       } 
00937       case 'S':
00938       {
00939         os << "'" << entry.getString() << "'";
00940         break;
00941       }
00942       case 's':
00943       {
00944         
00945         os << "{";
00946         std::string start ="'";
00947         const std::string between(",'");
00948         std::vector<std::string> strings = entry.getVString();
00949         for(std::vector<std::string>::const_iterator it = strings.begin(), itEnd = strings.end();
00950             it != itEnd;
00951             ++it) {
00952           os << start << *it << "'";
00953           start = between;
00954         }
00955         os << "}";
00956         break;
00957       }
00958       case 'I':
00959       {
00960         os << entry.getInt32();
00961         break;
00962       }
00963       case 'U':
00964       {
00965         os << entry.getUInt32();
00966         break;
00967       }
00968       case 'v':
00969       {
00970         //VInputTag needs to be treated seperately because it is encode like
00971         // vector<string> rather than using the individual encodings of each InputTag
00972         os << "{";
00973         std::string start = "";
00974         const std::string between(",");
00975         std::vector<InputTag> tags = entry.getVInputTag();
00976         for(std::vector<InputTag>::const_iterator it = tags.begin(), itEnd = tags.end();
00977             it != itEnd;
00978             ++it) {
00979           os << start << it->encode();
00980           start = between;
00981         }
00982         os << "}";
00983         break;
00984       }
00985       default:
00986       {
00987         os << entry.rep;
00988         break;
00989       }
00990     }
00991 
00992     return os;
00993   }

std::ostream& edm::operator<<	(	std::ostream &	os,
		const edm::FileInPath &	fip
	)			`[inline]`

Definition at line 144 of file FileInPath.h.

References edm::FileInPath::write().

00145   {
00146     fip.write(os);
00147     return os;
00148   }

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

Definition at line 112 of file JobReport.cc.

References print().

00112                                                                                   {
00113     return print(os,f);
00114   }

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

Definition at line 109 of file JobReport.cc.

References print().

00109                                                                                    {
00110     return print(os,f);
00111   }

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

Definition at line 106 of file JobReport.cc.

References print().

00106                                                                                    {
00107     return print(os,f);
00108   }

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

Definition at line 101 of file JobReport.cc.

References print().

00101                                                                       {
00102     return print(os,f);
00103   }

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

Definition at line 315 of file ELseverityLevel.cc.

References edm::ELseverityLevel::getName().

00315                                                                          {
00316   return os << " -" << sev.getName() << "- ";
00317 }

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

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

Definition at line 97 of file JobReport.cc.

References print().

00097                                                                        {
00098     return print(os,f);
00099   }

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

Definition at line 94 of file JobReport.cc.

References print().

00094                                                                        {
00095     return print(os,f);
00096   }

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

Definition at line 274 of file ErrorObj.cc.

References edm::ErrorObj::opltlt().

00274                                                       {
00275   return e.opltlt(s);
00276 }

template<class T>

ErrorObj& edm::operator<<	(	ErrorObj &	e,
		const T &	t
	)			`[inline]`

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

Definition at line 86 of file GroupSelector.cc.

References edm::GroupSelector::print().

00087   {
00088     gs.print(os);
00089     return os;
00090   }

std::ostream& edm::operator<<	(	std::ostream &	os,
		Group const &	g
	)			`[inline]`

Definition at line 125 of file Group.h.

References edm::Group::write().

00125                                              {
00126     g.write(os);
00127     return os;
00128   }

template<typename PROD>

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

Definition at line 272 of file DataViewImpl.h.

References h.

00273   {
00274     os << h.product() << " " << h.provenance() << " " << h.id();
00275     return os;
00276   }

std::ostream& edm::operator<<	(	std::ostream &	os,
		RunLumiEntryInfo const &	p
	)			`[inline]`

Definition at line 74 of file RunLumiEntryInfo.h.

References edm::RunLumiEntryInfo::write().

00074                                                         {
00075     p.write(os);
00076     return os;
00077   }

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

Definition at line 5 of file RunID.cc.

References edm::RunID::run().

00005                                                                 {
00006     oStream << "run: " << iID.run();
00007     return oStream;
00008   }

std::ostream& edm::operator<<	(	std::ostream &	os,
		const RunAuxiliary &	p
	)			`[inline]`

Definition at line 67 of file RunAuxiliary.h.

References edm::RunAuxiliary::write().

00067                                                     {
00068     p.write(os);
00069     return os;
00070   }

std::ostream& edm::operator<<	(	std::ostream &	os,
		Provenance const &	p
	)			`[inline]`

Definition at line 91 of file Provenance.h.

References edm::Provenance::write().

00091                                                   {
00092     p.write(os);
00093     return os;
00094   }

std::ostream& edm::operator<<	(	std::ostream &	os,
		ProductRegistry const &	pr
	)			`[inline]`

Definition at line 166 of file ProductRegistry.h.

References edm::ProductRegistry::print().

00166                                                         {
00167     pr.print(os);
00168     return os;    
00169   }

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

Definition at line 6 of file ProductID.cc.

00006                                                   {
00007     os << id.id_;
00008     return os;
00009   }

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

Definition at line 57 of file ProcessHistory.cc.

References copy_all().

00057                                                         {
00058     ost << "Process History = ";
00059     copy_all(ph, std::ostream_iterator<ProcessHistory::value_type>(ost,";"));
00060     return ost;
00061   }

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

Definition at line 29 of file ProcessConfiguration.cc.

References edm::ProcessConfiguration::parameterSetID_, edm::ProcessConfiguration::passID_, edm::ProcessConfiguration::processName_, and edm::ProcessConfiguration::releaseVersion_.

00029                                                               {
00030     os << pc.processName_ << ' ' 
00031        << pc.parameterSetID_ << ' '
00032        << pc.releaseVersion_ << ' '
00033        << pc.passID_;
00034     return os;
00035   }

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

Definition at line 5 of file ParameterSetBlob.cc.

References edm::ParameterSetBlob::pset_.

00005                                                            {
00006     os << blob.pset_;
00007     return os;
00008   }

std::ostream& edm::operator<<	(	std::ostream &	os,
		const ModuleDescription &	p
	)			`[inline]`

Definition at line 65 of file ModuleDescription.h.

References edm::ModuleDescription::write().

00065                                                          {
00066     p.write(os);
00067     return os;
00068   }

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

Definition at line 5 of file LuminosityBlockID.cc.

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

00005                                                                             {
00006     oStream<< "run: " << iID.run() << " luminosityBlock: " << iID.luminosityBlock();
00007     return oStream;
00008   }

std::ostream& edm::operator<<	(	std::ostream &	os,
		const LuminosityBlockAuxiliary &	p
	)			`[inline]`

Definition at line 61 of file LuminosityBlockAuxiliary.h.

References edm::LuminosityBlockAuxiliary::write().

00061                                                                 {
00062     p.write(os);
00063     return os;
00064   }

template<int I>

std::ostream& edm::operator<<	(	std::ostream &	os,
		Hash< I > const &	h
	)			`[inline]`

Definition at line 266 of file Hash.h.

References h.

00267   {
00268     return h.print(os);
00269   }

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

Definition at line 212 of file FileIndex.cc.

References edm::FileIndex::begin(), edm::FileIndex::end(), it, edm::FileIndex::kEvent, edm::FileIndex::kLumi, and edm::FileIndex::kRun.

00212                                                           {
00213 
00214     os << "\nPrinting FileIndex contents.  This includes a list of all Runs, LuminosityBlocks\n"
00215        << "and Events stored in the root file.\n\n";
00216     os << std::setw(15) << "Run"
00217        << std::setw(15) << "Lumi"
00218        << std::setw(15) << "Event"
00219        << std::setw(15) << "TTree Entry"
00220        << "\n";
00221     for (std::vector<FileIndex::Element>::const_iterator it = fileIndex.begin(), itEnd = fileIndex.end(); it != itEnd; ++it) {
00222       if (it->getEntryType() == FileIndex::kEvent) {
00223         os << std::setw(15) << it->run_
00224            << std::setw(15) << it ->lumi_
00225            << std::setw(15) << it->event_
00226            << std::setw(15) << it->entry_
00227            << "\n";
00228       }
00229       else if (it->getEntryType() == FileIndex::kLumi) {
00230         os << std::setw(15) << it->run_
00231            << std::setw(15) << it ->lumi_
00232            << std::setw(15) << " "
00233            << std::setw(15) << it->entry_ << "  (LuminosityBlock)"
00234            << "\n";
00235       }
00236       else if (it->getEntryType() == FileIndex::kRun) {
00237         os << std::setw(15) << it->run_
00238            << std::setw(15) << " "
00239            << std::setw(15) << " "
00240            << std::setw(15) << it->entry_ << "  (Run)"
00241            << "\n";
00242       }
00243     }
00244     return os;
00245   }

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

Definition at line 6 of file FileID.cc.

00006                                                {
00007     os << id.fid();
00008     return os;
00009   }

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

Definition at line 6 of file FileFormatVersion.cc.

References edm::FileFormatVersion::value_.

00006                                                            {
00007     os << ff.value_;
00008     return os;
00009   }

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

Definition at line 5 of file EventID.cc.

References edm::EventID::event(), and edm::EventID::run().

00005                                                                   {
00006     oStream << "run: " << iID.run() << " event: " << iID.event();
00007     return oStream;
00008   }

std::ostream& edm::operator<<	(	std::ostream &	os,
		EventEntryInfo const &	p
	)			`[inline]`

Definition at line 104 of file EventEntryInfo.h.

References edm::EventEntryInfo::write().

00104                                                       {
00105     p.write(os);
00106     return os;
00107   }

std::ostream& edm::operator<<	(	std::ostream &	os,
		EventEntryDescription const &	p
	)			`[inline]`

Definition at line 86 of file EventEntryDescription.h.

References edm::EventEntryDescription::write().

00086                                                              {
00087     p.write(os);
00088     return os;
00089   }

std::ostream& edm::operator<<	(	std::ostream &	os,
		const EventAuxiliary &	p
	)			`[inline]`

Definition at line 97 of file EventAuxiliary.h.

References edm::EventAuxiliary::write().

00097                                                       {
00098     p.write(os);
00099     return os;
00100   }

std::ostream& edm::operator<<	(	std::ostream &	os,
		EntryDescription const &	p
	)			`[inline]`

Definition at line 60 of file EntryDescription.h.

References edm::EntryDescription::write().

00060                                                         {
00061     p.write(os);
00062     return os;
00063   }

std::ostream& edm::operator<<	(	std::ostream &	os,
		ConstBranchDescription const &	p
	)			`[inline]`

Definition at line 69 of file ConstBranchDescription.h.

References edm::ConstBranchDescription::me().

00069                                                               {
00070     os << p.me();   
00071     return os;
00072   }

std::ostream& edm::operator<<	(	std::ostream &	os,
		BranchType const &	branchType
	)			`[inline]`

Definition at line 42 of file BranchType.h.

References BranchTypeToString().

00042                                                            {
00043     os << BranchTypeToString(branchType);
00044     return os;
00045   }

std::ostream& edm::operator<<	(	std::ostream &	os,
		BranchMapper const &	p
	)			`[inline]`

Definition at line 67 of file BranchMapper.h.

References edm::BranchMapper::write().

00067                                                     {
00068     p.write(os);
00069     return os;
00070   }

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

00028                                                   {
00029     os << "BranchKey("
00030        << bk.friendlyClassName_ << ", "
00031        << bk.moduleLabel_ << ", "
00032        << bk.productInstanceName_ << ", "
00033        << bk.processName_ << ')';
00034     return os;
00035   }

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

Definition at line 13 of file BranchID.cc.

00013                                                  {
00014     os << id.id();
00015     return os;
00016   }

std::ostream& edm::operator<<	(	std::ostream &	os,
		BranchEntryDescription const &	p
	)			`[inline]`

Definition at line 83 of file BranchEntryDescription.h.

References edm::BranchEntryDescription::write().

00083                                                               {
00084     p.write(os);
00085     return os;
00086   }

std::ostream& edm::operator<<	(	std::ostream &	os,
		BranchDescription const &	p
	)			`[inline]`

Definition at line 197 of file BranchDescription.h.

References edm::BranchDescription::write().

00197                                                          {
00198     p.write(os);
00199     return os;
00200   }

template<typename C, typename T, typename F>

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

Definition at line 248 of file RefVector.h.

References e, i, and r.

00249   {
00250     for (typename RefVector<C,T,F>::const_iterator
00251            i = r.begin(),
00252            e = r.end();
00253          i != e;
00254          ++i)
00255       {
00256         os << *i << '\n';
00257       }
00258     return os;
00259   }

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(), and edm::HLTGlobalStatus::state().

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

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

bool edm::operator<=	(	FileIndex::Element const &	lh,
		FileIndex::Element const &	rh
	)			`[inline]`

Definition at line 135 of file FileIndex.h.

00135 {return !(rh < lh);}

template<typename T>

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

Definition at line 414 of file View.h.

00415   {
00416     return !(rhs<lhs);
00417   }

bool edm::operator==	(	ParameterSet const &	a,
		ParameterSet const &	b
	)			`[inline]`

Definition at line 180 of file ParameterSet.h.

References edm::ParameterSet::toStringOfTracked().

00180                                                            {
00181     // Maybe can replace this with comparison of id_ values.
00182     return a.toStringOfTracked() == b.toStringOfTracked();
00183   }

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

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

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

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

Definition at line 89 of file RunLumiEntryInfo.cc.

References edm::RunLumiEntryInfo::branchID(), edm::RunLumiEntryInfo::moduleDescriptionID(), and edm::RunLumiEntryInfo::productStatus().

00089                                                                    {
00090     return
00091       a.branchID() == b.branchID()
00092       && a.productStatus() == b.productStatus()
00093       && a.moduleDescriptionID() == b.moduleDescriptionID();
00094   }

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

Definition at line 64 of file Provenance.cc.

References edm::Provenance::entryDescription(), and edm::Provenance::product().

00064                                                             {
00065     return
00066       a.product() == b.product()
00067       && a.entryDescription() == b.entryDescription();
00068   }

bool edm::operator==	(	ProductRegistry const &	a,
		ProductRegistry const &	b
	)			`[inline]`

Definition at line 154 of file ProductRegistry.h.

References edm::ProductRegistry::nextID(), and edm::ProductRegistry::productList().

00154                                                                  {
00155     return a.nextID() == b.nextID() && a.productList() == b.productList();
00156   }

bool edm::operator==	(	ProcessHistory const &	a,
		ProcessHistory const &	b
	)			`[inline]`

Definition at line 92 of file ProcessHistory.h.

References edm::ProcessHistory::data().

00092                                                                {
00093     return a.data() == b.data();
00094   }

bool edm::operator==	(	ProcessConfiguration const &	a,
		ProcessConfiguration const &	b
	)			`[inline]`

Definition at line 38 of file ProcessConfiguration.h.

References edm::ProcessConfiguration::parameterSetID(), edm::ProcessConfiguration::passID(), edm::ProcessConfiguration::processName(), and edm::ProcessConfiguration::releaseVersion().

00038                                                                            {
00039     return a.processName() == b.processName() &&
00040     a.parameterSetID() == b.parameterSetID() &&
00041     a.releaseVersion() == b.releaseVersion() &&
00042     a.passID() == b.passID();
00043   }

bool edm::operator==	(	FileIndex::Element const &	lh,
		FileIndex::Element const &	rh
	)			`[inline]`

Definition at line 138 of file FileIndex.h.

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

bool edm::operator==	(	FileID const &	lh,
		FileID const &	rh
	)			`[inline]`

Definition at line 25 of file FileID.h.

References edm::FileID::fid().

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

bool edm::operator==	(	FileFormatVersion const &	a,
		FileFormatVersion const &	b
	)			`[inline]`

Definition at line 20 of file FileFormatVersion.h.

References edm::FileFormatVersion::value_.

00021   {
00022     return a.value_ == b.value_;
00023   }

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

Definition at line 140 of file EventEntryInfo.cc.

References edm::EventEntryInfo::branchID(), edm::EventEntryInfo::entryDescriptionID(), edm::EventEntryInfo::moduleDescriptionID(), edm::EventEntryInfo::noEntryDescription(), edm::EventEntryInfo::productID(), and edm::EventEntryInfo::productStatus().

00140                                                                {
00141     if (a.noEntryDescription() != b.noEntryDescription()) return false;
00142     if (a.noEntryDescription()) {
00143       return
00144         a.branchID() == b.branchID()
00145         && a.productID() == b.productID()
00146         && a.productStatus() == b.productStatus()
00147         && a.moduleDescriptionID() == b.moduleDescriptionID();
00148     }
00149     return
00150       a.branchID() == b.branchID()
00151       && a.productID() == b.productID()
00152       && a.productStatus() == b.productStatus()
00153       && a.entryDescriptionID() == b.entryDescriptionID();
00154   }

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

Definition at line 56 of file EventEntryDescription.cc.

References edm::EventEntryDescription::moduleDescriptionID(), and edm::EventEntryDescription::parents().

00056                                                                              {
00057     return
00058       a.parents() == b.parents()
00059       && a.moduleDescriptionID() == b.moduleDescriptionID();
00060   }

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

Definition at line 45 of file EntryDescription.cc.

References edm::EntryDescription::moduleDescriptionID(), and edm::EntryDescription::parents().

00045                                                                    {
00046     return
00047       a.parents() == b.parents()
00048       && a.moduleDescriptionID() == b.moduleDescriptionID();
00049   }

bool edm::operator==	(	ConstBranchDescription const &	a,
		ConstBranchDescription const &	b
	)			`[inline]`

Definition at line 80 of file ConstBranchDescription.h.

References edm::ConstBranchDescription::me().

00080                                                                                     {
00081     return a.me() == b.me();
00082   }

bool edm::operator==	(	BranchKey const &	a,
		BranchKey const &	b
	)			`[inline]`

Definition at line 57 of file BranchKey.h.

00057                                                      {
00058     return !(a < b || b < a);
00059   }

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

Definition at line 42 of file BranchEntryDescription.cc.

References edm::BranchEntryDescription::creatorStatus(), edm::BranchEntryDescription::moduleDescriptionID(), edm::BranchEntryDescription::parents(), and edm::BranchEntryDescription::productID().

00042                                                                                {
00043     return
00044       a.productID() == b.productID()
00045       && a.creatorStatus() == b.creatorStatus()
00046       && a.parents() == b.parents()
00047       && a.moduleDescriptionID() == b.moduleDescriptionID();
00048   }

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

Definition at line 292 of file BranchDescription.cc.

References edm::BranchDescription::branchAliases(), combinable(), edm::BranchDescription::present(), edm::BranchDescription::processConfigurationIDs(), and edm::BranchDescription::psetIDs().

00292                                                                      {
00293     return combinable(a, b) &&
00294        (a.present() == b.present()) &&
00295        (a.psetIDs() == b.psetIDs()) &&
00296        (a.processConfigurationIDs() == b.processConfigurationIDs()) &&
00297        (a.branchAliases() == b.branchAliases());
00298   }

template<typename T>

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

Definition at line 386 of file View.h.

References edm::View< T >::begin(), edm::View< T >::end(), and edm::View< T >::size().

00387   {
00388     return 
00389       lhs.size() == rhs.size() &&
00390       std::equal(lhs.begin(), lhs.end(), rhs.begin());
00391   }

template<class T, class SORT>

bool edm::operator==	(	SortedCollection< T, SORT > const &	a,
		SortedCollection< T, SORT > const &	b
	)			`[inline]`

Definition at line 447 of file SortedCollection.h.

References edm::SortedCollection< T, SORT >::begin(), edm::SortedCollection< T, SORT >::end(), and edm::SortedCollection< T, SORT >::size().

00449   {
00450     return a.size() == b.size() && std::equal(a.begin(), a.end(), b.begin());    
00451   }

template<class T, class SORT, class ALLOC>

bool edm::operator==	(	SortedCollection< T, SORT > const &	c,
		std::vector< T, ALLOC > const &	v
	)			`[inline]`

Definition at line 434 of file SortedCollection.h.

References edm::SortedCollection< T, SORT >::begin(), and edm::SortedCollection< T, SORT >::size().

00436   {
00437     return c.size() == v.size() && std::equal(v.begin(), v.end(), c.begin());
00438   }

template<typename KEY>

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

Equality operator.

Definition at line 90 of file RefVectorBase.h.

References edm::RefVectorBase< KEY >::items(), and edm::RefVectorBase< KEY >::refCore().

00090                                                                            {
00091     return lhs.refCore() == rhs.refCore() && lhs.items() == rhs.items();
00092   }

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

References edm::RefVector< C, T, F >::refVector().

00213                                                                            {
00214     return lhs.refVector() == rhs.refVector();
00215   }

template<class T>

bool edm::operator==	(	RefToBaseVector< T > const &	a,
		RefToBaseVector< T > const &	b
	)			`[inline]`

Definition at line 95 of file RefToBaseVector.h.

References edm::RefToBaseVector< T >::begin(), edm::RefToBaseVector< T >::end(), edm::RefToBaseVector< T >::isInvalid(), and edm::RefToBaseVector< T >::size().

00097   {
00098     if ( a.isInvalid() && b.isInvalid() ) return true;
00099     if ( a.isInvalid() || b.isInvalid() ) return false;
00100     return  a.size() == b.size() && std::equal(a.begin(), a.end(), b.begin());
00101   }

template<typename T>

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

Definition at line 190 of file RefToBaseProd.h.

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

00190                                                                         {
00191     return lhs.refCore() == rhs.refCore();
00192   }

template<typename C>

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

Definition at line 217 of file RefProd.h.

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

00217                                                             {
00218     return lhs.refCore() == rhs.refCore();
00219   }

template<typename KEY>

bool edm::operator==	(	RefItem< KEY > const &	lhs,
		RefItem< KEY > const &	rhs
	)			`[inline]`

Definition at line 43 of file RefItem.h.

References edm::RefItem< KEY >::key().

00043                                                                {
00044     return lhs.key() == rhs.key();
00045   }

bool edm::operator==	(	RefCore const &	lhs,
		RefCore const &	rhs
	)			`[inline]`

Definition at line 76 of file RefCore.h.

References edm::RefCore::id(), edm::RefCore::isTransient(), and edm::RefCore::productPtr().

00076                                                      {
00077     return lhs.isTransient() == rhs.isTransient() && (lhs.isTransient() ? lhs.productPtr() == rhs.productPtr() : lhs.id() == rhs.id());
00078   }

template<typename KEY>

bool edm::operator==	(	RefBase< KEY > const &	lhs,
		RefBase< KEY > const &	rhs
	)			`[inline]`

Definition at line 59 of file RefBase.h.

References edm::RefBase< KEY >::item(), and edm::RefBase< KEY >::refCore().

00059                                                                {
00060     return lhs.refCore() == rhs.refCore() && lhs.item() == rhs.item();
00061   }

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

References edm::Ref< C, T, F >::ref().

00406                                                                {
00407     return lhs.ref() == rhs.ref();
00408   }

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

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

template<class X, class Y>

bool edm::operator==	(	debugging_allocator< X > const &	,
		debugging_allocator< Y > const &
	)			throw () `[inline]`

Definition at line 73 of file debugging_allocator.h.

00073 { return true; }

bool edm::operator>	(	const TypeIDBase &	a,
		const TypeIDBase &	b
	)			`[inline]`

Definition at line 72 of file TypeIDBase.h.

00073    { return b<a; }

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

bool edm::operator>	(	FileIndex::Element const &	lh,
		FileIndex::Element const &	rh
	)			`[inline]`

Definition at line 129 of file FileIndex.h.

00129 {return rh < lh;}

template<typename T>

bool edm::operator>	(	View< T > const &	lhs,
		View< T > const &	rhs
	)			`[inline]`

Definition at line 421 of file View.h.

00422   {
00423     return rhs<lhs;
00424   }

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

bool edm::operator>=	(	FileIndex::Element const &	lh,
		FileIndex::Element const &	rh
	)			`[inline]`

Definition at line 132 of file FileIndex.h.

00132 {return !(lh < rh);}

template<typename T>

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

Definition at line 428 of file View.h.

00429   {
00430     return !(lhs<rhs);
00431   }

std::istream& edm::operator>>	(	std::istream &	is,
		FileInPath &	fip
	)			`[inline]`

Definition at line 151 of file FileInPath.h.

References edm::FileInPath::read().

00152   {
00153     fip.read(is);
00154     return is;
00155   }

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
	)			`[inline]`

Definition at line 237 of file Selector.h.

00238   {
00239     return OrHelper<A,B>(a,b);
00240   }

template<>

boost::int64_t edm::ParameterSet::getParameter< boost::int64_t > ( std::string const & name ) const [inline]

template<>

boost::uint64_t edm::ParameterSet::getParameter< boost::uint64_t > ( std::string const & name ) const [inline]

template<>

edm::EventID edm::ParameterSet::getParameter< edm::EventID > ( std::string const & name ) const [inline]

template<>

edm::FileInPath edm::ParameterSet::getParameter< edm::FileInPath > ( std::string const & name ) const [inline]

template<>

edm::InputTag edm::ParameterSet::getParameter< edm::InputTag > ( std::string const & name ) const [inline]

template<>

edm::LuminosityBlockID edm::ParameterSet::getParameter< edm::LuminosityBlockID > ( std::string const & name ) const [inline]

template<>

edm::ParameterSet edm::ParameterSet::getParameter< edm::ParameterSet > ( std::string const & name ) const [inline]

template<>

std::string edm::ParameterSet::getParameter< std::string > ( std::string const & name ) const [inline]

template<>

std::vector<boost::int64_t> edm::ParameterSet::getParameter< std::vector< boost::int64_t > > ( std::string const & name ) const [inline]

template<>

std::vector<boost::uint64_t> edm::ParameterSet::getParameter< std::vector< boost::uint64_t > > ( std::string const & name ) const [inline]

template<>

std::vector<double> edm::ParameterSet::getParameter< std::vector< double > > ( std::string const & name ) const [inline]

template<>

std::vector<edm::EventID> edm::ParameterSet::getParameter< std::vector< edm::EventID > > ( std::string const & name ) const [inline]

template<>

std::vector<edm::InputTag> edm::ParameterSet::getParameter< std::vector< edm::InputTag > > ( std::string const & name ) const [inline]

template<>

std::vector<edm::LuminosityBlockID> edm::ParameterSet::getParameter< std::vector< edm::LuminosityBlockID > > ( std::string const & name ) const [inline]

template<>

std::vector<edm::ParameterSet> edm::ParameterSet::getParameter< std::vector< edm::ParameterSet > > ( std::string const & name ) const [inline]

template<>

std::vector<int> edm::ParameterSet::getParameter< std::vector< int > > ( std::string const & name ) const [inline]

template<>

std::vector<PdtEntry> edm::ParameterSet::getParameter< std::vector< PdtEntry > > ( std::string const & name ) const [inline]

template<>

std::vector<std::string> edm::ParameterSet::getParameter< std::vector< std::string > > ( std::string const & name ) const [inline]

template<>

std::vector<unsigned int> edm::ParameterSet::getParameter< std::vector< unsigned int > > ( std::string const & name ) const [inline]

template<>

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

template<>

boost::int64_t edm::ParameterSet::getUntrackedParameter< boost::int64_t > ( std::string const & name ) const [inline]

template<>

boost::int64_t edm::ParameterSet::getUntrackedParameter< boost::int64_t >	(	std::string const &	name,
		boost::int64_t const &	defaultValue
	)			const `[inline]`

template<>

boost::uint64_t edm::ParameterSet::getUntrackedParameter< boost::uint64_t > ( std::string const & name ) const [inline]

template<>

boost::uint64_t edm::ParameterSet::getUntrackedParameter< boost::uint64_t >	(	std::string const &	name,
		boost::uint64_t const &	defaultValue
	)			const `[inline]`

template<>

edm::EventID edm::ParameterSet::getUntrackedParameter< edm::EventID > ( std::string const & name ) const [inline]

template<>

edm::EventID edm::ParameterSet::getUntrackedParameter< edm::EventID >	(	std::string const &	name,
		edm::EventID const &	defaultValue
	)			const `[inline]`

template<>

edm::FileInPath edm::ParameterSet::getUntrackedParameter< edm::FileInPath > ( std::string const & name ) const [inline]

template<>

edm::FileInPath edm::ParameterSet::getUntrackedParameter< edm::FileInPath >	(	std::string const &	name,
		edm::FileInPath const &	defaultValue
	)			const `[inline]`

template<>

edm::InputTag edm::ParameterSet::getUntrackedParameter< edm::InputTag > ( std::string const & name ) const [inline]

template<>

edm::InputTag edm::ParameterSet::getUntrackedParameter< edm::InputTag >	(	std::string const &	name,
		edm::InputTag const &	defaultValue
	)			const `[inline]`

template<>

edm::LuminosityBlockID edm::ParameterSet::getUntrackedParameter< edm::LuminosityBlockID > ( std::string const & name ) const [inline]

template<>

edm::LuminosityBlockID edm::ParameterSet::getUntrackedParameter< edm::LuminosityBlockID >	(	std::string const &	name,
		edm::LuminosityBlockID const &	defaultValue
	)			const `[inline]`

template<>

ParameterSet edm::ParameterSet::getUntrackedParameter< edm::ParameterSet > ( std::string const & name ) const [inline]

template<>

ParameterSet edm::ParameterSet::getUntrackedParameter< edm::ParameterSet >	(	std::string const &	name,
		edm::ParameterSet const &	defaultValue
	)			const `[inline]`

template<>

std::string edm::ParameterSet::getUntrackedParameter< std::string > ( std::string const & name ) const [inline]

template<>

std::string edm::ParameterSet::getUntrackedParameter< std::string >	(	std::string const &	name,
		std::string const &	defaultValue
	)			const `[inline]`

template<>

std::vector<boost::int64_t> edm::ParameterSet::getUntrackedParameter< std::vector< boost::int64_t > > ( std::string const & name ) const [inline]

template<>

std::vector<boost::int64_t> edm::ParameterSet::getUntrackedParameter< std::vector< boost::int64_t > >	(	std::string const &	name,
		std::vector< boost::int64_t > const &	defaultValue
	)			const `[inline]`

template<>

std::vector<boost::uint64_t> edm::ParameterSet::getUntrackedParameter< std::vector< boost::uint64_t > > ( std::string const & name ) const [inline]

template<>

std::vector<boost::uint64_t> edm::ParameterSet::getUntrackedParameter< std::vector< boost::uint64_t > >	(	std::string const &	name,
		std::vector< boost::uint64_t > const &	defaultValue
	)			const `[inline]`

template<>

std::vector<double> edm::ParameterSet::getUntrackedParameter< std::vector< double > > ( std::string const & name ) const [inline]

template<>

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

template<>

std::vector<edm::EventID> edm::ParameterSet::getUntrackedParameter< std::vector< edm::EventID > > ( std::string const & name ) const [inline]

template<>

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

template<>

std::vector<edm::InputTag> edm::ParameterSet::getUntrackedParameter< std::vector< edm::InputTag > > ( std::string const & name ) const [inline]

template<>

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

template<>

std::vector<edm::LuminosityBlockID> edm::ParameterSet::getUntrackedParameter< std::vector< edm::LuminosityBlockID > > ( std::string const & name ) const [inline]

template<>

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

template<>

std::vector<edm::ParameterSet> edm::ParameterSet::getUntrackedParameter< std::vector< edm::ParameterSet > > ( std::string const & name ) const [inline]

template<>

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

template<>

std::vector<int> edm::ParameterSet::getUntrackedParameter< std::vector< int > > ( std::string const & name ) const [inline]

template<>

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

template<>

std::vector<PdtEntry> edm::ParameterSet::getUntrackedParameter< std::vector< PdtEntry > >	(	std::string const &	name,
		const std::vector< PdtEntry > &	defaultValue
	)			const `[inline]`

template<>

std::vector<PdtEntry> edm::ParameterSet::getUntrackedParameter< std::vector< PdtEntry > > ( std::string const & name ) const [inline]

template<>

std::vector<std::string> edm::ParameterSet::getUntrackedParameter< std::vector< std::string > > ( std::string const & name ) const [inline]

template<>

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

template<>

std::vector<unsigned int> edm::ParameterSet::getUntrackedParameter< std::vector< unsigned int > > ( std::string const & name ) const [inline]

template<>

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

std::string edm::parameterTypeEnumToString ( ParameterTypes iType )

Definition at line 31 of file ParameterDescription.cc.

References k_bool, k_int32, k_int64, k_string, k_uint32, k_uint64, k_vbool, k_vint32, k_vint64, k_vstring, k_vuint32, k_vuint64, and TYPE_TO_NAME.

00031                                                            {
00032     switch(iType) {
00033       case k_uint32:
00034         return "uint32";
00035       case k_vuint32:
00036         return "vuint32";
00037       case k_int32:
00038         return "int32";
00039       case k_vint32:
00040         return "vint32";
00041       case k_uint64:
00042         return "uint64";
00043       case k_vuint64:
00044         return "vuint64";
00045       case k_int64:
00046         return "int64";
00047       case k_vint64:
00048         return "vint64";
00049       case k_string:
00050         return "string";
00051       case k_vstring:
00052         return "vstring";
00053       case k_bool:
00054         return "bool";
00055       case k_vbool:
00056         return "vbool";
00057         TYPE_TO_NAME(double);
00058         TYPE_TO_NAME(vdouble);
00059         TYPE_TO_NAME(PSet);
00060         TYPE_TO_NAME(VPSet);
00061         TYPE_TO_NAME(FileInPath);
00062         TYPE_TO_NAME(InputTag);
00063         TYPE_TO_NAME(VInputTag);
00064         TYPE_TO_NAME(EventID);
00065         TYPE_TO_NAME(VEventID);
00066         TYPE_TO_NAME(LuminosityBlockID);
00067         TYPE_TO_NAME(VLuminosityBlockID);
00068       default:
00069         assert(false);
00070     }
00071     return "";
00072   }

bool edm::@7379::partial_match	(	const boost::regex &	regularExpression,
		const std::string &	branchstring
	)			`[inline, static]`

Definition at line 30 of file GroupSelectorRules.cc.

Referenced by edm::GroupSelectorRules::Rule::appliesTo().

00032     {
00033       if (regularExpression.empty()) {
00034         if (branchstring == "") return true;
00035         else return false;
00036       }
00037       return boost::regex_match(branchstring, regularExpression);
00038     }

template<typename S>

S& edm::print	(	S &	os,
		JobReport::RunReport const &	rep
	)			`[inline]`

Definition at line 75 of file JobReport.cc.

References edm::JobReport::RunReport::lumiSections, and edm::JobReport::RunReport::runNumber.

00076                                          {
00077     os << "\n<Run ID=\"" 
00078        <<rep.runNumber
00079        << "\">\n";
00080     
00081     std::set<unsigned int>::iterator il;
00082     for (il = rep.lumiSections.begin(); il != rep.lumiSections.end();
00083          ++il){
00084       os << "   <LumiSection ID=\"" << *il << "\"/>\n";
00085       
00086     }
00087     
00088     os << "</Run>\n";
00089     
00090 
00091         return os;
00092      }

template<typename S>

S& edm::print	(	S &	os,
		JobReport::OutputFile const &	f
	)			`[inline]`

Definition at line 55 of file JobReport.cc.

References edm::JobReport::OutputFile::branchHash, edm::JobReport::OutputFile::dataType, formatFile(), edm::JobReport::OutputFile::numEventsWritten, and edm::JobReport::OutputFile::outputModuleClassName.

00055                                                 {
00056       formatFile(f, os);
00057       os << "\n<OutputModuleClass>"
00058                         << f.outputModuleClassName
00059                         << "</OutputModuleClass>";
00060       os << "\n<TotalEvents>"
00061                         << f.numEventsWritten
00062                         << "</TotalEvents>\n";
00063       os << "\n<DataType>"
00064                         << f.dataType
00065                         << "</DataType>\n";
00066       os << "\n<BranchHash>"
00067                         << f.branchHash
00068                         << "</BranchHash>\n";
00069 
00070       return os;
00071     }

template<typename S>

S& edm::print	(	S &	os,
		JobReport::InputFile const &	f
	)			`[inline]`

Definition at line 42 of file JobReport.cc.

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

Referenced by operator<<().

00042                                                {
00043 
00044       os << "\n<InputFile>";
00045       formatFile(f, os);
00046       os << "\n<InputSourceClass>" << f.inputSourceClassName
00047          << "</InputSourceClass>";
00048       os << "\n<EventsRead>" << f.numEventsRead << "</EventsRead>";
00049       return os;
00050     }

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

00023                                                                                    {
00024     std::string programName(prog ? prog : "program");
00025     std::string shortDesc("std::bad_allocException");
00026     std::ostringstream longDesc;
00027     longDesc << "std::bad_alloc exception caught in "
00028              << programName
00029              << "\n"
00030              << "The job has probably exhausted the virtual memory available to the process.\n";
00031     edm::LogSystem(shortDesc) << longDesc.str() << "\n";
00032     if(jobRep) jobRep->reportError(shortDesc, longDesc.str(), rc);
00033   } catch(...) {
00034   }

void edm::printBranchNames ( TTree * tree )

Definition at line 62 of file CollUtil.cc.

References GenMuonPlsPt100GeV_cfg::cout, lat::endl(), and i.

00062                                       {
00063 
00064     if ( tree != 0 ) {
00065       Long64_t nB=tree->GetListOfBranches()->GetEntries();
00066       for ( Long64_t i=0; i<nB; ++i) {
00067         TBranch *btemp = (TBranch *)tree->GetListOfBranches()->At(i);
00068         std::cout << "Branch " << i <<" of " << tree->GetName() <<" tree: " << btemp->GetName() << " Total size = " << btemp->GetTotalSize() << std::endl;
00069       }
00070     }
00071     else{
00072       std::cout << "Missing Events tree?\n";
00073     }
00074 
00075   }

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

00010                                                                                           {
00011     std::string programName(prog ? prog : "program");
00012     std::string shortDesc("CMSException");
00013     std::ostringstream longDesc;
00014     longDesc << "cms::Exception caught in " 
00015              << programName
00016              << "\n"
00017              << e.explainSelf();
00018     edm::LogSystem(shortDesc) << longDesc.str() << "\n";
00019     if(jobRep) jobRep->reportError(shortDesc, longDesc.str(), rc);
00020   } catch(...) {
00021   }

void edm::printEventLists ( TFile * tfl )

Definition at line 100 of file CollUtil.cc.

References GenMuonPlsPt100GeV_cfg::cout, fileFormatVersion, edm::poolNames::fileFormatVersionBranchName(), fileIndex, edm::poolNames::fileIndexBranchName(), metaDataTree, and edm::poolNames::metaDataTreeName().

00100                                    {
00101 
00102     FileFormatVersion fileFormatVersion;
00103     FileFormatVersion *fftPtr = &fileFormatVersion;
00104 
00105     FileIndex fileIndex;
00106     FileIndex *findexPtr = &fileIndex;
00107 
00108     TTree *metaDataTree = dynamic_cast<TTree *>(tfl->Get(poolNames::metaDataTreeName().c_str()));
00109     metaDataTree->SetBranchAddress(poolNames::fileFormatVersionBranchName().c_str(), &fftPtr);
00110     if (metaDataTree->FindBranch(poolNames::fileIndexBranchName().c_str()) != 0) {
00111       metaDataTree->SetBranchAddress(poolNames::fileIndexBranchName().c_str(), &findexPtr);
00112     }
00113     else {
00114       std::cout << "FileIndex not found.  If this input file was created with release 1_8_0 or later\n"
00115                    "this indicates a problem with the file.  This condition should be expected with\n"
00116         "files created with earlier releases and printout of the event list will fail.\n";
00117       return;
00118     }
00119     metaDataTree->GetEntry(0);
00120 
00121     std::cout << "\n" << fileIndex;
00122 
00123     std::cout << "\nFileFormatVersion = " << fileFormatVersion << ".  ";
00124     if (fileFormatVersion.fastCopyPossible()) std::cout << "This version supports fast copy\n";
00125     else std::cout << "This version does not support fast copy\n";
00126 
00127     if (fileIndex.allEventsInEntryOrder()) {
00128       std::cout << "Events are sorted such that fast copy is possible in the default mode\n";
00129     }
00130     else {
00131       std::cout << "Events are sorted such that fast copy is NOT possible in the default mode\n";
00132     }
00133 
00134     fileIndex.sortBy_Run_Lumi_EventEntry();
00135     if (fileIndex.allEventsInEntryOrder()) {
00136       std::cout << "Events are sorted such that fast copy is possible in the \"noEventSort\" mode\n";
00137     }
00138     else {
00139       std::cout << "Events are sorted such that fast copy is NOT possible in the \"noEventSort\" mode\n";
00140     }
00141     std::cout << "(Note that other factors can prevent fast copy from occurring)\n\n";
00142   }

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

00036                                                                                               {
00037     std::string programName(prog ? prog : "program");
00038     std::string shortDesc("StdLibException");
00039     std::ostringstream longDesc;
00040     longDesc << "Standard library exception caught in " 
00041              << programName
00042              << "\n"
00043              << e.what();
00044     edm::LogSystem(shortDesc) << longDesc.str() << "\n";
00045     if (jobRep) jobRep->reportError(shortDesc, longDesc.str(), rc);
00046   } catch(...) {
00047   }

void edm::printTrees ( TFile * hdl )

Definition at line 33 of file CollUtil.cc.

References iter, getDQMSummary::key, and VarParsing::obj.

00033                               {
00034 
00035     hdl->ls();
00036     TList *keylist= hdl->GetListOfKeys();
00037     TIterator *iter= keylist->MakeIterator();
00038     TKey *key;
00039     while ( (key= (TKey*)iter->Next()) ) {
00040       TObject *obj= hdl->Get(key->GetName());
00041       if ( obj->IsA() == TTree::Class() ) {
00042         obj->Print();
00043       }
00044     }
00045     return;
00046   }

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

00049                                                                                   {
00050     std::string programName(prog ? prog : "program");
00051     std::string shortDesc("UnknownException");
00052     std::ostringstream longDesc;
00053     longDesc << "Unknown exception caught in "
00054              << programName
00055              << "\n";
00056     edm::LogSystem(shortDesc) << longDesc.str() << "\n";
00057     if (jobRep) jobRep->reportError(shortDesc, longDesc.str(), rc);
00058   } catch(...) {
00059   }

void edm::printUuids ( TTree * uuidTree )

Definition at line 91 of file CollUtil.cc.

References GenMuonPlsPt100GeV_cfg::cout, lat::endl(), edm::FileID::fid(), NewTree::fid, and edm::poolNames::fileIdentifierBranchName().

00091                                    {
00092     FileID fid;
00093     FileID *fidPtr = &fid;
00094     uuidTree->SetBranchAddress(poolNames::fileIdentifierBranchName().c_str(), &fidPtr);
00095     uuidTree->GetEntry(0);
00096 
00097     std::cout << "UUID: " << fid.fid() << std::endl;
00098   }

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

Definition at line 278 of file ReflexTools.cc.

References i, public_base_classes(), and search_all().

00279                                                        {
00280 
00281     if (type.IsClass() || type.IsStruct()) {
00282 
00283       int nBase = type.BaseSize();
00284       for (int i = 0; i < nBase; ++i) {
00285 
00286         Base base = type.BaseAt(i);
00287         if (base.IsPublic()) {
00288 
00289           Type baseType = type.BaseAt(i).ToType();
00290           if (bool(baseType)) {
00291 
00292             while (baseType.IsTypedef() == true) {
00293               baseType = baseType.ToType();
00294             }
00295 
00296             // Check to make sure this base appears only once in the
00297             // inheritance heirarchy.
00298             if (!search_all(baseTypes, baseType)) {
00299               // Save the type and recursive look for its base types
00300               baseTypes.push_back(baseType);
00301               public_base_classes(baseType, baseTypes);
00302             }
00303             // For now just ignore it if the class appears twice,
00304             // After some more testing we may decide to uncomment the following
00305             // exception.
00306             /*
00307             else {
00308               throw edm::Exception(edm::errors::UnimplementedFeature)
00309                 << "DataFormats/Common/src/ReflexTools.cc in function public_base_classes.\n"
00310                 << "Encountered class that has a public base class that appears\n"
00311                 << "multiple times in its inheritance heirarchy.\n"
00312                 << "Please contact the EDM Framework group with details about\n"
00313                 << "this exception.  It was our hope that this complicated situation\n"
00314                 << "would not occur.  There are three possible solutions.  1. Change\n"
00315                 << "the class design so the public base class does not appear multiple\n"
00316                 << "times in the inheritance heirarchy.  In many cases, this is a\n"
00317                 << "sign of bad design.  2.  Modify the code that supports Views to\n"
00318                 << "ignore these base classes, but not supply support for creating a\n"
00319                 << "View of this base class.  3.  Improve the View infrastructure to\n"
00320                 << "deal with this case. Class name of base class: " << baseType.Name() << "\n\n";
00321             }
00322             */
00323           }
00324         }
00325       }
00326     }
00327   }

void edm::public_base_classes	(	const ROOT::Reflex::Type &	type,
		std::vector< ROOT::Reflex::Type > &	baseTypes
	)

Referenced by edm::ProductRegistry::initializeTransients(), and public_base_classes().

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

Definition at line 15 of file pythonFileToConfigure.cc.

References dbtoconf::command, pythonToCppException(), and HLT_VtxMuL3::result.

00016 {
00017   std::string returnValue;
00018   std::string initCommand("import FWCore.ParameterSet.Config as cms\n"
00019                           "fileDict = dict()\n"
00020                           "execfile('");
00021   initCommand += iPythonFileName+"',fileDict)";
00022   
00023   Py_InitializeEx(0);
00024   using namespace boost::python;
00025   
00026   object main_module((
00027                       boost::python::handle<PyObject>(borrowed(PyImport_AddModule("__main__")))));
00028   object main_namespace = main_module.attr("__dict__");
00029   try {
00030     try {
00031       object result((boost::python::handle<>(PyRun_String(initCommand.c_str(),
00032                                                           Py_file_input,
00033                                                           main_namespace.ptr(),
00034                                                           main_namespace.ptr()))));
00035     } catch(error_already_set) {
00036       edm::pythonToCppException("Configuration");
00037     }
00038     try {
00039       std::string command("cms.findProcess(fileDict).dumpConfig()");
00040       object result((handle<>(PyRun_String(command.c_str(),
00041                                            Py_eval_input,
00042                                            main_namespace.ptr(),
00043                                            main_namespace.ptr()))));
00044       returnValue= extract<std::string>(result);
00045       
00046     }catch( error_already_set ) {
00047       edm::pythonToCppException("Configuration");
00048     }
00049   }catch(...) {
00050     Py_Finalize();
00051     throw;
00052   }
00053   Py_Finalize();
00054   return returnValue;
00055 }

void edm::pythonToCppException ( const std::string & iType )

Definition at line 6 of file PythonWrapper.cc.

References Exception, NULL, and GsfMatrixTools::trace().

Referenced by pythonFileToConfigure(), and PythonProcessDesc::read().

00007  {
00008   using namespace boost::python;
00009   PyObject *exc=NULL, *val=NULL, *trace=NULL;
00010   PyErr_Fetch(&exc,&val,&trace);
00011   PyErr_NormalizeException(&exc,&val,&trace);
00012   handle<> hExc(allow_null(exc));
00013   handle<> hVal(allow_null(val));
00014   handle<> hTrace(allow_null(trace));
00015  
00016   if(hTrace) {
00017     object oTrace(hTrace);
00018     handle<> hStringTr(PyObject_Str(oTrace.ptr()));
00019     object stringTr(hStringTr);
00020 //std::cout << "PR TR " << stringTr <<  " DONE "<<  std::endl;
00021   }
00022 
00023   if(hVal && hExc) {
00024     object oExc(hExc);
00025     object oVal(hVal);
00026     handle<> hStringVal(PyObject_Str(oVal.ptr()));
00027     object stringVal( hStringVal );
00028 
00029     handle<> hStringExc(PyObject_Str(oExc.ptr()));
00030     object stringExc( hStringExc);
00031 
00032     //PyErr_Print();
00033     throw cms::Exception(iType) <<"python encountered the error: "
00034                                 << PyString_AsString(stringExc.ptr())<<" "
00035                                 << PyString_AsString(stringVal.ptr())<<"\n";
00036   } else {
00037     throw cms::Exception(iType)<<" unknown python problem occurred.\n";
00038   }
00039 }

void edm::read_from_cin ( std::string & output )

Definition at line 27 of file Parse.cc.

References parsecf::pyparsing::line().

00027                                            {
00028       std::string line;
00029       while (getline(std::cin, line)) {
00030         output += line;
00031         output += '\n';
00032       }
00033     }

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, iggi_31X_cfg::input, and HLT_VtxMuL3::result.

Referenced by edm::pset::makeDefaultPSet(), and edm::pset::IncludeNode::resolve().

00010                                                           {
00011       std::string result;
00012       std::ifstream input(filename.c_str());
00013       if (!input) {
00014        throw edm::Exception(errors::Configuration,"MissingFile")
00015          << "Cannot read file " << filename;
00016       }
00017       std::string buffer;
00018       while (getline(input, buffer)) {
00019           // getline strips newlines; we have to put them back by hand.
00020           result += buffer;
00021           result += '\n';
00022       }
00023       return result; 
00024     }

boost::shared_ptr< edm::ProcessDesc > edm::readConfig	(	const std::string &	config,
		int	argc,
		char *	argv[]
	)

same, but with arguments

Definition at line 14 of file MakeParameterSets.cc.

References PythonProcessDesc::processDesc().

00015   {
00016     PythonProcessDesc pythonProcessDesc(config, argc, argv);
00017     return pythonProcessDesc.processDesc();
00018   }

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

Definition at line 7 of file MakeParameterSets.cc.

References PythonProcessDesc::processDesc().

Referenced by readConfigFile().

00008   {
00009     PythonProcessDesc pythonProcessDesc(config);
00010     return pythonProcessDesc.processDesc();
00011   }

boost::shared_ptr<edm::ProcessDesc> edm::readConfigFile ( const std::string & fileName )

Definition at line 39 of file MakeParameterSets.h.

References readConfig().

Referenced by VisEventProcessorService::initEventProcessor().

00039 {return readConfig(fileName);}

std::auto_ptr<SendJobHeader> edm::readHeaderFromStream ( ifstream & ist )

Not an init message should return

Definition at line 164 of file Utilities.cc.

References code, HeaderView::code(), edm::StreamerInputSource::deserializeRegistry(), Exception, Header::INIT, int, p, and HeaderView::size().

00165   {
00166     JobHeaderDecoder decoder;
00167     std::vector<char> regdata(1000*1000);
00168 
00169     //int len;
00170     //ist.read((char*)&len,sizeof(int));
00171     //regdata.resize(len);
00172     //ist.read(&regdata[0],len);
00173     ist.read(&regdata[0], sizeof(HeaderView));
00174 
00175     if (ist.eof() || (unsigned int)ist.gcount() < sizeof(HeaderView)  )
00176     {
00177           throw cms::Exception("ReadHeader","getRegFromFile")
00178                 << "No file exists or Empty file encountered:\n";
00179     }
00180 
00181     HeaderView head(&regdata[0]);
00182     uint32 code = head.code();
00183     if (code != Header::INIT) 
00184     {
00185       throw cms::Exception("ReadHeader","getRegFromFile")
00186                 << "Expecting an init Message at start of file\n";
00187     }
00188 
00189     uint32 headerSize = head.size();
00190     //Bring the pointer at start of Start Message/start of file
00191     ist.seekg(0, std::ios::beg);
00192     ist.read(&regdata[0], headerSize);
00193 
00194     //if(!ist)
00195     //  throw cms::Exception("ReadHeader","getRegFromFile")
00196     //  << "Could not read the registry information from the test\n"
00197     //  << "event stream file \n";
00198 
00199     //edm::InitMsg msg(&regdata[0],len);
00200     //std::auto_ptr<SendJobHeader> p = decoder.decodeJobHeader(msg);
00201     InitMsgView initView(&regdata[0]);
00202     std::auto_ptr<SendJobHeader> p = StreamerInputSource::deserializeRegistry(initView);
00203     return p;
00204   }

std::auto_ptr<SendJobHeader> edm::readHeaderFromStream ( std::ifstream & ist )

Referenced by getRegFromFile().

void edm::reenableSigs ( sigset_t * oldset )

Definition at line 81 of file UnixSignalHandlers.cc.

References MUST_BE_ZERO.

Referenced by installCustomHandler().

00082     {
00083       // reenable the signals
00084       MUST_BE_ZERO(pthread_sigmask(SIG_SETMASK,oldset,0));
00085     }

template<class T>

T const* edm::reflex_cast	(	void *	raw,
		ROOT::Reflex::Type const &	dynamicType
	)			`[inline]`

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 107 of file ReflexTools.h.

References VarParsing::obj.

00108   {
00109     static const ROOT::Reflex::Type 
00110       toType(ROOT::Reflex::Type::ByTypeInfo(typeid(T)));
00111 
00112     ROOT::Reflex::Object obj(dynamicType, raw);
00113     return static_cast<T const*>(obj.CastObject(toType).Address());
00114 
00115     // This alternative implementation of reflex_cast would allow us
00116     // to remove the compile-time depenency on Reflex/Type.h and
00117     // Reflex/Object.h, at the cost of some speed.
00118     //
00119     //     return static_cast<T const*>(reflex_pointer_adjust(raw, 
00120     //                                                 dynamicType,
00121     //                                                 typeid(T)));
00122   }

void const* edm::reflex_pointer_adjust	(	void *	raw,
		Type const &	dynamicType,
		std::type_info const &	toType
	)

Definition at line 330 of file ReflexTools.cc.

References VarParsing::obj.

00333   {
00334     Object  obj(dynamicType, raw);
00335     return obj.CastObject(Type::ByTypeInfo(toType)).Address();    
00336   }

void const* edm::reflex_pointer_adjust	(	void *	raw,
		ROOT::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.

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 ) [inline]

Definition at line 18 of file RefToPtr.h.

Referenced by TauGenJetProducer::produce(), PFRootEventManager::reconstructGenJets(), and reco::PFTau::sourceCandidatePtr().

00019                                                                                                   {
00020     typedef typename C::value_type T;
00021     if (ref.isTransient()) {
00022       return Ptr<T>(ref.product(), ref.key());
00023     } else if (ref.get() == 0 && ref.productGetter() != 0) {
00024       return Ptr<T>(ref.id(), ref.key(), ref.productGetter());
00025     }
00026     return Ptr<T>(ref.id(), ref.get(), ref.key());
00027   }

static void edm::registerTypes ( ) [static]

Definition at line 208 of file RootAutoLibraryLoader.cc.

References edmplugin::PluginManager::categoryToInfos(), cintToReflexSpecialCasesMap(), className(), classNameForRoot(), GenMuonPlsPt100GeV_cfg::cout, archive::db, lat::endl(), edmplugin::PluginCapabilities::get(), edmplugin::PluginManager::get(), name, and t.

Referenced by edm::RootAutoLibraryLoader::RootAutoLibraryLoader().

00208                      {
00209   edmplugin::PluginManager*db =  edmplugin::PluginManager::get();
00210 
00211   typedef edmplugin::PluginManager::CategoryToInfos CatToInfos;
00212 
00213   CatToInfos::const_iterator itFound = db->categoryToInfos().find("Capability");
00214 
00215   if(itFound == db->categoryToInfos().end()) {
00216     return;
00217   }
00218 
00219   //in order to determine if a name is from a class or a namespace, we will order
00220   // all the classes in descending order so that embedded classes will be seen before
00221   // their containing classes, that way we can say the containing class is a namespace
00222   // before finding out it is actually a class
00223   typedef std::vector<std::pair<std::string,std::string> > ClassAndLibraries;
00224   ClassAndLibraries classes;
00225   classes.reserve(1000);
00226   std::string lastClass;
00227 
00228   //find where special cases come from
00229   std::map<std::string,std::string> specialsToLib;
00230   const std::map<std::string,std::string>& specials = cintToReflexSpecialCasesMap();
00231   for(std::map<std::string,std::string>::const_iterator itSpecial = specials.begin();
00232       itSpecial != specials.end();
00233       ++itSpecial) {
00234     specialsToLib[classNameForRoot(itSpecial->second)];
00235   }
00236   static const std::string cPrefix("LCGReflex/");
00237   for (edmplugin::PluginManager::Infos::const_iterator itInfo = itFound->second.begin(),
00238        itInfoEnd = itFound->second.end();
00239        itInfo != itInfoEnd; ++itInfo)
00240   {
00241     if (lastClass == itInfo->name_) {
00242       continue;
00243     }
00244     lastClass = itInfo->name_;
00245     if(cPrefix == lastClass.substr(0,cPrefix.size())) {
00246       std::string className = classNameForRoot(lastClass.c_str()+cPrefix.size());
00247       classes.push_back(std::pair<std::string,std::string>(className, itInfo->loadable_.native_file_string()));
00248       std::map<std::string,std::string>::iterator itFound = specialsToLib.find(className);
00249       if(itFound !=specialsToLib.end()){
00250         itFound->second = itInfo->loadable_.native_file_string();
00251       }
00252     }
00253   }
00254   //sort_all(classes, std::greater<std::string>());
00255   //sort_all(classes, CompareFirst());
00256   //the values are already sorted by less, so just need to reverse to get greater
00257   for(ClassAndLibraries::reverse_iterator itClass = classes.rbegin(), itClassEnd = classes.rend();
00258       itClass != itClassEnd;
00259       ++itClass) {
00260 
00261     const std::string& className = itClass->first;
00262     const std::string& libraryName = itClass->second;
00263     //need to register namespaces and figure out if we have an embedded class
00264     static const std::string toFind(":<");
00265     std::string::size_type pos=0;
00266     while(std::string::npos != (pos = className.find_first_of(toFind,pos))) {
00267       if (className[pos] == '<') {break;}
00268       if (className.size() <= pos+1 || className[pos+1] != ':') {break;}
00269       //should check to see if this is a class or not
00270       G__set_class_autoloading_table(const_cast<char*>(className.substr(0,pos).c_str()),"");
00271       //std::cout <<"namespace "<<className.substr(0,pos).c_str()<<std::endl;
00272       pos += 2;
00273     }
00274     G__set_class_autoloading_table(const_cast<char*>(className.c_str()), const_cast<char*>(libraryName.c_str()));
00275     //std::cout <<"class "<<className.c_str()<<std::endl;
00276   }
00277    
00278   //now handle the special cases
00279   for(std::map<std::string,std::string>::const_iterator itSpecial = specials.begin();
00280       itSpecial != specials.end();
00281       ++itSpecial) {
00282     //std::cout <<"registering special "<<itSpecial->first<<" "<<itSpecial->second<<" "<<specialsToLib[classNameForRoot(itSpecial->second)]<<std::endl;
00283     //force loading of specials
00284     if(specialsToLib[classNameForRoot(itSpecial->second)].size()) {
00285       //std::cout <<"&&&&& found special case "<<itSpecial->first<<std::endl;
00286       std::string name=itSpecial->second;
00287       if(not edmplugin::PluginCapabilities::get()->tryToLoad(cPrefix+name)) {
00288         std::cout <<"failed to load plugin"<<std::endl;
00289         continue;
00290       } else {
00291         //need to construct the Class ourselves
00292         ROOT::Reflex::Type t = ROOT::Reflex::Type::ByName(name);
00293         if(ROOT::Reflex::Type() == t) {
00294           std::cout <<"reflex did not build "<<name<<std::endl;
00295           continue;
00296         }
00297         TClass* reflexNamedClass = TClass::GetClass(t.TypeInfo());
00298         if(0==reflexNamedClass){
00299           std::cout <<" failed to get TClass by typeid"<<std::endl;
00300           continue;
00301         }
00302         MyClass* myNewlyNamedClass = new MyClass(*reflexNamedClass);
00303         myNewlyNamedClass->SetName(itSpecial->first.c_str());
00304         gROOT->AddClass(myNewlyNamedClass);
00305       }
00306     }
00307   }
00308 }

bool edm::registryIsSubset	(	SendJobHeader const &	sd,
		SendJobHeader const &	ref
	)

Definition at line 120 of file Utilities.cc.

References edm::SendJobHeader::descs(), e, lat::endl(), Exception, FDEBUG, i, and getDQMSummary::key.

00122   {
00123     bool rc = true;
00124     SendDescs::const_iterator i(sd.descs().begin()),e(sd.descs().end());
00125 
00126     FDEBUG(6) << "registryIsSubset: Product List: " << std::endl;
00127     for(;i != e; ++i) {
00128         // the new products must be contained in the old registry
00129         // form a branchkey from the *i branchdescription,
00130         // use the productlist from the product registry to locate
00131         // the branchkey.  If not found, then error in this state
00132         BranchKey key(*i);
00133         // look for matching in ref
00134         FDEBUG(9) << "Looking for " << i->className() << "\n";
00135         SendDescs::const_iterator iref(ref.descs().begin()),eref(ref.descs().end());
00136         bool found = false;
00137         for(; iref != eref; ++iref) {
00138           FDEBUG(9) << "testing against " << iref->className() << "\n";
00139           BranchKey refkey(*iref);
00140           if(key == refkey) {
00141             found = true;
00142             FDEBUG(9) << "found!" << "\n";
00143             break;
00144           }
00145         }
00146         if(!found) {
00147           rc = false;
00148           break;
00149 #if 0
00150           throw cms::Exception("InconsistentRegistry","EventStreamer")
00151             << "A new product registry was received during the "
00152             << "running state with entries that were not present "
00153             << "in the original registry.\n"
00154             << "The new type is " << i->className() << "\n";
00155 #endif
00156           FDEBUG(6) << "Inconsistent Registry: new type is "
00157                     << i->className() << "\n";
00158         }
00159     }
00160 
00161     return rc;
00162   }

bool edm::registryIsSubset	(	SendJobHeader const &	sd,
		ProductRegistry const &	reg
	)

Definition at line 85 of file Utilities.cc.

References edm::SendJobHeader::descs(), e, lat::endl(), Exception, FDEBUG, i, getDQMSummary::key, and edm::ProductRegistry::productList().

Referenced by edmtestp::TestFileReader::TestFileReader().

00087   {
00088     bool rc = true;
00089     SendDescs::const_iterator i(sd.descs().begin()),e(sd.descs().end());
00090 
00091     // the next line seems to be not good.  what if the productdesc is
00092     // already there? it looks like I replace it.  maybe that it correct
00093 
00094     FDEBUG(6) << "registryIsSubset: Product List: " << std::endl;
00095     for(;i != e; ++i) {
00096         typedef edm::ProductRegistry::ProductList plist;
00097         // the new products must be contained in the old registry
00098         // form a branchkey from the *i branchdescription,
00099         // use the productlist from the product registry to locate
00100         // the branchkey.  If not found, then error in this state
00101         BranchKey key(*i);
00102         if(reg.productList().find(key)==reg.productList().end()) {
00103           rc = false;
00104           break;
00105 #if 0
00106           throw cms::Exception("InconsistentRegistry","EventStreamer")
00107             << "A new product registry was received during the "
00108             << "running state with entries that were not present "
00109             << "in the original registry.\n"
00110             << "The new type is " << i->className() << "\n";
00111 #endif
00112           FDEBUG(6) << "Inconsistent Registry: new type is "
00113                     << i->className() << "\n";
00114         }
00115     }
00116 
00117     return rc;
00118   }

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 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(), public_base_classes(), edm::pset::IncludeNode::resolve(), and edm::pset::CompositeNode::validate().

00046                                                        {
00047     return std::find(s.begin(), s.end(), d) != s.end();
00048   }

template<class T, class U>

U edm::second ( std::pair< T, U > const & p ) [inline]

Definition at line 106 of file ParameterSet.cc.

00107   { return p.second; }

void edm::setCacheStreamers ( )

Definition at line 30 of file CacheStreamers.cc.

References edm::ConstPtrCacheStreamer::ConstPtrCacheStreamer().

Referenced by AutoLibraryLoader::enable(), and edm::service::InitRootHandlers::InitRootHandlers().

00030                            {
00031     TClass *cl = gROOT->GetClass("edm::BoolCache");
00032     if (cl->GetStreamer() == 0) {
00033       cl->AdoptStreamer(new BoolCacheStreamer());
00034     /*} else {
00035       std::cout <<"ERROR: no edm::BoolCache found"<<std::endl;*/
00036     }
00037 
00038     cl = gROOT->GetClass("edm::ConstPtrCache");
00039     if (cl->GetStreamer() == 0) {
00040       cl->AdoptStreamer(new ConstPtrCacheStreamer());
00041     /*} else {
00042       std::cout <<"ERROR: no edm::ConstPtrCache found"<<std::endl;*/
00043     }
00044     
00045   }

template<typename T>

void edm::SetCustomStreamer ( T const & ) [inline]

Definition at line 49 of file CustomStreamer.h.

References className().

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

template<typename T>

void edm::SetCustomStreamer ( ) [inline]

Definition at line 40 of file CustomStreamer.h.

References className().

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

template<class T, class SORT>

void edm::setPtr	(	SortedCollection< T, SORT > const &	obj,
		std::type_info const &	toType,
		unsigned long	index,
		void const *&	ptr
	)			`[inline]`

Definition at line 472 of file SortedCollection.h.

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

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

template<class T, class A, class Comp>

void edm::setPtr	(	std::set< T, A, Comp > const &	obj,
		const std::type_info &	iToType,
		unsigned long	iIndex,
		void const *&	oPtr
	)			`[inline]`

Definition at line 106 of file setPtr.h.

References edm::detail::reallySetPtr().

00109                             {
00110     detail::reallySetPtr(obj, iToType, iIndex, oPtr);
00111   }

template<class T, class A>

void edm::setPtr	(	std::deque< T, A > const &	obj,
		const std::type_info &	iToType,
		unsigned long	iIndex,
		void const *&	oPtr
	)			`[inline]`

Definition at line 97 of file setPtr.h.

References edm::detail::reallySetPtr().

00100                             {
00101     detail::reallySetPtr(obj, iToType, iIndex, oPtr);
00102   }

template<class T, class A>

void edm::setPtr	(	std::list< T, A > const &	obj,
		const std::type_info &	iToType,
		unsigned long	iIndex,
		void const *&	oPtr
	)			`[inline]`

Definition at line 88 of file setPtr.h.

References edm::detail::reallySetPtr().

00091                             {
00092     detail::reallySetPtr(obj, iToType, iIndex, oPtr);
00093   }

template<class T, class A>

void edm::setPtr	(	std::vector< T, A > const &	obj,
		const std::type_info &	iToType,
		unsigned long	iIndex,
		void const *&	oPtr
	)			`[inline]`

Definition at line 79 of file setPtr.h.

References edm::detail::reallySetPtr().

00082                             {
00083     detail::reallySetPtr(obj, iToType, iIndex, oPtr);
00084   }

void edm::setRefCoreStreamer ( EDProductGetter const * ep )

Definition at line 32 of file RefCoreStreamer.cc.

References edm::RefCoreStreamer::setProductGetter(), and st.

00032                                                      {
00033     TClass *cl = gROOT->GetClass("edm::RefCore");
00034     RefCoreStreamer *st = static_cast<RefCoreStreamer *>(cl->GetStreamer());
00035     if (st == 0) {
00036       cl->AdoptStreamer(new RefCoreStreamer(ep));
00037     } else {
00038       st->setProductGetter(ep);
00039     }
00040   }

void edm::setRefCoreStreamer ( )

Definition at line 25 of file RefCoreStreamer.cc.

Referenced by edm::StreamerInputSource::deserializeEvent(), edm::RootDelayedReader::getProduct_(), and edm::service::InitRootHandlers::InitRootHandlers().

00025                             {
00026     TClass *cl = gROOT->GetClass("edm::RefCore");
00027     if (cl->GetStreamer() == 0) {
00028       cl->AdoptStreamer(new RefCoreStreamer(0));
00029     }
00030   }

template<typename T>

void edm::SetTransientStreamer ( T const & ) [inline]

Definition at line 53 of file TransientStreamer.h.

References className().

00053                                  {
00054     TClass *cl = gROOT->GetClass(TypeID(typeid(T)).className().c_str());
00055     if (cl->GetStreamer() == 0) {
00056       cl->AdoptStreamer(new TransientStreamer<T>());
00057     }
00058   }

template<typename T>

void edm::SetTransientStreamer ( ) [inline]

Definition at line 44 of file TransientStreamer.h.

References className().

00044                          {
00045     TClass *cl = gROOT->GetClass(TypeID(typeid(T)).className().c_str());
00046     if (cl->GetStreamer() == 0) {
00047       cl->AdoptStreamer(new TransientStreamer<T>());
00048     }
00049   }

void edm::setTransientStreamers ( )

Definition at line 11 of file TransientStreamer.cc.

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

00011                                {
00012     SetTransientStreamer<Transient<BranchDescription::Transients> >();
00013     SetTransientStreamer<Transient<EventEntryDescription::Transients> >();
00014     SetTransientStreamer<Transient<EventEntryInfo::Transients> >();
00015     SetTransientStreamer<Transient<FileIndex::Transients> >();
00016     SetTransientStreamer<Transient<ProcessHistory::Transients> >();
00017     SetTransientStreamer<Transient<ProductRegistry::Transients> >();
00018   }

void edm::sigInventory ( )

Definition at line 150 of file UnixSignalHandlers.cc.

References TestMuL1L2Filter_cff::cerr, lat::endl(), k, MUST_BE_ZERO, sigdelset, sigfillset, and sigismember.

00151     {
00152       sigset_t tmpset, oldset;
00153 //    Make a full house set of signals, except for SIGKILL = 9
00154 //    and SIGSTOP = 19 which cannot be blocked
00155       MUST_BE_ZERO(sigfillset(&tmpset));
00156       MUST_BE_ZERO(sigdelset(&tmpset, SIGKILL));
00157       MUST_BE_ZERO(sigdelset(&tmpset, SIGSTOP));
00158 //    Swap it with the current sigset_t
00159       MUST_BE_ZERO(pthread_sigmask( SIG_SETMASK, &tmpset, &oldset ));
00160 //    Now see what's included in the set
00161       for(int k=1; k<_NSIG; ++k) {
00162         std::cerr << "sigismember is " << sigismember( &tmpset, k )
00163                   << " for signal " << std::setw(2) << k
00164 #if defined(__linux__)
00165                   << " (" << strsignal(k) << ")"
00166 #endif
00167                   << std::endl;
00168       }
00169 //    Finally put the original sigset_t back
00170       MUST_BE_ZERO(pthread_sigmask( SIG_SETMASK, &oldset, &tmpset));
00171     }

template<typename RandomAccessSequence, typename Predicate>

void edm::sort_all	(	RandomAccessSequence &	s,
		Predicate	p
	)			`[inline]`

Definition at line 98 of file Algorithms.h.

References python::multivaluedict::sort().

Referenced by MixingModule::MixingModule(), and StreamerInputIndexFile::sort().

00098                                                   {
00099     std::sort(s.begin(), s.end(), p);
00100   }

template<typename RandomAccessSequence>

void edm::sort_all ( RandomAccessSequence & s ) [inline]

wrappers for std::sort

Definition at line 91 of file Algorithms.h.

References python::multivaluedict::sort().

Referenced by EventContentAnalyzer::EventContentAnalyzer(), edm::PoolOutputModule::fillSelectedItemList(), edm::RootFile::RootFile(), edm::RootInputFileSequence::RootInputFileSequence(), edm::RootOutputFile::RootOutputFile(), and edmplugin::CacheParser::write().

00091                                      {
00092     std::sort(s.begin(), s.end());
00093   }

bool edm::@9947::sorterForJobReportHash	(	BranchDescription const *	lh,
		BranchDescription const *	rh
	)			`[static]`

Definition at line 53 of file RootOutputFile.cc.

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

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

00053                                                                                      {
00054       return 
00055         lh->fullClassName() < rh->fullClassName() ? true :
00056         lh->fullClassName() > rh->fullClassName() ? false :
00057         lh->moduleLabel() < rh->moduleLabel() ? true :
00058         lh->moduleLabel() > rh->moduleLabel() ? false :
00059         lh->productInstanceName() < rh->productInstanceName() ? true :
00060         lh->productInstanceName() > rh->productInstanceName() ? false :
00061         lh->processName() < rh->processName() ? true :
00062         false;
00063     }

template<class OutIter>

bool edm::split	(	OutIter	result,
		std::string const &	string_to_split,
		char	first,
		char	sep,
		char	last
	)			`[inline]`

Definition at line 90 of file split.h.

References b, contextual_find(), contextual_find_not(), and e.

Referenced by decode(), and edm::ParameterSet::fromString().

00092 {
00093   typedef  std::string::const_iterator  str_c_iter;
00094   str_c_iter  b = s.begin()
00095            ,  e = s.end();
00096 
00097   if(static_cast<unsigned int>(e - b) < 2u)  return false;
00098 
00099   if(*b == first)  ++b;
00100   else               return false;
00101 
00102   if(*--e != last)  return false;
00103 
00104   // invariant:  we've found all items in [b..boi)
00105   for(str_c_iter  //boi = std::find_if(b, e, is_not_a(sep))
00106                    boi = contextual_find_not(b, e, first, sep, last)
00107                 ,  eoi
00108      ; boi != e
00109      //; boi = std::find_if(eoi, e, is_not_a(sep))
00110      ; boi = contextual_find_not(eoi, e, first, sep, last))
00111   {
00112     // find end of current item:
00113     //eoi = std::find_if(boi, e, is_a(sep));
00114     eoi = contextual_find(boi, e, first, sep, last);
00115 
00116     // copy the item formed from characters in [boi..eoi):
00117     *dest++ = std::string(boi, eoi);
00118   }  // for
00119 
00120   return true;
00121 }  // split< >()

template<typename RandomAccessSequence, typename Predicate>

void edm::stable_sort_all	(	RandomAccessSequence &	s,
		Predicate	p
	)			`[inline]`

Definition at line 113 of file Algorithms.h.

00113                                                          {
00114     std::stable_sort(s.begin(), s.end(), p);
00115   }

template<typename RandomAccessSequence>

void edm::stable_sort_all ( RandomAccessSequence & s ) [inline]

wrappers for std::stable_sort

Definition at line 106 of file Algorithms.h.

Referenced by edm::FileIndex::sortBy_Run_Lumi_Event(), and edm::FileIndex::sortBy_Run_Lumi_EventEntry().

00106                                             {
00107     std::stable_sort(s.begin(), s.end());
00108   }

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

std::string const& edm::@7381::suffix ( int count ) [static]

Definition at line 28 of file InputSource.cc.

References st.

Referenced by DQMFileSaver::analyze(), edm::PoolOutputModule::doOpenFile(), DQMFileSaver::endLuminosityBlock(), DQMFileSaver::endRun(), ZIterativeAlgorithmWithFit::gausfit(), PrimaryVertexAnalyzer::getSimPVs(), edm::InputSource::issueReports(), RFIOStorageMaker::normalise(), Ig3DBaseBrowser::print(), and DQMFileSaver::saveForOffline().

00028                                            {
00029           static std::string const st("st");
00030           static std::string const nd("nd");
00031           static std::string const rd("rd");
00032           static std::string const th("th");
00033           // *0, *4 - *9 use "th".
00034           int lastDigit = count % 10;
00035           if (lastDigit >= 4 || lastDigit == 0) return th;
00036           // *11, *12, or *13 use "th".
00037           if (count % 100 - lastDigit == 10) return th;
00038           return (lastDigit == 1 ? st : (lastDigit == 2 ? nd : rd));
00039         }

template<class T>

void edm::swap	(	value_ptr< T > &	vp1,
		value_ptr< T > &	vp2
	)			`[inline]`

Definition at line 146 of file value_ptr.h.

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

00146 { vp1.swap( vp2 ); }

void edm::swap	(	FileInPath &	a,
		FileInPath &	b
	)			`[inline]`

Definition at line 138 of file FileInPath.h.

References edm::FileInPath::swap().

00139   {
00140     a.swap(b);
00141   }

void edm::swap	(	Group &	a,
		Group &	b
	)			`[inline]`

Definition at line 119 of file Group.h.

References edm::Group::swap().

00119                            {
00120     a.swap(b);
00121   }

template<class T>

void edm::swap	(	ESHandle< T > &	a,
		ESHandle< T > &	b
	)			`[inline]`

Definition at line 79 of file ESHandle.h.

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

00080   {
00081     a.swap(b);
00082   }

void edm::swap	(	ProcessHistory &	a,
		ProcessHistory &	b
	)			`[inline]`

Definition at line 86 of file ProcessHistory.h.

References edm::ProcessHistory::swap().

00086                                              {
00087     a.swap(b);
00088   }

template<int I>

void edm::swap	(	Hash< I > &	a,
		Hash< I > &	b
	)			`[inline]`

Definition at line 258 of file Hash.h.

References edm::Hash::swap().

00259   {
00260     a.swap(b);
00261   }

template<typename T>

void edm::swap	(	View< T > &	lhs,
		View< T > &	rhs
	)			`[inline]`

Definition at line 436 of file View.h.

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

00436                                         {
00437     lhs.swap(rhs);
00438   }

template<typename T>

void edm::swap	(	Vector< T > &	a,
		Vector< T > &	b
	)			`[inline]`

Definition at line 250 of file Vector.h.

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

00250                                                {
00251     a.swap(b);
00252   }

template<typename T>

void edm::swap	(	ValueMap< T > &	lhs,
		ValueMap< T > &	rhs
	)			`[inline]`

Definition at line 246 of file ValueMap.h.

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

00246                                                 {
00247     lhs.swap(rhs);
00248   }

void edm::swap	(	TriggerResults &	lhs,
		TriggerResults &	rhs
	)			`[inline]`

Definition at line 100 of file TriggerResults.h.

References edm::TriggerResults::swap().

00100                                                  {
00101     lhs.swap(rhs);
00102   }

template<class T>

void edm::swap	(	TestHandle< T > &	a,
		TestHandle< T > &	b
	)			`[inline]`

Definition at line 122 of file TestHandle.h.

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

00123   {
00124     a.swap(b);
00125   }

template<class T, class SORT>

void edm::swap	(	SortedCollection< T, SORT > &	a,
		SortedCollection< T, SORT > &	b
	)			`[inline]`

Definition at line 408 of file SortedCollection.h.

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

00409   {
00410     a.swap(b);
00411   }

template<typename KEY>

void edm::swap	(	RefVectorBase< KEY > &	a,
		RefVectorBase< KEY > &	b
	)			`[inline]`

swap two vectors

Definition at line 105 of file RefVectorBase.h.

References edm::RefVectorBase< KEY >::swap().

00105                                                        {
00106     a.swap(b);
00107   }

template<typename C, typename T, typename F>

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

Definition at line 167 of file RefVector.h.

References edm::RefVector< C, T, F >::swap().

00167                                                        {
00168     a.swap(b);
00169   }

template<class T>

void edm::swap	(	RefToBaseVector< T > &	a,
		RefToBaseVector< T > &	b
	)			`[inline]`

Definition at line 88 of file RefToBaseVector.h.

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

00088                                                      {
00089     a.swap(b);
00090   }

template<typename T>

void edm::swap	(	edm::RefToBaseProd< T > const &	lhs,
		edm::RefToBaseProd< T > const &	rhs
	)			`[inline]`

Definition at line 209 of file RefToBaseProd.h.

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

00209                                                                                      {
00210     lhs.swap( rhs );
00211   }

template<class T>

void edm::swap	(	RefToBase< T > &	a,
		RefToBase< T > &	b
	)			`[inline]`

Definition at line 348 of file RefToBase.h.

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

00349   {
00350     a.swap(b);
00351   }

template<typename C>

void edm::swap	(	edm::RefProd< C > const &	lhs,
		edm::RefProd< C > const &	rhs
	)			`[inline]`

Definition at line 237 of file RefProd.h.

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

00237                                                                  {
00238     lhs.swap(rhs);
00239   }

template<class T>

void edm::swap	(	RefGetter< T > &	a,
		RefGetter< T > &	b
	)			`[inline]`

Definition at line 177 of file RefGetter.h.

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

00178     {
00179       a.swap(b);
00180     }

void edm::swap	(	edm::RefCore &	lhs,
		edm::RefCore &	rhs
	)			`[inline]`

Definition at line 101 of file RefCore.h.

References edm::RefCore::swap().

00101                                                        {
00102     lhs.swap(rhs);
00103   }

template<typename ID, typename C, typename P>

void edm::swap	(	RangeMap< ID, C, P > &	a,
		RangeMap< ID, C, P > &	b
	)			`[inline]`

Definition at line 221 of file RangeMap.h.

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

00221                                                        {
00222     a.swap(b);
00223   }

template<typename T>

void edm::swap	(	PtrVector< T > &	lhs,
		PtrVector< T > &	rhs
	)			`[inline]`

Definition at line 177 of file PtrVector.h.

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

00177                                              {
00178     lhs.swap(rhs);
00179   }

template<typename T, typename P>

void edm::swap	(	OwnVector< T, P > &	a,
		OwnVector< T, P > &	b
	)			`[inline]`

Definition at line 429 of file OwnVector.h.

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

00429                                                            {
00430     a.swap(b);
00431   }

template<typename T>

void edm::swap	(	OutputHandle< T > &	a,
		OutputHandle< T > &	b
	)			`[inline]`

Definition at line 124 of file OutputHandle.h.

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

00124                                                {
00125     a.swap(b);
00126   }

template<class T>

void edm::swap	(	OrphanHandle< T > &	a,
		OrphanHandle< T > &	b
	)			`[inline]`

Definition at line 150 of file OrphanHandle.h.

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

00151   {
00152     a.swap(b);
00153   }

template<typename C>

void edm::swap	(	MultiAssociation< C > &	lhs,
		MultiAssociation< C > &	rhs
	)			`[inline]`

Definition at line 288 of file MultiAssociation.h.

References edm::MultiAssociation< C >::swap().

00288 { lhs.swap(rhs); }

template<typename K, typename T>

void edm::swap	(	MapOfVectors< K, T > &	lhs,
		MapOfVectors< K, T > &	rhs
	)			`[inline]`

Definition at line 161 of file MapOfVectors.h.

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

00161                                                          {
00162     lhs.swap(rhs);
00163   }

template<class T>

void edm::swap	(	LazyGetter< T > &	a,
		LazyGetter< T > &	b
	)			`[inline]`

Definition at line 500 of file LazyGetter.h.

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

00501     {
00502       a.swap(b);
00503     }

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

00193                                                              {
00194     a.swap(b);
00195   }

void edm::swap	(	HLTGlobalStatus &	lhs,
		HLTGlobalStatus &	rhs
	)			`[inline]`

Free swap function.

Definition at line 112 of file HLTGlobalStatus.h.

References edm::HLTGlobalStatus::swap().

00112                                                    {
00113     lhs.swap(rhs);
00114   }

template<class T>

void edm::swap	(	Handle< T > &	a,
		Handle< T > &	b
	)			`[inline]`

Definition at line 215 of file Handle.h.

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

00216   {
00217     a.swap(b);
00218   }

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

00163   {
00164     a.swap(b);
00165   }

template<class T>

void edm::swap	(	DetSetVector< T > &	a,
		DetSetVector< T > &	b
	)			`[inline]`

Definition at line 437 of file DetSetVector.h.

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

00438   {
00439     a.swap(b);
00440   }

template<typename T, typename C>

void edm::swap	(	DetSetRefVector< T, C > &	a,
		DetSetRefVector< T, C > &	b
	)			`[inline]`

Definition at line 281 of file DetSetRefVector.h.

References edm::DetSetRefVector< T, C >::swap().

00281                                                            {
00282     a.swap(b);
00283   }

template<class T>

void edm::swap	(	DetSetLazyVector< T > &	a,
		DetSetLazyVector< T > &	b
	)			`[inline]`

Definition at line 261 of file DetSetLazyVector.h.

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

00262   {
00263     a.swap(b);
00264   }

template<class T>

void edm::swap	(	DetSet< T > &	a,
		DetSet< T > &	b
	)			`[inline]`

Definition at line 95 of file DetSet.h.

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

00095                                      {
00096     a.swap(b);
00097   }

void edm::swap	(	DataFrameContainer &	lhs,
		DataFrameContainer &	rhs
	)			`[inline]`

Definition at line 210 of file DataFrameContainer.h.

References edm::DataFrameContainer::swap().

00210                                                          {
00211     lhs.swap(rhs);
00212   }

template<class T, class P>

void edm::swap	(	CloningPtr< T, P > &	a,
		CloningPtr< T, P > &	b
	)			`[inline]`

Definition at line 65 of file CloningPtr.h.

References edm::CloningPtr< T, P >::swap().

00066   {
00067     a.swap(b);
00068   }

void edm::swap	(	BasicHandle &	a,
		BasicHandle &	b
	)			`[inline]`

Definition at line 109 of file BasicHandle.h.

References edm::BasicHandle::swap().

00109                                        {
00110     a.swap(b);
00111   }

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

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

00229                                                                                                   {
00230     a.swap(b);
00231   }

template<typename C>

void edm::swap	(	Association< C > &	lhs,
		Association< C > &	rhs
	)			`[inline]`

Definition at line 114 of file Association.h.

References edm::Association< C >::swap().

00114                                                              {
00115     lhs.swap(rhs);
00116   }

void edm::throwExceptionWithText ( const char * txt )

Definition at line 216 of file BranchDescription.cc.

References e, and edm::errors::LogicError.

Referenced by edm::BranchDescription::throwIfInvalid_().

00217   {
00218     edm::Exception e(edm::errors::LogicError);
00219     e << "Problem using an incomplete BranchDescription\n"
00220       << txt 
00221       << "\nPlease report this error to the FWCore developers";
00222     throw e;
00223   }

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(), HLT_VtxMuL3::result, and cmsScimarkStop::tokens.

Referenced by edm::pset::ParseTree::checkOkToModify(), decode(), edm::pset::ParseTree::findBlockModifiers(), edm::pset::ParseTree::findInPath(), edm::InputTag::InputTag(), and edm::pset::PythonFormWriter::visitModule().

00057                                                                   {
00058       typedef boost::char_separator<char>   separator_t;
00059       typedef boost::tokenizer<separator_t> tokenizer_t;
00060 
00061       std::vector<std::string> result;
00062       separator_t  sep(separator.c_str(), "", boost::keep_empty_tokens); // separator for elements in path
00063       tokenizer_t  tokens(input, sep);
00064       copy_all(tokens, std::back_inserter<std::vector<std::string> >(result));
00065       return result;
00066     }

template<typename T>

boost::python::list edm::toPythonList ( const std::vector< T > & v ) [inline]

Definition at line 15 of file PythonWrapper.h.

References i, list(), and HLT_VtxMuL3::result.

Referenced by PythonParameterSet::getParameters().

00015                                                        {
00016     boost::python::list result;
00017     for(unsigned i = 0; i < v.size(); ++i) {
00018        result.append(v[i]);
00019     }
00020     return result;
00021   }

template<typename T>

std::vector<T> edm::toVector ( boost::python::list & l ) [inline]

Definition at line 27 of file PythonWrapper.h.

References VarParsing::obj, dbtoconf::object, and HLT_VtxMuL3::result.

00028   {
00029     std::vector<T> result;
00030     try {
00031       boost::python::object iter_obj 
00032         = boost::python::object(boost::python::handle<>(PyObject_GetIter(l.ptr())));
00033       while(1) {
00034         boost::python::object obj = boost::python::extract<boost::python::object>(iter_obj.attr("next")());
00035         result.push_back(boost::python::extract<T>(obj)); 
00036       }
00037     }
00038     catch(boost::python::error_already_set) {
00039       // This is how it finds the end of the list.
00040       //  By throwing an exception.
00041       PyErr_Clear(); 
00042     }
00043 
00044     return result;
00045   }

template<class InputIterator, class ForwardIterator, class Func>

void edm::@7406::transform_into	(	InputIterator	begin,
		InputIterator	end,
		ForwardIterator	out,
		Func	func
	)			`[inline, static]`

Definition at line 38 of file Schedule.cc.

References stor::func().

Referenced by fill_summary().

00039                                                    {
00040       for (; begin != end; ++begin, ++out) func(*begin, *out);
00041     }

static std::string edm::typeToClassName ( const std::type_info & iType ) [static]

Definition at line 20 of file TypeID.cc.

References edm::errors::DictionaryNotFound, and t.

Referenced by edm::TypeID::className().

00020                                                        {
00021     ROOT::Reflex::Type t = ROOT::Reflex::Type::ByTypeInfo(iType);
00022     if (!bool(t)) {
00023       throw edm::Exception(errors::DictionaryNotFound,"NoMatch")
00024       << "TypeID::className: No dictionary for class " << iType.name() << '\n';
00025     }
00026     return t.Name(ROOT::Reflex::SCOPED);
00027   }

bool edm::value_type_of	(	ROOT::Reflex::Type const &	t,
		ROOT::Reflex::Type &	found_type
	)			`[inline]`

Definition at line 45 of file ReflexTools.h.

References find_nested_type_named().

Referenced by if_edm_ref_get_value_type(), if_edm_refToBase_get_value_type(), edm::ProductRegistry::initializeTransients(), and is_sequence_wrapper().

00046   {
00047     return find_nested_type_named("value_type", t, found_type);
00048   }

template<typename V, typename T>

void edm::walkTrie	(	V &	v,
		TrieNode< T > const &	n,
		std::string const &	label = `""`
	)			`[inline]`

visit each node of the trie

Definition at line 284 of file Trie.h.

References e, label, p, and v.

00284                                                                             {
00285     typedef TrieNode<T> const node_base;
00286     typedef TrieNodeIter<T> node_iterator;
00287     node_iterator e;
00288     for (node_iterator p(&n); p!=e; ++p) {
00289       v((*p).value(),label+(char)p.label());
00290       walkTrie(v,*p,label+(char)p.label());
00291     }
00292   }

std::string edm::withoutQuotes ( std::string const & from )

Definition at line 36 of file Parse.cc.

References HLT_VtxMuL3::result.

Referenced by edm::pset::VEntryNode::makeEntry(), and edm::pset::EntryNode::makeEntry().

00036                                                    {
00037       std::string result = from;
00038       if(!result.empty()) {
00039       // get rid of leading quotes
00040         if(result[0] == '"' || result[0] == '\'') {
00041           result.erase(0,1);
00042         }
00043       }
00044 
00045       if(!result.empty()) {
00046        // and trailing quotes
00047         int lastpos = result.size()-1;
00048         if(result[lastpos] == '"' || result[lastpos] == '\'') {
00049           result.erase(lastpos, 1);
00050         }
00051       }
00052      return result;
00053     }

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

Definition at line 5 of file WrappedClassName.cc.

Referenced by edm::StreamerInputSource::buildClassCache(), stor::HLTInfo::buildClassCache(), checkDicts(), BareRootProductGetter::createNewBuffer(), edm::StreamerInputSource::declareStreamers(), stor::HLTInfo::declareStreamers(), fwlite::Event::getByProductID(), edm::root::FWLiteDelayedReader::getProduct_(), and edm::BranchDescription::init().

00005                                                {
00006     std::string const wrapperBegin("edm::Wrapper<");
00007     std::string const wrapperEnd1(">");
00008     std::string const wrapperEnd2(" >");
00009     std::string const& wrapperEnd = (className[className.size()-1] == '>' ? wrapperEnd2 : wrapperEnd1);
00010     std::string wrapped;
00011     wrapped.reserve(wrapperBegin.size() + className.size() + wrapperEnd.size());
00012     wrapped += wrapperBegin;
00013     wrapped += className;
00014     wrapped += wrapperEnd;
00015     return wrapped;
00016   }

bool edm::wrapper_type_of	(	ROOT::Reflex::Type const &	possible_wrapper,
		ROOT::Reflex::Type &	found_wrapped_type
	)			`[inline]`

Definition at line 53 of file ReflexTools.h.

References find_nested_type_named().

Referenced by is_sequence_wrapper().

00055   {
00056     return find_nested_type_named("wrapped_type",
00057                                   possible_wrapper,
00058                                   found_wrapped_type);
00059   }

Variable Documentation

const MallocOpts edm::amd_opts(0, 8388608, 131072, 10485760) [static]

Referenced by edm::MallocOptionSetter::retrieveFromCpuType().

std::string const edm::aux = "Aux" [static]

Definition at line 8 of file BranchType.cc.

Referenced by DDTIBLayerAlgo_MTCC::execute(), HcalTB02HcalNumberingScheme::getetaID(), TFWLiteSelectorBasic::Process(), edm::EventAuxiliaryHistoryProducer::produce(), HelixArbitraryPlaneCrossing2Order::solutionByDirection(), TtFullLepKinSolver::SWAP(), funct::TEMPL(), and TtFullLepKinSolver::TopRec().

std::string const edm::auxiliary = "Auxiliary" [static]

Definition at line 7 of file BranchType.cc.

std::string const edm::branchEntryInfo = "BranchEntryInfo" [static]

Definition at line 10 of file BranchType.cc.

debugvalue edm::debugit

Definition at line 13 of file DebugMacros.cc.

Referenced by edm::ActionTable::addDefaults(), edm::ProcessDesc::fillPaths(), edm::RootDebug::RootDebug(), and edm::RootDebug::~RootDebug().

LogDebug_ edm::dummyLogDebugObject_

LogTrace_ edm::dummyLogTraceObject_

ELslProxy< ELabortGen > const edm::ELabort

Definition at line 401 of file ELseverityLevel.cc.

Referenced by loadMap().

ELslGen edm::ELabortGen

ELslProxy< ELerrorGen > const edm::ELerror

Definition at line 365 of file ELseverityLevel.cc.

Referenced by loadMap().

ELslProxy< ELerror2Gen > const edm::ELerror2

Definition at line 371 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 407 of file ELseverityLevel.cc.

Referenced by loadMap(), and edm::ErrorObj::setSeverity().

ELslGen edm::ELfatalGen

ELslProxy< ELhighestSeverityGen > const edm::ELhighestSeverity

Definition at line 413 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 335 of file ELseverityLevel.cc.

Referenced by loadMap(), and edm::ErrorObj::setSeverity().

ELslGen edm::ELincidentalGen

ELslProxy< ELinfoGen > const edm::ELinfo

Definition at line 347 of file ELseverityLevel.cc.

Referenced by loadMap().

ELslGen edm::ELinfoGen

ELslProxy< ELnextEventGen > const edm::ELnextEvent

Definition at line 377 of file ELseverityLevel.cc.

Referenced by loadMap().

ELslGen edm::ELnextEventGen

ELslProxy< ELsevereGen > const edm::ELsevere

Definition at line 389 of file ELseverityLevel.cc.

Referenced by loadMap(), and edm::service::ELoutput::log().

ELslProxy< ELsevere2Gen > const edm::ELsevere2

Definition at line 395 of file ELseverityLevel.cc.

Referenced by loadMap().

ELslGen edm::ELsevere2Gen

ELslGen edm::ELsevereGen

ELslProxy< ELsuccessGen > const edm::ELsuccess

Definition at line 341 of file ELseverityLevel.cc.

Referenced by loadMap(), and edm::service::ELoutput::log().

ELslGen edm::ELsuccessGen

ELslProxy< ELunspecifiedGen > const edm::ELunspecified

Definition at line 383 of file ELseverityLevel.cc.

Referenced by edm::ELextendedID::clear(), edm::service::ErrorLog::emit(), edm::service::ELtsErrorLog::item(), and loadMap().

ELslGen edm::ELunspecifiedGen

ELslProxy< ELwarningGen > const edm::ELwarning

Definition at line 353 of file ELseverityLevel.cc.

Referenced by loadMap(), and edm::MessageSender::~MessageSender().

ELslProxy< ELwarning2Gen > const edm::ELwarning2

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

std::string const edm::entryDescriptionBranch = "Description" [static]

Definition at line 57 of file BranchType.cc.

Referenced by edm::poolNames::entryDescriptionBranchName().

std::string const edm::entryDescriptionIDBranch = "Hash" [static]

Definition at line 56 of file BranchType.cc.

Referenced by edm::poolNames::entryDescriptionIDBranchName().

std::string const edm::entryDescriptionTree = "EntryDescription" [static]

Definition at line 55 of file BranchType.cc.

Referenced by edm::poolNames::entryDescriptionTreeName(), and edm::RootFile::readEntryDescriptionTree().

std::string const edm::event = "Event" [static]

Definition at line 15 of file BranchType.cc.

Referenced by BranchTypeToString(), edm::service::MsgContext::compress(), decode(), edm::RootFile::overrideRunNumber(), edm::RootFile::readEvent(), edm::InputSource::readEvent(), edm::RootInputFileSequence::readIt(), edm::RootInputFileSequence::readMany_(), and edm::XMLOutputModule::write().

std::string const edm::eventAux = event + aux [static]

Definition at line 53 of file BranchType.cc.

Referenced by BranchTypeToAuxBranchName(), edm::DaqSource::getNextItemType(), edm::RawInputSource::makeEvent(), and edm::ConfigurableInputSource::reallyReadEvent().

std::string const edm::eventAuxiliary = event + auxiliary [static]

Definition at line 32 of file BranchType.cc.

Referenced by BranchTypeToAuxiliaryBranchName().

std::string const edm::eventBranchMapper = "EventBranchMapper" [static]

Definition at line 70 of file BranchType.cc.

std::string const edm::eventEventEntryInfo = event + branchEntryInfo [static]

Definition at line 40 of file BranchType.cc.

Referenced by BranchTypeToBranchEntryInfoBranchName().

std::string const edm::eventHistory = "EventHistory" [static]

Definition at line 69 of file BranchType.cc.

Referenced by edm::poolNames::eventHistoryBranchName(), and edm::poolNames::eventHistoryTreeName().

std::string const edm::eventInfo = event + "StatusInformation" [static]

Definition at line 28 of file BranchType.cc.

Referenced by BranchTypeToInfoTreeName().

std::string const edm::eventMajorIndex = eventAuxiliary + majorIndex [static]

Definition at line 45 of file BranchType.cc.

Referenced by BranchTypeToMajorIndexName().

std::string const edm::eventMeta = event + metaData [static]

Definition at line 24 of file BranchType.cc.

Referenced by BranchTypeToMetaDataTreeName(), and edm::poolNames::eventMetaDataTreeName().

std::string const edm::eventMinorIndex = eventAuxiliary + ".id_.event_" [static]

Definition at line 49 of file BranchType.cc.

Referenced by BranchTypeToMinorIndexName().

std::string const edm::eventProductStatus = event + productStatus [static]

Definition at line 36 of file BranchType.cc.

Referenced by BranchTypeToProductStatusBranchName().

std::string const edm::events = event + 's' [static]

Definition at line 20 of file BranchType.cc.

Referenced by BranchTypeToProductTreeName(), and edm::poolNames::eventTreeName().

std::string const edm::fileFormatVersion = "FileFormatVersion" [static]

Definition at line 66 of file BranchType.cc.

Referenced by edm::poolNames::fileFormatVersionBranchName(), printEventLists(), and edm::RootOutputFile::writeFileFormatVersion().

std::string const edm::fileIdentifier = "FileIdentifier" [static]

Definition at line 67 of file BranchType.cc.

Referenced by edm::poolNames::fileIdentifierBranchName().

std::string const edm::fileIndex = "FileIndex" [static]

Definition at line 68 of file BranchType.cc.

Referenced by edm::poolNames::fileIndexBranchName(), DDLParser::parse(), and printEventLists().

const char* edm::fmt_Guid [static]

Initial value:

 
    "%08lX-%04hX-%04hX-%02hhX%02hhX-%02hhX%02hhX%02hhX%02hhX%02hhX%02hhX"

Definition at line 19 of file Guid.cc.

Referenced by edm::Guid::fromString(), and edm::Guid::toString().

MallocOptionSetter edm::global_malloc_options

Definition at line 204 of file MallocOpts.cc.

Referenced by getGlobalOptionSetter().

BufHolder edm::holder [static]

Definition at line 25 of file BufferArea.cc.

Referenced by edm::serviceregistry::connect_but_block_self(), edm::Schedule::fillEndPath(), edm::Schedule::fillTrigPath(), getEventBuffer(), FileReaderSP::isHeader(), and FileReaderSP::readSP().

int const edm::improbable = -65783927 [static]

Definition at line 27 of file InputSource.cc.

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

const int edm::init_size = 1024*1024 [static]

Definition at line 17 of file StreamDQMDeserializer.cc.

const MallocOpts edm::intel_opts(262144, 524288, 5242880, 131072) [static]

Referenced by edm::MallocOptionSetter::retrieveFromCpuType().

const unsigned int edm::kAveEventPerSec = 200U [static]

Definition at line 19 of file ConfigurableInputSource.cc.

const unsigned int edm::kNanoSecPerSec = 1000000000U [static]

Definition at line 18 of file ConfigurableInputSource.cc.

std::string const edm::lumi = "LuminosityBlock" [static]

Definition at line 14 of file BranchType.cc.

Referenced by BranchTypeToString(), decode(), LumiblockFilter::filter(), edm::PrincipalCache::insert(), L3NominalEfficiencyConfigurator::L3NominalEfficiencyConfigurator(), edm::OccurrenceTraits< LuminosityBlockPrincipal, BranchActionBegin >::postScheduleSignal(), edm::OccurrenceTraits< LuminosityBlockPrincipal, BranchActionEnd >::postScheduleSignal(), and edm::RootFile::readLumi().

std::string const edm::lumiAux = lumi + aux [static]

Definition at line 52 of file BranchType.cc.

Referenced by BranchTypeToAuxBranchName(), edm::StreamerInputSource::deserializeEvent(), edm::RootFile::fillLumiAuxiliary(), edm::DaqSource::getNextItemType(), TFWLiteSelectorBasic::Process(), edm::RootFile::readLumi(), edm::RawInputSource::readLuminosityBlock_(), and edm::ConfigurableInputSource::readLuminosityBlock_().

std::string const edm::lumiAuxiliary = lumi + auxiliary [static]

Definition at line 31 of file BranchType.cc.

Referenced by BranchTypeToAuxiliaryBranchName().

std::string const edm::lumiEventEntryInfo = lumi + branchEntryInfo [static]

Definition at line 39 of file BranchType.cc.

Referenced by BranchTypeToBranchEntryInfoBranchName().

std::string const edm::lumiInfo = lumi + "StatusInformation" [static]

Definition at line 27 of file BranchType.cc.

Referenced by BranchTypeToInfoTreeName().

std::string const edm::lumiMajorIndex = lumiAuxiliary + majorIndex [static]

Definition at line 44 of file BranchType.cc.

Referenced by BranchTypeToMajorIndexName().

std::string const edm::lumiMeta = lumi + metaData [static]

Definition at line 23 of file BranchType.cc.

Referenced by BranchTypeToMetaDataTreeName().

std::string const edm::lumiMinorIndex = lumiAuxiliary + ".id_.luminosityBlock_" [static]

Definition at line 48 of file BranchType.cc.

Referenced by BranchTypeToMinorIndexName().

std::string const edm::lumiProductStatus = lumi + productStatus [static]

Definition at line 35 of file BranchType.cc.

Referenced by BranchTypeToProductStatusBranchName().

std::string const edm::lumis = lumi + 's' [static]

Definition at line 19 of file BranchType.cc.

Referenced by BranchTypeToProductTreeName().

std::string const edm::majorIndex = ".id_.run_" [static]

Definition at line 42 of file BranchType.cc.

std::string const edm::metaData = "MetaData" [static]

Definition at line 6 of file BranchType.cc.

std::string const edm::metaDataTree = "MetaData" [static]

Definition at line 59 of file BranchType.cc.

Referenced by fwlite::BranchMapReader::Strategy::getBranchRegistry(), fwlite::BranchMapReader::getFileVersion(), edm::poolNames::metaDataTreeName(), printEventLists(), edm::RootFile::RootFile(), TFWLiteSelectorBasic::setupNewFile(), and fwlite::internal::BranchMapReaderStrategyV8::updateFile().

const unsigned char edm::MLSCRIBE_RUNNING_INDICATOR = 29 [static]

Definition at line 80 of file MessageDrop.h.

Referenced by FlushMessageLog(), isMessageProcessingSetUp(), and edm::service::MessageLoggerScribe::run().

std::string const edm::moduleDescriptionMap = "ModuleDescriptionMap" [static]

Definition at line 63 of file BranchType.cc.

Referenced by edm::poolNames::moduleDescriptionMapBranchName().

char const* edm::msgNames[] [static]

Initial value:

 {
      "SetRun",
      "Skip",
      "RunAsync",
      "Run(ID)",
      "Run(count)",
      "BeginJob",
      "StopAsync",
      "ShutdownAsync",
      "EndJob",
      "CountComplete",
      "InputExhausted",
      "StopSignal",
      "ShutdownSignal",
      "Finished",
      "Any",
      "dtor",
      "Exception",
      "Rewind"
    }

Definition at line 93 of file EventProcessor.cc.

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

std::string const edm::oneParam[oneParamArraySize] [static]

Initial value:

 {
      "vector",
      "basic_string",
      "set",
      "list",
      "deque",
      "multiset"
    }

Definition at line 147 of file ReflexTools.cc.

int const edm::oneParamArraySize = 6 [static]

Definition at line 146 of file ReflexTools.cc.

std::string const edm::parameterSetMap = "ParameterSetMap" [static]

Definition at line 62 of file BranchType.cc.

Referenced by edm::poolNames::parameterSetMapBranchName().

std::string const edm::processConfigurationMap = "ProcessConfigurationMap" [static]

Definition at line 65 of file BranchType.cc.

Referenced by edm::poolNames::processConfigurationMapBranchName().

std::string const edm::processHistoryMap = "ProcessHistoryMap" [static]

Definition at line 64 of file BranchType.cc.

Referenced by edm::poolNames::processHistoryMapBranchName().

std::string const edm::productDependencies = "ProductDependencies" [static]

Definition at line 61 of file BranchType.cc.

Referenced by edm::poolNames::productDependenciesBranchName().

std::string const edm::productRegistry = "ProductRegistry" [static]

Definition at line 60 of file BranchType.cc.

Referenced by edm::DaqSource::getNextItemType(), edm::poolNames::productDescriptionBranchName(), and edm::DaqSource::readRun_().

std::string const edm::productStatus = "ProductStatus" [static]

Definition at line 9 of file BranchType.cc.

std::string const edm::run = "Run" [static]

Definition at line 13 of file BranchType.cc.

Referenced by BranchTypeToString(), edm::service::MsgContext::compress(), decode(), edm::RootFile::getNextEntryTypeWanted(), edm::PrincipalCache::insert(), edm::RootFile::overrideRunNumber(), edm::OccurrenceTraits< RunPrincipal, BranchActionEnd >::postScheduleSignal(), edm::OccurrenceTraits< RunPrincipal, BranchActionBegin >::postScheduleSignal(), edm::RootFile::readEvent(), edm::RootInputFileSequence::readIt(), edm::RootInputFileSequence::readMany_(), edm::RootFile::readRun(), and edm::StreamerOutputModuleBase::serializeRegistry().

std::string const edm::runAux = run + aux [static]

Definition at line 51 of file BranchType.cc.

Referenced by BranchTypeToAuxBranchName(), edm::StreamerInputSource::deserializeEvent(), TFWLiteSelectorBasic::Process(), edm::RawInputSource::readRun_(), edm::ConfigurableInputSource::readRun_(), and edm::DaqSource::readRun_().

std::string const edm::runAuxiliary = run + auxiliary [static]

Definition at line 30 of file BranchType.cc.

Referenced by BranchTypeToAuxiliaryBranchName().

std::string const edm::runEventEntryInfo = run + branchEntryInfo [static]

Definition at line 38 of file BranchType.cc.

Referenced by BranchTypeToBranchEntryInfoBranchName().

std::string const edm::runInfo = run + "StatusInformation" [static]

Definition at line 26 of file BranchType.cc.

Referenced by edm::AlpgenProducer::beginRun(), AlpgenExtractor::beginRun(), edm::AlpgenSource::beginRun(), BranchTypeToInfoTreeName(), and ThePEG::LesHouchesInterface::open().

std::string const edm::runMajorIndex = runAuxiliary + majorIndex [static]

Definition at line 43 of file BranchType.cc.

Referenced by BranchTypeToMajorIndexName().

std::string const edm::runMeta = run + metaData [static]

Definition at line 22 of file BranchType.cc.

Referenced by BranchTypeToMetaDataTreeName().

std::string const edm::runMinorIndex [static]

Definition at line 47 of file BranchType.cc.

Referenced by BranchTypeToMinorIndexName().

std::string const edm::runProductStatus = run + productStatus [static]

Definition at line 34 of file BranchType.cc.

Referenced by BranchTypeToProductStatusBranchName().

std::string const edm::runs = run + 's' [static]

Definition at line 18 of file BranchType.cc.

Referenced by BranchTypeToProductTreeName().

volatile bool edm::shutdown_flag = false

Definition at line 14 of file UnixSignalHandlers.cc.

Referenced by ep_sigusr2(), edm::DQMHttpSource::getOneDQMEvent(), edm::OnlineHttpReader::getOneEvent(), edm::EventStreamHttpReader::getOneEvent(), edm::OnlineHttpReader::read(), edm::EventStreamHttpReader::read(), edm::EventStreamHttpReader::readHeader(), edm::OnlineHttpReader::readHeader(), edm::DQMHttpSource::readOneEvent(), edm::EventStreamHttpReader::registerWithEventServer(), edm::OnlineHttpReader::registerWithEventServer(), and edm::EventProcessor::runCommon().

boost::mutex edm::signum_lock

Definition at line 26 of file UnixSignalHandlers.cc.

Referenced by getSigNum().

volatile int edm::signum_value

Initial value:

Definition at line 27 of file UnixSignalHandlers.cc.

Referenced by getSigNum().

char const* edm::stateNames[] [static]

Initial value:

 {
      "Init",
      "JobReady",
      "RunGiven",
      "Running",
      "Stopping",
      "ShuttingDown",
      "Done",
      "JobEnded",
      "Error",
      "ErrorEnded",
      "End",
      "Invalid"
    }

Definition at line 78 of file EventProcessor.cc.

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

const edm::pset::TypeTrans edm::sTypeTranslations [static]

Definition at line 71 of file Entry.cc.

Referenced by edm::Entry::Entry(), operator<<(), and edm::Entry::throwValueError().

std::string const edm::twoParam[twoParamArraySize] [static]

Initial value:

 {
      "map",
      "pair",
      "multimap"
    }

Definition at line 156 of file ReflexTools.cc.

int const edm::twoParamArraySize = 3 [static]

Definition at line 155 of file ReflexTools.cc.

boost::mutex edm::usr2_lock

Definition at line 10 of file UnixSignalHandlers.cc.

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

Generated on Tue Jun 9 18:37:43 2009 for CMSSW by

1.5.4