| C__longlong | |
| CNTuple::_Accessor< TYP > | Class acting as a smart pointer holding a N tuple entry |
| ►CNTuple::_Accessor< _Array< TYP > > | |
| CNTuple::Array< TYP > | Class acting as a smart pointer holding a N tuple _Item |
| ►CNTuple::_Accessor< _Item< bool > > | |
| CNTuple::Item< bool > | Specialization acting as a smart pointer holding a N tuple _Item |
| ►CNTuple::_Accessor< _Item< IOpaqueAddress * > > | |
| CNTuple::Item< IOpaqueAddress * > | |
| ►CNTuple::_Accessor< _Item< TYP > > | |
| CNTuple::Item< TYP > | Class acting as a smart pointer holding a N tuple _Item |
| ►CNTuple::_Accessor< _Item< VALUE > > | |
| CNTuple::Item< VALUE > | |
| ►CNTuple::_Accessor< _Matrix< TYP > > | |
| CNTuple::Matrix< TYP > | Class acting as a smart pointer holding a N tuple _Item |
| ►C_CallbackStreamBufBase | |
| CGaudiPython.Bindings.CallbackStreamBuf | |
| CGaudi::details::_container< CONTAINER, bool > | |
| CGaudi::details::_container< CONTAINER, false > | |
| CGaudi::details::_container< CONTAINER, true > | |
| CGenfun::GaudiMathImplementation::NumericalDefiniteIntegral::_Function | |
| CGenfun::GaudiMathImplementation::NumericalIndefiniteIntegral::_Function | |
| ►C_GaudiAlgorithm | |
| CGaudiPython.GaudiAlgs.GaudiAlgo | Base class for all algorithm Python-image of C++ clkass GaudiAlgorithm |
| ►C_GaudiHistoAlg | |
| CGaudiPython.GaudiAlgs.HistoAlgo | The base class for easy histogramming |
| ►C_GaudiTupleAlg | |
| CGaudiPython.GaudiAlgs.TupleAlgo | The base class for easy manupulations with N-Tuples |
| CGaudi::Utils::_GetType< TYPE > | Helper structure to define the proper return type for "get"-functions |
| CGaudi::Utils::_GetType< Gaudi::NamedRange_< CONTAINER > > | Template specialization for "named ranges" |
| CGaudi::Utils::_GetType< Gaudi::Range_< CONTAINER > > | Template specialization for "ranges" |
| CGaudi::Utils::_GetType< TYPE & > | Template specialization for references |
| CGaudi::Utils::_GetType< TYPE * > | Template specialization for pointers |
| CGaudi::details::_has_typename_container_< T > | |
| CKeyedContainer< DATATYPE, MAPPING >::_InsertRelease | Internal functor for insertion of objects |
| ►C_PyAlgorithm | |
| CGaudiPython.Bindings.PyAlgorithm | |
| CKeyedContainer< DATATYPE, MAPPING >::_RemoveRelease | Internal functor for insertion of objects |
| CGaudiKernel.ProcessJobOptions._TempSysPath | |
| CGenfun::GaudiMathImplementation::NumericalDefiniteIntegral::_Workspace | |
| CGenfun::GaudiMathImplementation::NumericalIndefiniteIntegral::_Workspace | |
| ►CAbsFunction | |
| CGenfun::GaudiMathImplementation::Adapter2DoubleFunction | Mandatory macro from CLHEP/GenericFunctions |
| CGenfun::GaudiMathImplementation::Adapter3DoubleFunction | Mandatory macro from CLHEP/GenericFunctions |
| CGenfun::GaudiMathImplementation::AdapterIFunction | Constructor from the IFunction ( see AIDA/IFunction.h) |
| CGenfun::GaudiMathImplementation::Constant | Fixed constant function |
| CGenfun::GaudiMathImplementation::GSLFunctionWithError | |
| CGenfun::GaudiMathImplementation::GSLFunctionWithMode | Mandatory macro from CLHEP/GenericFunctions |
| CGenfun::GaudiMathImplementation::GSLFunctionWithModeAndError | Mandatory macro from CLHEP/GenericFunctions |
| CGenfun::GaudiMathImplementation::GSLSpline | |
| CGenfun::GaudiMathImplementation::GSLSplineDeriv | |
| CGenfun::GaudiMathImplementation::GSLSplineDeriv2 | |
| CGenfun::GaudiMathImplementation::GSLSplineInteg | |
| CGenfun::GaudiMathImplementation::NumericalDefiniteIntegral | This class allows the numerical evaluation of the following functions: |
| CGenfun::GaudiMathImplementation::NumericalDerivative | Numerical derivative (using GSL adaptive numerical differentiation) |
| CGenfun::GaudiMathImplementation::NumericalIndefiniteIntegral | The simple class for numerical integrations |
| CGenfun::GaudiMathImplementation::SimpleFunction | Mandatory macro from CLHEP/GenericFunctions |
| ►Cadd_serviceLocator | |
| CCommonMessaging< BASE > | |
| ►CCommonMessaging< IExecutionFlowManager > | |
| Cconcurrency::ExecutionFlowManager | Manage the execution flow using a graph of task precedence rules Once initialized, the graph is const and can be shared across events |
| ►CCommonMessaging< implements< IAlgorithm, IDataHandleHolder, IProperty, IStateful > > | |
| ►CPropertyHolder< CommonMessaging< implements< IAlgorithm, IDataHandleHolder, IProperty, IStateful > > > | |
| ►Cextends< PropertyHolder< CommonMessaging< implements< IAlgorithm, IDataHandleHolder, IProperty, IStateful > > >, IDataHandleHolder > | |
| ►CDataHandleHolderBase< PropertyHolder< CommonMessaging< implements< IAlgorithm, IDataHandleHolder, IProperty, IStateful > > > > | |
| ►CAlgorithm | Base class from which all concrete algorithm classes should be derived |
| CCollectionCloneAlg | Small algorithm, which allows to merge N-tuples in a generic way |
| CEventCounter | |
| CEvtCollectionStream | A small to stream Data I/O |
| ►Cextends< Algorithm, IPartitionControl > | |
| CPartitionSwitchAlg | Small algorithm which switches the partition of a configurable multi-service |
| ►CGaudiCommon< Algorithm > | |
| ►CGaudiAlgorithm | The useful base class for data processing algorithms |
| CCallgrindProfile | Algorithm to enable/disable the profiling by Callgrind at given events |
| CContextEventCounterData | |
| CContextEventCounterPtr | |
| CCPUCruncher | A class that implements a search for prime numbers |
| CEventNodeKiller | Algorithm to kill nodes in the event data store |
| CGaudi::Hive::FetchDataFromFile | |
| ►CGaudiHistos< GaudiAlgorithm > | |
| ►CGaudiHistoAlg | Simple class to extend the functionality of class GaudiAlgorithm |
| ►CGaudiTuples< GaudiHistoAlg > | |
| CGaudiTupleAlg | Simple class to extend the functionality of class GaudiHistoAlg |
| CGaudiParallelizer | |
| CGaudiSequencer | Sequencer for executing several algorithms, stopping when one is faulty |
| CHiveReadAlgorithm | |
| CHiveTestAlgorithm | |
| CJemallocProfile | Algorithm to enable/disable the profiling of the head by Jemalloc |
| CPrescaler | |
| CRecordOutputStream | Simple class that adds an entry to the Transient Event Store to record that the processing flow triggered its execution |
| CReplayOutputStream | |
| ►CGaudiPython::PyAlgorithm | Python Algorithm base class |
| CGaudiMP.GMPBase.CollectHistograms | |
| CIncidentProcAlg | |
| ►COutputStream | A small to stream Data I/O |
| CInputCopyStream | Extension of OutputStream to copy the content of the main input file |
| CRecordStream | Extension of OutputStream to write run records after last event |
| CRunRecordStream | Extension of OutputStream to write run records after last event |
| CSequentialOutputStream | Extension of OutputStream to write run records after last event |
| CTagCollectionStream | Specialized output stream class for event tag collections, where the basic Event entry point should be placed as well into the collection itself |
| CSequencer | ClassName: Sequencer |
| CStoreExplorerAlg | Small algorith, which traverses the data store and prints generic information about all leaves, which can be loaded/accessed |
| CStoreSnifferAlg | Small algorithm, which traverses the data store and prints a summary of the leafs accessed during the run |
| ►CCommonMessaging< implements< IAlgTool, IDataHandleHolder, IProperty, IStateful > > | |
| ►CPropertyHolder< CommonMessaging< implements< IAlgTool, IDataHandleHolder, IProperty, IStateful > > > | |
| ►Cextends< PropertyHolder< CommonMessaging< implements< IAlgTool, IDataHandleHolder, IProperty, IStateful > > >, IDataHandleHolder > | |
| ►CDataHandleHolderBase< PropertyHolder< CommonMessaging< implements< IAlgTool, IDataHandleHolder, IProperty, IStateful > > > > | |
| ►CAlgTool | Base class from which all the concrete tool classes should be derived |
| ►Cextends< AlgTool, IDataStoreLeaves, IIncidentListener > | |
| CDataSvcFileEntriesTool | Tool to scan a transient store branch that collects all the objects that belong to the same source (file) |
| ►Cextends< AlgTool, IDataStreamTool > | |
| CDataStreamTool | |
| ►Cextends< AlgTool, IDODAlgMapper, IDODNodeMapper > | |
| CDODBasicMapper | Default implementation of a DataOnDemand mapper |
| ►Cextends< AlgTool, IFileAccess > | |
| CFileReadTool | Basic implementation of the IFileAccess interface |
| ►Cextends< AlgTool, IGslErrorHandler > | |
| CGslErrorCount | Concrete GSL error handler It is just counts number of GSL errors |
| CGslErrorException | Concrete GSL eror handler It is just thrown the exception |
| CGslErrorPrint | Concrete GSL eror handler It is just prints the GSL errors |
| ►Cextends< AlgTool, IPartitionControl > | |
| CPartitionSwitchTool | |
| ►CGaudiCommon< AlgTool > | |
| ►CGaudiTool | The useful base class for tools |
| CErrorTool | |
| ►Cextends< GaudiTool, IEqSolver > | |
| CEqSolver | The simplest concrete implementation of IEqSolver interface |
| ►Cextends< GaudiTool, IFuncMinimum > | |
| CFuncMinimum | The simplest concrete implementation of IFuncMinimum interface |
| ►CGaudiHistos< GaudiTool > | |
| ►CGaudiHistoTool | Simple class to extend the functionality of class GaudiTool |
| ►CGaudiTuples< GaudiHistoTool > | |
| ►CGaudiTupleTool | Simple class to extend the functionality of class GaudiHistoTool |
| CTupleTool | |
| CHistoTool | Simple tool for histogramming (component) |
| CSequencerTimerTool | Implements the time measurement inside a sequencer |
| ►CCommonMessaging< implements< IAppMgrUI, IEventProcessor, IService, IStateful, INamedInterface, IProperty > > | |
| ►CPropertyHolder< CommonMessaging< implements< IAppMgrUI, IEventProcessor, IService, IStateful, INamedInterface, IProperty > > > | |
| CApplicationMgr | The Application Manager class |
| ►CCommonMessaging< implements< IAuditor, IProperty > > | |
| ►CPropertyHolder< CommonMessaging< implements< IAuditor, IProperty > > > | |
| ►CAuditor | Base class from which all concrete auditor classes should be derived |
| CAlgContextAuditor | Description: Register/Unregister the AlgContext of each algorithm before entering the algorithm and after leaving it |
| CAlgErrorAuditor | Monitors the cpu time usage of each algorithm |
| ►CCommonAuditor | Base class with common functionalities shared by few auditor implementations |
| CChronoAuditor | Monitors the cpu time usage of each algorithm |
| ►CMemoryAuditor | Monitors the memory use of each algorithm |
| CMemStatAuditor | Just a minor modification of MemoryAuditor to allow the output memory statistics table to be printed |
| CNameAuditor | Prints the name of each algorithm before entering the algorithm and after leaving it |
| ►Cextends< Auditor, IIncidentListener > | |
| ►CGoogle::AuditorBase | Base for Google Auditors |
| CGoogle::CPUProfiler | Auditor using the Google CPU Profiler |
| CGoogle::HeapChecker | Auditor using the Google Heap Checker |
| CGoogle::HeapProfiler | Auditor based on the Google Heap Profiler |
| CIntelProfilerAuditor | |
| CTimingAuditor | Simple auditor which uses SequencerTimerTool for ALL algorithms, including the algorithm from main Gaudi "TopAlg" list and algorithms managed by Data-On-Demand Service |
| CPerfMonAuditor | Performance Monitoring Auditor that uses Perfmon2 library to monitor algorithms |
| ►CCommonMessaging< implements< IComponentManager > > | |
| ►CComponentManager | Base class for a component manager |
| ►Cextends< ComponentManager, IAlgManager > | |
| CAlgorithmManager | In charge of the creation of concrete instances of Algorithms |
| ►Cextends< ComponentManager, ISvcManager, ISvcLocator > | |
| CServiceManager | In charge of the creation of concrete instances of Services |
| ►CCommonMessaging< implements< IService, IProperty, IStateful > > | |
| ►CPropertyHolder< CommonMessaging< implements< IService, IProperty, IStateful > > > | |
| ►CService | Base class for all services |
| ►Cextends< Service, Gaudi::ISignalMonitor > | |
| CGaudi::Utils::SignalMonitorSvc | Implementation of Gaudi::ISignalMonitor |
| ►Cextends< Service, IAlgContextSvc, IIncidentListener > | |
| CAlgContextSvc | |
| ►Cextends< Service, IAlgExecStateSvc > | |
| CAlgExecStateSvc | A service that keeps track of the execution state of Algorithm
|
| ►Cextends< Service, IAlgResourcePool > | |
| CAlgResourcePool | The AlgResourcePool is a concrete implementation of the IAlgResourcePool interface |
| ►Cextends< Service, IAuditorSvc > | |
| CAuditorSvc | |
| ►Cextends< Service, IChronoStatSvc, IIncidentListener > | |
| CChronoStatSvc | The Chrono & Stat Sservice: service implements the IChronoStatSvc interface and provides the basic chronometry and some statistical counts needed by all applications |
| ►Cextends< Service, IConversionSvc, IAddressCreator > | |
| ►CConversionSvc | Base class for all conversion services |
| CGaudi::RootCnvSvc | Description: |
| CRootHistCnv::PersSvc | Persistency service - to store histograms in ROOT format |
| ►Cextends< Service, IConversionSvc, IPersistencySvc, IAddressCreator > | |
| ►CPersistencySvc | PersistencySvc class implementation definition |
| CDetPersistencySvc | |
| CEvtPersistencySvc | EvtPersistencySvc class implementation definition |
| CHistogramPersistencySvc | HistogramPersistencySvc class implementation definition |
| ►Cextends< Service, ICounterSvc > | |
| CCounterSvc | Simple implementation of the abstract interface ICounterSvc |
| ►Cextends< Service, IDataProviderSvc, IDataManagerSvc > | |
| ►CDataSvc | Data service base class |
| CEvtDataSvc | A EvtDataSvc is the base class for event services |
| ►Cextends< DataSvc, IHistogramSvc > | |
| CHistogramSvc | HistogramSvc class definition |
| ►Cextends< DataSvc, IIncidentListener > | |
| ►CRecordDataSvc | A RecordDataSvc is the base class for event services |
| CFileRecordDataSvc | A FileRecordDataSvc is the base class for event services |
| CRunRecordDataSvc | A RunRecordDataSvc is the base class for event services |
| ►Cextends< DataSvc, INTupleSvc, IDataSourceMgr > | |
| ►CNTupleSvc | NTuple service |
| CTagCollectionSvc | Gaudi tag collection service definition |
| ►CTsDataSvc | Data service base class |
| ►Cextends< TsDataSvc, IDetDataSvc, IIncidentListener > | |
| CDetDataSvc |
|
| ►Cextends< Service, IDataProviderSvc, IDataManagerSvc, IHiveWhiteBoard > | |
| CHiveWhiteBoard | Data service base class |
| ►Cextends< Service, IDataProviderSvc, IDataManagerSvc, IPartitionControl > | |
| CMultiStoreSvc | Data service base class |
| ►Cextends< Service, IEventProcessor > | |
| CHiveSlimEventLoopMgr | |
| ►CMinimalEventLoopMgr | This is the default processing manager of the application manager |
| CEventLoopMgr | Class definition of EventLoopMgr |
| ►Cextends< Service, IEvtSelector > | |
| CEventCollectionSelector | Definition of class EventCollectionSelector |
| CEventSelector | Definition of class EventSelector |
| CGaudi::RootEvtSelector | Concrete event selector implementation to access ROOT files |
| ►Cextends< Service, IExceptionSvc > | |
| CExceptionSvc | Simple implementation of IExceptionSvc abstract interface |
| ►Cextends< Service, IFileAccess > | |
| CVFSSvc | Simple service that allows to read files independently from the storage |
| ►Cextends< Service, IFileCatalog, IFileCatalogMgr > | |
| CGaudi::MultiFileCatalog | This class constitutes the core of the XML based FileCatalog API for using POOL within Gaudi |
| ►Cextends< Service, IFileMgr, IIncidentListener > | |
| CFileMgr | |
| ►Cextends< Service, IGslSvc > | |
| CGslSvc | The implementation of IGslSvc interface |
| ►Cextends< Service, IHistorySvc, IIncidentListener > | |
| CHistorySvc | HistorySvc class definition |
| ►Cextends< Service, IIncidentListener > | |
| CDataOnDemandSvc | The DataOnDemandSvc listens to incidents typically triggered by the data service of the configurable name "IncidentName" |
| CGaudi::RootPerfMonSvc | Description: |
| CGaudi::Utils::StopSignalHandler | Service that stop the processing if a signal is received |
| CJemallocProfileSvc | Service that enables the Jemalloc profiler on demand |
| CStalledEventMonitor | Service that monitor the time taken by processing of single events using a separate thread |
| ►Cextends< Service, IIncidentSvc > | |
| CIncidentSvc | Default implementation of the IIncidentSvc interface |
| ►Cextends< Service, IIoComponentMgr, IIncidentListener > | |
| CIoComponentMgr | |
| ►Cextends< Service, IIODataManager > | |
| CGaudi::IODataManager | |
| ►Cextends< Service, IIssueLogger > | |
| CIssueLogger | |
| ►Cextends< Service, IJobOptionsSvc > | |
| CJobOptionsSvc | |
| ►Cextends< Service, IMessageSvc, IInactiveMessageCounter > | |
| ►CMessageSvc | |
| CInertMessageSvc | Thread safe extension to the standard MessageSvc |
| CTBBMessageSvc | |
| ►Cextends< Service, IMetaDataSvc > | |
| CGaudi::MetaDataSvc | |
| ►Cextends< Service, IParticlePropertySvc > | |
| CGaudi::ParticlePropertySvc | This service provides access to particle properties |
| ►Cextends< Service, IPartPropSvc > | |
| CPartPropSvc | |
| ►Cextends< Service, IRndmEngine, ISerialize, IIncidentListener > | |
| ►CRndmEngine | Random Generator engine definition |
| ►CHepRndm::BaseEngine | |
| CHepRndm::Engine< TYPE > | |
| ►Cextends< Service, IRndmGenSvc, IRndmEngine, ISerialize > | |
| CRndmGenSvc | Random Generator service definition |
| ►Cextends< Service, IRunable > | |
| CAppMgrRunable | Class definition of AppMgrRunable |
| CPythonScriptingSvc | This service handles scripting implemented using Python |
| ►Cextends< Service, IScheduler > | |
| CAvalancheSchedulerSvc | Introduction
|
| CForwardSchedulerSvc | The SchedulerSvc implements the IScheduler interface |
| ►Cextends< Service, IStatusCodeSvc > | |
| CStatusCodeSvc | |
| ►Cextends< Service, ITHistSvc, IIncidentListener, IIoComponent > | |
| CTHistSvc | |
| ►Cextends< Service, IThreadPoolSvc > | |
| CThreadPoolSvc | A service which initializes a TBB thread pool |
| ►Cextends< Service, ITimelineSvc > | |
| CTimelineSvc | |
| ►Cextends< Service, IToolSvc > | |
| CToolSvc | This service manages tools |
| ►CCommonMessaging< IPrecedenceRulesGraph > | |
| Cconcurrency::PrecedenceRulesGraph | |
| CGaudi::Utils::Aida2ROOT | Accessor to underlying ROOT-representation of transient histograms The actual code is imported from Bender project |
| CAlgContexSvc | Simple implementation of interface IAlgContextSvc for Algorithm Context Service |
| CGaudi::Utils::AlgContext | Helper "sentry" class to automatize the safe register/unregister the algorithm's context |
| CGaudiPython::AlgDecorator | |
| CAlgExecState | |
| CAlgFactory< T > | |
| Cboost::AlgoNodeStruct | |
| ►CALGORITHM | |
| CGaudiPython::PyAlg< ALGORITHM > | General class to embed the existing algorithm/base class into the python |
| CGaudiSequencer::AlgorithmEntry | |
| CGaudiParallelizer::AlgorithmEntry | |
| CAlgorithmManager::AlgorithmItem | |
| ►CGaudi::Utils::AlgSelector | Simple interface class for selection of algorithms |
| CGaudi::Utils::AlgNameSelector | The trivial selector of algorithm by type |
| CGaudi::Utils::AlgTypeSelector< TYPE > | The trivial selector of algorithm by type |
| CAlgsExecutionStates | The AlgsExecutionStates encodes the state machine for the execution of algorithms within a single event |
| CGaudiUtils::Allocator< Type > | Allocator |
| CGaudiUtils::AllocatorPool | Allocator pool |
| CAIDA::Annotation::AnnotationItem | Internal private annotation item class |
| CGaudi::meta::detail::append1< List, I > | |
| ►CGaudi::meta::detail::appendN< typename, typename > | |
| CGaudi::interface_list_cat< interface_list< I... > > | |
| CGaudi::interface_list_cat< interface_list< I1... >, interface_list< I2... > > | |
| CGaudi::meta::detail::appendN< interface_list< I, Is... >, List > | |
| CGaudi::meta::detail::appendN< interface_list< Is... >, append1< List, I >::type > | |
| CContainers::array | |
| CNTuple::Array< IOpaqueAddress * > | |
| CGaudi::Utils::AttribStringParser::Attrib | Simple class to wrap tag/value pairs |
| CGaudi::Utils::AttribStringParser | Parse attribute strings allowing iteration over the various attributes |
| Cboost::spirit::repository::qi::iter_pos_parser::attribute< Context, Iterator > | |
| CAudFactory< T > | |
| CGaudi::Guards::AuditorGuard | It is a simple guard, which "locks" the scope for the Auditor Service is am exception-safe way |
| ►CBaseClass_t | |
| ►CGaudi::Functional::details::DataHandleMixin< std::tuple< Out... >, std::tuple< In... >, Traits_ > | |
| ►CGaudi::Functional::MultiTransformer< std::tuple< Out... >(const In &...), Traits_ > | |
| CGaudi::Functional::MultiScalarTransformer< ScalarOp, std::tuple< Out... >(const In &...), Traits_ > | |
| CGaudi::Functional::MultiTransformerFilter< std::tuple< Out... >(const In &...), Traits_ > | |
| ►CGaudi::Functional::details::DataHandleMixin< std::tuple< Out... >, void, Traits_ > | |
| CGaudi::Functional::Producer< std::tuple< Out... >(), Traits_ > | |
| ►CGaudi::Functional::details::DataHandleMixin< void, std::tuple< In... >, Traits_ > | |
| CGaudi::Functional::Consumer< void(const In &...), Traits_ > | |
| CGaudi::Functional::FilterPredicate< bool(const In &...), Traits_ > | |
| CGaudi::Functional::SplittingTransformer< vector_of_< Out >(const In &...), Traits_ > | |
| CGaudi::Functional::Traits::BaseClass_t< Base > | |
| ►CBaseObjectMemberFunction | Base class of ObjectMemberFunction |
| CObjectMemberFunction< 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 |
| ►CBasePtrSetter | Base class to set the pointer to an object of a class derived from DataObject in a generic way |
| CIUpdateManagerSvc::PtrSetter< ActualType > | Templated specialization of BasePtrSetter |
| CGaudiTesting.BaseTest.BasicOutputValidator | |
| CGaudiTest.BasicOutputValidator | Output Validation Classes |
| ►Cstd::binary_function< double, double, bool > [external] | |
| CGaudi::Math::Lomont< double > | Specialization for double numbers |
| ►Cstd::binary_function< float, float, bool > [external] | |
| CGaudi::Math::Lomont< float > | Specialization for float numbers |
| ►Cstd::binary_function< Property, Property, bool > [external] | |
| CGaudi::Parsers::Property::LessThen | |
| CGaudi::Details::Property::BoundedVerifier< TYPE > | |
| CFileInfo::CacheItem | |
| CFileInfo::CacheItemComparator | |
| CROOT::Math::Cartesian3D< T > | |
| CGaudi::Parsers::Catalog | |
| Ccgaudi_factory_t | |
| Ccgaudi_pluginsvc_t | |
| Ccgaudi_property_t | |
| ►CGaudi::Utils::CheckData< TYPE > | Helper structure for implementation of "exists"-functions for GaudiCommon<BASE> |
| CGaudi::Utils::CheckData< const TYPE > | Template specialization for 'const'-type |
| CGaudi::Utils::CheckData< TYPE & > | Template specialization for reference types |
| CGaudi::Utils::CheckData< TYPE * > | Template specialization for pointer types |
| ►CGaudi::Utils::CheckData< Gaudi::Range_< std::vector< const TYPE * > > > | Template specialization for ranges |
| CGaudi::Utils::CheckData< Gaudi::NamedRange_< std::vector< const TYPE * > > > | Template specialization for ranges |
| CChrono | A small utility class for chronometry of user codes |
| CChronoEntity | Small helper class for implementation of ChronoStatSvc service, It also could be used as some local timer |
| ►CCLASS | |
| CRootHistCnv::RHistogramCnv< T, S, Q >::TTH< CLASS > | |
| CProcStats::cleanup | |
| CCLibSymbolInfo | |
| CGaudiTest.CMT | |
| CCnvFactory< T > | |
| ►CCommonMessagingBase | |
| CCommonMessaging< BASE > | |
| CCommonMessaging< IExecutionFlowManager > | |
| CCommonMessaging< implements< IAlgorithm, IDataHandleHolder, IProperty, IStateful > > | |
| CCommonMessaging< implements< IAlgTool, IDataHandleHolder, IProperty, IStateful > > | |
| CCommonMessaging< implements< IAppMgrUI, IEventProcessor, IService, IStateful, INamedInterface, IProperty > > | |
| CCommonMessaging< implements< IAuditor, IProperty > > | |
| CCommonMessaging< implements< IComponentManager > > | |
| CCommonMessaging< implements< IService, IProperty, IStateful > > | |
| CCommonMessaging< IPrecedenceRulesGraph > | |
| CCompareFirstOfPointerPair_t | |
| CGaudi::Concurrency::ConcurrencyFlags | |
| CConcurrencyFlags | Provides information about the level of concurrency of the currently executing job |
| CconfigGenerator | |
| CNTupleSvc::Connection | |
| CConst_int_t< n > | |
| CConst_uint_t< n > | |
| CLockedHandle< T, MutexType >::ConstGuard | |
| CGaudi::Functional::Consumer< Signature, Traits_ > | |
| CStreamBuffer::ContainedLink | Definition of the contained link set |
| ►CContainedObject | All classes that their objects may be contained in an LHCb ObjectContainer (e.g |
| CKeyedObject< KEY > | Definition of the templated KeyedObject class |
| CGaudi::details::container< CONTAINER > | Helper structure to get container type |
| CGaudi::RootDataConnection::ContainerSection | Internal helper class, which described a TBranch section in a ROOT file |
| ►CIEvtSelector::Context | |
| CEventCollectionContext | |
| CEventCollectionSelector::MyContextType | |
| CEvtSelectorContext | Definition of class EventIterator |
| CGaudi::RootEvtSelectorContext | ROOT specific event selector context |
| CContextEventCounter | |
| CGaudi::Hive::ContextSpecificData< T > | Implementation of a context specific storage accessible as a sort of smart reference class |
| CGaudi::Hive::ContextSpecificData< int > | |
| CGaudi::Hive::ContextSpecificPtr< T > | Simple implementation of a smart pointer with different values for different event contexts (slots) |
| CGaudi::Hive::ContextSpecificPtr< int > | |
| ►Cconcurrency::ControlFlowNode | |
| Cconcurrency::AlgorithmNode | |
| Cconcurrency::DecisionNode | |
| ►CControlFlowNode | |
| CGaudiKernel.Configurable.SuperAlgorithm | |
| CConverterID | |
| CGaudiToolLocal::Counter | Simple local counter |
| CTuples::Local::Counter | |
| CIgHookTrace::Counter | Nearly dummy object type to identify a counter |
| CIgHookTrace::CounterValue | Value for a counter chained from a trace |
| CCTest | |
| Chivetimeline.Data | |
| CDataFlowManager | The DataFlowManager takes care of keeping track of the dependencies of the algorithms in terms of dataObjects |
| ►CGaudi::DataHandle | |
| ►CDataObjectHandleBase | DataObjectHandleBase GaudiKernel/DataObjectHandleBase.h |
| CDataObjectHandle< T > | DataObjectHandle.h GaudiKernel/DataObjectHandle.h |
| ►CDataObjectHandle< AnyDataWrapper< T > > | |
| CAnyDataHandle< T > | |
| CDataObjectHandle< DataObject > | |
| ►CGaudi::Functional::details::DataHandleMixin< OutputSpec, InputSpec, Traits_ > | |
| CGaudi::Functional::Producer< Out(), Traits_ > | |
| ►CGaudi::Functional::Transformer< Out(const In &...), Traits_ > | |
| CGaudi::Functional::ScalarTransformer< ScalarOp, Out(const In &...), Traits_ > | |
| CGaudi::Functional::details::DataHandleMixin< std::tuple< Out >, std::tuple< In... >, Traits_ > | |
| CGaudi::Functional::details::DataHandleMixin< std::tuple< Out >, void, Traits_ > | |
| CDataHistory::DataHistoryOrder | |
| CDataIncident | Data service incident class |
| ►CStreamBuffer::DataIO | A small base class to handle generic data streaming |
| CStreamBuffer::Istream | Reader for standard input streams |
| CStreamBuffer::Ostream | Writer for standard output streams |
| CNTuple::DataItem< TYP > | |
| Cconcurrency::DataNode | |
| ►CDataObject | A DataObject is the base class of any identifiable object on any data store |
| ►CAnyDataWrapperBase | |
| CAnyDataWrapper< T > | |
| CGaudi::Histogram1D | AIDA implementation for 1 D histograms using ROOT THD1 |
| CGaudi::Histogram2D | AIDA implementation for 2 D histograms using ROOT THD2 |
| CGaudi::Histogram3D | AIDA implementation for 3 D histograms using ROOT THD2 |
| CGaudi::Profile1D | AIDA implementation for 1 D profiles using ROOT TProfile |
| CGaudi::Profile2D | AIDA implementation for 2 D profiles using ROOT TProfile2D |
| ►CHistoryObj | Base class for History Objects |
| CAlgorithmHistory | AlgorithmHistory class definition |
| CAlgToolHistory | AlgToolHistory class definition |
| CDataHistory | DataHistory class definition |
| CJobHistory | JobHistory class definition |
| CServiceHistory | ServiceHistory class definition |
| CMyObject | |
| ►CNTuple::Directory | Small class representing an N tuple directory in the transient store |
| CNTuple::File | Small class representing an N tuple file in the transient store |
| ►CNTuple::Tuple | Abstract base class which allows the user to interact with the actual N tuple implementation |
| ►CNTuple::TupleImp | |
| CNTuple::ColumnWiseTuple | |
| CNTuple::RowWiseTuple | |
| ►CObjectContainerBase | ObjectContainerBase is the base class for Gaudi container classes |
| CKeyedContainer< DATATYPE, MAPPING > | Template class KeyedContainer, KeyedContainer.h |
| CObjectList< TYPE > | ObjectList is one of the basic Gaudi container classes capable of being registered in Data Stores |
| CObjectVector< TYPE > | ObjectVector is one of the basic Gaudi container classes capable of being registered in Data Stores |
| CSharedObjectsContainer< TYPE > | Very simple class to represent the container of objects which are not owned by this container |
| CRefTableBase< FROM, MAPENTRY > | Template <class FROM, class TO, class MAPENTRY> class RefTable |
| ►CRefTableBase< FROM, SmartRef< TO > > | |
| CRefTable1to1< FROM, TO > | |
| ►CRefTableBase< FROM, SmartRefVector< TO > > | |
| CRefTable1toN< FROM, TO > | |
| CDataObjID | |
| CDataObjID_Hasher | |
| CDataStoreItem | Description of the DataStoreItem class |
| CDataTypeInfo | Small class which allows access to internal type IDs |
| CDecorator | Simple class with allows to "decorate" the python algorithm with 'basic' funtionality from class GaudiAlgorithm |
| CContainers::array::decrement | |
| CGaudiKernel.Configurable.Configurable.DefaultName | For detecting the default name |
| CGaudi::Functional::details::deref_t | |
| CGaudi::Functional::details::detail2::detector< Default, AlwaysVoid, Op, Args > | Implementation of the detection idiom (negative case) |
| CGaudi::Functional::details::detail2::detector< Default, void_t< Op< Args... > >, Op, Args... > | Implementation of the detection idiom (positive case) |
| CDHH | |
| ►Cdict | |
| CGaudiKernel.ConfigurableDb._CfgDb | |
| CGaudiMP.FdsRegistry.FdsDict | |
| CGaudiProfiling.GenerateGaudiOpts.XmlDictObject | |
| CDirSearchPath | Search for files in a list of directories |
| CROOT::Math::DisplacementVector3D< CoordSystem, Tag > | |
| Cboost::threadpool::empty_controller< Pool > | SizePolicyController which provides no functionality |
| ►Cenable_shared_from_this | |
| Cboost::threadpool::detail::pool_core< Task, SchedulingPolicy, SizePolicy, SizePolicyController, ShutdownPolicy > | Thread pool |
| Cboost::threadpool::detail::worker_thread< Pool > | Thread pool worker |
| CGaudi::IODataManager::Entry | |
| CEqSolver::EqSolverMisc | |
| CTuples::detail::ErrorHandler< OBJECT, FUNCTION > | Concrete error handlers for dealing with classes, which supports member functions Error,Warning and Print ( e.g |
| CEventContext | This class represents an entry point to all the event specific data |
| CEventContextHash | Hash from EventContext so EvenContexts can be used as keys in unordered maps |
| CEventIDBase | This class provides a unique identification for each event, in terms of run/event number and/or a time stamp |
| CEventIDRange | Event ID Range object |
| CEventIterator< TYPE > | |
| CEventSchedulingState | |
| CEventSlot | Class representing the event slot |
| ►Cstd::exception [external] | STL class |
| CGaudi::PluginService::Exception | |
| ►CGaudiException | Define general base for Gaudi exception |
| CTimeException | Exception thrown by Gaudi::Time |
| CUpdateManagerException | Exception thrown by the UpdateManagerSvc when something goes wrong |
| ►Cstd::runtime_error [external] | STL class |
| CGaudi::Parsers::PositionalPropertyValueException | |
| CGaudi::Parsers::PropertyValueException | |
| CGaudi::Guards::ExceptionGuard | The most simple guard - it execute the certain code withing typical "try {} catch" clause, used in Auditor, Algorithm, AlgTool, etc |
| CGaudi::PluginService::Details::Factory< T > | Class providing default factory functions |
| CGaudi::PluginService::Factory< R, Args > | Class wrapping the signature for a factory with any number of arguments |
| CGaudi::PluginService::Details::Registry::FactoryInfo | |
| ►Cstd::false_type [external] | |
| CGaudi::Functional::details::is_optional< T > | |
| Cboost::threadpool::fifo_scheduler< Task > | SchedulingPolicy which implements FIFO ordering |
| CIo::FileAttr | |
| CIo::FileHdlr | |
| CFileInfo | |
| ►CGaudiTesting.BaseTest.FilePreprocessor | |
| CGaudiTesting.BaseTest.BlockSkipper | |
| CGaudiTesting.BaseTest.FilePreprocessorSequence | |
| CGaudiTesting.BaseTest.LineSkipper | |
| CGaudiTesting.BaseTest.LineSorter | Special preprocessor sorting the list of strings (whitespace separated) that follow a signature on a single line |
| CGaudiTesting.BaseTest.RegexpReplacer | |
| CGaudiTesting.BaseTest.SortGroupOfLines | |
| ►CGaudiTest.FilePreprocessor | |
| CGaudiTest.BlockSkipper | |
| CGaudiTest.FilePreprocessorSequence | |
| CGaudiTest.LineSkipper | |
| CGaudiTest.LineSorter | Special preprocessor sorting the list of strings (whitespace separated) that follow a signature on a single line |
| CGaudiTest.RegexpReplacer | |
| CGaudiMP.pTools.FileRecordsAgent | |
| ►CFilter | |
| CGaudiTest.GaudiFilterExecutable | |
| ►CFilter | |
| CGaudiKernel.ProcessJobOptions.LogFilter | |
| CGaudi::Functional::FilterPredicate< T, Traits_ > | |
| Cfinal_action< F > | |
| CContainers::find< CONT > | |
| CGaudi::Parsers::PairGrammar< Iterator, PairT, Skipper >::first | |
| CGaudi::Parsers::KeyValueGrammar< Iterator, Skipper >::first | |
| ►CFormatter | |
| CGaudiKernel.ProcessJobOptions.LogFormatter | |
| CGaudi::fullMatch_t | |
| CFuncMinimum::FuncMinimumMisc | |
| Cboost::threadpool::future< Result > | Experimental |
| Cboost::threadpool::detail::future_impl< Result > | |
| Cboost::threadpool::detail::future_impl_task_func< Future, Function > | |
| CGaudi | This is a number of static methods for bootstrapping the Gaudi framework |
| CGaudiDll | |
| CGaudiGSL | Helper class to get (static) access to Gaudi GSL Service General users are not supposed to use it |
| ►CGaudiHandleInfo | |
| ►CGaudiHandleArrayBase | Base class of array's of various gaudihandles |
| CGaudiHandleArray< T > | T is the concrete handle type, e.g |
| ►CGaudiHandleArray< ServiceHandle< T > > | |
| CServiceHandleArray< T > | Array of Handles to be used in lieu of vector of naked pointers to tools |
| ►CGaudiHandleArray< ToolHandle< IThreadInitTool > > | |
| CToolHandleArray< IThreadInitTool > | |
| ►CGaudiHandleArray< ToolHandle< T > > | |
| CToolHandleArray< T > | Array of Handles to be used in lieu of vector of naked pointers to tools |
| ►CGaudiHandleBase | Base class to handles to be used in lieu of naked pointers to various Gaudi components |
| ►CGaudiHandle< T > | Handle to be used in lieu of naked pointers to gaudis |
| CServiceHandle< T > | Handle to be used in lieu of naked pointers to services |
| CToolHandle< T > | Handle to be used in lieu of naked pointers to tools |
| ►CGaudiHandle< IThreadInitTool > | |
| CToolHandle< IThreadInitTool > | |
| ►CGaudiHandle< IToolSvc > | |
| CServiceHandle< IToolSvc > | |
| CRndm::Generator< TYPE > | |
| CGaudi::Functional::details::details2::get_from_handle< In > | |
| ►CGaudi::Utils::GetData< TYPE > | Helper structure for implementation of "get"-functions for GaudiCommon<BASE> |
| CGaudi::Utils::GetData< const TYPE > | Template specialization for const types |
| CGaudi::Utils::GetData< TYPE & > | Template specialization for reference types |
| CGaudi::Utils::GetData< TYPE * > | Template specialization for pointer types |
| CGaudi::Utils::GetData< Gaudi::Gaudi::Range_< std::vector< const TYPE * > > > | |
| CGaudi::Utils::GetData< Gaudi::NamedRange_< std::vector< const TYPE * > > > | Template specialization for named ranges |
| CGaudi::Utils::GetData< Gaudi::Range_< std::vector< const TYPE * > > > | Template specialization for ranges |
| CGaudi::Utils::GetData< Range > | |
| ►CGaudi::Utils::GetOrCreateData< TYPE, TYPE2 > | Helper structure for implementation of "getOrCreate"-functions for GaudiCommon<BASE> |
| CGaudi::Utils::GetOrCreateData< TYPE, const TYPE2 > | |
| CGaudi::Utils::GetOrCreateData< const TYPE, TYPE2 > | |
| CGaudi::Utils::GetOrCreateData< const TYPE, const TYPE2 > | |
| CGaudi::Utils::GetOrCreateData< TYPE &, TYPE2 & > | |
| CGaudi::Utils::GetOrCreateData< TYPE &, TYPE2 > | |
| CGaudi::Utils::GetOrCreateData< TYPE *, TYPE2 * > | |
| CGaudi::Utils::GetOrCreateData< TYPE *, TYPE2 > | |
| CGaudi::Utils::GetOrCreateData< TYPE, TYPE2 & > | |
| CGaudi::Utils::GetOrCreateData< TYPE, TYPE2 * > | |
| CGaudi::Utils::GetOrCreateData< Gaudi::NamedRange_< std::vector< const TYPE * > >, TYPE2 > | |
| CGaudi::Utils::GetOrCreateData< Gaudi::Range_< std::vector< const TYPE * > >, TYPE2 > | |
| CGaudi::Utils::GetOrCreateData< Range_, TYPE2 > | |
| CTHistSvc::GlobalDirectoryRestore | |
| CGlobalDirectoryRestore | |
| ►Cgrammar | |
| CGaudi::Parsers::BoolGrammar< Iterator, Gaudi::Parsers::SkipperGrammar > | |
| CGaudi::Parsers::BoolGrammar< Iterator, Gaudi::Parsers::SkipperGrammar > | |
| CGaudi::Parsers::EdgeGrammar< Iterator, Gaudi::Parsers::SkipperGrammar > | |
| CGaudi::Parsers::BoolGrammar< Iterator, Skipper > | |
| CGaudi::Parsers::BoolGrammar< Iterator, Skipper > | |
| CGaudi::Parsers::CharGrammar< Iterator, Skipper > | |
| CGaudi::Parsers::EdgeGrammar< Iterator, Skipper > | |
| CGaudi::Parsers::FileGrammar< Iterator, Skipper > | |
| CGaudi::Parsers::H1Grammar< Iterator, Skipper > | |
| CGaudi::Parsers::H2Grammar< Iterator, Skipper > | |
| CGaudi::Parsers::Histo1DGrammar< Iterator, Skipper > | |
| CGaudi::Parsers::IdentifierGrammar< Iterator, Skipper > | |
| CGaudi::Parsers::IntGrammar< Iterator, RT, Skipper > | |
| CGaudi::Parsers::KeyValueGrammar< Iterator, Skipper > | |
| CGaudi::Parsers::MapGrammar< Iterator, MapT, Skipper > | |
| CGaudi::Parsers::PairGrammar< Iterator, PairT, Skipper > | |
| CGaudi::Parsers::Pnt3DGrammar< Iterator, PointT, Skipper > | |
| CGaudi::Parsers::Pnt4DGrammar< Iterator, PointT, Skipper > | |
| CGaudi::Parsers::RealGrammar< Iterator, Skipper > | |
| CGaudi::Parsers::RealGrammar< Iterator, Skipper > | |
| CGaudi::Parsers::SkipperGrammar< Iterator > | |
| CGaudi::Parsers::SkipperGrammar< Iterator > | |
| CGaudi::Parsers::StringGrammar< Iterator, Skipper > | |
| CGaudi::Parsers::StringGrammar< Iterator, Skipper > | |
| CGaudi::Parsers::TupleGrammar< Iterator, TupleT, N, Skipper > | |
| CGaudi::Parsers::TupleInnerGrammar< Iterator, TupleT, N, Skipper > | |
| CGaudi::Parsers::TupleInnerGrammar< Iterator, TupleT, 1, Skipper > | |
| CGaudi::Parsers::UnitsGrammar< Iterator, Skipper > | |
| CGaudi::Parsers::VectorGrammar< Iterator, VectorT, Skipper > | |
| CGaudi::Parsers::IdentifierGrammar< Iterator, double > | |
| CGaudi::Parsers::IdentifierGrammar< Iterator, Gaudi::Parsers::SkipperGrammar > | |
| CGaudi::Parsers::IntGrammar< Iterator, unsigned int, Gaudi::Parsers::SkipperGrammar > | |
| CGaudi::Parsers::IntGrammar< Iterator, unsigned int, Skipper > | |
| CGaudi::Parsers::RealGrammar< Iterator, double, Gaudi::Parsers::SkipperGrammar > | |
| CGaudi::Parsers::RealGrammar< Iterator, double, Gaudi::Parsers::SkipperGrammar > | |
| CGaudi::Parsers::RealGrammar< Iterator, double, Skipper > | |
| CGaudi::Parsers::RealGrammar< Iterator, double, Skipper > | |
| CGaudi::Parsers::RealGrammar< Iterator, Gaudi::Parsers::SkipperGrammar > | |
| CGaudi::Parsers::RealGrammar< Iterator, Gaudi::Parsers::SkipperGrammar > | |
| CGaudi::Parsers::StringGrammar< Iterator, Gaudi::Parsers::SkipperGrammar > | |
| CGaudi::Parsers::StringGrammar< Iterator, Gaudi::Parsers::SkipperGrammar > | |
| CGaudi::Parsers::TupleInnerGrammar< Iterator, TupleT, N, Gaudi::Parsers::SkipperGrammar > | |
| CGaudi::Parsers::VectorGrammar< Iterator, std::vector< double >, Gaudi::Parsers::SkipperGrammar > | |
| CGaudi::Parsers::VectorGrammar< Iterator, std::vector< double >, Skipper > | |
| CGaudi::Parsers::VectorGrammar< Iterator, std::vector< std::pair< double, double > >, Gaudi::Parsers::SkipperGrammar > | |
| CGaudi::Parsers::Grammar_< Iterator, T, Skipper, Enable > | |
| CGaudi::Parsers::Grammar_< Iterator, GaudiUtils::VectorMap< KeyT, ValueT, KeyCompareT, AllocatorT >, Skipper > | |
| CGaudi::Parsers::Grammar_< Iterator, HeadT, Gaudi::Parsers::SkipperGrammar > | |
| CGaudi::Parsers::Grammar_< Iterator, HeadT, Skipper > | |
| CGaudi::Parsers::Grammar_< Iterator, ROOT::Math::DisplacementVector3D< T1, T2 >, Skipper > | |
| CGaudi::Parsers::Grammar_< Iterator, ROOT::Math::LorentzVector< T1 >, Skipper > | |
| CGaudi::Parsers::Grammar_< Iterator, ROOT::Math::PositionVector3D< T1, T2 >, Skipper > | |
| CGaudi::Parsers::Grammar_< Iterator, Scalar, Gaudi::Parsers::SkipperGrammar > | |
| CGaudi::Parsers::Grammar_< Iterator, ScalarT, Gaudi::Parsers::SkipperGrammar > | |
| CGaudi::Parsers::Grammar_< Iterator, std::list< InnerT, AllocatorT >, Skipper > | |
| CGaudi::Parsers::Grammar_< Iterator, std::map< KeyT, ValueT, KeyCompareT, AllocatorT >, Skipper > | |
| CGaudi::Parsers::Grammar_< Iterator, std::pair< KeyT, ValueT >, Skipper > | |
| CGaudi::Parsers::Grammar_< Iterator, std::set< InnerT, CompareT, AllocatorT >, Skipper > | |
| CGaudi::Parsers::Grammar_< Iterator, std::tuple< Args... >, Skipper > | |
| CGaudi::Parsers::Grammar_< Iterator, std::vector< InnerT, AllocatorT >, Skipper > | |
| CGaudi::Parsers::Grammar_< Iterator, T, Skipper, typename boost::enable_if< boost::is_floating_point< T > >::type > | |
| CGaudi::Parsers::Grammar_< Iterator, T, Skipper, typename boost::enable_if< boost::is_integral< T > >::type > | |
| CGaudi::Parsers::Grammar_< Iterator, typename MapT::key_type, Gaudi::Parsers::SkipperGrammar > | |
| CGaudi::Parsers::Grammar_< Iterator, typename MapT::mapped_type, Gaudi::Parsers::SkipperGrammar > | |
| CGaudi::Parsers::Grammar_< Iterator, typename PairT::first_type, Gaudi::Parsers::SkipperGrammar > | |
| CGaudi::Parsers::Grammar_< Iterator, typename PairT::second_type, Gaudi::Parsers::SkipperGrammar > | |
| CGaudi::Parsers::Grammar_< Iterator, typename std::tuple_element< 0, ResultT >::type, Gaudi::Parsers::SkipperGrammar > | |
| CGaudi::Parsers::Grammar_< Iterator, typename std::vector< double >::value_type, Gaudi::Parsers::SkipperGrammar > | |
| CGaudi::Parsers::Grammar_< Iterator, typename std::vector< double >::value_type, Skipper > | |
| CGaudi::Parsers::Grammar_< Iterator, typename std::vector< std::pair< double, double > >::value_type, Gaudi::Parsers::SkipperGrammar > | |
| CGaudi::Parsers::Grammar_< Iterator, typename VectorT::value_type, Skipper > | |
| CGenfun::GaudiMathImplementation::GSL_Helper | Simple structure to be used for adaption interface Genfun::AbsFunction to gsl_function structure |
| CGenfun::GaudiMathImplementation::NumericalDefiniteIntegral::gsl_ws_deleter | |
| CGenfun::GaudiMathImplementation::NumericalIndefiniteIntegral::gsl_ws_deleter | |
| CGslError | Helper class to represent GSL errors |
| CLockedHandle< T, MutexType >::Guard | |
| Cpool::Guid | |
| Cstd::hash< Gaudi::StringKey > | Specialization of hash function used in C++11 collections like std::unordered_map |
| CContainers::hashmap | |
| CHistogramSvc::Helper | |
| CGaudiPython::Helper | |
| CGaudi::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 |
| CGaudiMP.pTools.HistoAgent | |
| CGaudiPython::HistoDecorator | Simple decorator class to allow to reuse the functionality of GaudiHistos<TYPE> class in pythin |
| CGaudiPython.HistoUtils.HistoFile | |
| ►CGaudi::HistogramBase | Common base class for all histograms Use is solely functional to minimize dynamic_casts inside HistogramSvc |
| ►CGaudi::Generic1D< INTERFACE, IMPLEMENTATION > | Common AIDA implementation stuff for histograms and profiles using ROOT implementations |
| CGaudi::Histogram1D | AIDA implementation for 1 D histograms using ROOT THD1 |
| CGaudi::Profile1D | AIDA implementation for 1 D profiles using ROOT TProfile |
| ►CGaudi::Generic2D< INTERFACE, IMPLEMENTATION > | Common AIDA implementation stuff for histograms and profiles using ROOT implementations |
| CGaudi::Histogram2D | AIDA implementation for 2 D histograms using ROOT THD2 |
| CGaudi::Profile2D | AIDA implementation for 2 D profiles using ROOT TProfile2D |
| ►CGaudi::Generic3D< INTERFACE, IMPLEMENTATION > | Common AIDA implementation stuff for histograms and profiles using ROOT implementations |
| CGaudi::Histogram3D | AIDA implementation for 3 D histograms using ROOT THD2 |
| CGaudi::Generic1D< AIDA::IHistogram1D, TH1D > | |
| CGaudi::Generic1D< AIDA::IProfile1D, TProfile > | |
| CGaudi::Generic2D< AIDA::IHistogram2D, TH2D > | |
| CGaudi::Generic2D< AIDA::IProfile2D, TProfile2D > | |
| CGaudi::Generic3D< AIDA::IHistogram3D, TH3D > | |
| CGaudi::Utils::HistoStats | The collection of trivial functions to access the statistical information for the histograms |
| CGaudi::Utils::Histos::HistoStrings | Helper class to produce "good" dictionaries |
| CHiveRndm::HiveNumbers | |
| ►CIAlgTask | General interface for a wrapper around Gaudi algorithm |
| CIOBoundAlgTask | Wrapper around I/O-bound Gaudi-algorithms |
| ►CIAxis | |
| CGaudi::Axis | An IAxis represents a binned histogram axis |
| Cibs_param_t | |
| Cibsfetchctl_t | |
| Cibsopctl_t | |
| Cibsopdata2_t | |
| Cibsopdata3_t | |
| Cibsopdata_t | |
| CIClassInfo | Data base class allowing to store persistent type information |
| CGaudiAlg::ID | ID class for Histogram and Ntuples |
| ►CGaudi::meta::id_< T > | |
| CGaudi::meta::detail::append1< interface_list< Is... >, I > | |
| CGaudi::meta::detail::appendN< interface_list<>, State > | |
| CGaudi::meta::id_< State > | |
| CGaudi::meta::id_< std::conditional< std::is_base_of< id_< I >, inherit_from< id_< Is >... > >::value, interface_list< Is... >, interface_list< Is..., I > >::type > | |
| ►CGaudi::IDataConnection | ABC describing basic data connection |
| CGaudi::RootDataConnection | Concrete implementation of the IDataConnection interface to access ROOT files |
| ►CIDataHandleVisitor | |
| CDHHVisitor | |
| ►CIDataStoreAgent | Generic data agent interface |
| CDataSelectionAgent | DataSelectionAgent base in charge of collecting all the refereces to DataObjects in a transient store that passes some selection criteria |
| CGaudiMP::TESSerializer | |
| CHistogramAgent | HistogramAgent base in charge of collecting all the refereces to DataObjects in a transient store that passes some selection criteria |
| CHistogramAgent | HistogramAgent base in charge of collecting all the refereces to DataObjects in a transient store that passes some selection criteria |
| COutputStreamAgent | |
| CStreamBuffer::IdentifiedLink | Definition of the contained link set |
| CGaudiUtils::details::IdentityOutputter | |
| Cconcurrency::IExecutionFlowManager | |
| CIgHookTrace | |
| CIgHookTraceAlloc | |
| CIgnoreError | |
| ►Cconcurrency::IGraphVisitor | |
| Cconcurrency::RankerByCummulativeOutDegree | |
| Cconcurrency::RankerByDataRealmEccentricity | |
| Cconcurrency::RankerByEccentricity | |
| Cconcurrency::RankerByProductConsumption | |
| Cconcurrency::RankerByTiming | |
| Cconcurrency::RunSimulator | |
| Cconcurrency::Supervisor | |
| Cconcurrency::Trigger | A visitor, performing full top-down traversals of a graph |
| ►CIHistogram1D | |
| CGaudi::Generic1D< AIDA::IHistogram1D, TH1D > | |
| ►CIHistogram2D | |
| CGaudi::Generic2D< AIDA::IHistogram2D, TH2D > | |
| ►CIHistogram3D | |
| CGaudi::Generic3D< AIDA::IHistogram3D, TH3D > | |
| ►CIHistogramFactory | |
| CHistogramSvc | HistogramSvc class definition |
| CGaudi::iid_cast_details::iid_cast_t< Is > | |
| CGaudi::iid_cast_details::iid_cast_t< I, Is... > | |
| CGaudi::iid_cast_details::iid_cast_t<> | |
| CIInspectable | Interface definition of an inspectable object |
| ►CIInterface | Definition of the basic interface |
| CGaudi::IFileCatalog | File catalog interface |
| CGaudi::IFileCatalogMgr | File catalog manager |
| CGaudi::IIODataManager | |
| CGaudi::ISignalMonitor | Interface for the service that monitors the occurrences of system signals |
| CIAccelerator | General interface for an accelerator-based algorithm scheduler |
| CIAddressCreator | IAddressCreator interface definition |
| CIAlgContextSvc | An abstract interface for Algorithm Context Service |
| CIAlgExecStateSvc | Abstract interface for a service that manages the Algorithm execution states |
| CIAlgResourcePool | The IAlgResourcePool is the interface for managing algorithm instances, in particular if clones of the same algorithm exist |
| CIChronoSvc | "Chrono"-related part of interface IChronoStatSvc |
| CIClassManager | The IClassManager is the interface implemented by the generic Factory in the Application Manager to support class management functions |
| ►CIConverter | The data converters are responsible to translate data from one representation into another |
| CIConversionSvc | |
| CICounterSvc | Create / access multi purpose counters |
| CIDataManagerSvc | |
| ►CIDataProviderSvc | Data provider interface definition |
| CIAIDATupleSvc | Definition of the IAIDATupleSvc interface class |
| CIHistogramSvc | Definition of the IHistogramSvc interface class |
| CINTupleSvc | |
| CIDataSourceMgr | IDataSourceMgr interface definition |
| CIDetDataSvc |
|
| CIEventProcessor | The IEventProcessor is the interface to process events |
| CIEvtSelector | The Event Selector Interface |
| CIExceptionSvc | The abstract interface for exception handling service |
| CIFileAccess | Abstract interface for a service or tool implementing a read access to files |
| CIHiveWhiteBoard | |
| CIInactiveMessageCounter | |
| CIIncidentListener | The interface implemented by any class wanting to listen to Incidents |
| CIIncidentSvc | The interface implemented by the IncidentSvc service |
| CIInspector | Inspector base class |
| CIJobOptionsSvc | Main interface for the JobOptions service |
| CIMessageSvc | The IMessage is the interface implemented by the message service |
| CIMonitorSvc | Definition of the IMonitorSvc interface, which publishes Gaudi variables to outside monitoring processes |
| ►CINamedInterface | IInterface compliant class extending IInterface with the name() method |
| ►CIAlgTool | The interface implemented by the AlgTool base class |
| CIDataStoreLeaves | Interface for a tool or service that returns a list of leaves (paths) in a transient store |
| CIDataStreamTool | |
| CIDODAlgMapper | Interface of tools used by the DataOnDemandSvc to choose the algorithm to be run to produce the data at a path |
| CIDODNodeMapper | Interface of tools used by the DataOnDemandSvc to choose the type of node to be created at a path |
| CIEqSolver | Interface file for multidimensional root-finding (solving nonlinear system with n equations in n unknowns) |
| ►CIErrorTool | |
| CErrorTool | |
| CIEventTimeDecoder | Interface that a Tool that decodes the event time has to implement |
| CIFuncMinimum | Interface file to find minimum of the function and compute covariance matrix (matrix of error) |
| CIGenericTool | General purpose interface class for tools that "do something" |
| CIGslErrorHandler | The abstract interface for arbitrary GSL error handler |
| ►CIHistoTool | An abstract interface for "histogramming tool" |
| CHistoTool | Simple tool for histogramming (component) |
| ►CISequencerTimerTool | Implements the time measurement inside a sequencer |
| CSequencerTimerTool | Implements the time measurement inside a sequencer |
| CIThreadInitTool | Abstract interface for AlgTools to do thread local initialization |
| ►CITupleTool | |
| CTupleTool | |
| CIAppMgrUI | Application Manager User Interface |
| CIAuditor | The IAuditor is the interface implmented by the AlgAuditor base class |
| CIDataHandleHolder | |
| CIIoComponent | |
| CIIoComponentMgr | |
| CIPartitionControl | Create / access partitions |
| CIPersistencySvc | Data persistency service interface |
| CIProperty | The IProperty is the basic interface for all components which have properties that can be set or get |
| CIPublishSvc | Definition of the IPublishSvc interface, which publishes variables to outside monitoring processes |
| CIRndmEngine | Definition of a interface for a generic random number generator giving randomly distributed numbers in the range [0...1] number generators |
| CIRndmGen | Definition of a interface for a generic random number generators |
| CIRunable | Runable interface definition |
| CIScheduler | General interface for algorithm scheduler |
| CIScheduler | General interface for algorithm scheduler |
| CISelectStatement | A select statement can either contain |
| CISerialize | Object serialization interface definition |
| CIStagerSvc | |
| ►CIStateful | Interface for classes that implement the Gaudi State Machine |
| ►CIComponentManager | |
| CIAlgManager | The IAlgManager is the interface implemented by the Algorithm Factory in the Application Manager to support management functions |
| CISvcManager | The ISvcManager is the interface implemented by the Service Factory in the Application Manager to support management functions |
| CIStatSvc | "Stat"-related part of interface IChronoStatSvc |
| CISvcLocator | The ISvcLocator is the interface implemented by the Service Factory in the Application Manager to locate services in the framework |
| CIThreadPoolSvc | Abstract interface for a service that manages a thread pool |
| CIToolSvc | The interface implemented by the IToolSvc base class |
| CIUpdateableIF | |
| CIUpdateManagerSvc | Interface class to the Update Manager service |
| Cimage | |
| Cboost::threadpool::immediately< Pool > | ShutdownPolicy which does not wait for any tasks or worker termination |
| ►CIncident | Base class for all Incidents (computing events) |
| CContextIncident< T > | |
| CFileIncident | This class is the FileIncident |
| ►CModuleIncident | Base class for Module-related incident |
| CModuleLoadedIncident | Fired when a module (DLL) is loaded |
| CIIncidentSvc::IncidentPack | |
| CGaudi::Parsers::IncludedFiles | |
| CIndefiniteIntegral | |
| CGaudi::Functional::Traits::InputHandle_t< Handle > | |
| CGaudi::Functional::details::insert_t | |
| CIntegration | Collection of common types for classes NumericalIndefiniteIntegral and NumericalDefiniteIntegral |
| CGaudiPython::Interface< TYPE > | Minor mofidication of original Pere's structure GaudiPython::Interface This helper class is nesessary to perform C++ castings from python |
| CGaudi::interface_list< I > | |
| CGaudi::interface_list_append< I > | |
| ►CGaudi::interface_list_cat< I > | |
| CGaudi::interface_list_append< interface_list< Is... >, I > | |
| CGaudi::interface_list_cat< interface_list< I1... >, interface_list< I2... >, Others... > | |
| CGaudi::interface_list_cat< interface_list< I1..., I2... >, Others... > | |
| CGaudi::interface_list_cat< interface_list< Is... >, interface_list< I > > | |
| CInterfaceID | Interface ID class |
| CGaudi::InterfaceId< INTERFACE, majVers, minVers > | Class to handle automatically the versioning of the interfaces when they are inheriting from other interfaces |
| ►CInterfaces | |
| Cextend_interfaces< Interfaces > | Base class to be used to extend an interface |
| ►Cextend_interfaces< INamedInterface, IStateful > | |
| CIAlgorithm | The IAlgorithm is the interface implemented by the Algorithm base class |
| ►CIService | General service interface definition |
| CIClassIDSvc | Interface to the CLID database |
| CICounterSummarySvc | Simple service interface to collect counters to persist in a summary file |
| CIFileMgr | |
| CIGslSvc | The abstract interface to "deal" with GNU Scientific Library (GLS) The main task is the error handling |
| CIHistorySvc | Definition of the IHistorySvc interface class |
| CIIssueLogger | |
| CIMagneticFieldSvc | The interface to the MagneticFieldSvc |
| CIMetaDataSvc | |
| CIParticlePropertySvc | This class is an interface to the ParticlePropertySvc |
| CIPartPropSvc | |
| CIRndmGenSvc | Random Generator service interface definition Definition of a interface for a service to access random generators according to predefined distributions: |
| CIStatusCodeSvc | |
| CITHistSvc | |
| CITimelineSvc | |
| ►Cextend_interfaces< Interfaces... > | |
| ►Cextends< BASE, Interfaces > | Base class used to extend a class implementing other interfaces |
| CIOBoundAlgSchedulerSvc | Please refer to the full documentation of the methods for more details |
| Cextends< Algorithm, IPartitionControl > | |
| Cextends< AlgTool, IDataStoreLeaves, IIncidentListener > | |
| Cextends< AlgTool, IDataStreamTool > | |
| Cextends< AlgTool, IDODAlgMapper, IDODNodeMapper > | |
| Cextends< AlgTool, IFileAccess > | |
| Cextends< AlgTool, IGslErrorHandler > | |
| Cextends< AlgTool, IPartitionControl > | |
| Cextends< Auditor, IIncidentListener > | |
| ►Cextends< BASE, IDataHandleHolder > | |
| CDataHandleHolderBase< BASE > | |
| Cextends< ComponentManager, IAlgManager > | |
| Cextends< ComponentManager, ISvcManager, ISvcLocator > | |
| Cextends< DataSvc, IHistogramSvc > | |
| Cextends< DataSvc, IIncidentListener > | |
| Cextends< DataSvc, INTupleSvc, IDataSourceMgr > | |
| Cextends< GaudiTool, IEqSolver > | |
| Cextends< GaudiTool, IFuncMinimum > | |
| Cextends< PropertyHolder< CommonMessaging< implements< IAlgorithm, IDataHandleHolder, IProperty, IStateful > > >, IDataHandleHolder > | |
| Cextends< PropertyHolder< CommonMessaging< implements< IAlgTool, IDataHandleHolder, IProperty, IStateful > > >, IDataHandleHolder > | |
| Cextends< Service, Gaudi::ISignalMonitor > | |
| Cextends< Service, IAlgContextSvc, IIncidentListener > | |
| Cextends< Service, IAlgExecStateSvc > | |
| Cextends< Service, IAlgResourcePool > | |
| Cextends< Service, IAuditorSvc > | |
| Cextends< Service, IChronoStatSvc, IIncidentListener > | |
| Cextends< Service, IConversionSvc, IAddressCreator > | |
| Cextends< Service, IConversionSvc, IPersistencySvc, IAddressCreator > | |
| Cextends< Service, ICounterSvc > | |
| Cextends< Service, IDataProviderSvc, IDataManagerSvc > | |
| Cextends< Service, IDataProviderSvc, IDataManagerSvc, IHiveWhiteBoard > | |
| Cextends< Service, IDataProviderSvc, IDataManagerSvc, IPartitionControl > | |
| Cextends< Service, IEventProcessor > | |
| Cextends< Service, IEvtSelector > | |
| Cextends< Service, IExceptionSvc > | |
| Cextends< Service, IFileAccess > | |
| Cextends< Service, IFileCatalog, IFileCatalogMgr > | |
| Cextends< Service, IFileMgr, IIncidentListener > | |
| Cextends< Service, IGslSvc > | |
| Cextends< Service, IHistorySvc, IIncidentListener > | |
| Cextends< Service, IIncidentListener > | |
| Cextends< Service, IIncidentSvc > | |
| Cextends< Service, IIoComponentMgr, IIncidentListener > | |
| Cextends< Service, IIODataManager > | |
| Cextends< Service, IIssueLogger > | |
| Cextends< Service, IJobOptionsSvc > | |
| Cextends< Service, IMessageSvc, IInactiveMessageCounter > | |
| Cextends< Service, IMetaDataSvc > | |
| Cextends< Service, IParticlePropertySvc > | |
| Cextends< Service, IPartPropSvc > | |
| Cextends< Service, IRndmEngine, ISerialize, IIncidentListener > | |
| Cextends< Service, IRndmGenSvc, IRndmEngine, ISerialize > | |
| Cextends< Service, IRunable > | |
| Cextends< Service, IScheduler > | |
| Cextends< Service, IStatusCodeSvc > | |
| Cextends< Service, ITHistSvc, IIncidentListener, IIoComponent > | |
| Cextends< Service, IThreadPoolSvc > | |
| Cextends< Service, ITimelineSvc > | |
| Cextends< Service, IToolSvc > | |
| Cextends< TsDataSvc, IDetDataSvc, IIncidentListener > | |
| Cimplements< Interfaces > | Base class used to implement the interfaces |
| ►Cimplements< IClassManager > | |
| CDLLClassManager | |
| ►Cimplements< IConverter > | |
| ►CConverter | Converter base class |
| ►CGaudi::RootConverter | Description: Definition of the ROOT data converter |
| ►CGaudi::RootStatCnv | Description: Base class converter for N-tuples and related classes |
| ►CGaudi::RootDirectoryCnv | Description: NTuple directory converter class definition Definition of the converter to manage the directories in an database representing N-Tuples |
| CGaudi::RootDatabaseCnv | Statistics file converter class definition |
| CGaudi::RootNTupleCnv | NTuple converter class definition for NTuples writted/read using ROOT |
| ►CRootHistCnv::RConverter | Root Converter |
| CRootHistCnv::DirectoryCnv | |
| ►CRootHistCnv::RDirectoryCnv | Create persistent and transient representations of data store directories |
| CRootHistCnv::RFileCnv | NTuple converter class definition |
| CRootHistCnv::RHistogramCnv< T, S, Q > | Generic converter to save/read AIDA_ROOT histograms using ROOT |
| ►CRootHistCnv::RNTupleCnv | NTuple converter class definition |
| CRootHistCnv::RCWNTupleCnv | Converter of Column-wise NTuple into ROOT format |
| CRootHistCnv::RRWNTupleCnv | Row wise NTuple converter class definition |
| ►Cimplements< IFileCatalog > | |
| CGaudi::XMLFileCatalog | This class constitutes the core of the XML based FileCatalog API for POOL |
| ►Cimplements< IInterface > | |
| CEventSelectorDataStream | Definition of class EventSelectorDataStream |
| ►Cimplements< IRndmGen > | |
| ►CRndmGen | Random Generator definition |
| CHepRndm::Generator< TYPE > | |
| CHepRndm::Generator< Rndm::DefinedPdf > | |
| ►Cimplements< ISelectStatement > | |
| ►CSelectStatement | Class of a selection statement |
| CNTuple::Selector | NTuple Selector class |
| ►Cimplements< ISvcLocator > | |
| CGaudi::BootSvcLocator | A dual-stage boostrap mechanism is used to ensure an orderly startup of the ApplicationMgr |
| ►Cextend_interfaces< IService, IAuditor > | |
| CIAuditorSvc | The interface implemented by the IAuditorSvc base class |
| ►Cextend_interfaces< IService, IChronoSvc, IStatSvc > | |
| CIChronoStatSvc | The IChronoStatSvc is the interface implemented by the ChronoStatService |
| ►CINTuple | NTuple interface class definition |
| CNTuple::Tuple | Abstract base class which allows the user to interact with the actual N tuple implementation |
| ►CINTupleItem | NTuple interface class definition |
| ►CNTuple::_Data< bool > | |
| CNTuple::_Item< bool > | |
| ►CNTuple::_Data< IOpaqueAddress * > | |
| CNTuple::_Item< IOpaqueAddress * > | |
| ►CNTuple::_Data< VALUE > | |
| CNTuple::_Item< VALUE > | |
| ►CNTuple::_Data< TYP > | Abstract class describing basic data in an Ntuple |
| ►CNTuple::_Array< TYP > | Abstract class describing a column-array in a N tuple |
| CNTuple::_ArrayImp< TYP > | Concrete class discribing a column-array in a N tuple |
| ►CNTuple::_DataImp< TYP > | Concrete class discribing basic data items in an N tuple |
| CNTuple::_ArrayImp< TYP > | Concrete class discribing a column-array in a N tuple |
| CNTuple::_ItemImp< TYP > | Concrete class discribing a column in a N tuple |
| CNTuple::_MatrixImp< TYP > | Concrete class discribing a matrix column in a N tuple |
| ►CNTuple::_Item< TYP > | Abstract class describing a column in a N tuple |
| CNTuple::_ItemImp< TYP > | Concrete class discribing a column in a N tuple |
| ►CNTuple::_Matrix< TYP > | Abstract class describing a matrix column in a N tuple |
| CNTuple::_MatrixImp< TYP > | Concrete class discribing a matrix column in a N tuple |
| CSystem::IO_COUNTERS | Process I/O Counters NtQueryInformationProcess using ProcessIoCounters |
| CIoComponentMgr::IoComponentEntry | |
| CIo::IoFlags | |
| CIIoComponentMgr::IoMode | |
| ►CIOpaqueAddress | Opaque address interface definition |
| ►CGenericAddress | Generic Transient Address |
| CGaudi::RootAddress | Description: |
| CRootHistCnv::RootObjAddress | |
| Cconcurrency::IPrecedenceRulesGraph | |
| ►CIProfile1D | |
| CGaudi::Generic1D< AIDA::IProfile1D, TProfile > | |
| ►CIProfile2D | |
| CGaudi::Generic2D< AIDA::IProfile2D, TProfile2D > | |
| ►CIRegistry | The IRegistry represents the entry door to the environment any data object residing in a transient data store is embedded |
| ►CDataSvcHelpers::RegistryEntry | Definition of an entry in the transient data store |
| CHive::HiveEventRegistryEntry | |
| CIssueSeverity | |
| CTuples::ItemStore< VALUE > | Simple class, which represents the local storage of N-tuple items of the given type |
| CGaudi::Functional::details::vector_of_const_< Container >::iterator | |
| ►Cstd::iterator< std::forward_iterator_tag, uint > [external] | |
| CAlgsExecutionStates::Iterator | |
| ►Cstd::iterator< std::input_iterator_tag, Attrib > [external] | |
| CGaudi::Utils::AttribStringParser::Iterator | Iterator to loop over the tag/value pairs in the attribute string |
| ►Citerator_facade | |
| CGaudi::details::index_iterator< ITERATOR, INDICES > | "index" iterator iterates ober "indiced" intries in the cotainer/range |
| CGaudi::details::masked_iterator< ITERATOR, MASK > | "masked" iterator iterates ober "masked" intries in the cotainner/range |
| ►CIUpdateable | Object update interface definition |
| CIUpdateableIF | |
| CIUpdateableInterface | Component interface counterpart to the above ABC |
| CIValidity | Interface for objects with a validity |
| ►CIInspector::IValue | |
| CIInspector::_V< T > | |
| ►CIVersHistoryObj | Interface for Versioned History Objects |
| CAlgorithmHistory | AlgorithmHistory class definition |
| CAlgToolHistory | AlgToolHistory class definition |
| CJobHistory | JobHistory class definition |
| CServiceHistory | ServiceHistory class definition |
| CGaudiKernel.ProcessJobOptions.JobOptsParser | |
| CSystem::KERNEL_USER_TIMES | Process/Thread System and User Time NtQueryInformationProcess using ProcessTimes NtQueryInformationThread using ThreadTimes |
| ►Ckey_compare | |
| CGaudiUtils::VectorMap< KEY, VALUE, KEYCOMPARE, ALLOCATOR >::_compare_type | The actual structure used to compare the elements Only "key" is important for comparison |
| CContainers::key_traits< KEY > | Key traits class |
| ►CContainers::key_traits< DATATYPE::key_type > | |
| CContainers::traits< CONTAINER, DATATYPE > | Container traits class |
| CGaudiDict::KeyedContainerDict< T > | |
| CGaudiDict::KeyedObjectDict< T > | |
| CContainers::KeyedObjectManager< SETUP > | KeyedObjectManager Class to manage keyed objects |
| CDataOnDemandSvc::Leaf | |
| CStoreSnifferAlg::LeafInfo | |
| Cboost::threadpool::lifo_scheduler< Task > | SchedulingPolicy which implements LIFO ordering |
| CLinkManager::Link | Embedded class defining a symbolic link Note: No copy constructor; bitwise copy (done by the compiler) is just fine |
| CLinkManager | A LinkManager is the object aggregated into a DataObject, which is responsible for the handling of non-tree like links |
| Clinux_proc | |
| ►Clist | |
| ►CGaudiKernel.GaudiHandles.GaudiHandleArray | |
| CGaudiKernel.GaudiHandles.PrivateToolHandleArray | |
| CGaudiKernel.GaudiHandles.PublicToolHandleArray | |
| CGaudiKernel.GaudiHandles.ServiceHandleArray | |
| CIncidentSvc::Listener | |
| CGaudi::Utils::LockedChrono | Helper object, useful for measurement of CPU-performance of highly-recursive structures, e.g |
| CLockedHandle< T, MutexType > | Provides automatic lock/unlock access to a class upon deref of ptr |
| CGaudi::PluginService::Details::Logger | Simple logging class, just to provide a default implementation |
| CIssueLogger::logger_t | |
| CGaudi::Math::Lomont< TYPE > | The equality comparison of double numbers using as the metric the maximal number of Units in the Last Place (ULP) |
| Cboost::threadpool::looped_task_func | Looped task function object |
| CGaudiMP.pTools.LumiFSR | |
| CGaudi::majorMatch_t | |
| Cboost::spirit::qi::make_primitive< repository::qi::tag::iter_pos, Modifiers > | |
| CContainers::map | |
| ►CGaudi::Utils::MapBase | Helper base-class to allow the generic Python-decoration for all "map-like" classes in Gaudi |
| ►CGaudiUtils::Map< K, T, M > | Extension of the STL map |
| CGaudiUtils::HashMap< K, T, H, M > | Common class providing an architecture-independent hash map |
| CGaudiUtils::HashMap< const void *, EntryType > | |
| CGaudiUtils::HashMap< Gaudi::StringKey, Leaf > | |
| CGaudiUtils::HashMap< Gaudi::StringKey, Node > | |
| CGaudiUtils::HashMap< Gaudi::StringKey, std::unique_ptr< ListenerList > > | |
| CGaudiUtils::HashMap< long, void * > | |
| CGaudiUtils::HashMap< std::string, int > | |
| CGaudiUtils::HashMap< std::string, NameMap > | |
| CGaudiUtils::HashMap< std::string, SmartIF< IAlgorithm > > | |
| CGaudiUtils::HashMap< std::string, std::string > | |
| CGaudiUtils::HashMap< std::string, std::unique_ptr< Address > > | |
| CGaudiUtils::HashMap< std::string, std::unique_ptr< Bool > > | |
| CGaudiUtils::HashMap< std::string, std::unique_ptr< Char > > | |
| CGaudiUtils::HashMap< std::string, std::unique_ptr< Double > > | |
| CGaudiUtils::HashMap< std::string, std::unique_ptr< FArray > > | |
| CGaudiUtils::HashMap< std::string, std::unique_ptr< Float > > | |
| CGaudiUtils::HashMap< std::string, std::unique_ptr< FMatrix > > | |
| CGaudiUtils::HashMap< std::string, std::unique_ptr< Int > > | |
| CGaudiUtils::HashMap< std::string, std::unique_ptr< LongLong > > | |
| CGaudiUtils::HashMap< std::string, std::unique_ptr< NTuple::Item< VALUE > > > | |
| CGaudiUtils::HashMap< std::string, std::unique_ptr< Short > > | |
| CGaudiUtils::HashMap< std::string, std::unique_ptr< UChar > > | |
| CGaudiUtils::HashMap< std::string, std::unique_ptr< UInt > > | |
| CGaudiUtils::HashMap< std::string, std::unique_ptr< ULongLong > > | |
| CGaudiUtils::HashMap< std::string, std::unique_ptr< UShort > > | |
| CGaudiUtils::HashMap< std::string, std::vector< IFileAccess * > > | |
| CGaudiUtils::VectorMap< KEY, VALUE, KEYCOMPARE, ALLOCATOR > | A bit modified version of 'Loki::AssocVector' associative vector from Loki library by Andrei Alexandrescu |
| CGaudiUtils::Map< const void *, EntryType, std::unordered_map< const void *, EntryType, Hash< const void * > > > | |
| CGaudiUtils::Map< Gaudi::StringKey, Leaf, std::unordered_map< Gaudi::StringKey, Leaf, Hash< Gaudi::StringKey > > > | |
| CGaudiUtils::Map< Gaudi::StringKey, Node, std::unordered_map< Gaudi::StringKey, Node, Hash< Gaudi::StringKey > > > | |
| CGaudiUtils::Map< Gaudi::StringKey, std::unique_ptr< ListenerList >, std::unordered_map< Gaudi::StringKey, std::unique_ptr< ListenerList >, Hash< Gaudi::StringKey > > > | |
| CGaudiUtils::Map< InterfaceID, SmartIF< IInterface > > | |
| CGaudiUtils::Map< long, void *, std::unordered_map< long, void *, Hash< long > > > | |
| CGaudiUtils::Map< std::string, int, std::unordered_map< std::string, int, Hash< std::string > > > | |
| CGaudiUtils::Map< std::string, NameMap, std::unordered_map< std::string, NameMap, Hash< std::string > > > | |
| CGaudiUtils::Map< std::string, SmartIF< IAlgorithm >, std::unordered_map< std::string, SmartIF< IAlgorithm >, Hash< std::string > > > | |
| CGaudiUtils::Map< std::string, std::string > | |
| CGaudiUtils::Map< std::string, std::string, std::unordered_map< std::string, std::string, Hash< std::string > > > | |
| CGaudiUtils::Map< std::string, std::unique_ptr< Address >, std::unordered_map< std::string, std::unique_ptr< Address >, Hash< std::string > > > | |
| CGaudiUtils::Map< std::string, std::unique_ptr< Bool >, std::unordered_map< std::string, std::unique_ptr< Bool >, Hash< std::string > > > | |
| CGaudiUtils::Map< std::string, std::unique_ptr< Char >, std::unordered_map< std::string, std::unique_ptr< Char >, Hash< std::string > > > | |
| CGaudiUtils::Map< std::string, std::unique_ptr< Double >, std::unordered_map< std::string, std::unique_ptr< Double >, Hash< std::string > > > | |
| CGaudiUtils::Map< std::string, std::unique_ptr< FArray >, std::unordered_map< std::string, std::unique_ptr< FArray >, Hash< std::string > > > | |
| CGaudiUtils::Map< std::string, std::unique_ptr< Float >, std::unordered_map< std::string, std::unique_ptr< Float >, Hash< std::string > > > | |
| CGaudiUtils::Map< std::string, std::unique_ptr< FMatrix >, std::unordered_map< std::string, std::unique_ptr< FMatrix >, Hash< std::string > > > | |
| CGaudiUtils::Map< std::string, std::unique_ptr< Int >, std::unordered_map< std::string, std::unique_ptr< Int >, Hash< std::string > > > | |
| CGaudiUtils::Map< std::string, std::unique_ptr< LongLong >, std::unordered_map< std::string, std::unique_ptr< LongLong >, Hash< std::string > > > | |
| CGaudiUtils::Map< std::string, std::unique_ptr< NTuple::Item< VALUE > >, std::unordered_map< std::string, std::unique_ptr< NTuple::Item< VALUE > >, Hash< std::string > > > | |
| CGaudiUtils::Map< std::string, std::unique_ptr< Short >, std::unordered_map< std::string, std::unique_ptr< Short >, Hash< std::string > > > | |
| CGaudiUtils::Map< std::string, std::unique_ptr< UChar >, std::unordered_map< std::string, std::unique_ptr< UChar >, Hash< std::string > > > | |
| CGaudiUtils::Map< std::string, std::unique_ptr< UInt >, std::unordered_map< std::string, std::unique_ptr< UInt >, Hash< std::string > > > | |
| CGaudiUtils::Map< std::string, std::unique_ptr< ULongLong >, std::unordered_map< std::string, std::unique_ptr< ULongLong >, Hash< std::string > > > | |
| CGaudiUtils::Map< std::string, std::unique_ptr< UShort >, std::unordered_map< std::string, std::unique_ptr< UShort >, Hash< std::string > > > | |
| CGaudiUtils::Map< std::string, std::vector< IFileAccess * >, std::unordered_map< std::string, std::vector< IFileAccess * >, Hash< std::string > > > | |
| CGaudiUtils::VectorMap< const INamedInterface *, int > | |
| CGaudi::Utils::RegEx::matchList | |
| CNTuple::Matrix< IOpaqueAddress * > | |
| CMEMORY_MAPPED_FILE | |
| Cmerge_job< T > | |
| CGaudi::Functional::MergingTransformer< Signature, Traits_ > | |
| CMessage | The Message class |
| CGaudi::Parsers::Messages | |
| CMetaData | |
| CMessageSvc::MsgAry | Private helper class to keep the count of messages of a type (MSG::LEVEL) |
| CMsgStream | Definition of the MsgStream class used to transmit messages |
| CGaudi::Functional::MultiScalarTransformer< ScalarOp, TransformerSignature, Traits_ > | |
| CGaudi::Functional::MultiTransformer< Signature, Traits_ > | |
| CGaudi::Functional::MultiTransformerFilter< Signature, Traits_ > | |
| CNamedRange | New concept of "named" range : range with name |
| CDataOnDemandSvc::Node | Helper class of the DataOnDemandSvc |
| CGaudi::Parsers::Node | |
| CGaudi::Parsers::NodeOperations | |
| ►CGaudi::Details::Property::NoHandler | |
| ►CGaudi::Details::Property::ReadHandler | |
| CGaudi::Details::Property::ReadUpdateHandler | |
| ►CGaudi::Details::Property::UpdateHandler | |
| CGaudi::Details::Property::ReadUpdateHandler | |
| ►Cnoncopyable | |
| Cboost::threadpool::detail::locking_ptr< T, Mutex > | Smart pointer with a scoped locking mechanism |
| Cboost::threadpool::detail::pool_core< Task, SchedulingPolicy, SizePolicy, SizePolicyController, ShutdownPolicy > | Thread pool |
| Cboost::threadpool::detail::scope_guard | |
| Cboost::threadpool::detail::worker_thread< Pool > | Thread pool worker |
| CNTupleItems | NTupleItems namespace parts definition This header file is not intended to be included by the public! It's only used for the ntuple service |
| CGaudi::Details::Property::NullVerifier | |
| CRndm::Numbers | Random number accessor This small class encapsulates the use of the random number generator |
| ►Cobject | |
| CGaudi._ConfigurablesModule | Small class that allows to access all the configurables as attributes of the instance |
| CGaudi.Main.BootstrapHelper | |
| CGaudi.Main.BootstrapHelper.AppMgr | |
| CGaudi.Main.BootstrapHelper.Property | |
| CGaudi.Main.BootstrapHelper.StatusCode | |
| CGaudi.Main.gaudimain | |
| CGaudiConfig.ControlFlow._TestVisitor | |
| ►CGaudiConfig.ControlFlow.ControlFlowNode | |
| CGaudiConfig.ControlFlow.AndNode | |
| ►CGaudiConfig.ControlFlow.ControlFlowLeaf | |
| CGaudiConfig.ControlFlow._TestAlgorithm | |
| CGaudiConfig.ControlFlow.ControlFlowBool | |
| CGaudiConfig.ControlFlow.ignore | |
| CGaudiConfig.ControlFlow.InvertNode | |
| CGaudiConfig.ControlFlow.OrderedNode | |
| CGaudiConfig.ControlFlow.OrNode | |
| CGaudiConfig.ControlFlow.par | |
| CGaudiConfig.ControlFlow.seq | |
| CGaudiConfig.ControlFlow.DotVisitor | |
| CGaudiConfig.ControlFlow.line | |
| CGaudiHive.precedence.CruncherSequence | |
| CGaudiHive.precedence.RealTimeValue | |
| CGaudiHive.precedence.RndBiased10BooleanValue | |
| CGaudiHive.precedence.UniformBooleanValue | |
| CGaudiHive.precedence.UniformTimeValue | |
| ►CGaudiKernel.Configurable.Configurable | |
| CGaudiKernel.Configurable.ConfigurableAlgorithm | |
| CGaudiKernel.Configurable.ConfigurableAlgTool | |
| CGaudiKernel.Configurable.ConfigurableAuditor | |
| CGaudiKernel.Configurable.ConfigurableGeneric | |
| CGaudiKernel.Configurable.ConfigurableService | |
| ►CGaudiKernel.Configurable.ConfigurableUser | |
| CGaudi.Configuration.GaudiPersistency | |
| CGaudiKernel.Configurable.CreateSequencesVisitor | |
| CGaudiKernel.Configurable.DummyDescriptor | Classes for generic Gaudi component =========== |
| CGaudiKernel.Configurable.PropertyReference | Allow references to options as in old style |
| CGaudiKernel.ConfigurableDb._Singleton | |
| CGaudiKernel.DataObjectHandleBase.DataObjectHandleBase | |
| ►CGaudiKernel.GaudiHandles.GaudiHandle | |
| CGaudiKernel.GaudiHandles.PrivateToolHandle | |
| CGaudiKernel.GaudiHandles.PublicToolHandle | |
| CGaudiKernel.GaudiHandles.ServiceHandle | |
| ►CGaudiKernel.PropertyProxy.PropertyProxy | |
| CGaudiKernel.PropertyProxy.DataObjectHandleBasePropertyProxy | |
| ►CGaudiKernel.PropertyProxy.GaudiHandlePropertyProxyBase | |
| CGaudiKernel.PropertyProxy.GaudiHandleArrayPropertyProxy | |
| CGaudiKernel.PropertyProxy.GaudiHandlePropertyProxy | |
| CGaudiMP.GMPBase.Coord | |
| CGaudiMP.GMPBase.EventCommunicator | |
| ►CGaudiMP.GMPBase.GMPComponent | |
| CGaudiMP.GMPBase.Reader | |
| CGaudiMP.GMPBase.Subworker | |
| CGaudiMP.GMPBase.Worker | |
| CGaudiMP.GMPBase.Writer | |
| CGaudiMP.GMPBase.MiniWriter | |
| CGaudiMP.GMPBase.TESSerializer | |
| CGaudiMP.IoRegistry.IoRegistry | |
| CGaudiMP.Parallel.SshSession | |
| CGaudiMP.Parallel.Statistics | |
| CGaudiMP.Parallel.Task | |
| CGaudiMP.Parallel.WorkManager | |
| CGaudiMP.pTools.Syncer | |
| CGaudiMP.pTools.SyncMini | |
| ►CGaudiPython.Bindings.InterfaceCast | |
| CGaudiPython.Bindings.Interface | |
| ►CGaudiPython.Bindings.iProperty | |
| ►CGaudiPython.Bindings.iAlgorithm | |
| CGaudiPython.GaudiAlgs.GaudiAlgo | Base class for all algorithm Python-image of C++ clkass GaudiAlgorithm |
| CGaudiPython.GaudiAlgs.HistoAlgo | The base class for easy histogramming |
| CGaudiPython.GaudiAlgs.TupleAlgo | The base class for easy manupulations with N-Tuples |
| CGaudiPython.Bindings.iAlgTool | |
| ►CGaudiPython.Bindings.iService | |
| CGaudiPython.Bindings.AppMgr | |
| ►CGaudiPython.Bindings.iDataSvc | |
| CGaudiPython.Bindings.iHistogramSvc | |
| CGaudiPython.Bindings.iNTupleSvc | |
| CGaudiPython.Bindings.iEventSelector | |
| CGaudiPython.Bindings.iJobOptSvc | |
| CGaudiPython.Bindings.iToolSvc | |
| CGaudiPython.Bindings.PropertyEntry | |
| CGaudiPython.GaudiAlgs.objectmethod | |
| CGaudiPython.GaudiAlgs.TupleDecColumnDispatcher | |
| CGaudiPython.Persistency.FileDescription | |
| ►CGaudiPython.Persistency.PersistencyHelper | |
| CGaudiPython.Persistency.RootPersistency | |
| Cgaudirun.FakeModule | |
| ►CGaudiTesting.BaseTest.BaseTest | |
| CGaudiTesting.QMTTest.QMTTest | |
| CmakePlots.TimingInfo | |
| CSmartDataObjectPtr::ObjectFinder | Helper class to configure smart pointer functionality |
| CSmartDataObjectPtr::ObjectLoader | Helper class to configure smart pointer functionality |
| CIToolSvc::Observer | Allow call-backs when a tool is a created or retrieved |
| CGaudi::Parsers::TupleInnerGrammar< Iterator, TupleT, N, Skipper >::Operations | |
| CGaudi::Parsers::TupleInnerGrammar< Iterator, TupleT, 1, Skipper >::Operations | |
| CGaudi::Parsers::MapGrammar< Iterator, MapT, Skipper >::Operations | |
| CGaudi::Parsers::Pnt3DGrammar< Iterator, PointT, Skipper >::Operations | |
| CGaudi::Parsers::Pnt4DGrammar< Iterator, PointT, Skipper >::Operations | |
| CGaudi::Parsers::Histo1DGrammar< Iterator, Skipper >::Operations | |
| CGaudi::Functional::Traits::OutputHandle_t< Handle > | |
| CReplayOutputStream::OutStreamAdder | Helper class to fill the internal map of OutputStreams |
| CReplayOutputStream::OutStreamTrigger | Helper class to call the required OutputStream |
| CGaudiMP.pTools.PackedCaloHypo | |
| ►CIRndmGen::Param | |
| CRndm::Binomial | Parameters for the Binomial distributed random number generation |
| CRndm::Bit | Parameters for the bit value generation: returns values 0 and 1 |
| CRndm::BreitWigner | Parameters for the BreitWigner distributed random number generation |
| CRndm::BreitWignerCutOff | Parameters for the BreitWigner distributed random number generation with cut off; |
| CRndm::Chi2 | Parameters for the Chi2 distributed random number generation |
| CRndm::DefinedPdf | Generate a random number Generator following generally distributed random values, given a user-defined probability distribution function |
| CRndm::Exponential | Parameters for the Gauss random number generation |
| CRndm::Flat | Parameters for the flat random number generation within boundaries [minimum, maximum] |
| CRndm::Gamma | Parameters for the Gamma distributed random number generation |
| CRndm::Gauss | Parameters for the Gauss random number generation |
| CRndm::GaussianTail | Parameters for the Gaussian tail number generation |
| CRndm::Landau | Parameters for the Landau distributed random number generation |
| CRndm::Poisson | Parameters for the Poisson distributed random number generation with a given mean |
| CRndm::StudentT | Parameters for the StudentT distributed random number generation |
| CParticleProperty | A trivial class to hold information about a single particle properties |
| CSystem::PathResolver | |
| Cpentium4_cccr_value_t | Pentium4_cccr_value_t |
| Cpentium4_escr_value_t | |
| Cpfarg_ctx_t | |
| Cpfarg_load_t | |
| Cpfarg_msg_t | |
| Cpfarg_ovfl_msg_t | |
| Cpfarg_pmc_t | |
| Cpfarg_pmd_attr_t | |
| Cpfarg_pmd_t | |
| Cpfarg_pmr_t | |
| Cpfarg_set_desc_t | |
| Cpfarg_set_info_t | |
| Cpfarg_setdesc_t | |
| Cpfarg_setinfo_t | |
| Cpfarg_sinfo_t | |
| Cpfarg_start_t | |
| Cpfm_amd64_ctr_reg_t | |
| Cpfm_amd64_sel_reg_t | |
| Cpfm_core_sel_reg_t | |
| Cpfm_coreduo_counter_t | |
| Cpfm_coreduo_sel_reg_t | |
| Cpfm_dfl_smpl_arg_t | |
| Cpfm_dfl_smpl_entry_t | |
| Cpfm_dfl_smpl_hdr_t | |
| Cpfm_ds_area_core_t | |
| Cpfm_ds_area_p4_t | |
| Cpfm_gen_ia32_sel_reg_t | |
| Cpfm_i386_p6_ctr_reg_t | |
| Cpfm_i386_p6_sel_reg_t | |
| Cpfm_intel_atom_sel_reg_t | |
| Cpfm_nhm_sel_reg_t | |
| Cpfm_pebs_core_smpl_arg_t | |
| Cpfm_pebs_core_smpl_entry_t | |
| Cpfm_pebs_core_smpl_hdr_t | |
| Cpfm_pebs_nhm_smpl_entry_t | |
| Cpfm_pebs_p4_smpl_arg_t | |
| Cpfm_pebs_p4_smpl_entry_t | |
| Cpfm_pebs_p4_smpl_hdr_t | |
| Cpfm_pebs_smpl_arg_t | |
| Cpfm_pebs_smpl_hdr_t | |
| CPfmCodeAnalyser | |
| Cpfmlib_amd64_counter_t | |
| Cpfmlib_amd64_input_param_t | |
| Cpfmlib_amd64_output_param_t | |
| Cpfmlib_core_counter_t | |
| Cpfmlib_core_input_param_t | |
| Cpfmlib_core_output_param_t | |
| Cpfmlib_core_pebs_t | |
| Cpfmlib_coreduo_input_param_t | |
| Cpfmlib_event_t | |
| Cpfmlib_gen_ia32_counter_t | |
| Cpfmlib_gen_ia32_input_param_t | |
| Cpfmlib_gen_ia32_output_param_t | |
| Cpfmlib_i386_p6_counter_t | |
| Cpfmlib_i386_p6_input_param_t | |
| Cpfmlib_i386_p6_output_param_t | |
| Cpfmlib_input_param_t | |
| Cpfmlib_intel_atom_counter_t | |
| Cpfmlib_intel_atom_input_param_t | |
| Cpfmlib_nhm_counter_t | |
| Cpfmlib_nhm_input_param_t | |
| Cpfmlib_nhm_lbr_t | |
| Cpfmlib_nhm_pebs_t | |
| Cpfmlib_options_t | |
| Cpfmlib_output_param_t | |
| Cpfmlib_reg_t | |
| Cpfmlib_regmask_t | |
| CPipeReader | |
| CGaudiUtils::AllocatorPool::PoolChunk | |
| CPoolDbLinkManager | Description: PoolDbLinkManager class implementation definition |
| CPoolDbTokenWrap | Description: |
| CSystem::POOLED_USAGE_AND_LIMITS | Process Pooled Quota Usage and Limits NtQueryInformationProcess using ProcessPooledUsageAndLimits |
| CGaudiUtils::AllocatorPool::PoolLink | |
| CGaudi::Parsers::Position | |
| CROOT::Math::PositionVector3D< CoordSystem, Tag > | |
| CPOSIXFileHandler | |
| CGaudi::Parsers::PragmaOptions | |
| ►Cprimitive_parser | |
| Cboost::spirit::repository::qi::iter_pos_parser | |
| CGaudiAlg::Print | Collection of useful utilities to print IHistogram1D (currently used for implementation of class GaudiHistoAlg and class GaudiHistoTool) |
| CGaudiAlg::Print1D | Collection of useful utilities to print IHistogram1D (currently used for implementation of class GaudiHistoAlg and class GaudiHistoTool) |
| CGaudiAlg::Print1DProf | Collection of useful utilities to print IProfile1D (currently used for implementation of class GaudiHistoAlg and class GaudiHistoTool) |
| CGaudiAlg::Print2D | Collection of useful utilities to print IHistogram1D (currently used for implementation of class GaudiHistoAlg and class GaudiHistoTool) |
| CGaudiAlg::Print2DProf | Collection of useful utilities to print IProfile2D (currently used for implementation of class GaudiHistoAlg and class GaudiHistoTool) |
| CGaudiAlg::Print3D | Collection of useful utilities to print IHistogram1D (currently used for implementation of class GaudiHistoAlg and class GaudiHistoTool) |
| CGaudiPython::Printer< TYPE > | |
| CGaudiPython::Printer< ContainedObject > | |
| CGaudiPython::Printer< DataObject > | |
| CICounterSvc::Printout | Print counters for each element in the range [first, last) e.g |
| CGaudiAlg::PrintStat | Collection of useful utilities to print StatEntity (currently used for implementation of class GaudiAlgorithm and class GaudiTool) |
| CGaudiAlg::PrintTuple | Collection of useful utilities to print INTuple object (currently used for implementation of class GaudiTupleAlg and class GaudiTupleTool) |
| Cboost::threadpool::prio_scheduler< Task > | SchedulingPolicy which implements prioritized ordering |
| Cboost::threadpool::prio_task_func | Prioritized task function object |
| CSystem::PROCESS_BASIC_INFORMATION | |
| CSystem::ProcessDescriptor | Provides access to process information |
| CSystem::ProcessDescriptor::ProcessHandle | |
| CSystem::ProcessTime | Simple class to hold the time information of a process |
| CprocInfo | |
| CProcStats | |
| CGaudi::Functional::Producer< Signature, Traits_ > | |
| ►CProperty | |
| CPropertyList | List of properties |
| CGaudi::Parsers::Property | |
| ►CGaudi::Details::PropertyBase | PropertyBase base class allowing PropertyBase* collections to be "homogeneous" |
| CGaudi::Property< TYPE, VERIFIER, HANDLERS > | Implementation of property with value of concrete type |
| ►CGaudi::Property< TYPE[N], VERIFIER, HANDLERS > | |
| CGaudi::Property< TYPE(&)[N], VERIFIER, HANDLERS > | |
| CGaudi::Property< bool > | |
| CGaudi::Property< CLID > | |
| CGaudi::Property< double > | |
| CGaudi::Property< float > | |
| CGaudi::Property< GaudiAlg::ID::NumericID > | |
| CGaudi::Property< int > | |
| CGaudi::Property< long > | |
| CGaudi::Property< map< std::string, std::string > > | |
| CGaudi::Property< std::map > | |
| CGaudi::Property< std::map< std::string, std::string > > | |
| CGaudi::Property< std::string > | |
| CGaudi::Property< std::string::size_type > | |
| CGaudi::Property< std::unordered_set > | |
| CGaudi::Property< std::vector< int > > | |
| CGaudi::Property< std::vector< long > > | |
| CGaudi::Property< std::vector< std::string > > | |
| CGaudi::Property< std::vector< std::vector< std::string > > > | |
| CGaudi::Property< std::vector< unsigned int > > | |
| CGaudi::Property< unsigned int > | |
| CGaudi::Property< unsigned long long > | |
| CGaudi::Property< unsigned short > | |
| CGaudi::Property< vector< std::string > > | |
| CPropertyWithHandlers< Handler > | Helper class to simplify the migration old properties deriving directly from PropertyBase |
| ►CPropertyWithHandlers<> | |
| ►CDataObjectHandleProperty | DataObjectHandleProperty.h GaudiKernel/DataObjectHandleProperty.h |
| CGaudi::Property< DataObjectHandleBase & > | |
| ►CDataObjIDCollProperty | |
| CGaudi::Property< DataObjIDColl & > | |
| CGaudi::Property< DataObjIDColl > | |
| ►CDataObjIDProperty | DataObjIDProperty.h GaudiKernel/DataObjProperty.h |
| CGaudi::Property< DataObjID & > | |
| CGaudiHandleArrayProperty | |
| CGaudiHandleProperty | |
| CPropertyMgr | Property manager helper class |
| CGaudi::Parsers::PropertyName | |
| CGaudi::Parsers::PropertyValue | |
| CDataOnDemandSvc::Protection | Helper class of the DataOnDemandSvc |
| CGaudiPython::CallbackStreamBuf::PyObject_t | |
| CGaudiMP::PyROOTPickle | |
| CPythonAdaptor | |
| CPythonConfig | |
| CIUpdateManagerSvc::PythonHelper | Helper class implemented in the python dictionary to allow access from python to template member functions |
| CSystem::QUOTA_LIMITS | Process Quotas NtQueryInformationProcess using ProcessQuotaLimits NtQueryInformationProcess using ProcessPooledQuotaLimits NtSetInformationProcess using ProcessQuotaLimits |
| CNTuple::Range< TYP > | Class defining a range |
| CNTuple::Range< bool > | |
| ►CGaudi::RangeBase_ | Helper class to simplify the dealing with ranges in Python |
| ►CGaudi::Range_< CONTAINER, ITERATOR > | Useful class for representation of "sequence" of the objects through the range of valid iterators |
| CGaudi::NamedRange_< CONTAINER, ITERATOR > | |
| CGaudiUtils::Allocator< Type >::rebind< U > | |
| CGaudiRoot::RefAccessor | |
| CGaudiTest.ReferenceFileValidator | |
| CGaudiTesting.BaseTest.ReferenceFileValidator | |
| CGaudi::PluginService::Details::Registry | In-memory database of the loaded factories |
| CGaudi::Functional::details::details2::remove_optional< T > | |
| CGaudi::Functional::details::details2::remove_optional< boost::optional< T > > | |
| Cboost::threadpool::resize_controller< Pool > | SizePolicyController which allows resizing |
| CGaudi::Parsers::NodeOperations::result< A, B, C, D > | |
| CGaudi::Parsers::TupleInnerGrammar< Iterator, TupleT, N, Skipper >::Operations::result< A, B, C, D > | |
| CGaudi::Parsers::MapGrammar< Iterator, MapT, Skipper >::Operations::result< A, B, C, D > | |
| CGaudi::Parsers::TupleInnerGrammar< Iterator, TupleT, 1, Skipper >::Operations::result< A, B, C, D > | |
| CGaudiTesting.BaseTest.Result | |
| CGaudi::Parsers::Pnt3DGrammar< Iterator, PointT, Skipper >::Operations::result< A, B, C, D > | |
| CGaudi::Parsers::Histo1DGrammar< Iterator, Skipper >::Operations::result< A, B, C, D > | |
| CGaudi::Parsers::Pnt4DGrammar< Iterator, PointT, Skipper >::Operations::result< A, B, C, D > | |
| CRetCodeGuard | Helper class to set the application return code in case of early exit (e.g |
| Creverse_wrapper< Iterable > | |
| CRootHistCnv::RootCompressionSettings | Simple class to decode a ROOT compression settings string, of the form '<Alg>:<level>' into the integer code to pass to ROOT |
| CRootConnectionSet | Class describing the setup parameters of a ROOT data connection |
| CGaudi::RootConnectionSetup | |
| CRootFileHandler | |
| CGaudi::RootNTupleDescriptor | Description: |
| CGaudi::RootObjectRefs | Persistent reference object containing all leafs and links corresponding to a Gaudi DataObject |
| CGaudi::RootRef | Persistent reference object |
| ►CRuntimeError | |
| CGaudiKernel.Configurable.Error | |
| CGaudiKernel.ProcessJobOptions.ParserError | |
| ►CGaudiPython.Persistency.PersistencyError | |
| CGaudiPython.Persistency.UnknownPersistency | |
| CZipPythonDir.ZipdirError | Class for generic exception coming from the zipdir() function |
| CS_module | |
| CGaudi::Functional::ScalarTransformer< ScalarOp, TransformerSignature, Traits_ > | |
| CAvalancheSchedulerSvc::SchedulerState | |
| CForwardSchedulerSvc::SchedulerState | |
| CStatusCode::ScopedDisableChecking | Simple RAII class to ignore unchecked StatusCode instances in a scope |
| CGaudi::Parsers::PairGrammar< Iterator, PairT, Skipper >::second | |
| CGaudi::Parsers::KeyValueGrammar< Iterator, Skipper >::second | |
| CGaudi::SerialTaskQueue | Class for a generic serial queue of tasks (modeled on the Intel Threading Building Blocks Design Pattern "Local Serializer") |
| CGaudi::SerialTaskQueue::SerialWorkItem | Wrapper for the WorkItem class for internal concurrency bookkeeping |
| CPersistencySvc::ServiceEntry | |
| CServiceManager::ServiceItem | |
| CServiceLocatorHelper | Helper to share the implementation of service() among the various kernel base classes |
| ►CSmartDataObjectPtr | A small class used to access easily (and efficiently) data items residing in data stores |
| CSmartDataStorePtr< TYPE, LOADER > | A small class used to access easily (and efficiently) data items residing in data stores |
| ►CSmartDataStorePtr< TYPE, SmartDataObjectPtr::ObjectLoader > | |
| CSmartDataLocator< TYPE > | A small class used to access easily (and efficiently) data items residing in data stores |
| CSmartDataPtr< TYPE > | A small class used to access easily (and efficiently) data items residing in data stores |
| CSmartIF< TYPE > | Small smart pointer class with automatic reference counting for IInterface |
| CSmartIF< AvalancheSchedulerSvc > | |
| CSmartIF< DLLClassManager > | |
| CSmartIF< ForwardSchedulerSvc > | |
| CSmartIF< Gaudi::Gaudi::IIODataManager > | |
| CSmartIF< Gaudi::Gaudi::ISignalMonitor > | |
| CSmartIF< Gaudi::IFileCatalog > | |
| CSmartIF< IAccelerator > | |
| CSmartIF< IAddressCreator > | |
| CSmartIF< IAlgContextSvc > | |
| CSmartIF< IAlgExecStateSvc > | |
| CSmartIF< IAlgManager > | |
| CSmartIF< IAlgorithm > | |
| CSmartIF< IAlgResourcePool > | |
| CSmartIF< IAppMgrUI > | |
| CSmartIF< IAuditor > | |
| CSmartIF< IAuditorSvc > | |
| CSmartIF< IChronoStatSvc > | |
| CSmartIF< IComponentManager > | |
| CSmartIF< IConversionSvc > | |
| CSmartIF< ICounterSummarySvc > | |
| CSmartIF< ICounterSvc > | |
| CSmartIF< IDataManagerSvc > | |
| CSmartIF< IDataProviderSvc > | |
| CSmartIF< IEventProcessor > | |
| CSmartIF< IEvtSelector > | |
| CSmartIF< IExceptionSvc > | |
| CSmartIF< IFileAccess > | |
| CSmartIF< IHistogramSvc > | |
| CSmartIF< IHiveWhiteBoard > | |
| CSmartIF< IIncidentListener > | |
| CSmartIF< IIncidentSvc > | |
| CSmartIF< IInterface > | |
| CSmartIF< IJobOptionsSvc > | |
| CSmartIF< IMessageSvc > | |
| CSmartIF< IMonitorSvc > | |
| CSmartIF< INamedInterface > | |
| CSmartIF< INTupleSvc > | |
| CSmartIF< IPartitionControl > | |
| CSmartIF< IProperty > | |
| CSmartIF< IRndmEngine > | |
| CSmartIF< IRndmGen > | |
| CSmartIF< IRndmGenSvc > | |
| CSmartIF< IRunable > | |
| CSmartIF< IScheduler > | |
| CSmartIF< ISelectStatement > | |
| CSmartIF< ISerialize > | |
| CSmartIF< IService > | |
| CSmartIF< IStateful > | |
| CSmartIF< IStatSvc > | |
| CSmartIF< ISvcLocator > | |
| CSmartIF< ISvcManager > | |
| CSmartIF< IThreadPoolSvc > | |
| CSmartIF< ITimelineSvc > | |
| CSmartIF< IToolSvc > | |
| CSmartIF< Tuples::TupleObj > | |
| CSmartRef< TYPE > | Kernel objects: SmartRef |
| CSmartRef< ContainedObject > | |
| CSmartRef< DataObject > | |
| CSmartRef< KeyType > | |
| CSmartRefArray< TYPE > | |
| CSmartRefBase | User example objects: SmartRefBase |
| CSmartRefList< TYPE > | |
| CSmartRefMap< TYPE > | |
| CEventIDBase::SortByLumiEvent | |
| CEventIDBase::SortByRunEvent | |
| CEventIDBase::SortByTimeStamp | |
| CGenfun::GaudiMathImplementation::SplineBase | |
| CGaudi::Functional::SplittingTransformer< Signature, Traits_ > | |
| CIntelProfilerAuditor::stack_entity | |
| CStat | Small wrapper class for easy manipulation with generic counters and IStatSvc&ICounterSvc interface |
| CStatusCodeSvc::StatCodeDat | |
| CStatEntity | The basic counter used for Monitoring purposes |
| CStatic_error_check< bool > | |
| CStatic_error_check< false > | |
| Cboost::threadpool::static_size< Pool > | SizePolicy which preserves the thread count |
| CStatusCode | This class is used for returning status codes from appropriate routines |
| CStreamBuffer | The stream buffer is a small object collecting object data |
| ►CStreamHandler | |
| CGaudiKernel.ProcessJobOptions.ConsoleHandler | |
| CStreamLogger | |
| ►Cstd::stringbuf [external] | |
| CGaudiPython::CallbackStreamBuf | |
| CGaudi::Details::Property::StringConverter< TYPE > | |
| CGaudi::StringKey | The helper class to represent the efficient "key" for access |
| ►CStructure | |
| CGaudiPluginService.cpluginsvc.Factory | |
| CGaudiPluginService.cpluginsvc.Property | |
| CGaudiPluginService.cpluginsvc.Registry | |
| CGaudiCommon_details::svc_eq_t | |
| CGaudiCommon_details::svc_lt_t | |
| CSvcCatalog | |
| CSvcFactory< T > | |
| CGaudi::Details::Property::SwapCall | Helper to disable a while triggering it, to avoid infinite recursion |
| CGaudi::SysProcStat | |
| CGaudi::Utils::Histos::Table | Simple class for the customizeble printout of the histogram tables |
| ►CIInspector::Tag | |
| CIInspector::_TT< T > | |
| CGaudi::Parsers::MapGrammar< Iterator, MapT, Skipper >::tag_key | |
| CGaudi::Parsers::MapGrammar< Iterator, MapT, Skipper >::tag_mapped | |
| CMultiStoreSvc::tagROOT | |
| ►Ctask | |
| CAlgoExecutionTask | |
| CAvalancheSchedulerSvc::enqueueSchedulerActionTask | |
| CForwardSchedulerSvc::enqueueSchedulerActionTask | |
| CGaudi::SerialTaskQueue::SerialWorkItemRunner | Helper class to wrap a SerialWorkItem in a tbb::task |
| CThreadInitTask | Special TBB task used by ThreadPoolSvc to wrap execution of IThreadInitTools |
| CTBMessageSvc | Extension to the standard MessageSvc that |
| ►CTClassStreamer | |
| CGaudiRoot::IOHandler< T > | |
| CGaudiTest.TempDir | |
| CGaudiTest.TempFile | |
| CGaudiTest.TemporaryEnvironment | Utility Classes |
| CTHistSvc::THistID | |
| Cboost::threadpool::thread_pool< Task, SchedulingPolicy, SizePolicy, SizePolicyController, ShutdownPolicy > | Thread pool |
| CThreadGaudi | Singleton mapping the pthread ID to the Gaudi thread ID |
| CGaudi::Time | Based on seal::Time |
| CTimelineEvent | |
| CTimerForSequencer | Auxiliary class |
| CGaudi::TimeSpan | Based on seal::TimeSpan |
| CTuples::detail::to_< T > | |
| CTuples::detail::to_float | |
| Cpool::Token | Shadow class to mimik POOL tokens |
| ►CGaudi::RootDataConnection::Tool | Helper class to facilitate an abstraction layer for reading POOL style files with this package |
| CGaudi::PoolTool | |
| CGaudi::RootTool | Description: |
| CToolFactory< T > | |
| ►CToolHandleInfo | General info and helper functions for toolhandles and arrays |
| ►CBaseToolHandle | Non-templated base class for actual ToolHandle<T> |
| CToolHandle< T > | Handle to be used in lieu of naked pointers to tools |
| CToolHandle< IThreadInitTool > | |
| CToolHandleArray< T > | Array of Handles to be used in lieu of vector of naked pointers to tools |
| CToolHandleArray< IThreadInitTool > | |
| CGaudi::Functional::Transformer< Signature, Traits_ > | |
| ►Ctrue_ | |
| Cboost::spirit::use_terminal< qi::domain, repository::qi::tag::iter_pos > | |
| ►Cstd::true_type [external] | |
| CGaudi::Functional::details::is_optional< boost::optional< T > > | |
| CTuples::Tuple | A simple wrapper class over standard Gaudi NTuple::Tuple facility |
| CGaudi::Parsers::tuple_get_first_type< T > | |
| CGaudi::Parsers::tuple_get_first_type< std::tuple< T, Ts... > > | |
| CGaudi::Parsers::tuple_remove_first_type< T > | |
| CGaudi::Parsers::tuple_remove_first_type< std::tuple< T, Ts... > > | |
| CGaudiPython::TupleAlgDecorator | Simple class to perform the "decoration" of Tuples in Python/ROOT |
| CTuples::TupleColumn< ITEM > | Helper class which allows to extend the functionality of Tuple with possibility to use your own representation of complex objects |
| CGaudiPython::TupleDecorator | Simple class which performs the decoration of the standard N-Tuple |
| CTuples::TupleItem< ITEM > | |
| ►CTuples::TupleObj | A simple wrapper class over standard Gaudi NTuple::Tuple facility |
| CTuples::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 |
| CGaudi::Utils::TuplePrinter< Tuple, N > | |
| CGaudi::Utils::TuplePrinter< Tuple, 1 > | |
| CGaudiPython::TupleToolDecorator | Simple class to perform the "decoration" of Tuples in Python/ROOT |
| ►Ctype | |
| CGaudiKernel.ConfigurableMeta.ConfigurableMeta | This metaclass installs PropertyProxy descriptors for Gaudi properties |
| CGaudi::Utils::TypeNameString | Helper class to parse a string of format "type/name" |
| CUCharDbArray | Shadow class to mimik POOL blobs |
| ►Cstd::unary_function< const IInterface *, IInterface * > [external] | |
| CGaudiPython::Interface< IInterface > | |
| ►Cstd::unary_function< const path &, bool > [external] | |
| CDirSearchPath::eqPath | Name |
| ►Cstd::unary_function< const T *, std::size_t > [external] | |
| ►CGaudiUtils::Hash< T * > | Partial specialization for pointers |
| CGaudiUtils::Hash< const T * > | Remove extra qualifiers: |
| ►Cstd::unary_function< const T(&)[N], std::size_t > [external] | |
| CGaudiUtils::Hash< const T(&)[N]> | Generic specialization for arrays |
| ►Cstd::unary_function< ParticleProperty *, bool > [external] | |
| CFindByMassRange | 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 |
| ►Cstd::unary_function< Property, bool > [external] | |
| CGaudi::Parsers::Property::Equal | |
| ►Cstd::unary_function< T(&)[N], std::size_t > [external] | |
| CGaudiUtils::Hash< T(&)[N]> | Generic specialization for arrays |
| ►Cstd::unary_function< T, std::size_t > [external] | |
| CGaudiUtils::GenericHash< T > | Generic hash implementation (for easy migration to the new Hash class) |
| ►CGaudiUtils::Hash< T > | Simple hash function |
| CGaudiUtils::Hash< const T & > | Remove extra qualifiers: |
| CGaudiUtils::Hash< const T > | Remove extra qualifiers: |
| CGaudiUtils::Hash< T & > | Remove extra qualifiers: |
| ►Cstd::unary_function< TYPE, TYPE > [external] | |
| CGaudiPython::_identity< TYPE > | It is here due to 'missing'(?) std::identity |
| ►Cstd::unary_function< WorkerEntry, bool > [external] | |
| CConversionSvc::CnvTest | |
| CProcStats::unique_fd | |
| CGaudi::Parsers::Units | |
| CGaudi::Parsers::NodeOperations::value | |
| CContainers::vector | |
| ►Cstd::vector< SmartRef< TYPE > > [external] | |
| CSmartRefVector< TYPE > | Kernel objects: SmartRefVector |
| CContainers::vector< void * > | |
| CGaudi::Functional::details::vector_of_const_< Container > | |
| CSystem::VM_COUNTERS | Process Virtual Memory Counters NtQueryInformationProcess using ProcessVmCounters |
| Cimplementation_detail::void_t< typename > | |
| CGaudi::Functional::details::detail2::void_t_<... > | |
| Cboost::threadpool::wait_for_active_tasks< Pool > | ShutdownPolicy which waits for the completion of all active tasks and the worker termination afterwards |
| Cboost::threadpool::wait_for_all_tasks< Pool > | ShutdownPolicy which waits for the completion of all tasks and the worker termination afterwards |
| CWatchdogThread | Simple class for asynchronous check of time-out |
| CConversionSvc::WorkerEntry | |
| ►CGaudi::SerialTaskQueue::WorkItem | Base class for the task to be executed by the serial queue |
| ►CTBBMessageSvc::MessageTaskCommon | Common base class for the different reportMessage cases |
| CTBBMessageSvc::MessageWithLevel | Specialized class to report a message with explicit output level |
| CTBBMessageSvc::MessageWithoutLevel | Specialized class to report a message with implicit output level |
| CTBBMessageSvc::StatusCodeMessage | Specialized class to report a StatusCode message |
| ►CBASE | |
| Cextends< BASE, Interfaces > | Base class used to extend a class implementing other interfaces |
| Cextends< BASE, IDataHandleHolder > | |
| CPropertyHolder< BASE > | Helper class to implement the IProperty interface |
| ►CBase | |
| CGaudi::Functional::Traits::use_< Base > | |
| ►CExecTestBase | |
| CGaudiTest.GaudiExeTest | |
| ►CIAnnotation | |
| CAIDA::Annotation | Implementation of the AIDA IAnnotation interface class |
| ►CINTERFACE | |
| CGaudi::Generic1D< INTERFACE, IMPLEMENTATION > | Common AIDA implementation stuff for histograms and profiles using ROOT implementations |
| CGaudi::Generic2D< INTERFACE, IMPLEMENTATION > | Common AIDA implementation stuff for histograms and profiles using ROOT implementations |
| CGaudi::Generic3D< INTERFACE, IMPLEMENTATION > | Common AIDA implementation stuff for histograms and profiles using ROOT implementations |
| ►CIs | |
| CGaudi::meta::detail::inherit_from< Is > | |
| ►CPBASE | |
| CGaudiCommon< PBASE > | Implements the common functionality between GaudiTools and GaudiAlgorithms |
| CGaudiHistos< PBASE > | Templated base class providing common histogramming methods for GaudiAlgorithm and GaudiTool like classes |
| CGaudiTuples< PBASE > | Templated base class providing common 'ntupling' methods |
| ►CResultStream | |
| CGaudiTest.HTMLResultStream | |
| CGaudiTest.XMLResultStream | |
1.8.11 
