| The Gaudi Framework v27r1

- Main Page
- Related Pages
- Modules
- Namespaces
- Classes
- Files

- Class List
- Class Index
- Class Hierarchy
- Class Members

Class Hierarchy

Go to the graphical class hierarchy

This inheritance list is sorted roughly, but not completely, alphabetically:
[detail level 1 2 3 4 5 6 7 8 9 10]

C__Instantiations |
C__longlong |
C NTuple::_Accessor< TYP > | Class acting as a smart pointer holding a N tuple entry
►C NTuple::_Accessor< _Array< TYP > > |
C NTuple::Array< TYP > | Class acting as a smart pointer holding a N tuple _Item
►C NTuple::_Accessor< _Item< bool > > |
C NTuple::Item< bool > | Specialization acting as a smart pointer holding a N tuple _Item
►C NTuple::_Accessor< _Item< IOpaqueAddress * > > |
C NTuple::Item< IOpaqueAddress * > |
►C NTuple::_Accessor< _Item< TYP > > |
C NTuple::Item< TYP > | Class acting as a smart pointer holding a N tuple _Item
►C NTuple::_Accessor< _Item< VALUE > > |
C NTuple::Item< VALUE > |
►C NTuple::_Accessor< _Matrix< TYP > > |
C NTuple::Matrix< TYP > | Class acting as a smart pointer holding a N tuple _Item
►C_CallbackStreamBufBase |
C GaudiPython.Bindings.CallbackStreamBuf |
C Genfun::GaudiMathImplementation::NumericalDefiniteIntegral::_Function |
C Genfun::GaudiMathImplementation::NumericalIndefiniteIntegral::_Function |
►C_GaudiAlgorithm |
C GaudiPython.GaudiAlgs.GaudiAlgo | Base class for all algorithm Python-image of C++ clkass GaudiAlgorithm
►C_GaudiHistoAlg |
C GaudiPython.GaudiAlgs.HistoAlgo | The base class for easy histogramming
►C_GaudiTupleAlg |
C GaudiPython.GaudiAlgs.TupleAlgo | The base class for easy manupulations with N-Tuples
C Gaudi::Utils::_GetType< TYPE > | Helper structure to define the proper return type for "get"-functions
C Gaudi::Utils::_GetType< Gaudi::NamedRange_< CONTAINER > > | Template specialization for "named ranges"
C Gaudi::Utils::_GetType< Gaudi::Range_< CONTAINER > > | Template specialization for "ranges"
C Gaudi::Utils::_GetType< TYPE & > | Template specialization for references
C Gaudi::Utils::_GetType< TYPE * > | Template specialization for pointers
C KeyedContainer< DATATYPE, MAPPING >::_InsertRelease | Internal functor for insertion of objects
►C_PyAlgorithm |
C GaudiPython.Bindings.PyAlgorithm |
C KeyedContainer< DATATYPE, MAPPING >::_RemoveRelease | Internal functor for insertion of objects
C GaudiKernel.ProcessJobOptions._TempSysPath |
C Genfun::GaudiMathImplementation::NumericalIndefiniteIntegral::_Workspace |
C Genfun::GaudiMathImplementation::NumericalDefiniteIntegral::_Workspace |
►C AbsFunction |
C Genfun::GaudiMathImplementation::Adapter2DoubleFunction | Constructor from the trivial function with two argument
C Genfun::GaudiMathImplementation::Adapter3DoubleFunction | Constructor from the trivial function with two argument
C Genfun::GaudiMathImplementation::AdapterIFunction | Constructor from the IFunction ( see AIDA/IFunction.h)
C Genfun::GaudiMathImplementation::Constant | Fixed constant function
C Genfun::GaudiMathImplementation::GSLFunctionWithError |
C Genfun::GaudiMathImplementation::GSLFunctionWithMode |
C Genfun::GaudiMathImplementation::GSLFunctionWithModeAndError |
C Genfun::GaudiMathImplementation::GSLSpline |
C Genfun::GaudiMathImplementation::GSLSplineDeriv |
C Genfun::GaudiMathImplementation::GSLSplineDeriv2 |
C Genfun::GaudiMathImplementation::GSLSplineInteg |
C Genfun::GaudiMathImplementation::NumericalDefiniteIntegral | This class allows the numerical evaluation of the following functions:
C Genfun::GaudiMathImplementation::NumericalDerivative | Numerical derivative (using GSL adaptive numerical differentiation)
C Genfun::GaudiMathImplementation::NumericalIndefiniteIntegral | The simple class for numerical integrations
C Genfun::GaudiMathImplementation::SimpleFunction |
►C add_serviceLocator |
C CommonMessaging< BASE > |
►C CommonMessaging< IExecutionFlowGraph > |
C concurrency::ExecutionFlowGraph |
►C CommonMessaging< IExecutionFlowManager > |
C concurrency::ExecutionFlowManager | Manage the execution flow using an execution flow graph Once initialized, the graph is const and can be shared across events
►C CommonMessaging< implements< IAlgorithm, IDataHandleHolder, IProperty, IStateful > > |
►C Algorithm | Base class from which all concrete algorithm classes should be derived
C CollectionCloneAlg | Small algorithm, which allows to merge N-tuples in a generic way
C EventCounter |
C EvtCollectionStream | A small to stream Data I/O
►C extends< Algorithm, IPartitionControl > |
C PartitionSwitchAlg | Small algorithm which switches the partition of a configurable multi-service
►C GaudiCommon< Algorithm > |
►C GaudiAlgorithm | The useful base class for data processing algorithms
C CallgrindProfile | Algorithm to enable/disable the profiling by Callgrind at given events
C ContextEventCounterData |
C ContextEventCounterPtr |
C CPUCruncher | A class that implements a search for prime numbers
C EventNodeKiller | Algorithm to kill nodes in the event data store
►C GaudiHistos< GaudiAlgorithm > |
►C GaudiHistoAlg | Simple class to extend the functionality of class GaudiAlgorithm
►C GaudiTuples< GaudiHistoAlg > |
C GaudiTupleAlg | Simple class to extend the functionality of class GaudiHistoAlg
C GaudiParallelizer |
►C GaudiSequencer | Sequencer for executing several algorithms, stopping when one is faulty
C GaudiAtomicSequencer | Sequencer for executing several algorithms, stopping when one is faulty
C HiveReadAlgorithm |
C HiveTestAlgorithm |
C JemallocProfile | Algorithm to enable/disable the profiling of the head by Jemalloc
C Prescaler |
C RecordOutputStream | Simple class that adds an entry to the Transient Event Store to record that the processing flow triggered its execution
C ReplayOutputStream |
►C GaudiPython::PyAlgorithm | Python Algorithm base class
C GaudiMP.GMPBase.CollectHistograms |
C read_lhcb_event_file.DumpAlg |
C HelloWorld | Trivial Algorithm for tutotial purposes
►C OutputStream | A small to stream Data I/O
C InputCopyStream | Extension of OutputStream to copy the content of the main input file
C RecordStream | Extension of OutputStream to write run records after last event
C RunRecordStream | Extension of OutputStream to write run records after last event
C SequentialOutputStream | Extension of OutputStream to write run records after last event
C TagCollectionStream | Specialized output stream class for event tag collections, where the basic Event entry point should be placed as well into the collection itself
C PropertyAlg | Trivial Algorithm for tutotial purposes
C RandomNumberAlg | A small algorithm class using the random number service
C Sequencer | ClassName: Sequencer
C StoreExplorerAlg | Small algorith, which traverses the data store and prints generic information about all leaves, which can be loaded/accessed
C StoreSnifferAlg | Small algorithm, which traverses the data store and prints a summary of the leafs accessed during the run
C WriteAlg | WriteAlg class for the RootIOExample
►C CommonMessaging< implements< IAlgTool, IDataHandleHolder, IProperty, IStateful > > |
►C AlgTool | Base class from which all the concrete tool classes should be derived
►C extends< AlgTool, IDataStoreLeaves, IIncidentListener > |
C DataSvcFileEntriesTool | Tool to scan a transient store branch that collects all the objects that belong to the same source (file)
►C extends< AlgTool, IDataStreamTool > |
C DataStreamTool |
►C extends< AlgTool, IDODAlgMapper, IDODNodeMapper > |
C DODBasicMapper | Default implementation of a DataOnDemand mapper
►C extends< AlgTool, IFileAccess > |
C FileReadTool | Basic implementation of the IFileAccess interface
►C extends< AlgTool, IGslErrorHandler > |
C GslErrorCount | Concrete GSL error handler It is just counts number of GSL errors
C GslErrorException | Concrete GSL eror handler It is just thrown the exception
C GslErrorPrint | Concrete GSL eror handler It is just prints the GSL errors
►C extends< AlgTool, IPartitionControl > |
C PartitionSwitchTool |
►C GaudiCommon< AlgTool > |
►C GaudiTool | The useful base class for tools
C ErrorTool |
►C extends< GaudiTool, IEqSolver > |
C EqSolver | The simplest concrete implementation of IEqSolver interface
►C extends< GaudiTool, IFuncMinimum > |
C FuncMinimum | The simplest concrete implementation of IFuncMinimum interface
►C GaudiHistos< GaudiTool > |
►C GaudiHistoTool | Simple class to extend the functionality of class GaudiTool
►C GaudiTuples< GaudiHistoTool > |
►C GaudiTupleTool | Simple class to extend the functionality of class GaudiHistoTool
C TupleTool |
C HistoTool | Simple tool for histogramming (component)
C SequencerTimerTool | Implements the time measurement inside a sequencer
►C CommonMessaging< implements< IAppMgrUI, IEventProcessor, IService, IStateful > > |
C ApplicationMgr | The Application Manager class
►C CommonMessaging< implements< IAuditor, IProperty > > |
►C Auditor | Base class from which all concrete auditor classes should be derived
C AlgContextAuditor | Description: Register/Unregister the AlgContext of each algorithm before entering the algorithm and after leaving it
C AlgErrorAuditor | Monitors the cpu time usage of each algorithm
►C CommonAuditor | Base class with common functionalities shared by few auditor implementations
C ChronoAuditor | Monitors the cpu time usage of each algorithm
►C MemoryAuditor | Monitors the memory use of each algorithm
C MemStatAuditor | Just a minor modification of MemoryAuditor to allow the output memory statistics table to be printed
C NameAuditor | Prints the name of each algorithm before entering the algorithm and after leaving it
►C extends< Auditor, IIncidentListener > |
►C Google::AuditorBase | Base for Google Auditors
C Google::CPUProfiler | Auditor using the Google CPU Profiler
C Google::HeapChecker | Auditor using the Google Heap Checker
C Google::HeapProfiler | Auditor based on the Google Heap Profiler
C TimingAuditor | Simple auditor which uses SequencerTimerTool for ALL algorithms, including the algorithm from main Gaudi "TopAlg" list and algorithms managed by Data-On-Demand Service
C IntelProfilerAuditor |
C PerfMonAuditor | Performance Monitoring Auditor that uses Perfmon2 library to monitor algorithms
►C CommonMessaging< implements< IComponentManager > > |
►C ComponentManager | Base class for a component manager
►C extends< ComponentManager, IAlgManager > |
C AlgorithmManager | In charge of the creation of concrete instances of Algorithms
►C extends< ComponentManager, ISvcManager, ISvcLocator > |
C ServiceManager | In charge of the creation of concrete instances of Services
►C CommonMessaging< implements< IService, IProperty, IStateful > > |
►C Service | Base class for all services
►C extends< Service, Gaudi::ISignalMonitor > |
C Gaudi::Utils::SignalMonitorSvc | Implementation of Gaudi::ISignalMonitor
►C extends< Service, IAlgContextSvc, IIncidentListener > |
C AlgContextSvc |
►C extends< Service, IAlgResourcePool > |
C AlgResourcePool | The AlgResourcePool is a concrete implementation of the IAlgResourcePool interface
►C extends< Service, IAuditorSvc > |
C AuditorSvc |
►C extends< Service, IChronoStatSvc, IIncidentListener > |
C ChronoStatSvc | The Chrono & Stat Sservice: service implements the IChronoStatSvc interface and provides the basic chronometry and some statistical counts needed by all applications
►C extends< Service, IConversionSvc, IAddressCreator > |
►C ConversionSvc | Base class for all conversion services
C Gaudi::RootCnvSvc | Description:
C RootHistCnv::PersSvc | Persistency service - to store histograms in ROOT format
►C extends< Service, IConversionSvc, IPersistencySvc, IAddressCreator > |
►C PersistencySvc | PersistencySvc class implementation definition
C DetPersistencySvc |
C EvtPersistencySvc | EvtPersistencySvc class implementation definition
C HistogramPersistencySvc | HistogramPersistencySvc class implementation definition
►C extends< Service, ICounterSvc > |
C CounterSvc | Simple implementation of the abstract interface ICounterSvc
►C extends< Service, IDataProviderSvc, IDataManagerSvc > |
►C DataSvc | Data service base class
C EvtDataSvc | A EvtDataSvc is the base class for event services
►C extends< DataSvc, IHistogramSvc > |
C HistogramSvc | HistogramSvc class definition
►C extends< DataSvc, IIncidentListener > |
►C RecordDataSvc | A RecordDataSvc is the base class for event services
C FileRecordDataSvc | A FileRecordDataSvc is the base class for event services
C RunRecordDataSvc | A RunRecordDataSvc is the base class for event services
►C extends< DataSvc, INTupleSvc, IDataSourceMgr > |
►C NTupleSvc | NTuple service
C TagCollectionSvc | Gaudi tag collection service definition
►C TsDataSvc | Data service base class
►C extends< TsDataSvc, IDetDataSvc, IIncidentListener > |
C DetDataSvc |
►C extends< Service, IDataProviderSvc, IDataManagerSvc, IHiveWhiteBoard > |
C HiveWhiteBoard | Data service base class
►C extends< Service, IDataProviderSvc, IDataManagerSvc, IPartitionControl > |
C MultiStoreSvc | Data service base class
►C extends< Service, IEventProcessor > |
C HiveSlimEventLoopMgr |
►C MinimalEventLoopMgr | This is the default processing manager of the application manager
C EventLoopMgr | Class definition of EventLoopMgr
C HiveEventLoopMgr |
►C extends< Service, IEvtSelector > |
C EventCollectionSelector | Definition of class EventCollectionSelector
C EventSelector | Definition of class EventSelector
C Gaudi::RootEvtSelector | Concrete event selector implementation to access ROOT files
►C extends< Service, IExceptionSvc > |
C ExceptionSvc | Simple implementation of IExceptionSvc abstract interface
►C extends< Service, IFileAccess > |
C VFSSvc | Simple service that allows to read files independently from the storage
►C extends< Service, IFileCatalog, IFileCatalogMgr > |
C Gaudi::MultiFileCatalog | This class constitutes the core of the XML based FileCatalog API for using POOL within Gaudi
►C extends< Service, IFileMgr, IIncidentListener > |
C FileMgr |
►C extends< Service, IGslSvc > |
C GslSvc | The implementation of IGslSvc interface
►C extends< Service, IHistorySvc, IIncidentListener > |
C HistorySvc | HistorySvc class definition
►C extends< Service, IIncidentListener > |
C DataOnDemandSvc | The DataOnDemandSvc listens to incidents typically triggered by the data service of the configurable name "IncidentName"
C Gaudi::Utils::StopSignalHandler | Service that stop the processing if a signal is received
C JemallocProfileSvc | Service that enables the Jemalloc profiler on demand
C StalledEventMonitor | Service that monitor the time taken by processing of single events using a separate thread
►C extends< Service, IIncidentSvc > |
C IncidentSvc | Default implementation of the IIncidentSvc interface
►C extends< Service, IIoComponentMgr, IIncidentListener > |
C IoComponentMgr |
►C extends< Service, IIODataManager > |
C Gaudi::IODataManager |
►C extends< Service, IIssueLogger > |
C IssueLogger |
►C extends< Service, IMessageSvc, IInactiveMessageCounter > |
►C MessageSvc |
C InertMessageSvc | Thread safe extension to the standard MessageSvc
C TBBMessageSvc |
►C extends< Service, IMetaDataSvc > |
C Gaudi::MetaDataSvc |
►C extends< Service, IParticlePropertySvc > |
C Gaudi::ParticlePropertySvc | This service provides access to particle properties
►C extends< Service, IPartPropSvc > |
C PartPropSvc |
►C extends< Service, IProperty, IJobOptionsSvc > |
C JobOptionsSvc |
►C extends< Service, IRndmEngine, ISerialize, IIncidentListener > |
►C RndmEngine | Random Generator engine definition
►C HepRndm::BaseEngine |
C HepRndm::Engine< TYPE > |
►C extends< Service, IRndmGenSvc, IRndmEngine, ISerialize > |
C RndmGenSvc | Random Generator service definition
►C extends< Service, IRunable > |
C AppMgrRunable | Class definition of AppMgrRunable
C PythonScriptingSvc | This service handles scripting implemented using Python
►C extends< Service, IScheduler > |
C ForwardSchedulerSvc | The SchedulerSvc implements the IScheduler interface
C ParallelSequentialSchedulerSvc | This SchedulerSvc implements the IScheduler interface
C RoundRobinSchedulerSvc | The RoundRobinSchedulerSvc implements the IScheduler interface
C SequentialSchedulerSvc | This SchedulerSvc implements the IScheduler interface
►C extends< Service, IStatusCodeSvc > |
C StatusCodeSvc |
►C extends< Service, ITHistSvc, IIncidentListener, IIoComponent > |
C THistSvc |
►C extends< Service, IThreadPoolSvc > |
C ThreadPoolSvc |
►C extends< Service, ITimelineSvc > |
C TimelineSvc |
►C extends< Service, IToolSvc > |
C ToolSvc | This service manages tools
C Gaudi::RootPerfMonSvc | Description:
C Gaudi::Utils::Aida2ROOT | Accessor to underlying ROOT-representation of transient histograms The actual code is imported from Bender project
C AlgContexSvc | Simple implementation of interface IAlgContextSvc for Algorithm Context Service
C Gaudi::Utils::AlgContext | Helper "sentry" class to automatize the safe register/unregister the algorithm's context
C GaudiPython::AlgDecorator |
C AlgFactory< T > |
C boost::AlgoNodeStruct |
►C ALGORITHM |
C GaudiPython::PyAlg< ALGORITHM > | General class to embed the existing algorithm/base class into the python
C GaudiSequencer::AlgorithmEntry |
C GaudiParallelizer::AlgorithmEntry |
C AlgorithmManager::AlgorithmItem |
►C Gaudi::Utils::AlgSelector | Simple interface class for selection of algorithms
C Gaudi::Utils::AlgNameSelector | The trivial selector of algorithm by type
C Gaudi::Utils::AlgTypeSelector< TYPE > | The trivial selector of algorithm by type
C AlgsExecutionStates | The AlgsExecutionStates encodes the state machine for the execution of algorithms within a single event
C GaudiUtils::Allocator< Type > | Allocator
C GaudiUtils::AllocatorPool | Allocator pool
C AIDA::Annotation::AnnotationItem | Internal private annotation item class
C Gaudi::meta::detail::append1< List, I > |
►C Gaudi::meta::detail::appendN< typename, typename > |
C Gaudi::interface_list_cat< interface_list< I...> > |
C Gaudi::interface_list_cat< interface_list< I1...>, interface_list< I2...> > |
C Gaudi::meta::detail::appendN< interface_list< I, Is...>, List > |
C Gaudi::meta::detail::appendN< interface_list< Is... >, append1< List, I >::type > |
C Containers::array |
C NTuple::Array< IOpaqueAddress * > |
C Gaudi::Utils::AttribStringParser::Attrib | Simple class to wrap tag/value pairs
C Gaudi::Utils::AttribStringParser | Parse attribute strings allowing iteration over the various attributes
C boost::spirit::repository::qi::iter_pos_parser::attribute< Context, Iterator > |
C AudFactory< T > |
C Gaudi::Guards::AuditorGuard | It is a simple guard, which "locks" the scope for the Auditor Service is am exception-safe way
►C BaseObjectMemberFunction | Base class of ObjectMemberFunction
C ObjectMemberFunction< CallerClass > | This class is used by IUpdateManagerSvc to keep pairs made of a member function and a pointer to the object for which that member function has to be called
►C BasePtrSetter | Base class to set the pointer to an object of a class derived from DataObject in a generic way
C IUpdateManagerSvc::PtrSetter< ActualType > | Templated specialization of BasePtrSetter
C GaudiTesting.BaseTest.BasicOutputValidator |
C GaudiTest.BasicOutputValidator | Output Validation Classes
►C std::binary_function< double, double, bool > [external] |
C Gaudi::Math::Lomont< double > | Specialization for double numbers
►C std::binary_function< float, float, bool > [external] |
C Gaudi::Math::Lomont< float > | Specialization for float numbers
►C std::binary_function< Property, Property, bool > [external] |
C Gaudi::Parsers::Property::LessThen |
C C_dict |
C FileInfo::CacheItem |
C FileInfo::CacheItemComparator |
C ROOT::Math::Cartesian3D< T > |
C Gaudi::Parsers::Catalog |
C cgaudi_factory_t |
C cgaudi_pluginsvc_t |
C cgaudi_property_t |
►C Gaudi::Utils::CheckData< TYPE > | Helper structure for implementation of "exists"-functions for GaudiCommon<BASE>
C Gaudi::Utils::CheckData< const TYPE > | Template specialization for 'const'-type
C Gaudi::Utils::CheckData< TYPE & > | Template specialization for reference types
C Gaudi::Utils::CheckData< TYPE * > | Template specialization for pointer types
►C Gaudi::Utils::CheckData< Gaudi::Range_< std::vector< const TYPE * > > > | Template specialization for ranges
C Gaudi::Utils::CheckData< Gaudi::NamedRange_< std::vector< const TYPE * > > > | Template specialization for ranges
C Chrono | A small utility class for chronometry of user codes
C ChronoEntity | Small helper class for implementation of ChronoStatSvc service, It also could be used as some local timer
►C CLASS |
C RootHistCnv::RHistogramCnv< T, S, Q >::TTH< CLASS > |
C ProcStats::cleanup |
C CLibSymbolInfo |
C GaudiTest.CMT |
C CnvFactory< T > |
►C CommonMessagingBase |
C CommonMessaging< BASE > |
C CommonMessaging< IExecutionFlowGraph > |
C CommonMessaging< IExecutionFlowManager > |
C CommonMessaging< implements< IAlgorithm, IDataHandleHolder, IProperty, IStateful > > |
C CommonMessaging< implements< IAlgTool, IDataHandleHolder, IProperty, IStateful > > |
C CommonMessaging< implements< IAppMgrUI, IEventProcessor, IService, IStateful > > |
C CommonMessaging< implements< IAuditor, IProperty > > |
C CommonMessaging< implements< IComponentManager > > |
C CommonMessaging< implements< IService, IProperty, IStateful > > |
C CompareFirstOfPointerPair_t |
C configGenerator |
C NTupleSvc::Connection |
C Const_int_t< n > |
C Const_uint_t< n > |
C StreamBuffer::ContainedLink | Definition of the contained link set
►C ContainedObject | All classes that their objects may be contained in an LHCb ObjectContainer (e.g
C KeyedObject< KEY > | Definition of the templated KeyedObject class
►C KeyedObject< int > |
C MyTrack |
C MyVertex | Simple class that represents a vertex for testing purposes
C Gaudi::RootDataConnection::ContainerSection | Internal helper class, which described a TBranch section in a ROOT file
►C IEvtSelector::Context |
C EventCollectionContext |
C EventCollectionSelector::MyContextType |
C EvtSelectorContext | Definition of class EventIterator
C Gaudi::RootEvtSelectorContext | ROOT specific event selector context
C ContextEventCounter |
C Gaudi::Hive::ContextSpecificData< T > | Implementation of a context specific storage accessible as a sort of smart reference class
C Gaudi::Hive::ContextSpecificData< int > |
C Gaudi::Hive::ContextSpecificPtr< T > | Simple implementation of a smart pointer with different values for different event contexts (slots)
C Gaudi::Hive::ContextSpecificPtr< int > |
►C concurrency::ControlFlowNode |
C concurrency::AlgorithmNode |
C concurrency::DecisionNode |
C ConverterID |
C GaudiToolLocal::Counter | Simple local counter
C Tuples::Local::Counter |
C IgHookTrace::Counter | Nearly dummy object type to identify a counter
C IgHookTrace::CounterValue | Value for a counter chained from a trace
C CTest |
C DataFlowManager | The DataFlowManager takes care of keeping track of the dependencies of the algorithms in terms of dataObjects
►C Gaudi::DataHandle |
►C DataObjectHandleBase | DataObjectHandleBase GaudiKernel/DataObjectHandleBase.h
C DataObjectHandle< T > | DataObjectHandle.h GaudiKernel/DataObjectHandle.h
C DataObjectHandle< DataObject > |
C DataHistory::DataHistoryOrder |
C DataIncident | Data service incident class
►C StreamBuffer::DataIO | A small base class to handle generic data streaming
C StreamBuffer::Istream | Reader for standard input streams
C StreamBuffer::Ostream | Writer for standard output streams
C NTuple::DataItem< TYP > |
C concurrency::DataNode |
►C DataObject | A DataObject is the base class of any identifiable object on any data store
C Event | Essential information of the event used in examples It can be identified by "/Event"
C Gaudi::Histogram1D | AIDA implementation for 1 D histograms using ROOT THD1
C Gaudi::Histogram2D | AIDA implementation for 2 D histograms using ROOT THD2
C Gaudi::Histogram3D | AIDA implementation for 2 D histograms using ROOT THD2
C Gaudi::Profile1D | AIDA implementation for 1 D profiles using ROOT TProfile
C Gaudi::Profile2D | AIDA implementation for 2 D profiles using ROOT TProfile2D
►C HistoryObj | Base class for History Objects
C AlgorithmHistory | AlgorithmHistory class definition
C AlgToolHistory | AlgToolHistory class definition
C DataHistory | DataHistory class definition
C JobHistory | JobHistory class definition
C ServiceHistory | ServiceHistory class definition
C MyObject |
►C NTuple::Directory | Small class representing an N tuple directory in the transient store
C NTuple::File | Small class representing an N tuple file in the transient store
►C NTuple::Tuple | Abstract base class which allows the user to interact with the actual N tuple implementation
►C NTuple::TupleImp |
C NTuple::ColumnWiseTuple |
C NTuple::RowWiseTuple |
►C ObjectContainerBase | ObjectContainerBase is the base class for Gaudi container classes
C KeyedContainer< DATATYPE, MAPPING > | Template class KeyedContainer, KeyedContainer.h
C KeyedContainer< MyTrack > |
C KeyedContainer< MyVertex > |
C ObjectList< TYPE > | ObjectList is one of the basic Gaudi container classes capable of being registered in Data Stores
C ObjectVector< TYPE > | ObjectVector is one of the basic Gaudi container classes capable of being registered in Data Stores
C SharedObjectsContainer< TYPE > | Very simple class to represent the container of objects which are not ownered by the container
C RefTableBase< FROM, MAPENTRY > | Template <class FROM, class TO, class MAPENTRY> class RefTable
►C RefTableBase< FROM, SmartRef< TO > > |
C RefTable1to1< FROM, TO > |
►C RefTableBase< FROM, SmartRefVector< TO > > |
C RefTable1toN< FROM, TO > |
C DataObjID |
C DataObjID_Hasher |
C DataStoreItem | Description of the DataStoreItem class
C DataTypeInfo | Small class which allows access to internal type IDs
C Decorator | Simple class with allows to "decorate" the python algorithm with 'basic' funtionality from class GaudiAlgorithm
C Containers::array::decrement |
C GaudiKernel.Configurable.Configurable.DefaultName | For detecting the default name
C DHH |
►C dict |
C GaudiKernel.ConfigurableDb._CfgDb |
C GaudiMP.FdsRegistry.FdsDict |
C GaudiProfiling.GenerateGaudiOpts.XmlDictObject |
C DirSearchPath | Search for files in a list of directories
C ROOT::Math::DisplacementVector3D< CoordSystem, Tag > |
C boost::threadpool::empty_controller< Pool > | SizePolicyController which provides no functionality
►C enable_shared_from_this |
C boost::threadpool::detail::pool_core< Task, SchedulingPolicy, SizePolicy, SizePolicyController, ShutdownPolicy > | Thread pool
C boost::threadpool::detail::worker_thread< Pool > | Thread pool worker
C Gaudi::IODataManager::Entry |
C EqSolver::EqSolverMisc |
C Tuples::detail::ErrorHandler< OBJECT, FUNCTION > | Concrete error handlers for dealing with classes, which supports member functions Error,Warning and Print ( e.g
C EventContext | This class represents an entry point to all the event specific data
C EventIDBase | This class provides a unique identification for each event, in terms of run/event number and/or a time stamp
C EventIterator< TYPE > |
C EventSchedulingState |
C EventSlot | Class representing the event slot
C ExcelPlotter.Excel |
►C std::exception [external] | STL class
C Gaudi::PluginService::Exception |
►C GaudiException | Define general base for Gaudi exception
C TimeException | Exception thrown by Gaudi::Time
C UpdateManagerException | Exception thrown by the UpdateManagerSvc when something goes wrong
►C std::runtime_error [external] | STL class
C Gaudi::Parsers::PositionalPropertyValueException |
C Gaudi::Parsers::PropertyValueException |
C Gaudi::Guards::ExceptionGuard | The most simple guard - it execute the certain code withing typical "try {} catch" clause, used in Auditor, Algorithm, AlgTool, etc
C Gaudi::PluginService::Details::Factory< T > | Class providing default factory functions
C Gaudi::PluginService::Factory< R, Args > | Class wrapping the signature for a factory with any number of arguments
C Gaudi::PluginService::Details::Registry::FactoryInfo |
C boost::threadpool::fifo_scheduler< Task > | SchedulingPolicy which implements FIFO ordering
C Io::FileAttr |
C Io::FileHdlr |
C FileInfo |
►C GaudiTesting.BaseTest.FilePreprocessor |
C GaudiTesting.BaseTest.BlockSkipper |
C GaudiTesting.BaseTest.FilePreprocessorSequence |
C GaudiTesting.BaseTest.LineSkipper |
C GaudiTesting.BaseTest.LineSorter | Special preprocessor sorting the list of strings (whitespace separated) that follow a signature on a single line
C GaudiTesting.BaseTest.RegexpReplacer |
►C GaudiTest.FilePreprocessor |
C GaudiTest.BlockSkipper |
C GaudiTest.FilePreprocessorSequence |
C GaudiTest.LineSkipper |
C GaudiTest.LineSorter | Special preprocessor sorting the list of strings (whitespace separated) that follow a signature on a single line
C GaudiTest.RegexpReplacer |
C GaudiMP.pTools.FileRecordsAgent |
►C Filter |
C GaudiTest.GaudiFilterExecutable |
►C Filter |
C GaudiKernel.ProcessJobOptions.LogFilter |
C Containers::find< CONT > |
C Gaudi::Parsers::PairGrammar< Iterator, PairT, Skipper >::first |
C Gaudi::Parsers::KeyValueGrammar< Iterator, Skipper >::first |
C ana.FirstSummary |
►C Formatter |
C GaudiKernel.ProcessJobOptions.LogFormatter |
C Gaudi::fullMatch_t |
C FuncMinimum::FuncMinimumMisc |
C boost::threadpool::future< Result > | Experimental
C boost::threadpool::detail::future_impl< Result > |
C boost::threadpool::detail::future_impl_task_func< Future, Function > |
C Gaudi | This is a number of static methods for bootstrapping the Gaudi framework
C GaudiDll |
C GaudiGSL | Helper class to get (static) access to Gaudi GSL Service General users are not supposed to use it
►C GaudiHandleInfo |
►C GaudiHandleArrayBase | Base class of array's of various gaudihandles
C GaudiHandleArray< T > | T is the concrete handle type, e.g
►C GaudiHandleArray< ServiceHandle< T > > |
C ServiceHandleArray< T > | Array of Handles to be used in lieu of vector of naked pointers to tools
►C GaudiHandleArray< ToolHandle< IThreadInitTool > > |
C ToolHandleArray< IThreadInitTool > |
►C GaudiHandleArray< ToolHandle< T > > |
C ToolHandleArray< T > | Array of Handles to be used in lieu of vector of naked pointers to tools
►C GaudiHandleBase | Base class to handles to be used in lieu of naked pointers to various Gaudi components
►C GaudiHandle< T > | Handle to be used in lieu of naked pointers to gaudis
C ServiceHandle< T > | Handle to be used in lieu of naked pointers to services
C ToolHandle< T > | Handle to be used in lieu of naked pointers to tools
►C GaudiHandle< IThreadInitTool > |
C ToolHandle< IThreadInitTool > |
►C GaudiHandle< IToolSvc > |
C ServiceHandle< IToolSvc > |
C Rndm::Generator< TYPE > |
►C Gaudi::Utils::GetData< TYPE > | Helper structure for implementation of "get"-functions for GaudiCommon<BASE>
C Gaudi::Utils::GetData< const TYPE > | Template specialization for const types
C Gaudi::Utils::GetData< TYPE & > | Template specialization for reference types
C Gaudi::Utils::GetData< TYPE * > | Template specialization for pointer types
C Gaudi::Utils::GetData< Gaudi::Gaudi::Range_< std::vector< const TYPE * > > > |
C Gaudi::Utils::GetData< Gaudi::NamedRange_< std::vector< const TYPE * > > > | Template specialization for named ranges
C Gaudi::Utils::GetData< Gaudi::Range_< std::vector< const TYPE * > > > | Template specialization for ranges
C Gaudi::Utils::GetData< Range > |
►C Gaudi::Utils::GetOrCreateData< TYPE, TYPE2 > | Helper structure for implementation of "getOrCreate"-functions for GaudiCommon<BASE>
C Gaudi::Utils::GetOrCreateData< const TYPE, const TYPE2 > |
C Gaudi::Utils::GetOrCreateData< const TYPE, TYPE2 > |
C Gaudi::Utils::GetOrCreateData< TYPE &, TYPE2 & > |
C Gaudi::Utils::GetOrCreateData< TYPE &, TYPE2 > |
C Gaudi::Utils::GetOrCreateData< TYPE *, TYPE2 * > |
C Gaudi::Utils::GetOrCreateData< TYPE *, TYPE2 > |
C Gaudi::Utils::GetOrCreateData< TYPE, const TYPE2 > |
C Gaudi::Utils::GetOrCreateData< TYPE, TYPE2 & > |
C Gaudi::Utils::GetOrCreateData< TYPE, TYPE2 * > |
C Gaudi::Utils::GetOrCreateData< Gaudi::NamedRange_< std::vector< const TYPE * > >, TYPE2 > |
C Gaudi::Utils::GetOrCreateData< Gaudi::Range_< std::vector< const TYPE * > >, TYPE2 > |
C Gaudi::Utils::GetOrCreateData< Range_, TYPE2 > |
C THistSvc::GlobalDirectoryRestore |
C GlobalDirectoryRestore |
►C grammar |
C Gaudi::Parsers::BoolGrammar< Iterator, Gaudi::Parsers::SkipperGrammar > |
C Gaudi::Parsers::BoolGrammar< Iterator, Gaudi::Parsers::SkipperGrammar > |
C Gaudi::Parsers::EdgeGrammar< Iterator, Gaudi::Parsers::SkipperGrammar > |
C Gaudi::Parsers::BoolGrammar< Iterator, Skipper > |
C Gaudi::Parsers::BoolGrammar< Iterator, Skipper > |
C Gaudi::Parsers::CharGrammar< Iterator, Skipper > |
C Gaudi::Parsers::EdgeGrammar< Iterator, Skipper > |
C Gaudi::Parsers::FileGrammar< Iterator, Skipper > |
C Gaudi::Parsers::H1Grammar< Iterator, Skipper > |
C Gaudi::Parsers::H2Grammar< Iterator, Skipper > |
C Gaudi::Parsers::Histo1DGrammar< Iterator, Skipper > |
C Gaudi::Parsers::IdentifierGrammar< Iterator, Skipper > |
C Gaudi::Parsers::IntGrammar< Iterator, RT, Skipper > |
C Gaudi::Parsers::KeyValueGrammar< Iterator, Skipper > |
C Gaudi::Parsers::MapGrammar< Iterator, MapT, Skipper > |
C Gaudi::Parsers::PairGrammar< Iterator, PairT, Skipper > |
C Gaudi::Parsers::Pnt3DGrammar< Iterator, PointT, Skipper > |
C Gaudi::Parsers::Pnt4DGrammar< Iterator, PointT, Skipper > |
C Gaudi::Parsers::RealGrammar< Iterator, Skipper > |
C Gaudi::Parsers::RealGrammar< Iterator, Skipper > |
C Gaudi::Parsers::SkipperGrammar< Iterator > |
C Gaudi::Parsers::SkipperGrammar< Iterator > |
C Gaudi::Parsers::StringGrammar< Iterator, Skipper > |
C Gaudi::Parsers::StringGrammar< Iterator, Skipper > |
C Gaudi::Parsers::TupleGrammar< Iterator, TupleT, N, Skipper > |
C Gaudi::Parsers::TupleInnerGrammar< Iterator, TupleT, N, Skipper > |
C Gaudi::Parsers::TupleInnerGrammar< Iterator, TupleT, 1, Skipper > |
C Gaudi::Parsers::UnitsGrammar< Iterator, Skipper > |
C Gaudi::Parsers::VectorGrammar< Iterator, VectorT, Skipper > |
C Gaudi::Parsers::IdentifierGrammar< Iterator, double > |
C Gaudi::Parsers::IdentifierGrammar< Iterator, Gaudi::Parsers::SkipperGrammar > |
C Gaudi::Parsers::IntGrammar< Iterator, unsigned int, Gaudi::Parsers::SkipperGrammar > |
C Gaudi::Parsers::IntGrammar< Iterator, unsigned int, Skipper > |
C Gaudi::Parsers::RealGrammar< Iterator, double, Gaudi::Parsers::SkipperGrammar > |
C Gaudi::Parsers::RealGrammar< Iterator, double, Gaudi::Parsers::SkipperGrammar > |
C Gaudi::Parsers::RealGrammar< Iterator, double, Skipper > |
C Gaudi::Parsers::RealGrammar< Iterator, double, Skipper > |
C Gaudi::Parsers::RealGrammar< Iterator, Gaudi::Parsers::SkipperGrammar > |
C Gaudi::Parsers::RealGrammar< Iterator, Gaudi::Parsers::SkipperGrammar > |
C Gaudi::Parsers::StringGrammar< Iterator, Gaudi::Parsers::SkipperGrammar > |
C Gaudi::Parsers::StringGrammar< Iterator, Gaudi::Parsers::SkipperGrammar > |
C Gaudi::Parsers::TupleInnerGrammar< Iterator, TupleT, N, Gaudi::Parsers::SkipperGrammar > |
C Gaudi::Parsers::VectorGrammar< Iterator, std::vector< double >, Gaudi::Parsers::SkipperGrammar > |
C Gaudi::Parsers::VectorGrammar< Iterator, std::vector< double >, Skipper > |
C Gaudi::Parsers::VectorGrammar< Iterator, std::vector< std::pair< double, double > >, Gaudi::Parsers::SkipperGrammar > |
C Gaudi::Parsers::Grammar_< Iterator, T, Skipper, Enable > |
C Gaudi::Parsers::Grammar_< Iterator, GaudiUtils::VectorMap< KeyT, ValueT, KeyCompareT, AllocatorT >, Skipper > |
C Gaudi::Parsers::Grammar_< Iterator, HeadT, Gaudi::Parsers::SkipperGrammar > |
C Gaudi::Parsers::Grammar_< Iterator, HeadT, Skipper > |
C Gaudi::Parsers::Grammar_< Iterator, ROOT::Math::DisplacementVector3D< T1, T2 >, Skipper > |
C Gaudi::Parsers::Grammar_< Iterator, ROOT::Math::LorentzVector< T1 >, Skipper > |
C Gaudi::Parsers::Grammar_< Iterator, ROOT::Math::PositionVector3D< T1, T2 >, Skipper > |
C Gaudi::Parsers::Grammar_< Iterator, Scalar, Gaudi::Parsers::SkipperGrammar > |
C Gaudi::Parsers::Grammar_< Iterator, ScalarT, Gaudi::Parsers::SkipperGrammar > |
C Gaudi::Parsers::Grammar_< Iterator, std::list< InnerT, AllocatorT >, Skipper > |
C Gaudi::Parsers::Grammar_< Iterator, std::map< KeyT, ValueT, KeyCompareT, AllocatorT >, Skipper > |
C Gaudi::Parsers::Grammar_< Iterator, std::pair< KeyT, ValueT >, Skipper > |
C Gaudi::Parsers::Grammar_< Iterator, std::set< InnerT, CompareT, AllocatorT >, Skipper > |
C Gaudi::Parsers::Grammar_< Iterator, std::tuple< Args...>, Skipper > |
C Gaudi::Parsers::Grammar_< Iterator, std::vector< InnerT, AllocatorT >, Skipper > |
C Gaudi::Parsers::Grammar_< Iterator, T, Skipper, typename boost::enable_if< boost::is_floating_point< T > >::type > |
C Gaudi::Parsers::Grammar_< Iterator, T, Skipper, typename boost::enable_if< boost::is_integral< T > >::type > |
C Gaudi::Parsers::Grammar_< Iterator, typename MapT::key_type, Gaudi::Parsers::SkipperGrammar > |
C Gaudi::Parsers::Grammar_< Iterator, typename MapT::mapped_type, Gaudi::Parsers::SkipperGrammar > |
C Gaudi::Parsers::Grammar_< Iterator, typename PairT::first_type, Gaudi::Parsers::SkipperGrammar > |
C Gaudi::Parsers::Grammar_< Iterator, typename PairT::second_type, Gaudi::Parsers::SkipperGrammar > |
C Gaudi::Parsers::Grammar_< Iterator, typename std::tuple_element< 0, ResultT >::type, Gaudi::Parsers::SkipperGrammar > |
C Gaudi::Parsers::Grammar_< Iterator, typename std::vector< double >::value_type, Gaudi::Parsers::SkipperGrammar > |
C Gaudi::Parsers::Grammar_< Iterator, typename std::vector< double >::value_type, Skipper > |
C Gaudi::Parsers::Grammar_< Iterator, typename std::vector< std::pair< double, double > >::value_type, Gaudi::Parsers::SkipperGrammar > |
C Gaudi::Parsers::Grammar_< Iterator, typename VectorT::value_type, Skipper > |
C Genfun::GaudiMathImplementation::GSL_Helper | Simple structure to be used for adaption interface `Genfun::AbsFunction` to `gsl_function` structure
C Genfun::GaudiMathImplementation::NumericalDefiniteIntegral::gsl_ws_deleter |
C Genfun::GaudiMathImplementation::NumericalIndefiniteIntegral::gsl_ws_deleter |
C GslError | Helper class to represent GSL errors
C pool::Guid |
C Containers::hashmap |
C HistogramSvc::Helper |
C GaudiPython::Helper |
C Gaudi::Histo1DDef | Simple helper class for description of 1D-histogram The class is targeted to act as the primary "histogram property", but clearly have significantly wider application range
C GaudiMP.pTools.HistoAgent |
C GaudiPython::HistoDecorator | Simple decorator class to allow to reuse the functionality of GaudiHistos<TYPE> class in pythin
C GaudiPython.HistoUtils.HistoFile |
►C Gaudi::HistogramBase | Common base class for all histograms Use is solely functional to minimize dynamic_casts inside HistogramSvc
►C Gaudi::Generic1D< INTERFACE, IMPLEMENTATION > | Common AIDA implementation stuff for histograms and profiles using ROOT implementations
C Gaudi::Histogram1D | AIDA implementation for 1 D histograms using ROOT THD1
C Gaudi::Profile1D | AIDA implementation for 1 D profiles using ROOT TProfile
►C Gaudi::Generic2D< INTERFACE, IMPLEMENTATION > | Common AIDA implementation stuff for histograms and profiles using ROOT implementations
C Gaudi::Histogram2D | AIDA implementation for 2 D histograms using ROOT THD2
C Gaudi::Profile2D | AIDA implementation for 2 D profiles using ROOT TProfile2D
►C Gaudi::Generic3D< INTERFACE, IMPLEMENTATION > | Common AIDA implementation stuff for histograms and profiles using ROOT implementations
C Gaudi::Histogram3D | AIDA implementation for 2 D histograms using ROOT THD2
C Gaudi::Generic1D< AIDA::IHistogram1D, TH1D > |
C Gaudi::Generic1D< AIDA::IProfile1D, TProfile > |
C Gaudi::Generic2D< AIDA::IProfile2D, TProfile2D > |
C Gaudi::Generic2D< IHistogram2D, TH2D > |
C Gaudi::Generic3D< AIDA::IHistogram3D, TH3D > |
C Gaudi::Utils::HistoStats | The collection of trivial functions to access the statistical information for the histograms
C Gaudi::Utils::Histos::HistoStrings | Helper class to produce "good" dictionaries
C HiveRndm::HiveNumbers |
►C IAxis |
C Gaudi::Axis | An IAxis represents a binned histogram axis
C ibs_param_t |
C ibsfetchctl_t |
C ibsopctl_t |
C ibsopdata2_t |
C ibsopdata3_t |
C ibsopdata_t |
C IClassInfo | Data base class allowing to store persistent type information
C GaudiAlg::ID | ID class for Histogram and Ntuples
►C Gaudi::meta::id_< T > |
C Gaudi::meta::detail::append1< interface_list< Is...>, I > |
C Gaudi::meta::detail::appendN< interface_list<>, State > |
C Gaudi::meta::id_< State > |
C Gaudi::meta::id_< std::conditional< std::is_base_of< id_< I >, inherit_from< id_< Is >...> >::value, interface_list< Is...>, interface_list< Is..., I > >::type > |
►C Gaudi::IDataConnection | ABC describing basic data connection
C Gaudi::RootDataConnection | Concrete implementation of the IDataConnection interface to access ROOT files
►C IDataHandleVisitor |
C DHHVisitor |
►C IDataStoreAgent | Generic data agent interface
C DataSelectionAgent | DataSelectionAgent base in charge of collecting all the refereces to DataObjects in a transient store that passes some selection criteria
C GaudiMP::TESSerializer |
C HistogramAgent | HistogramAgent base in charge of collecting all the refereces to DataObjects in a transient store that passes some selection criteria
C HistogramAgent | HistogramAgent base in charge of collecting all the refereces to DataObjects in a transient store that passes some selection criteria
C OutputStreamAgent |
C StreamBuffer::IdentifiedLink | Definition of the contained link set
C GaudiUtils::details::IdentityOutputter |
C concurrency::IExecutionFlowGraph |
C concurrency::IExecutionFlowManager |
C IgHookTrace |
C IgHookTraceAlloc |
C IgnoreError |
►C concurrency::IGraphVisitor |
C concurrency::RankerByCummulativeOutDegree |
C concurrency::RankerByDataRealmEccentricity |
C concurrency::RankerByEccentricity |
C concurrency::RankerByProductConsumption |
C concurrency::RankerByTiming |
C concurrency::RunSimulator |
C concurrency::Trigger | A visitor, performing full top-down traversals of a graph
►C IHistogram1D |
C Gaudi::Generic1D< AIDA::IHistogram1D, TH1D > |
►C IHistogram3D |
C Gaudi::Generic3D< AIDA::IHistogram3D, TH3D > |
►C IHistogramFactory |
C HistogramSvc | HistogramSvc class definition
C Gaudi::iid_cast_details::iid_cast_t< Is > |
C Gaudi::iid_cast_details::iid_cast_t< I, Is...> |
C Gaudi::iid_cast_details::iid_cast_t<> |
C IInspectable | Interface definition of an inspectable object
►C IInterface | Definition of the basic interface
C Gaudi::IFileCatalog | File catalog interface
C Gaudi::IFileCatalogMgr | File catalog manager
C Gaudi::IIODataManager |
C Gaudi::ISignalMonitor | Interface for the service that monitors the occurrences of system signals
C IAddressCreator | IAddressCreator interface definition
C IAlgContextSvc | An abstract interface for Algorithm Context Service
C IAlgResourcePool | The IAlgResourcePool is the interface for managing algorithm instances, in particular if clones of the same algorithm exist
C IChronoSvc | "Chrono"-related part of interface IChronoStatSvc
C IClassManager | The IClassManager is the interface implemented by the generic Factory in the Application Manager to support class management functions
►C IConverter | The data converters are responsible to translate data from one representation into another
C IConversionSvc |
C ICounterSvc | Create / access multi purpose counters
C IDataManagerSvc |
►C IDataProviderSvc | Data provider interface definition
C IAIDATupleSvc | Definition of the IAIDATupleSvc interface class
C IHistogramSvc | Definition of the IHistogramSvc interface class
C INTupleSvc |
C IDataSourceMgr | IDataSourceMgr interface definition
C IDetDataSvc |
C IEventProcessor | The IEventProcessor is the interface to process events
C IEvtSelector | The Event Selector Interface
C IExceptionSvc | The abstract interface for exception handling service
C IFileAccess | Abstract interface for a service or tool implementing a read access to files
C IHiveWhiteBoard |
C IInactiveMessageCounter |
►C IIncidentListener | The interface implemented by any class wanting to listen to Incidents
C Gaudi::RootPerfMonSvc | Description:
C IntelProfilerAuditor |
C IIncidentSvc | The interface implemented by the IncidentSvc service
C IInspector | Inspector base class
C IJobOptionsSvc | Main interface for the JobOptions service
C IMessageSvc | The IMessage is the interface implemented by the message service
C IMonitorSvc | Definition of the IMonitorSvc interface, which publishes Gaudi variables to outside monitoring processes
►C INamedInterface | IInterface compliant class extending IInterface with the name() method
►C IAlgTool | The interface implemented by the AlgTool base class
C IDataStoreLeaves | Interface for a tool or service that returns a list of leaves (paths) in a transient store
C IDataStreamTool |
C IDODAlgMapper | Interface of tools used by the DataOnDemandSvc to choose the algorithm to be run to produce the data at a path
C IDODNodeMapper | Interface of tools used by the DataOnDemandSvc to choose the type of node to be created at a path
C IEqSolver | Interface file for multidimensional root-finding (solving nonlinear system with n equations in n unknowns)
►C IErrorTool |
C ErrorTool |
C IEventTimeDecoder | Interface that a Tool that decodes the event time has to implement
C IFuncMinimum | Interface file to find minimum of the function and compute covariance matrix (matrix of error)
C IGenericTool | General purpose interface class for tools that "do something"
C IGslErrorHandler | The abstract interface for arbitrary GSL error handler
►C IHistoTool | An abstract interface for "histogramming tool"
C HistoTool | Simple tool for histogramming (component)
►C ISequencerTimerTool | Implements the time measurement inside a sequencer
C SequencerTimerTool | Implements the time measurement inside a sequencer
C IThreadInitTool | IThreadInitTool GaudiKernel/IThreadInitTool.h
►C ITupleTool |
C TupleTool |
C IAppMgrUI | Application Manager User Interface
C IAuditor | The IAuditor is the interface implmented by the AlgAuditor base class
C IDataHandleHolder |
C IIoComponent |
C IIoComponentMgr |
C IPartitionControl | Create / access partitions
C IPersistencySvc | Data persistency service interface
C IProperty | The IProperty is the basic interface for all components which have properties that can be set or get
C IPublishSvc | Definition of the IPublishSvc interface, which publishes variables to outside monitoring processes
C IRndmEngine | Definition of a interface for a generic random number generator giving randomly distributed numbers in the range [0...1] number generators
C IRndmGen | Definition of a interface for a generic random number generators
C IRunable | Runable interface definition
C IScheduler | General interface for algorithm scheduler
C IScheduler | General interface for algorithm scheduler
C ISelectStatement | A select statement can either contain
C ISerialize | Object serialization interface definition
C IStagerSvc |
►C IStateful | Interface for classes that implement the Gaudi State Machine
►C IComponentManager |
C IAlgManager | The IAlgManager is the interface implemented by the Algorithm Factory in the Application Manager to support management functions
C ISvcManager | The ISvcManager is the interface implemented by the Service Factory in the Application Manager to support management functions
C IStatSvc | "Stat"-related part of interface IChronoStatSvc
C ISvcLocator | The ISvcLocator is the interface implemented by the Service Factory in the Application Manager to locate services in the framework
C IThreadPoolSvc | IThreadPoolSvc GaudiKernel/IThreadPoolSvc.h
C IToolSvc | The interface implemented by the IToolSvc base class
C IUpdateableIF |
C IUpdateManagerSvc | Interface class to the Update Manager service
C image |
C boost::threadpool::immediately< Pool > | ShutdownPolicy which does not wait for any tasks or worker termination
►C Incident | Base class for all Incidents (computing events)
C ContextIncident< T > |
C FileIncident | This class is the FileIncident
►C ModuleIncident | Base class for Module-related incident
C ModuleLoadedIncident | Fired when a module (DLL) is loaded
C Gaudi::Parsers::IncludedFiles |
C IndefiniteIntegral |
C Integration | Collection of common types for classes NumericalIndefiniteIntegral and NumericalDefiniteIntegral
C GaudiPython::Interface< TYPE > | Minor mofidication of original Pere's structure GaudiPython::Interface This helper class is nesessary to perform C++ castings from python
C Gaudi::interface_list< I > |
C Gaudi::interface_list_append< I > |
►C Gaudi::interface_list_cat< I > |
C Gaudi::interface_list_append< interface_list< Is...>, I > |
C Gaudi::interface_list_cat< interface_list< I1...>, interface_list< I2...>, Others...> |
C Gaudi::interface_list_cat< interface_list< I1..., I2...>, Others... > |
C Gaudi::interface_list_cat< interface_list< Is...>, interface_list< I > > |
C InterfaceID | Interface ID class
C Gaudi::InterfaceId< INTERFACE, majVers, minVers > | Class to handle automatically the versioning of the interfaces when they are inheriting from other interfaces
►C Interfaces |
C extend_interfaces< Interfaces > | Base class to be used to extend an interface
►C extend_interfaces< INamedInterface, IStateful > |
C IAlgorithm | The IAlgorithm is the interface implemented by the Algorithm base class
►C IService | General service interface definition
C IClassIDSvc | Interface to the CLID database
C ICounterSummarySvc | Simple service interface to collect counters to persist in a summary file
C IFileMgr |
C IGslSvc | The abstract interface to "deal" with GNU Scientific Library (GLS) The main task is the error handling
C IHistorySvc | Definition of the IHistorySvc interface class
C IIssueLogger |
C IMagneticFieldSvc | The interface to the MagneticFieldSvc
C IMetaDataSvc |
C IParticlePropertySvc | This class is an interface to the ParticlePropertySvc
C IPartPropSvc |
C IRndmGenSvc | Random Generator service interface definition Definition of a interface for a service to access random generators according to predefined distributions:
C IStatusCodeSvc |
C ITHistSvc |
C ITimelineSvc |
►C extend_interfaces< Interfaces...> |
C extends< BASE, Interfaces > | Base class used to extend a class implementing other interfaces
C extends< Algorithm, IPartitionControl > |
C extends< AlgTool, IDataStoreLeaves, IIncidentListener > |
C extends< AlgTool, IDataStreamTool > |
C extends< AlgTool, IDODAlgMapper, IDODNodeMapper > |
C extends< AlgTool, IFileAccess > |
C extends< AlgTool, IGslErrorHandler > |
C extends< AlgTool, IPartitionControl > |
C extends< Auditor, IIncidentListener > |
C extends< ComponentManager, IAlgManager > |
C extends< ComponentManager, ISvcManager, ISvcLocator > |
C extends< DataSvc, IHistogramSvc > |
C extends< DataSvc, IIncidentListener > |
C extends< DataSvc, INTupleSvc, IDataSourceMgr > |
C extends< GaudiTool, IEqSolver > |
C extends< GaudiTool, IFuncMinimum > |
C extends< Service, Gaudi::ISignalMonitor > |
C extends< Service, IAlgContextSvc, IIncidentListener > |
C extends< Service, IAlgResourcePool > |
C extends< Service, IAuditorSvc > |
C extends< Service, IChronoStatSvc, IIncidentListener > |
C extends< Service, IConversionSvc, IAddressCreator > |
C extends< Service, IConversionSvc, IPersistencySvc, IAddressCreator > |
C extends< Service, ICounterSvc > |
C extends< Service, IDataProviderSvc, IDataManagerSvc > |
C extends< Service, IDataProviderSvc, IDataManagerSvc, IHiveWhiteBoard > |
C extends< Service, IDataProviderSvc, IDataManagerSvc, IPartitionControl > |
C extends< Service, IEventProcessor > |
C extends< Service, IEvtSelector > |
C extends< Service, IExceptionSvc > |
C extends< Service, IFileAccess > |
C extends< Service, IFileCatalog, IFileCatalogMgr > |
C extends< Service, IFileMgr, IIncidentListener > |
C extends< Service, IGslSvc > |
C extends< Service, IHistorySvc, IIncidentListener > |
C extends< Service, IIncidentListener > |
C extends< Service, IIncidentSvc > |
C extends< Service, IIoComponentMgr, IIncidentListener > |
C extends< Service, IIODataManager > |
C extends< Service, IIssueLogger > |
C extends< Service, IMessageSvc, IInactiveMessageCounter > |
C extends< Service, IMetaDataSvc > |
C extends< Service, IParticlePropertySvc > |
C extends< Service, IPartPropSvc > |
C extends< Service, IProperty, IJobOptionsSvc > |
C extends< Service, IRndmEngine, ISerialize, IIncidentListener > |
C extends< Service, IRndmGenSvc, IRndmEngine, ISerialize > |
C extends< Service, IRunable > |
C extends< Service, IScheduler > |
C extends< Service, IStatusCodeSvc > |
C extends< Service, ITHistSvc, IIncidentListener, IIoComponent > |
C extends< Service, IThreadPoolSvc > |
C extends< Service, ITimelineSvc > |
C extends< Service, IToolSvc > |
C extends< TsDataSvc, IDetDataSvc, IIncidentListener > |
C implements< Interfaces > | Base class used to implement the interfaces
►C implements< IClassManager > |
C DLLClassManager |
►C implements< IConverter > |
►C Converter | Converter base class
►C Gaudi::RootConverter | Description: Definition of the ROOT data converter
►C Gaudi::RootStatCnv | Description: Base class converter for N-tuples and related classes
►C Gaudi::RootDirectoryCnv | Description: NTuple directory converter class definition Definition of the converter to manage the directories in an database representing N-Tuples
C Gaudi::RootDatabaseCnv | Statistics file converter class definition
C Gaudi::RootNTupleCnv | NTuple converter class definition for NTuples writted/read using ROOT
►C RootHistCnv::RConverter | Root Converter
C RootHistCnv::DirectoryCnv |
►C RootHistCnv::RDirectoryCnv | Create persistent and transient representations of data store directories
C RootHistCnv::RFileCnv | NTuple converter class definition
C RootHistCnv::RHistogramCnv< T, S, Q > | Generic converter to save/read AIDA_ROOT histograms using ROOT
►C RootHistCnv::RNTupleCnv | NTuple converter class definition
C RootHistCnv::RCWNTupleCnv | Converter of Column-wise NTuple into ROOT format
C RootHistCnv::RRWNTupleCnv | Row wise NTuple converter class definition
►C implements< IFileCatalog > |
C Gaudi::XMLFileCatalog | This class constitutes the core of the XML based FileCatalog API for POOL
►C implements< IInterface > |
C EventSelectorDataStream | Definition of class EventSelectorDataStream
►C implements< IProperty > |
C PropertyMgr | Property manager helper class
►C implements< IRndmGen > |
►C RndmGen | Random Generator definition
C HepRndm::Generator< TYPE > |
C HepRndm::Generator< Rndm::DefinedPdf > |
►C implements< ISelectStatement > |
►C SelectStatement | Class of a selection statement
C NTuple::Selector | NTuple Selector class
►C implements< ISvcLocator > |
C Gaudi::BootSvcLocator | A dual-stage boostrap mechanism is used to ensure an orderly startup of the ApplicationMgr
►C extend_interfaces< IService, IAuditor > |
C IAuditorSvc | The interface implemented by the IAuditorSvc base class
►C extend_interfaces< IService, IChronoSvc, IStatSvc > |
C IChronoStatSvc | The IChronoStatSvc is the interface implemented by the ChronoStatService
►C INTuple | NTuple interface class definition
C NTuple::Tuple | Abstract base class which allows the user to interact with the actual N tuple implementation
►C INTupleItem | NTuple interface class definition
►C NTuple::_Data< bool > |
C NTuple::_Item< bool > |
►C NTuple::_Data< IOpaqueAddress * > |
C NTuple::_Item< IOpaqueAddress * > |
►C NTuple::_Data< VALUE > |
C NTuple::_Item< VALUE > |
►C NTuple::_Data< TYP > | Abstract class describing basic data in an Ntuple
►C NTuple::_Array< TYP > | Abstract class describing a column-array in a N tuple
C NTuple::_ArrayImp< TYP > | Concrete class discribing a column-array in a N tuple
►C NTuple::_DataImp< TYP > | Concrete class discribing basic data items in an N tuple
C NTuple::_ArrayImp< TYP > | Concrete class discribing a column-array in a N tuple
C NTuple::_ItemImp< TYP > | Concrete class discribing a column in a N tuple
C NTuple::_MatrixImp< TYP > | Concrete class discribing a matrix column in a N tuple
►C NTuple::_Item< TYP > | Abstract class describing a column in a N tuple
C NTuple::_ItemImp< TYP > | Concrete class discribing a column in a N tuple
►C NTuple::_Matrix< TYP > | Abstract class describing a matrix column in a N tuple
C NTuple::_MatrixImp< TYP > | Concrete class discribing a matrix column in a N tuple
C System::IO_COUNTERS | Process I/O Counters NtQueryInformationProcess using ProcessIoCounters
C IoComponentMgr::IoComponentEntry |
C Io::IoFlags |
C IIoComponentMgr::IoMode |
►C IOpaqueAddress | Opaque address interface definition
►C GenericAddress | Generic Transient Address
C Gaudi::RootAddress | Description:
C RootHistCnv::RootObjAddress |
►C IProfile1D |
C Gaudi::Generic1D< AIDA::IProfile1D, TProfile > |
►C IProfile2D |
C Gaudi::Generic2D< AIDA::IProfile2D, TProfile2D > |
►C IRegistry | The IRegistry represents the entry door to the environment any data object residing in a transient data store is embedded
►C DataSvcHelpers::RegistryEntry | Definition of an entry in the transient data store
C Hive::HiveEventRegistryEntry |
C IssueSeverity |
C Tuples::ItemStore< VALUE > | Simple class, which represents the local storage of N-tuple items of the given type
►C std::iterator< std::forward_iterator_tag, uint > [external] |
C AlgsExecutionStates::Iterator |
►C std::iterator< std::input_iterator_tag, Attrib > [external] |
C Gaudi::Utils::AttribStringParser::Iterator | Iterator to loop over the tag/value pairs in the attribute string
►C IUpdateable | Object update interface definition
C IUpdateableIF |
C IUpdateableInterface | Component interface counterpart to the above ABC
C IValidity | Interface for objects with a validity
►C IInspector::IValue |
C IInspector::_V< T > |
►C IVersHistoryObj | Interface for Versioned History Objects
C AlgorithmHistory | AlgorithmHistory class definition
C AlgToolHistory | AlgToolHistory class definition
C JobHistory | JobHistory class definition
C ServiceHistory | ServiceHistory class definition
C GaudiKernel.ProcessJobOptions.JobOptsParser |
C System::KERNEL_USER_TIMES | Process/Thread System and User Time NtQueryInformationProcess using ProcessTimes NtQueryInformationThread using ThreadTimes
►C key_compare |
C GaudiUtils::VectorMap< KEY, VALUE, KEYCOMPARE, ALLOCATOR >::_compare_type | The actual structure used to compare the elements Only "key" is important for comparison
C Containers::key_traits< KEY > | Key traits class
►C Containers::key_traits< DATATYPE::key_type > |
C Containers::traits< CONTAINER, DATATYPE > | Container traits class
C GaudiDict::KeyedContainerDict< T > |
C GaudiDict::KeyedObjectDict< T > |
C Containers::KeyedObjectManager< SETUP > | KeyedObjectManager Class to manage keyed objects
C DataOnDemandSvc::Leaf |
C StoreSnifferAlg::LeafInfo |
C boost::threadpool::lifo_scheduler< Task > | SchedulingPolicy which implements LIFO ordering
C LinkManager::Link | Embedded class defining a symbolic link Note: No copy constructor; bitwise copy (done by the compiler) is just fine
C LinkManager | A LinkManager is the object aggregated into a DataObject, which is responsible for the handling of non-tree like links
C linux_proc |
►C list |
►C GaudiKernel.GaudiHandles.GaudiHandleArray |
C GaudiKernel.GaudiHandles.PrivateToolHandleArray |
C GaudiKernel.GaudiHandles.PublicToolHandleArray |
C GaudiKernel.GaudiHandles.ServiceHandleArray |
C IncidentSvc::Listener |
C Gaudi::Utils::LockedChrono | Helper object, useful for measurement of CPU-performance of highly-recursive structures, e.g
C install.LogFile |
C Gaudi::PluginService::Details::Logger | Simple logging class, just to provide a default implementation
C IssueLogger::logger_t |
C Gaudi::Math::Lomont< TYPE > | The equality comparison of double numbers using as the metric the maximal number of Units in the Last Place (ULP)
C boost::threadpool::looped_task_func | Looped task function object
C GaudiMP.pTools.LumiFSR |
C Gaudi::majorMatch_t |
C boost::spirit::qi::make_primitive< repository::qi::tag::iter_pos, Modifiers > |
C Containers::map |
►C Gaudi::Utils::MapBase | Helper base-class to allow the generic Python-decoration for all "map-like" classes in Gaudi
►C GaudiUtils::Map< K, T, M > | Extension of the STL map
C GaudiUtils::HashMap< K, T, H, M > | Common class providing an architecture-independent hash map
C GaudiUtils::HashMap< const void *, EntryType > |
C GaudiUtils::HashMap< Gaudi::StringKey, Leaf > |
C GaudiUtils::HashMap< Gaudi::StringKey, Node > |
C GaudiUtils::HashMap< Gaudi::StringKey, std::unique_ptr< ListenerList > > |
C GaudiUtils::HashMap< long, void * > |
C GaudiUtils::HashMap< std::string, Gaudi::Utils::TypeNameString > |
C GaudiUtils::HashMap< std::string, IFileAccess * > |
C GaudiUtils::HashMap< std::string, int > |
C GaudiUtils::HashMap< std::string, NameMap > |
C GaudiUtils::HashMap< std::string, SmartIF< IAlgorithm > > |
C GaudiUtils::HashMap< std::string, std::string > |
C GaudiUtils::HashMap< std::string, std::unique_ptr< Address > > |
C GaudiUtils::HashMap< std::string, std::unique_ptr< Bool > > |
C GaudiUtils::HashMap< std::string, std::unique_ptr< Char > > |
C GaudiUtils::HashMap< std::string, std::unique_ptr< Double > > |
C GaudiUtils::HashMap< std::string, std::unique_ptr< FArray > > |
C GaudiUtils::HashMap< std::string, std::unique_ptr< Float > > |
C GaudiUtils::HashMap< std::string, std::unique_ptr< FMatrix > > |
C GaudiUtils::HashMap< std::string, std::unique_ptr< Int > > |
C GaudiUtils::HashMap< std::string, std::unique_ptr< LongLong > > |
C GaudiUtils::HashMap< std::string, std::unique_ptr< NTuple::Item< VALUE > > > |
C GaudiUtils::HashMap< std::string, std::unique_ptr< Short > > |
C GaudiUtils::HashMap< std::string, std::unique_ptr< UChar > > |
C GaudiUtils::HashMap< std::string, std::unique_ptr< UInt > > |
C GaudiUtils::HashMap< std::string, std::unique_ptr< ULongLong > > |
C GaudiUtils::HashMap< std::string, std::unique_ptr< UShort > > |
C GaudiUtils::VectorMap< KEY, VALUE, KEYCOMPARE, ALLOCATOR > | A bit modified version of 'Loki::AssocVector' associative vector from Loki library by Andrei Alexandrescu
C GaudiUtils::Map< const void *, EntryType, std::unordered_map< const void *, EntryType, Hash< const void * > > > |
C GaudiUtils::Map< Gaudi::StringKey, Leaf, std::unordered_map< Gaudi::StringKey, Leaf, Hash< Gaudi::StringKey > > > |
C GaudiUtils::Map< Gaudi::StringKey, Node, std::unordered_map< Gaudi::StringKey, Node, Hash< Gaudi::StringKey > > > |
C GaudiUtils::Map< Gaudi::StringKey, std::unique_ptr< ListenerList >, std::unordered_map< Gaudi::StringKey, std::unique_ptr< ListenerList >, Hash< Gaudi::StringKey > > > |
C GaudiUtils::Map< InterfaceID, SmartIF< IInterface > > |
C GaudiUtils::Map< long, void *, std::unordered_map< long, void *, Hash< long > > > |
C GaudiUtils::Map< std::string, Gaudi::Utils::TypeNameString, std::unordered_map< std::string, Gaudi::Utils::TypeNameString, Hash< std::string > > > |
C GaudiUtils::Map< std::string, IFileAccess *, std::unordered_map< std::string, IFileAccess *, Hash< std::string > > > |
C GaudiUtils::Map< std::string, int, std::unordered_map< std::string, int, Hash< std::string > > > |
C GaudiUtils::Map< std::string, NameMap, std::unordered_map< std::string, NameMap, Hash< std::string > > > |
C GaudiUtils::Map< std::string, SmartIF< IAlgorithm >, std::unordered_map< std::string, SmartIF< IAlgorithm >, Hash< std::string > > > |
C GaudiUtils::Map< std::string, std::string > |
C GaudiUtils::Map< std::string, std::string, std::unordered_map< std::string, std::string, Hash< std::string > > > |
C GaudiUtils::Map< std::string, std::unique_ptr< Address >, std::unordered_map< std::string, std::unique_ptr< Address >, Hash< std::string > > > |
C GaudiUtils::Map< std::string, std::unique_ptr< Bool >, std::unordered_map< std::string, std::unique_ptr< Bool >, Hash< std::string > > > |
C GaudiUtils::Map< std::string, std::unique_ptr< Char >, std::unordered_map< std::string, std::unique_ptr< Char >, Hash< std::string > > > |
C GaudiUtils::Map< std::string, std::unique_ptr< Double >, std::unordered_map< std::string, std::unique_ptr< Double >, Hash< std::string > > > |
C GaudiUtils::Map< std::string, std::unique_ptr< FArray >, std::unordered_map< std::string, std::unique_ptr< FArray >, Hash< std::string > > > |
C GaudiUtils::Map< std::string, std::unique_ptr< Float >, std::unordered_map< std::string, std::unique_ptr< Float >, Hash< std::string > > > |
C GaudiUtils::Map< std::string, std::unique_ptr< FMatrix >, std::unordered_map< std::string, std::unique_ptr< FMatrix >, Hash< std::string > > > |
C GaudiUtils::Map< std::string, std::unique_ptr< Int >, std::unordered_map< std::string, std::unique_ptr< Int >, Hash< std::string > > > |
C GaudiUtils::Map< std::string, std::unique_ptr< LongLong >, std::unordered_map< std::string, std::unique_ptr< LongLong >, Hash< std::string > > > |
C GaudiUtils::Map< std::string, std::unique_ptr< NTuple::Item< VALUE > >, std::unordered_map< std::string, std::unique_ptr< NTuple::Item< VALUE > >, Hash< std::string > > > |
C GaudiUtils::Map< std::string, std::unique_ptr< Short >, std::unordered_map< std::string, std::unique_ptr< Short >, Hash< std::string > > > |
C GaudiUtils::Map< std::string, std::unique_ptr< UChar >, std::unordered_map< std::string, std::unique_ptr< UChar >, Hash< std::string > > > |
C GaudiUtils::Map< std::string, std::unique_ptr< UInt >, std::unordered_map< std::string, std::unique_ptr< UInt >, Hash< std::string > > > |
C GaudiUtils::Map< std::string, std::unique_ptr< ULongLong >, std::unordered_map< std::string, std::unique_ptr< ULongLong >, Hash< std::string > > > |
C GaudiUtils::Map< std::string, std::unique_ptr< UShort >, std::unordered_map< std::string, std::unique_ptr< UShort >, Hash< std::string > > > |
C GaudiUtils::VectorMap< const INamedInterface *, int > |
C Gaudi::Utils::RegEx::matchList |
C NTuple::Matrix< IOpaqueAddress * > |
C MEMORY_MAPPED_FILE |
C merge_job< T > |
C Message | The Message class
C Gaudi::Parsers::Messages |
C MetaData |
C MessageSvc::MsgAry | Private helper class to keep the count of messages of a type (MSG::LEVEL)
C MsgStream | Definition of the MsgStream class used to transmit messages
C MyTack | Simple class that represents a track for testing purposes
C NamedRange | New concept of "named" range : range with name
C DataOnDemandSvc::Node | Helper class of the DataOnDemandSvc
C Gaudi::Parsers::Node |
C Gaudi::Parsers::NodeOperations |
►C noncopyable |
C boost::threadpool::detail::locking_ptr< T, Mutex > | Smart pointer with a scoped locking mechanism
C boost::threadpool::detail::pool_core< Task, SchedulingPolicy, SizePolicy, SizePolicyController, ShutdownPolicy > | Thread pool
C boost::threadpool::detail::scope_guard |
C boost::threadpool::detail::worker_thread< Pool > | Thread pool worker
C NTupleItems | NTupleItems namespace parts definition This header file is not intended to be included by the public! It's only used for the ntuple service
C Rndm::Numbers | Random number accessor This small class encapsulates the use of the random number generator
►C object |
C Gaudi._ConfigurablesModule | Small class that allows to access all the configurables as attributes of the instance
C Gaudi.Main.BootstrapHelper |
C Gaudi.Main.BootstrapHelper.AppMgr |
C Gaudi.Main.BootstrapHelper.Property |
C Gaudi.Main.BootstrapHelper.StatusCode |
C Gaudi.Main.gaudimain |
►C GaudiKernel.Configurable.Configurable |
C GaudiKernel.Configurable.ConfigurableAlgorithm |
C GaudiKernel.Configurable.ConfigurableAlgTool |
C GaudiKernel.Configurable.ConfigurableAuditor |
C GaudiKernel.Configurable.ConfigurableGeneric |
C GaudiKernel.Configurable.ConfigurableService |
►C GaudiKernel.Configurable.ConfigurableUser |
C Gaudi.Configuration.GaudiPersistency |
C GaudiKernel.Configurable.DummyDescriptor | Classes for generic Gaudi component ===========
C GaudiKernel.Configurable.PropertyReference | Allow references to options as in old style
C GaudiKernel.ConfigurableDb._Singleton |
C GaudiKernel.DataObjectHandleBase.DataObjectHandleBase |
►C GaudiKernel.GaudiHandles.GaudiHandle |
C GaudiKernel.GaudiHandles.PrivateToolHandle |
C GaudiKernel.GaudiHandles.PublicToolHandle |
C GaudiKernel.GaudiHandles.ServiceHandle |
►C GaudiKernel.PropertyProxy.PropertyProxy |
C GaudiKernel.PropertyProxy.DataObjectHandleBasePropertyProxy |
►C GaudiKernel.PropertyProxy.GaudiHandlePropertyProxyBase |
C GaudiKernel.PropertyProxy.GaudiHandleArrayPropertyProxy |
C GaudiKernel.PropertyProxy.GaudiHandlePropertyProxy |
C GaudiMP.GMPBase.Coord |
C GaudiMP.GMPBase.EventCommunicator |
►C GaudiMP.GMPBase.GMPComponent |
C GaudiMP.GMPBase.Reader |
C GaudiMP.GMPBase.Subworker |
C GaudiMP.GMPBase.Worker |
C GaudiMP.GMPBase.Writer |
C GaudiMP.GMPBase.MiniWriter |
C GaudiMP.GMPBase.TESSerializer |
C GaudiMP.IoRegistry.IoRegistry |
C GaudiMP.Parallel.SshSession |
C GaudiMP.Parallel.Statistics |
C GaudiMP.Parallel.Task |
C GaudiMP.Parallel.WorkManager |
C GaudiMP.pTools.Syncer |
C GaudiMP.pTools.SyncMini |
►C GaudiPython.Bindings.InterfaceCast |
C GaudiPython.Bindings.Interface |
►C GaudiPython.Bindings.iProperty |
►C GaudiPython.Bindings.iAlgorithm |
C GaudiPython.GaudiAlgs.GaudiAlgo | Base class for all algorithm Python-image of C++ clkass GaudiAlgorithm
C GaudiPython.GaudiAlgs.HistoAlgo | The base class for easy histogramming
C GaudiPython.GaudiAlgs.TupleAlgo | The base class for easy manupulations with N-Tuples
C GaudiPython.Bindings.iAlgTool |
►C GaudiPython.Bindings.iService |
C GaudiPython.Bindings.AppMgr |
►C GaudiPython.Bindings.iDataSvc |
C GaudiPython.Bindings.iHistogramSvc |
C GaudiPython.Bindings.iNTupleSvc |
C GaudiPython.Bindings.iEventSelector |
C GaudiPython.Bindings.iJobOptSvc |
C GaudiPython.Bindings.iToolSvc |
C GaudiPython.Bindings.PropertyEntry |
C GaudiPython.GaudiAlgs.objectmethod |
C GaudiPython.GaudiAlgs.TupleDecColumnDispatcher |
C GaudiPython.Persistency.FileDescription |
►C GaudiPython.Persistency.PersistencyHelper |
C GaudiPython.Persistency.RootPersistency |
C gaudirun.FakeModule |
►C GaudiTesting.BaseTest.BaseTest |
C GaudiTesting.QMTTest.QMTTest |
C locker.LockFile | Lock a file
C makePlots.TimingInfo |
C run_qmtest.Options |
C validate_patch.PatchData |
C validate_patch.TempDir |
C SmartDataObjectPtr::ObjectFinder | Helper class to configure smart pointer functionality
C SmartDataObjectPtr::ObjectLoader | Helper class to configure smart pointer functionality
C IToolSvc::Observer | Allow call-backs when a tool is a created or retrieved
C Gaudi::Parsers::TupleInnerGrammar< Iterator, TupleT, N, Skipper >::Operations |
C Gaudi::Parsers::TupleInnerGrammar< Iterator, TupleT, 1, Skipper >::Operations |
C Gaudi::Parsers::MapGrammar< Iterator, MapT, Skipper >::Operations |
C Gaudi::Parsers::Pnt3DGrammar< Iterator, PointT, Skipper >::Operations |
C Gaudi::Parsers::Pnt4DGrammar< Iterator, PointT, Skipper >::Operations |
C Gaudi::Parsers::Histo1DGrammar< Iterator, Skipper >::Operations |
C ReplayOutputStream::OutStreamAdder | Helper class to fill the internal map of OutputStreams
C ReplayOutputStream::OutStreamTrigger | Helper class to call the required OutputStream
C GaudiMP.pTools.PackedCaloHypo |
►C IRndmGen::Param |
C Rndm::Binomial | Parameters for the Binomial distributed random number generation
C Rndm::Bit | Parameters for the bit value generation: returns values 0 and 1
C Rndm::BreitWigner | Parameters for the BreitWigner distributed random number generation
C Rndm::BreitWignerCutOff | Parameters for the BreitWigner distributed random number generation with cut off;
C Rndm::Chi2 | Parameters for the Chi2 distributed random number generation
C Rndm::DefinedPdf | Generate a random number Generator following generally distributed random values, given a user-defined probability distribution function
C Rndm::Exponential | Parameters for the Gauss random number generation
C Rndm::Flat | Parameters for the flat random number generation within boundaries [minimum, maximum]
C Rndm::Gamma | Parameters for the Gamma distributed random number generation
C Rndm::Gauss | Parameters for the Gauss random number generation
C Rndm::GaussianTail | Parameters for the Gaussian tail number generation
C Rndm::Landau | Parameters for the Landau distributed random number generation
C Rndm::Poisson | Parameters for the Poisson distributed random number generation with a given mean
C Rndm::StudentT | Parameters for the StudentT distributed random number generation
C ParticleProperty | A trivial class to hold information about a single particle properties
C System::PathResolver |
C pentium4_cccr_value_t | Pentium4_cccr_value_t
C pentium4_escr_value_t |
C pfarg_ctx_t |
C pfarg_load_t |
C pfarg_msg_t |
C pfarg_ovfl_msg_t |
C pfarg_pmc_t |
C pfarg_pmd_attr_t |
C pfarg_pmd_t |
C pfarg_pmr_t |
C pfarg_set_desc_t |
C pfarg_set_info_t |
C pfarg_setdesc_t |
C pfarg_setinfo_t |
C pfarg_sinfo_t |
C pfarg_start_t |
C pfm_amd64_ctr_reg_t |
C pfm_amd64_sel_reg_t |
C pfm_core_sel_reg_t |
C pfm_coreduo_counter_t |
C pfm_coreduo_sel_reg_t |
C pfm_dfl_smpl_arg_t |
C pfm_dfl_smpl_entry_t |
C pfm_dfl_smpl_hdr_t |
C pfm_ds_area_core_t |
C pfm_ds_area_p4_t |
C pfm_gen_ia32_sel_reg_t |
C pfm_i386_p6_ctr_reg_t |
C pfm_i386_p6_sel_reg_t |
C pfm_intel_atom_sel_reg_t |
C pfm_nhm_sel_reg_t |
C pfm_pebs_core_smpl_arg_t |
C pfm_pebs_core_smpl_entry_t |
C pfm_pebs_core_smpl_hdr_t |
C pfm_pebs_nhm_smpl_entry_t |
C pfm_pebs_p4_smpl_arg_t |
C pfm_pebs_p4_smpl_entry_t |
C pfm_pebs_p4_smpl_hdr_t |
C pfm_pebs_smpl_arg_t |
C pfm_pebs_smpl_hdr_t |
C PfmCodeAnalyser |
C pfmlib_amd64_counter_t |
C pfmlib_amd64_input_param_t |
C pfmlib_amd64_output_param_t |
C pfmlib_core_counter_t |
C pfmlib_core_input_param_t |
C pfmlib_core_output_param_t |
C pfmlib_core_pebs_t |
C pfmlib_coreduo_input_param_t |
C pfmlib_event_t |
C pfmlib_gen_ia32_counter_t |
C pfmlib_gen_ia32_input_param_t |
C pfmlib_gen_ia32_output_param_t |
C pfmlib_i386_p6_counter_t |
C pfmlib_i386_p6_input_param_t |
C pfmlib_i386_p6_output_param_t |
C pfmlib_input_param_t |
C pfmlib_intel_atom_counter_t |
C pfmlib_intel_atom_input_param_t |
C pfmlib_nhm_counter_t |
C pfmlib_nhm_input_param_t |
C pfmlib_nhm_lbr_t |
C pfmlib_nhm_pebs_t |
C pfmlib_options_t |
C pfmlib_output_param_t |
C pfmlib_reg_t |
C pfmlib_regmask_t |
C PipeReader |
C GaudiUtils::AllocatorPool::PoolChunk |
C PoolDbLinkManager | Description: PoolDbLinkManager class implementation definition
C PoolDbTokenWrap | Description:
C System::POOLED_USAGE_AND_LIMITS | Process Pooled Quota Usage and Limits NtQueryInformationProcess using ProcessPooledUsageAndLimits
C GaudiUtils::AllocatorPool::PoolLink |
C Gaudi::Parsers::Position |
C ROOT::Math::PositionVector3D< CoordSystem, Tag > |
C POSIXFileHandler |
C Gaudi::Parsers::PragmaOptions |
►C primitive_parser |
C boost::spirit::repository::qi::iter_pos_parser |
C GaudiAlg::Print | Collection of useful utilities to print IHistogram1D (currently used for implementation of class GaudiHistoAlg and class GaudiHistoTool)
C GaudiAlg::Print1D | Collection of useful utilities to print IHistogram1D (currently used for implementation of class GaudiHistoAlg and class GaudiHistoTool)
C GaudiAlg::Print1DProf | Collection of useful utilities to print IProfile1D (currently used for implementation of class GaudiHistoAlg and class GaudiHistoTool)
C GaudiAlg::Print2D | Collection of useful utilities to print IHistogram1D (currently used for implementation of class GaudiHistoAlg and class GaudiHistoTool)
C GaudiAlg::Print2DProf | Collection of useful utilities to print IProfile2D (currently used for implementation of class GaudiHistoAlg and class GaudiHistoTool)
C GaudiAlg::Print3D | Collection of useful utilities to print IHistogram1D (currently used for implementation of class GaudiHistoAlg and class GaudiHistoTool)
C GaudiPython::Printer< TYPE > |
C GaudiPython::Printer< ContainedObject > |
C GaudiPython::Printer< DataObject > |
C ICounterSvc::Printout | Print counters for each element in the range [first, last) e.g
C GaudiAlg::PrintStat | Collection of useful utilities to print StatEntity (currently used for implementation of class GaudiAlgorithm and class GaudiTool)
C GaudiAlg::PrintTuple | Collection of useful utilities to print INTuple object (currently used for implementation of class GaudiTupleAlg and class GaudiTupleTool)
C boost::threadpool::prio_scheduler< Task > | SchedulingPolicy which implements prioritized ordering
C boost::threadpool::prio_task_func | Prioritized task function object
C System::PROCESS_BASIC_INFORMATION |
C System::ProcessDescriptor | Provides access to process information
C System::ProcessDescriptor::ProcessHandle |
C System::ProcessTime | Simple class to hold the time information of a process
C procInfo |
C ProcStats |
►C Property | Property base class allowing Property* collections to be "homogeneous"
►C DataObjectHandleProperty | DataObjectHandleProperty.h GaudiKernel/DataObjectHandleProperty.h
C SimplePropertyRef< DataObjectHandleBase > |
►C DataObjIDCollProperty |
C SimplePropertyRef< DataObjIDColl > |
►C DataObjIDProperty | DataObjIDProperty.h GaudiKernel/DataObjProperty.h
C SimplePropertyRef< DataObjID > |
C GaudiHandleArrayProperty |
C GaudiHandleProperty |
C PropertyList | List of properties
►C PropertyWithValue< TYPE > | Helper intermediate class which represent partly implemented property with value of concrete type
►C PropertyWithVerifier< TYPE, VERIFIER > | Helper intermediate class which represent partly implemented property with value of concrete type and concrete verifier
C SimpleProperty< TYPE, VERIFIER > | SimpleProperty concrete class which implements the full Property interface
C SimplePropertyRef< TYPE, VERIFIER > | SimplePropertyRef templated class
►C PropertyWithValue< bool > |
►C PropertyWithVerifier< bool, BoundedVerifier< bool > > |
C SimpleProperty< bool > |
►C PropertyWithValue< double > |
►C PropertyWithVerifier< double, BoundedVerifier< double > > |
C SimpleProperty< double > |
►C PropertyWithValue< int > |
►C PropertyWithVerifier< int, BoundedVerifier< int > > |
C SimpleProperty< int > |
►C PropertyWithValue< std::string > |
►C PropertyWithVerifier< std::string, BoundedVerifier< std::string > > |
C SimpleProperty< std::string > |
►C PropertyWithValue< std::vector< std::string > > |
►C PropertyWithVerifier< std::vector< std::string >, BoundedVerifier< std::vector< std::string > > > |
C SimpleProperty< std::vector< std::string > > |
►C PropertyWithValue< unsigned int > |
►C PropertyWithVerifier< unsigned int, BoundedVerifier< unsigned int > > |
C SimpleProperty< unsigned int > |
C Gaudi::Parsers::Property |
C Gaudi::Parsers::PropertyName |
C Gaudi::Utils::PropertyTypeTraits< TYPE > | Helper structure to define the types for properties
C Gaudi::Utils::PropertyTypeTraits< boost::array< T, N > > | Specialization of property-traits for class boost::array to take care the non-trivial assignements and constructors for this class
C Gaudi::Utils::PropertyTypeTraits< char(&)[N]> | Specialisation for C-strings
C Gaudi::Utils::PropertyTypeTraits< const T(&)[N]> | Specialiation for const-arrays
C Gaudi::Utils::PropertyTypeTraits< std::array< T, N > > | Specialization of property-traits for class std::array to take care the non-trivial assignements and constructors for this class
►C Gaudi::Utils::PropertyTypeTraits< T(&)[N]> |
C Gaudi::Utils::PropertyTypeTraits< T[N]> | Specialization for arrays
C Gaudi::Parsers::PropertyValue |
►C PropertyVerifier< T > | Templated Verifier base class
C BoundedVerifier< T > |
C NullVerifier< T > | Default, always true verifier
►C PropertyVerifier< bool > |
C BoundedVerifier< bool > |
►C PropertyVerifier< double > |
C BoundedVerifier< double > |
►C PropertyVerifier< int > |
C BoundedVerifier< int > |
►C PropertyVerifier< std::string > |
C BoundedVerifier< std::string > |
►C PropertyVerifier< std::vector< std::string > > |
C BoundedVerifier< std::vector< std::string > > |
►C PropertyVerifier< T[N]> |
C BoundedVerifier< T[N]> | Specialization of Bounded verifier for for C-arrays
►C PropertyVerifier< unsigned int > |
C BoundedVerifier< unsigned int > |
C DataOnDemandSvc::Protection | Helper class of the DataOnDemandSvc
►C PyAlgorithm |
C AnalysisInit.PhysAnalAlg |
►C PyAlgorithm |
C Test.PhysAnalAlg |
C GaudiPython::CallbackStreamBuf::PyObject_t |
C GaudiMP::PyROOTPickle |
C PythonAdaptor |
C PythonConfig |
C IUpdateManagerSvc::PythonHelper | Helper class implemented in the python dictionary to allow access from python to template member functions
C System::QUOTA_LIMITS | Process Quotas NtQueryInformationProcess using ProcessQuotaLimits NtQueryInformationProcess using ProcessPooledQuotaLimits NtSetInformationProcess using ProcessQuotaLimits
C NTuple::Range< TYP > | Class defining a range
C NTuple::Range< bool > |
►C Gaudi::RangeBase_ | Helper class to simplify the dealing with ranges in Python
►C Gaudi::Range_< CONTAINER > | Useful class for representation of "sequence" of the objects through the range of valid iterators
C Gaudi::NamedRange_< TYPE > |
C Gaudi::Range_< TYPE > |
C GaudiUtils::Allocator< Type >::rebind< U > |
C GaudiRoot::RefAccessor |
C GaudiTesting.BaseTest.ReferenceFileValidator |
C GaudiTest.ReferenceFileValidator |
C Gaudi::PluginService::Details::Registry | In-memory database of the loaded factories
C boost::threadpool::resize_controller< Pool > | SizePolicyController which allows resizing
C Gaudi::Parsers::Pnt3DGrammar< Iterator, PointT, Skipper >::Operations::result< A, B, C, D > |
C Gaudi::Parsers::Pnt4DGrammar< Iterator, PointT, Skipper >::Operations::result< A, B, C, D > |
C Gaudi::Parsers::TupleInnerGrammar< Iterator, TupleT, 1, Skipper >::Operations::result< A, B, C, D > |
C Gaudi::Parsers::TupleInnerGrammar< Iterator, TupleT, N, Skipper >::Operations::result< A, B, C, D > |
C Gaudi::Parsers::MapGrammar< Iterator, MapT, Skipper >::Operations::result< A, B, C, D > |
C Gaudi::Parsers::Histo1DGrammar< Iterator, Skipper >::Operations::result< A, B, C, D > |
C Gaudi::Parsers::NodeOperations::result< A, B, C, D > |
C GaudiTesting.BaseTest.Result |
C RetCodeGuard | Helper class to set the application return code in case of early exit (e.g
C reverse_wrapper< Iterable > |
C RootHistCnv::RootCompressionSettings | Simple class to decode a ROOT compression settings string, of the form '<Alg>:<level>' into the integer code to pass to ROOT
C RootConnectionSet | Class describing the setup parameters of a ROOT data connection
C Gaudi::RootConnectionSetup |
C RootFileHandler |
C Gaudi::RootNTupleDescriptor | Description:
C Gaudi::RootObjectRefs | Persistent reference object containing all leafs and links corresponding to a Gaudi DataObject
C Gaudi::RootRef | Persistent reference object
►C RuntimeError |
C GaudiKernel.Configurable.Error |
C GaudiKernel.ProcessJobOptions.ParserError |
►C GaudiPython.Persistency.PersistencyError |
C GaudiPython.Persistency.UnknownPersistency |
C ZipPythonDir.ZipdirError | Class for generic exception coming from the zipdir() function
C S_module |
C ForwardSchedulerSvc::SchedulerState |
C StatusCode::ScopedDisableChecking | Simple RAII class to ignore unchecked StatusCode instances in a scope
C Gaudi::Parsers::KeyValueGrammar< Iterator, Skipper >::second |
C Gaudi::Parsers::PairGrammar< Iterator, PairT, Skipper >::second |
C select1st_t |
C Gaudi::SerialTaskQueue | Class for a generic serial queue of tasks (modeled on the Intel Threading Building Blocks Design Pattern "Local Serializer")
C Gaudi::SerialTaskQueue::SerialWorkItem | Wrapper for the WorkItem class for internal concurrency bookkeeping
C PersistencySvc::ServiceEntry |
C ServiceManager::ServiceItem |
C ServiceLocatorHelper | Helper to share the implementation of service() among the various kernel base classes
►C SmartDataObjectPtr | A small class used to access easily (and efficiently) data items residing in data stores
C SmartDataStorePtr< TYPE, LOADER > | A small class used to access easily (and efficiently) data items residing in data stores
►C SmartDataStorePtr< TYPE, SmartDataObjectPtr::ObjectLoader > |
C SmartDataLocator< TYPE > | A small class used to access easily (and efficiently) data items residing in data stores
C SmartDataPtr< TYPE > | A small class used to access easily (and efficiently) data items residing in data stores
C SmartIF< TYPE > | Small smart pointer class with automatic reference counting for IInterface
C SmartIF< DLLClassManager > |
C SmartIF< ForwardSchedulerSvc > |
C SmartIF< Gaudi::Gaudi::IIODataManager > |
C SmartIF< Gaudi::Gaudi::ISignalMonitor > |
C SmartIF< Gaudi::IFileCatalog > |
C SmartIF< IAddressCreator > |
C SmartIF< IAlgContextSvc > |
C SmartIF< IAlgManager > |
C SmartIF< IAlgorithm > |
C SmartIF< IAlgResourcePool > |
C SmartIF< IAppMgrUI > |
C SmartIF< IAuditor > |
C SmartIF< IAuditorSvc > |
C SmartIF< IChronoStatSvc > |
C SmartIF< IComponentManager > |
C SmartIF< IConversionSvc > |
C SmartIF< ICounterSummarySvc > |
C SmartIF< ICounterSvc > |
C SmartIF< IDataManagerSvc > |
C SmartIF< IDataProviderSvc > |
C SmartIF< IEventProcessor > |
C SmartIF< IEvtSelector > |
C SmartIF< IExceptionSvc > |
C SmartIF< IFileAccess > |
C SmartIF< IHistogramSvc > |
C SmartIF< IHiveWhiteBoard > |
C SmartIF< IIncidentListener > |
C SmartIF< IIncidentSvc > |
C SmartIF< IInterface > |
C SmartIF< IJobOptionsSvc > |
C SmartIF< IMessageSvc > |
C SmartIF< IMonitorSvc > |
C SmartIF< INamedInterface > |
C SmartIF< INTupleSvc > |
C SmartIF< IPartitionControl > |
C SmartIF< IProperty > |
C SmartIF< IRndmEngine > |
C SmartIF< IRndmGen > |
C SmartIF< IRndmGenSvc > |
C SmartIF< IRunable > |
C SmartIF< IScheduler > |
C SmartIF< ISelectStatement > |
C SmartIF< ISerialize > |
C SmartIF< IService > |
C SmartIF< IStateful > |
C SmartIF< IStatSvc > |
C SmartIF< ISvcLocator > |
C SmartIF< ISvcManager > |
C SmartIF< IThreadPoolSvc > |
C SmartIF< ITimelineSvc > |
C SmartIF< IToolSvc > |
C SmartIF< ParallelSequentialSchedulerSvc > |
C SmartIF< PropertyMgr > |
C SmartIF< Tuples::TupleObj > |
C SmartRef< TYPE > | Kernel objects: SmartRef
C SmartRef< ContainedObject > |
C SmartRef< DataObject > |
C SmartRef< Event > |
C SmartRef< KeyType > |
C SmartRef< MyTrack > |
C SmartRef< MyVertex > |
C SmartRefArray< TYPE > |
C SmartRefBase | User example objects: SmartRefBase
C SmartRefList< TYPE > |
C SmartRefMap< TYPE > |
C Genfun::GaudiMathImplementation::SplineBase |
C IntelProfilerAuditor::stack_entity |
C Stat | Small wrapper class for easy manipulation with generic counters and IStatSvc&ICounterSvc interface
C StatusCodeSvc::StatCodeDat |
C StatEntity | The basic counter used for Monitoring purposes
C Static_error_check< bool > |
C Static_error_check< false > |
C boost::threadpool::static_size< Pool > | SizePolicy which preserves the thread count
C StatusCode | This class is used for returning status codes from appropriate routines
C ana.Step |
C StreamBuffer | The stream buffer is a small object collecting object data
►C StreamHandler |
C GaudiKernel.ProcessJobOptions.ConsoleHandler |
C StreamLogger |
►C std::stringbuf [external] |
C GaudiPython::CallbackStreamBuf |
C Gaudi::StringKey | The helper class to represent the efficient "key" for access
►C Structure |
C GaudiPluginService.cpluginsvc.Factory |
C GaudiPluginService.cpluginsvc.Property |
C GaudiPluginService.cpluginsvc.Registry |
C ana.Summary |
C GaudiCommon_details::svc_eq_t |
C GaudiCommon_details::svc_lt_t |
C SvcCatalog |
C SvcFactory< T > |
C Gaudi::SysProcStat |
C Gaudi::Utils::Histos::Table | Simple class for the customizeble printout of the histogram tables
►C IInspector::Tag |
C IInspector::_TT< T > |
C Gaudi::Parsers::MapGrammar< Iterator, MapT, Skipper >::tag_key |
C Gaudi::Parsers::MapGrammar< Iterator, MapT, Skipper >::tag_mapped |
C MultiStoreSvc::tagROOT |
►C task |
C AlgoExecutionTask |
C Gaudi::SerialTaskQueue::SerialWorkItemRunner | Helper class to wrap a SerialWorkItem in a tbb::task
C HiveAlgoTask | dirty place for adding an AlgoTask wrapper
C SequentialTask |
C ThreadInitTask |
C TBMessageSvc | Extension to the standard MessageSvc that
►C TClassStreamer |
C GaudiRoot::IOHandler< T > |
C GaudiTest.TempDir |
C GaudiTest.TempFile |
C GaudiTest.TemporaryEnvironment | Utility Classes
C THistSvc::THistID |
C boost::threadpool::thread_pool< Task, SchedulingPolicy, SizePolicy, SizePolicyController, ShutdownPolicy > | Thread pool
C ThreadGaudi | Singleton mapping the pthread ID to the Gaudi thread ID
C Gaudi::Time | Based on seal::Time
C TimelineEvent |
C TimerForSequencer | Auxiliary class
C Gaudi::TimeSpan | Based on seal::TimeSpan
C Tuples::detail::to_< T > |
C Tuples::detail::to_float |
C pool::Token | Shadow class to mimik POOL tokens
►C Gaudi::RootDataConnection::Tool | Helper class to facilitate an abstraction layer for reading POOL style files with this package
C Gaudi::PoolTool |
C Gaudi::RootTool | Description:
C ToolFactory< T > |
►C ToolHandleInfo | General info and helper functions for toolhandles and arrays
►C BaseToolHandle | Non-templated base class for actual ToolHandle<T>
C ToolHandle< T > | Handle to be used in lieu of naked pointers to tools
C ToolHandle< IThreadInitTool > |
C ToolHandleArray< T > | Array of Handles to be used in lieu of vector of naked pointers to tools
C ToolHandleArray< IThreadInitTool > |
►C true_ |
C boost::spirit::use_terminal< qi::domain, repository::qi::tag::iter_pos > |
C Tuples::Tuple | A simple wrapper class over standard Gaudi NTuple::Tuple facility
C Gaudi::Parsers::tuple_get_first_type< T > |
C Gaudi::Parsers::tuple_get_first_type< std::tuple< T, Ts...> > |
C Gaudi::Parsers::tuple_remove_first_type< T > |
C Gaudi::Parsers::tuple_remove_first_type< std::tuple< T, Ts...> > |
C GaudiPython::TupleAlgDecorator | Simple class to perform the "decoration" of Tuples in Python/ROOT
C Tuples::TupleColumn< ITEM > | Helper class which allows to extend the functionality of Tuple with possibility to use your own representation of complex objects
C GaudiPython::TupleDecorator | Simple class which performs the decoration of the standard N-Tuple
C Tuples::TupleItem< ITEM > |
►C Tuples::TupleObj | A simple wrapper class over standard Gaudi NTuple::Tuple facility
C Tuples::detail::TupleObjImp< HANDLER1, HANDLER2 > | The simplest concrete implementation of class TupleObj with 3 arbitrary error handlers Any types (classes, functions, etc.) which supports the semantics
C Gaudi::Utils::TuplePrinter< Tuple, N > |
C Gaudi::Utils::TuplePrinter< Tuple, 1 > |
C GaudiPython::TupleToolDecorator | Simple class to perform the "decoration" of Tuples in Python/ROOT
►C type |
C GaudiKernel.ConfigurableMeta.ConfigurableMeta | This metaclass installs PropertyProxy descriptors for Gaudi properties
C Gaudi::Utils::TypeNameString | Helper class to parse a string of format "type/name"
C UCharDbArray | Shadow class to mimik POOL blobs
►C std::unary_function< const IInterface *, IInterface * > [external] |
C GaudiPython::Interface< IInterface > |
►C std::unary_function< const path &, bool > [external] |
C DirSearchPath::eqPath | Name
►C std::unary_function< const T *, std::size_t > [external] |
►C GaudiUtils::Hash< T * > | Partial specialization for pointers
C GaudiUtils::Hash< const T * > | Remove extra qualifiers:
►C std::unary_function< const T(&)[N], std::size_t > [external] |
C GaudiUtils::Hash< const T(&)[N]> | Generic specialization for arrays
►C std::unary_function< ParticleProperty *, bool > [external] |
C FindByMassRange | The function object must be derived from std::unary_function< IParticlePropertySvc::value_type ,bool > IParticlePropertySvc::value_type is a typedef that defines the internal service storage type that is returned when an iterator is dereferenced
►C std::unary_function< Property, bool > [external] |
C Gaudi::Parsers::Property::Equal |
►C std::unary_function< T(&)[N], std::size_t > [external] |
C GaudiUtils::Hash< T(&)[N]> | Generic specialization for arrays
►C std::unary_function< T, std::size_t > [external] |
C GaudiUtils::GenericHash< T > | Generic hash implementation (for easy migration to the new Hash class)
►C GaudiUtils::Hash< T > | Simple hash function
C GaudiUtils::Hash< const T & > | Remove extra qualifiers:
C GaudiUtils::Hash< const T > | Remove extra qualifiers:
C GaudiUtils::Hash< T & > | Remove extra qualifiers:
►C std::unary_function< TYPE, TYPE > [external] |
C GaudiPython::_identity< TYPE > | It is here due to 'missing'(?) std::identity
►C std::unary_function< WorkerEntry, bool > [external] |
C ConversionSvc::CnvTest |
C ProcStats::unique_fd |
C Gaudi::Parsers::Units |
C Gaudi::Parsers::NodeOperations::value |
C Containers::vector |
►C std::vector< SmartRef< MyTrack > > [external] |
C SmartRefVector< MyTrack > |
►C std::vector< SmartRef< TYPE > > [external] |
C SmartRefVector< TYPE > | Kernel objects: SmartRefVector
C Containers::vector< void * > |
C System::VM_COUNTERS | Process Virtual Memory Counters NtQueryInformationProcess using ProcessVmCounters
C implementation_detail::void_t< typename > |
C boost::threadpool::wait_for_active_tasks< Pool > | ShutdownPolicy which waits for the completion of all active tasks and the worker termination afterwards
C boost::threadpool::wait_for_all_tasks< Pool > | ShutdownPolicy which waits for the completion of all tasks and the worker termination afterwards
C WatchdogThread | Simple class for asynchronous check of time-out
C ConversionSvc::WorkerEntry |
►C Gaudi::SerialTaskQueue::WorkItem | Base class for the task to be executed by the serial queue
►C TBBMessageSvc::MessageTaskCommon | Common base class for the different reportMessage cases
C TBBMessageSvc::MessageWithLevel | Specialized class to report a message with explicit output level
C TBBMessageSvc::MessageWithoutLevel | Specialized class to report a message with implicit output level
C TBBMessageSvc::StatusCodeMessage | Specialized class to report a StatusCode message
►C BASE |
C extends< BASE, Interfaces > | Base class used to extend a class implementing other interfaces
►C ExecTestBase |
C GaudiTest.GaudiExeTest |
►C HTMLParser |
C validate_patch.SavannahParser | Parse the
►C IAnnotation |
C AIDA::Annotation | Implementation of the AIDA IAnnotation interface class
►C IHistogram2D |
C Gaudi::Generic2D< IHistogram2D, TH2D > |
►C INTERFACE |
C Gaudi::Generic1D< INTERFACE, IMPLEMENTATION > | Common AIDA implementation stuff for histograms and profiles using ROOT implementations
C Gaudi::Generic2D< INTERFACE, IMPLEMENTATION > | Common AIDA implementation stuff for histograms and profiles using ROOT implementations
C Gaudi::Generic3D< INTERFACE, IMPLEMENTATION > | Common AIDA implementation stuff for histograms and profiles using ROOT implementations
►C Is |
C Gaudi::meta::detail::inherit_from< Is > |
►C PBASE |
C GaudiCommon< PBASE > | Implements the common functionality between GaudiTools and GaudiAlgorithms
C GaudiHistos< PBASE > | Templated base class providing common histogramming methods for GaudiAlgorithm and GaudiTool like classes
C GaudiTuples< PBASE > | Templated base class providing common 'ntupling' methods
►C ResultStream |
C GaudiTest.HTMLResultStream |
C GaudiTest.XMLResultStream |