| CNTuple::_Accessor< TYP > | Class acting as a smart pointer holding a N tuple entry |
| CNTuple::Array< IOpaqueAddress * > | |
| CNTuple::Matrix< IOpaqueAddress * > | |
| CNTuple::_Accessor< _Array< double > > | |
| CNTuple::Array< double > | |
| CNTuple::_Accessor< _Array< float > > | |
| CNTuple::Array< float > | |
| CNTuple::_Accessor< _Array< int > > | |
| CNTuple::Array< int > | |
| CNTuple::_Accessor< _Array< long > > | |
| CNTuple::Array< long > | |
| 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::Item< bool > | Specialization acting as a smart pointer holding a N tuple _Item |
| CNTuple::_Accessor< _Item< double > > | |
| CNTuple::Item< double > | |
| CNTuple::_Accessor< _Item< float > > | |
| CNTuple::Item< float > | |
| CNTuple::_Accessor< _Item< Gaudi::TestSuite::MyTrack * > > | |
| CNTuple::Item< Gaudi::TestSuite::MyTrack * > | |
| CNTuple::_Accessor< _Item< int > > | |
| CNTuple::Item< int > | |
| CNTuple::_Accessor< _Item< IOpaqueAddress * > > | |
| CNTuple::Item< IOpaqueAddress * > | |
| CNTuple::_Accessor< _Item< long > > | |
| CNTuple::Item< long > | |
| CNTuple::_Accessor< _Item< TYP > > | |
| CNTuple::Item< TYP > | Class acting as a smart pointer holding a N tuple _Item |
| CNTuple::_Accessor< _Item< uint32_t > > | |
| CNTuple::Item< uint32_t > | |
| CNTuple::_Accessor< _Matrix< double > > | |
| CNTuple::Matrix< double > | |
| CNTuple::_Accessor< _Matrix< float > > | |
| CNTuple::Matrix< float > | |
| CNTuple::_Accessor< _Matrix< TYP > > | |
| CNTuple::Matrix< TYP > | Class acting as a smart pointer holding a N tuple _Item |
| C_CallbackStreamBufBase | |
| CGaudiPython.Bindings.CallbackStreamBuf | |
| CGaudi._ConfigurablesModule | |
| CGaudiKernel.Configurable._DefaultPropertiesCollectorHelper | |
| CGaudiPython::_identity | It is here due to 'missing'(?) std::identity |
| CKeyedContainer< DATATYPE, MAPPING >::_InsertRelease | Internal functor for insertion of objects |
| CGaudiConfig2.semantics._JSONValue | |
| CGaudi::Decays::Nodes::_Node | Helper structure (especially it is light version node-holder the default constructor |
| C_PyAlgorithm | |
| CGaudiPython.Bindings.PyAlgorithm | |
| CKeyedContainer< DATATYPE, MAPPING >::_RemoveRelease | Internal functor for insertion of objects |
| CGaudiKernel.ConfigurableDb._Singleton | |
| CGaudiKernel.ProcessJobOptions._TempSysPath | |
| CControlFlow._TestVisitor | |
| CAccumulator | |
| CGaudi::Accumulators::Buffer< Accumulator, Atomicity, Args... > | |
| CGaudi::Accumulators::BufferableCounter< Atomicity, Accumulator, Arithmetic, NumberDimensions, AxisTupleType > | |
| CGaudi::Accumulators::BufferableCounter< Atomicity, Accumulator, Arithmetic, std::integral_constant< unsigned int, ND >, std::tuple< AxisTypes... > > | |
| CGaudi::Accumulators::HistogramingCounterBase< ND, Atomicity, Arithmetic, Type, Accumulator, std::tuple< AxisTypes... > > | |
| CGaudi::Accumulators::BufferableCounter< Atomicity, Accumulator, Args > | An empty ancester of all counters that provides a buffer method that returns a buffer on itself Also registers the counter to its owner, with default type "counter" Due to this registration, move semantic is disabled |
| CGaudi::Accumulators::AveragingCounter< Arithmetic, Atomicity > | |
| CGaudi::Accumulators::StatCounter< Unit > | |
| Cadd_serviceLocator | |
| 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, IDODAlgMapper, IDODNodeMapper > | |
| CDODBasicMapper | Default implementation of a DataOnDemand mapper |
| Cextends< AlgTool, IDataStreamTool > | |
| CDataStreamTool | |
| 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, IFileAccess > | |
| CFileReadTool | Basic implementation of the IFileAccess interface |
| Cextends< AlgTool, IMyTool > | |
| CGaudi::TestSuite::MyExampleTool | |
| Cbug_34121::Tool | |
| Cextends< AlgTool, ITestTool > | |
| CGaudiTesting::TestTool | |
| CTestTool | |
| CTestToolFailing | |
| Cextends< AlgTool, IMyTool, IMyOtherTool > | |
| CMyTool | This is an interface class for a example tool |
| CGaudi::TestSuite::FloatTool | |
| CGaudi::Tests::Histograms::Directories::HistoGroupsTool | |
| CCommonMessaging< implements< IAppMgrUI, Gaudi::Interfaces::IQueueingEventProcessor, IService, IStateful, INamedInterface, IProperty > > | |
| CPropertyHolder< CommonMessaging< implements< IAppMgrUI, Gaudi::Interfaces::IQueueingEventProcessor, IService, IStateful, INamedInterface, IProperty > > > | |
| CApplicationMgr | The Application Manager class |
| 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< 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 > > > > | |
| CGaudi::Algorithm | Base class from which all concrete algorithm classes should be derived |
| CGaudi::TestSuite::Conditions::ConditionAccessorHolder< Algorithm > | |
| CGaudi::TestSuite::Conditions::UserAlg | Example of a simple algorithm using conditions via the ConditionAccessorHolder pattern |
| CTemplatedAlg< int, std::vector< std::string > > | |
| CTemplatedAlg< double, bool > | |
| CGaudi::AsynchronousAlgorithm | Base class for asynchronous algorithms |
| CGPUCruncher | A test asynchronous algorithm on the GPU |
| CGaudi::TestSuite::AsyncSleeperAlg | |
| CGaudi::NTuple::GenericReader | |
| CGaudi::NTuple::GenericWriter | A Gaudi algorithm for writing data of any type from N locations in the event store to a TTree |
| CGaudi::Sequence | |
| CGaudi::Sequencer | A Sequencer is essentially a list of Algorithms and is responsible for their management |
| CParentAlg | Trivial Algorithm for tutotial purposes |
| CGaudi::TestSuite::Counter::HistoTimingAlg< Arithmetic, Atomicity > | Simple timing of counter based histograms filling |
| CGaudi::TestSuite::FileSvc::HistogramWriterAlg | |
| CGaudi::TestSuite::FileSvc::NTupleWriterAlg | |
| CGaudi::TestSuite::PartPropAlg | Algorithm to test the particle property service |
| CGaudi::details::LegacyAlgorithmAdapter | |
| CAlgorithm | Alias for backward compatibility |
| Cextends< Algorithm, IFSMCallbackHolder > | |
| CGaudi::FSMCallbackHolder< Algorithm > | |
| CGaudi::TestSuite::FSMCallbackTestAlgo | Example of usage of callbacks, when using CallbackHolder |
| CAIDATupleAlgorithmRead | |
| CAIDATupleAlgorithmWrite | |
| CAbortEventAlg | Small algorithm that after a given number of events triggers an AbortEvent |
| CAnyDataGetAlgorithm< T > | |
| CAnyDataPutAlgorithm | |
| CAuditorTestAlg | |
| CCPUCruncher | A class that implements a search for prime numbers |
| CCollectionCloneAlg | Small algorithm, which allows to merge N-tuples in a generic way |
| CColorMsgAlg | |
| CContextEventCounterData | |
| CContextEventCounterPtr | |
| CDataCreator | Trivial Algorithm for test purposes |
| CEvtCollectionStream | A small to stream Data I/O |
| CEvtCollectionWrite | User example objects: EvtCollectionWrite |
| CExtendedProperties | Simple DEMO-file for "extended properties", implementation file for class ExtendedProperties |
| CFileMgrTest | Algorithm to test the FileMgr |
| CGaudi::Hive::FetchDataFromFile | |
| CGaudi::TestSuite::HistoProps | Simple example, which illustrates the usage of "histogram properties" DO NOT USE |
| CGaudi::TestSuite::MultiInput::DumpAddress | Write the content of the RootAddress of a data object |
| CGaudi::TestSuite::MultiInput::ReadAlg | Simple algorithm used to read data from two files |
| CGaudi::TestSuite::MultiInput::WriteAlg | Simple algorithm used to produce dummy data in the transient store |
| CGaudi::TestSuite::ReadHandleAlg | |
| CGaudi::TestSuite::TestAlg | Simple algorithm useful as base class for tests |
| CGaudi::TestSuite::BoostArrayProperties | |
| CGaudi::TestSuite::CustomPropertiesAlg | Example on how to use custom property types |
| CGaudi::TestSuite::ExtendedProperties2 | Simple DEMO-file for "extended vector properties", |
| CGaudi::TestSuite::StringKeyEx | Simple example which illustrate the usage of class StringKey |
| CMyAlgorithm | Trivial Algorithm for tutorial purposes |
| CGaudi::TestSuite::WriteHandleAlg | |
| CGaudiEx::QotdAlg | |
| CGaudiPython::PyAlgorithm | Python Algorithm base class |
| CGaudiMP.GMPBase.CollectHistograms | |
| CGaudiTestSuite::CounterSvcAlg | Simple algorithm use for test case bug_30209_namespace_in_sequencer.qmt nothing to do anymore with ICounterSvc |
| CGaudiTestSuite::StatSvcAlg | Simple algorithm to illustrate the statistical abilities of "Stat"-part of Chrono&Stat Service |
| CGaudiTestSuite::TimingAlg | The primitive class to illustrate the usage of IChronoSvc , ChronoEntity & Chrono objects |
| CGaudiTesting::CustomIncidentAlg | |
| CGaudiTesting::DestructorCheckAlg | |
| CGaudiTesting::GetDataObjectAlg | Simple algorithm that retrieves objects from the transient store |
| CGaudiTesting::JIRA::GAUDI_1185 | Special service to expose GAUDI-1185 |
| CGaudiTesting::ListTools | Simple algorithm that creates dummy objects in the transient store |
| CGaudiTesting::OddEventsFilter | |
| CGaudiTesting::EvenEventsFilter | |
| CGaudiTesting::PrintMemoryUsage | Simple algorithm that prints the memory usage every N events (property "Frequency") |
| CGaudiTesting::PutDataObjectAlg | Simple algorithm that creates dummy objects in the transient store |
| CGaudiTesting::SignallingAlg | Simple algorithm that raise a signal after N events |
| CGaudiTesting::StopLoopAlg | |
| CGaudiTesting::TestAlg | |
| CHelloWorld | Trivial Algorithm for tutotial purposes |
| CHistoAlgorithm | |
| CHistory | |
| CHiveReadAlgorithm | |
| CHiveTestAlgorithm | |
| CIncidentAsyncTestAlg | |
| CIncidentListenerTestAlg | |
| CJSONPropertyAlg | |
| CLoopAlg | |
| CMapAlg | Simple algorithm which shows various "map-like" containers available in Gaudi |
| CMyDataAlgorithm | Trivial Algorithm for tutotial purposes |
| CNTupleAlgorithm | |
| COutputStream | A small to stream Data I/O |
| CCopyInputStream | |
| 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 |
| CPartPropExa | |
| CPluginServiceTest::CustomFactoryAlgorithm | |
| CPluginServiceTest::MyAlg | |
| CPluginServiceTest::MyTemplatedAlg< T1, T2 > | |
| CPropertyAlg | Trivial Algorithm for tutorial purposes |
| CPropertyProxy | Trivial Algorithm for tutotial purposes |
| CRandomNumberAlg | A small algorithm class using the random number service |
| CReadAlg | ReadAlg class for the RootIOExample |
| CReadTES | |
| CRecordOutputStream | Simple class that adds an entry to the Transient Event Store to record that the processing flow triggered its execution |
| CReplayOutputStream | |
| 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 |
| CSubAlg | Trivial Algorithm for tutotial purposes |
| CTHistRead | |
| CTHistWrite | |
| CTest::ViewTester | |
| CTestToolAlg | |
| CTestToolAlgFailure | Retrieve tools ignoring errors |
| CWideNTupleAlgorithm | Books a configurable grid of column-wise tuples: many trees, many columns, few entries |
| CWriteAlg | WriteAlg class for the RootIOExample |
| Cbug_34121::MyAlgorithm | |
| CGaudiTesting::SleepyAlg | |
| CIncidentProcAlg | |
| CReEntAlg | Algorithm to test reentrant Algorithms |
| CStopperAlg | |
| CTemplatedAlg< T, R > | |
| CCommonMessaging< implements< IAuditor, IProperty > > | |
| CPropertyHolder< CommonMessaging< implements< IAuditor, IProperty > > > | |
| CGaudi::Auditor | Base class from which all concrete auditor classes should be derived |
| Cextends< Gaudi::Auditor, IIncidentListener > | |
| CAlgTimingAuditor | |
| CNVTXAuditor | Auditor that uses NVTX to annotate ranges and incidents for profiling with NVIDIA tools |
| CAlgContextAuditor | Description: Register/Unregister the AlgContext of each algorithm before entering the algorithm and after leaving it |
| CChronoAuditor | Monitors the cpu time usage of each algorithm |
| CGaudiTestSuite::LoggingAuditor | |
| CMemStatAuditor | Just a minor modification of MemoryAuditor to allow the output memory statistics table to be printed |
| CMemoryAuditor | Monitors the memory use of each algorithm |
| CNameAuditor | Prints the name of each algorithm before entering the algorithm and after leaving it |
| CCommonMessaging< implements< IService, IProperty, IStateful > > | |
| CPropertyHolder< CommonMessaging< implements< IService, IProperty, IStateful > > > | |
| CService | Base class for all services |
| Cextends< Service, IAlgContextSvc, IIncidentListener > | |
| CAlgContextSvc | Simple implementation of interface IAlgContextSvc for Algorithm Context Service |
| 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, IRunable > | |
| CAppMgrRunable | Class definition of AppMgrRunable |
| CPythonScriptingSvc | This service handles scripting implemented using Python |
| Cextends< Service, IAuditorSvc > | |
| CAuditorSvc | This service manages Auditors |
| Cextends< Service, IScheduler > | |
| CAvalancheSchedulerSvc | |
| Cextends< Service, ICPUCrunchSvc > | |
| CCPUCrunchSvc | |
| 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, 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 |
| Cextends< Service, IDataProviderSvc, IDataManagerSvc > | |
| CDataSvc | Data service base class |
| Cextends< DataSvc, IHistogramSvc > | |
| CHistogramSvc | HistogramSvc class definition |
| Cextends< DataSvc, INTupleSvc, IDataSourceMgr > | |
| CNTupleSvc | NTuple service |
| CTagCollectionSvc | Gaudi tag collection service 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 |
| CEvtDataSvc | A EvtDataSvc is the base class for event services |
| CTsDataSvc | Data service base class |
| Cextends< TsDataSvc, IDetDataSvc, IIncidentListener > | |
| CDetDataSvc | A DataSvc specialized in detector data |
| 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, IDataProviderSvc, IDataManagerSvc, IHiveWhiteBoard, Gaudi::Concurrency::ConcurrencyManager > | |
| CEvtStoreSvc | Use a minimal event store implementation, and adds everything required to satisfy the IDataProviderSvc, IDataManagerSvc and IHiveWhiteBoard interfaces by throwing exceptions except when the functionality is really needed.. |
| CHiveWhiteBoard | Data service base class |
| Cextends< Service, IExceptionSvc > | |
| CExceptionSvc | Simple implementation of IExceptionSvc abstract interface |
| Cextends< Service, IFileMgr, IIncidentListener > | |
| CFileMgr | |
| Cextends< Service, Gaudi::Interfaces::IFileSvc > | |
| CFileSvc | Implementation of the IFileSvc interface, allowing algorithms to access ROOT files via a centralized service, and ensuring that files are shared appropriately and not unintentionally overwritten or duplicated |
| Cextends< Service, IRandomGenSvc > | |
| CGaudi::Example::TinyExperiment::RandomGenSvc | |
| Cextends< Service, IIODataManager > | |
| CGaudi::IODataManager | |
| Cextends< Service, IMetaDataSvc > | |
| CGaudi::MetaDataSvc | |
| Cextends< Service, IFileCatalog, IFileCatalogMgr > | |
| CGaudi::MultiFileCatalog | This class constitutes the core of the XML based FileCatalog API within Gaudi |
| Cextends< Service, Gaudi::Interfaces::IParticlePropertySvc > | |
| CGaudi::ParticlePropertySvc | This service provides access to particle properties |
| Cextends< Service, ICondSvc > | |
| CGaudi::TestSuite::Conditions::CondSvc | Implementation of ICondSvc used for testing Allows declaration of one or more algorithms or data objects as belonging to the "conditions realm" The scheduler will then treat them differently |
| Cextends< Service, Gaudi::ISignalMonitor > | |
| CGaudi::Utils::SignalMonitorSvc | Implementation of Gaudi::ISignalMonitor |
| Cextends< Service, IHistorySvc, IIncidentListener > | |
| CHistorySvc | HistorySvc class definition |
| Cextends< Service, IDataBroker > | |
| CHiveDataBrokerSvc | |
| Cextends< Service, IEventProcessor > | |
| CHiveSlimEventLoopMgr | |
| CMinimalEventLoopMgr | This is the default processing manager of the application manager |
| Cextends< MinimalEventLoopMgr, Gaudi::Interfaces::IQueueingEventProcessor > | |
| CGaudi::TestSuite::QueueingEventLoopMgr | |
| CEventLoopMgr | Class definition of EventLoopMgr |
| Cextends< Service, IIncidentListener, IIncidentAsyncTestSvc > | |
| CIncidentAsyncTestSvc | |
| Cextends< Service, IIncidentSvc > | |
| CIncidentSvc | Default implementation of the IIncidentSvc interface |
| Cextends< Service, IIoComponentMgr, IIncidentListener > | |
| CIoComponentMgr | |
| Cextends< Service, Gaudi::Interfaces::IOptionsSvc > | |
| CJobOptionsSvc | |
| Cextends< Service, IMessageSvc, IInactiveMessageCounter > | |
| CMessageSvc | |
| CInertMessageSvc | Thread safe extension to the standard MessageSvc |
| Cextends< Service, IPartPropSvc > | |
| CPartPropSvc | |
| Cextends< Service, IConversionSvc, IPersistencySvc, IAddressCreator > | |
| CPersistencySvc | PersistencySvc class implementation definition |
| CDetPersistencySvc | |
| CEvtPersistencySvc | EvtPersistencySvc class implementation definition |
| CHistogramPersistencySvc | HistogramPersistencySvc class implementation definition |
| Cextends< Service, IPrecedenceSvc > | |
| CPrecedenceSvc | A service to resolve the task execution precedence |
| Cextends< Service, IRndmEngine, ISerialize > | |
| CRndmEngine | Random Generator engine definition |
| CHepRndm::BaseEngine | |
| CHepRndm::Engine< DualRand > | |
| CHepRndm::Engine< TripleRand > | |
| CHepRndm::Engine< DRand48Engine > | |
| CHepRndm::Engine< Hurd160Engine > | |
| CHepRndm::Engine< Hurd288Engine > | |
| CHepRndm::Engine< HepJamesRandom > | |
| CHepRndm::Engine< MTwistEngine > | |
| CHepRndm::Engine< RanecuEngine > | |
| CHepRndm::Engine< Ranlux64Engine > | |
| CHepRndm::Engine< RanluxEngine > | |
| CHepRndm::Engine< RanshiEngine > | |
| CHepRndm::Engine< TYPE > | |
| CHepRndm::SynchronizedEngine< Engine > | |
| Cextends< Service, IRndmGenSvc, IRndmEngine, ISerialize > | |
| CRndmGenSvc | Random Generator service definition |
| Cextends< Service, ITHistSvc, IIncidentListener, IIoComponent > | |
| CTHistSvc | |
| Cextends< Service, IThreadPoolSvc, Gaudi::Concurrency::ConcurrencyManager > | |
| CThreadPoolSvc | A service which initializes a TBB thread pool |
| Cextends< Service, ITimelineSvc > | |
| CTimelineSvc | |
| Cextends< Service, IToolSvc > | |
| CToolSvc | This service manages tools |
| Cextends< Service, IFileAccess > | |
| CVFSSvc | Simple service that allows to read files independently from the storage |
| CGaudi::Monitoring::BaseSink | Base class for all Sinks registering to the Monitoring Hub Should be extended by actual Sinks |
| CGaudi::Histograming::Sink::Base | |
| CGaudi::Histograming::Sink::Root | |
| CGaudi::Monitoring::JSONSink | |
| CGaudi::Monitoring::MessageSvcSink | Sink dedicated to printing messages to the MessageSvc |
| CGaudi::TestSuite::SvcWithoutInterface | |
| CGaudiTesting::FailingSvc | Special service that issue a failure in one of the transitions (for testing) |
| CGaudiTesting::SvcWithTool | Special service that issue a failure in one of the transitions (for testing) |
| CServiceA | |
| CServiceB | |
| CCommonMessaging< IPrecedenceRulesGraph > | |
| Cconcurrency::PrecedenceRulesGraph | |
| CCommonMessaging< BASE > | |
| CGaudi::Accumulators::Adder< Arithmetic, Atomicity > | An Adder ValueHandler operator(a, b) means a += b |
| CGaudi::Accumulators::Adder< unsigned long, Atomicity > | |
| CGaudi::Accumulators::details::MsgCounter::Handler< Atomicity > | |
| Cnlohmann::adl_serializer< std::chrono::duration< Rep, Period > > | |
| CGaudi::Utils::Aida2ROOT | Accessor to underlying ROOT-representation of transient histograms The actual code is imported from Bender project |
| CGaudi::Utils::AlgContext | Helper "sentry" class to automatize the safe register/unregister the algorithm's context |
| CAlgExecStateSvc::AlgExecStateInternal | Internal state of an algorithm |
| CAlgExecStateRef | Wrapper on an Algorithm state |
| CAlgExecStateRefConst | Wrapper on an Algorithm state, const version |
| Cconcurrency::AlgoProps | |
| Cprecedence::AlgoProps | |
| CAlgorithmManager::AlgorithmItem | |
| Cprecedence::AlgoTraceProps | |
| CAvalancheSchedulerSvc::AlgQueueSort | Comparison operator to sort the queues |
| CAlgsExecutionStates | The AlgsExecutionStates encodes the state machine for the execution of algorithms within a single event |
| CAlgTask | |
| CGaudiUtils::Allocator< Type > | Allocator |
| CGaudiUtils::AllocatorPool | Allocator pool |
| Cprecedence::AllPass | |
| CAIDA::Annotation::AnnotationItem | Internal private annotation item class |
| CGaudi::meta::detail::append1< List, I > | |
| CGaudi::meta::detail::appendN< typename, typename > | |
| CGaudi::meta::detail::appendN< interface_list< Is... >, append1< List, I >::type > | |
| CGaudi::meta::detail::appendN< interface_list< I, Is... >, List > | |
| CGaudi::meta::detail::appendN< interface_list< Is... >, interface_list<> > | |
| CGaudi::interface_list_cat< interface_list< I... > > | |
| CGaudi::interface_list_cat< interface_list< I1... >, interface_list< I2... > > | |
| CGaudi.Application | Gaudi application entry point |
| CGaudi::TestSuite::QueueingApplication | |
| CGaudi.Main.BootstrapHelper.AppMgr | |
| CGaudi::Allocator::Arena< Resource, T, DefaultResource > | Custom allocator holding a pointer to a generic memory resource |
| Cdetails::arg_helper< lambda > | |
| Cdetails::arg_helper< Ret(T::*)(Arg) const > | |
| Cgaudirun.ArgProcessor | |
| CContainers::array | |
| Cstd::array< T > | STL class |
| CGaudi::Accumulators::SigmasValueHandler< Arithmetic, Atomicity, ND >::OutputTypeTS | |
| CGaudi::Accumulators::details::CounterArrayInternal< Counter, N > | Internal class implementing an array of counters |
| CGaudi::Accumulators::CounterArray< Counter, N > | Generic class implementing an array of counters The only addition to a raw array is the constructor that allows to build names of the counters automatically from the index of the counter in the array There are 2 possibilities : |
| CGaudi::Histograming::Sink::ArthTypeAccessor | |
| CGaudi::Utils::AttribStringParser::Attrib | Simple class to wrap tag/value pairs |
| CGaudi::Utils::AttribStringParser | Parse attribute strings allowing iteration over the various attributes |
| CGaudi::Guards::AuditorGuard | It is a simple guard, which "locks" the scope for the Auditor Service is am exception-safe way |
| CAvgAcc | |
| CGaudi::Accumulators::AccumulatorSet< Arithmetic, Atomicity, AvgAcc< Atomicity, Arithmetic >::InputType, AvgAcc, SquareAcc > | |
| CGaudi::Accumulators::SigmaAccumulatorBase< Atomicity, Arithmetic, AvgAcc, SquareAcc > | SigmaAccumulatorBase |
| CGaudi::Accumulators::Axis< Arithmetic > | Definition of a default type of Histogram Axis It contains number of bins, min and max value plus a title and defines the basic type of Axis (non log) It may also contain labels for the bins |
| CGaudi::Histograming::Sink::details::Axis | Small helper struct representing the Axis of an Histogram |
| Cbackwards_compatibility_hack_time_timespan | |
| CBASE | |
| Cextends< BASE, IFSMCallbackHolder > | |
| CGaudi::FSMCallbackHolder< BASE > | Helper class to implement the IFSMCallbackHolder interface |
| Cextends< BASE, I1 > | |
| Cextends< BASE, I1, I2 > | |
| Cextends< BASE, I1, I2, I3 > | |
| Cextends< BASE, I1, I2, I3, I4 > | |
| Cextends< BASE, IDataHandleHolder > | |
| CDataHandleHolderBase< BASE > | |
| CEventContextFormatter< BASE > | Custom formatter for EventContext to support std::format and fmt |
| CPropertyHolder< BASE > | Helper class to implement the IProperty interface |
| Cextends< BASE, Interfaces > | Base class used to extend a class implementing other interfaces |
| CGaudi::FSMCallbackHolder< Gaudi::Algorithm > | |
| CGaudi::TestSuite::Counter::GaudiHistoAlgorithm | Example of algorithm using histograms accumulators |
| CGaudi::TestSuite::Counter::GaudiRootHistoAlgorithm | Example of algorithm using root histograms accumulators |
| CBase | |
| CGaudi::NTuple::FileHolder< Base > | Small class wrapping an algorithm and adding management of a Root File via the FileSvc |
| CGaudi::TestSuite::Conditions::ConditionAccessorHolder< Base > | Example of a ConditionAccessorHolder implementation |
| Cimplementation_detail::add_name< Base > | |
| Cimplementation_detail::add_serviceLocator< Base > | |
| CBase... | |
| CGaudi::Functional::Traits::use_<> | |
| CGaudi::Functional::Traits::use_< Gaudi::Functional::Traits::writeViewFor< Data, View >, BaseClass_t > | |
| CGaudi::Functional::Traits::use_< Base > | |
| CGaudi::Functional::details::detail2::BaseClass< Tr, Default > | |
| CGaudi::Functional::details::detail2::BaseClass< Tr, Default > | |
| CBaseClass_t | |
| CGaudi::Functional::details::DataHandleMixin< type_list< Out... >, type_list< In... >, Traits_ > | |
| CGaudi::Functional::details::DataHandleMixin< std::tuple< Out... >, std::tuple< In... >, Traits_ > | |
| Cdetails::BaseClass_t | |
| Cextends< details::BaseClass_t< Traits, AlgTool >, Gaudi::Interface::Bind::IBinder< IFace > > | |
| CGaudi::Functional::details::ToolBinder< Gaudi::Interface::Bind::Box< IFace >(Args const &...), Traits > | |
| CGaudi::Functional::Traits::BaseClass_t< Base > | |
| CBases | |
| CGaudi::Accumulators::AccumulatorSet< Arithmetic, Atomicity, InputTypeT, Bases > | AccumulatorSet is an Accumulator that holds a set of Accumulators templated by same Arithmetic and Atomicity and increase them altogether |
| CGaudi::Accumulators::AveragingAccumulatorBase< Atomicity, Arithmetic, CountAccumulator, SumAccumulator > | |
| CGaudi::Accumulators::BufferableCounter< atomicity::full, AveragingAccumulator, double > | |
| CGaudi::Accumulators::AveragingCounter< Arithmetic, Atomicity > | A counter aiming at computing sum and average |
| CGaudi::Accumulators::BufferableCounter< atomicity::full, AveragingAccumulator, unsigned int > | |
| CGaudi::Accumulators::AveragingCounter< unsigned int > | |
| CGaudi::Accumulators::BufferableCounter< Atomicity, AveragingAccumulator, double > | |
| CGaudi::Accumulators::AveragingCounter< double, Gaudi::Accumulators::atomicity::none > | |
| CGaudi::Accumulators::BufferableCounter< atomicity::full, AveragingAccumulator, std::size_t > | |
| CGaudi::Accumulators::AveragingCounter< std::size_t > | |
| CGaudi::Accumulators::AveragingAccumulatorBase< Atomicity, Arithmetic, WeightedCountAccumulator, WeightedSumAccumulator > | |
| CGaudi::Accumulators::SigmaAccumulatorBase< Atomicity, Arithmetic, AveragingAccumulator, SquareAccumulator > | |
| CGaudi::Accumulators::AccumulatorSet< Arithmetic, Atomicity, Arithmetic, SigmaAccumulator, MinAccumulator, MaxAccumulator > | |
| CGaudi::Accumulators::AccumulatorSet< double, Gaudi::Accumulators::atomicity::full, double, Gaudi::Accumulators::StatAccumulator, Gaudi::Accumulators::BinomialAccumulator > | |
| CStatEntity | Backward compatible StatEntity class |
| CGaudi::Accumulators::BufferableCounter< atomicity::full, StatAccumulator, double > | |
| CGaudi::Accumulators::StatCounter< Arithmetic, Atomicity > | A counter aiming at computing average and sum2 / variance / standard deviation |
| CGaudi::Accumulators::BufferableCounter< atomicity::full, SigmaAccumulator, double > | |
| CGaudi::Accumulators::SigmaCounter< Arithmetic, Atomicity > | A counter aiming at computing average and sum2 / variance / standard deviation |
| CGaudi::Accumulators::SigmaAccumulatorBase< Atomicity, Arithmetic, WeightedAveragingAccumulator, WeightedSquareAccumulator > | |
| CGaudi::Accumulators::BaseValueHandler< Arithmetic, Atomicity > | Base type for all functors used as ValuesHandler |
| CGaudi::Accumulators::BaseValueHandler< Arithmetic, atomicity::full > | BaseValueHandler specialization in the case of atomicity full |
| CGaudi::Accumulators::Adder< Arithmetic, atomicity::full > | Adder specialization in the case of atomicity full |
| CGaudi::Accumulators::Extremum< Arithmetic, atomicity::full, Compare, Initial > | Extremum specialization in the case of atomicity full |
| CGaudi::Accumulators::BaseValueHandler< Arithmetic, atomicity::none > | BaseValueHandler specialization in the case of atomicity none |
| CGaudi::Accumulators::Adder< Arithmetic, atomicity::none > | Adder specialization in the case of atomicity none |
| CGaudi::Accumulators::Extremum< Arithmetic, atomicity::none, Compare, Initial > | Extremum specialization in the case of atomicity none |
| Cstd::basic_string< Char > | STL class |
| Cstd::string | STL class |
| CGaudi::Parsers::InputData | Helper class to enable ADL for parsers |
| CGaudi::Histograming::Sink::BinAccessor | |
| CGaudi::Histograming::Sink::details::BinAvValue< TYPE > | |
| CGaudi::Accumulators::BinomialAccumulator< Atomicity, Arithmetic >::binomial_t | |
| CWideNTupleAlgorithm::Block | One booked tuple and everything written into it |
| CGaudi.Main.BootstrapHelper | |
| CGaudi::Details::Property::BoundedVerifier< TYPE > | |
| CGaudi::Interface::Bind::Box< IFace > | |
| CGaudi::details::BranchReadHelper | |
| CGaudi::details::BranchWrapper | Encapsulates a branch within a ROOT TTree, managing the data and interaction with the TTree |
| CRootHistCnv::RCWNTupleCnv::Buffered | |
| CROOT::Math::Cartesian3D< T > | |
| CGaudi::Parsers::Catalog | |
| CStatusCode::Category | The category assigned to a StatusCode |
| CGaudi::Functional::FilterDecisionErrorCategory | |
| CCause | |
| Cprecedence::CFDecision | |
| Ccgaudi_factory_t | |
| Ccgaudi_pluginsvc_t | |
| Ccgaudi_property_t | |
| 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 |
| CCLibSymbolInfo | |
| CGaudi::NTuple::DiskBuffer::details::Close | |
| CGaudi::Decays::CC::CmpCC | Bit specific comparison of strings, useful for ordering according to the length as the primary parameter |
| CGaudiTesting.utils.CodeWrapper | |
| CColorMgs | Algorithm to test the color setting options of MsgService |
| CCommonMessagingBase | |
| CCommonMessaging< implements< IAlgTool, IDataHandleHolder, IProperty, IStateful > > | |
| CCommonMessaging< implements< IAppMgrUI, Gaudi::Interfaces::IQueueingEventProcessor, IService, IStateful, INamedInterface, IProperty > > | |
| CCommonMessaging< implements< IComponentManager > > | |
| CCommonMessaging< implements< IAlgorithm, IDataHandleHolder, IProperty, IStateful > > | |
| CCommonMessaging< implements< IAuditor, IProperty > > | |
| CCommonMessaging< implements< IService, IProperty, IStateful > > | |
| CCommonMessaging< IPrecedenceRulesGraph > | |
| CCommonMessaging< BASE > | |
| CGaudi::ParticleProperty::Compare | The comparison criteria for particle properties |
| CParticleProperty::Compare | The comparison criteria for particle properties |
| CCompareFirstOfPointerPair_t | |
| Cconcurrency::CompareNodes< T > | |
| CConcurrencyFlags | Provides information about the level of concurrency of the currently executing job |
| CGaudi::Concurrency::ConcurrencyFlags | |
| CGaudi::TestSuite::Conditions::ConditionAccessorHolder< Base >::ConditionAccessor< T > | Class wrapping the communication between condition users and conditions backend |
| CGaudi::TestSuite::Conditions::details::ConditionsStore | Example class to implement an actual backend for Gaudi::TestSuite::Conditions::ConditionAccessorHolder |
| CGaudiConfig2._db.ConfDB2 | |
| CconfigGenerator | |
| CGaudiConfig2._db.ConfigurablesDB | |
| CNTupleSvc::Connection | |
| Cstring::const_iterator | STL iterator class |
| Cvector< T >::const_iterator | STL iterator class |
| Cstring::const_reverse_iterator | STL iterator class |
| Cvector< T >::const_reverse_iterator | STL iterator class |
| CGaudi::Accumulators::Constant< T, N > | A functor always returning the value N |
| CLockedHandle< T, MutexType >::ConstGuard | |
| CGaudi::Accumulators::construct_empty_t | Constant used to disambiguate construction of an empty Accumulator versus the copy constructor |
| CGaudi::Functional::details::Consumer< Signature, Traits_, isLegacy > | |
| CGaudi::Functional::details::Consumer< Signature, Traits_, details::isLegacy< Traits_ > > | |
| CGaudi::NTuple::FileHolder< Gaudi::Functional::Consumer< void(const INPUTs &...), Traits_ > > | |
| CGaudi::NTuple::SimpleWriter< std::tuple< OUTPUTs... >(const INPUTs &...), Traits_ > | Specialized Algorithm for NTuple writing |
| CGaudi::NTuple::Writer< std::tuple< OUTPUTs... >(const INPUTs &...), Traits_ > | Specialized algorithm for NTuple writing when exactly one entry is written per event and a transformation is used to convert INPUTS to the stored items, aka OUTPUTS |
| CCounterAlg | Simple algorithm illustrating the usage of different "counters" |
| CGaudi::Example::TinyExperiment::CheckerAlg | Comparison of Reconstructed Tracks and MCTracks |
| CGaudi::TestSuite::ContextConsumer | |
| CGaudi::TestSuite::ContextIntConsumer | |
| CGaudi::TestSuite::CountingConsumer | |
| CGaudi::TestSuite::EventCounter | |
| CGaudi::TestSuite::FloatDataConsumer | |
| CGaudi::TestSuite::IntDataConsumer | |
| CGaudi::TestSuite::NTuple::CounterDataConsumer | |
| CGaudi::TestSuite::NTuple::FloatDataConsumer | |
| CGaudi::TestSuite::NTuple::IntVectorDataConsumer | |
| CGaudi::TestSuite::NTuple::StrDataConsumer | |
| CGaudi::TestSuite::NTuple::StructDataConsumer | |
| CGaudi::TestSuite::ShrdPtrConsumer | |
| CGaudi::TestSuite::StringDataConsumer | |
| CGaudi::TestSuite::THDataConsumer | |
| CGaudi::TestSuite::TestObjectVersion::UseObject | |
| CGaudi::TestSuite::ToolConsumer | |
| CGaudi::TestSuite::UseSvcWithoutInterface | |
| CGaudi::TestSuite::VoidConsumer | |
| CGaudi::Tests::Histograms::AxesLabels::HistWithLabelsAlg | |
| CGaudi::Tests::Histograms::CustomAxis::EnumAxisAlg | |
| CGaudi::Tests::Histograms::Directories::HistoGroupsAlg | |
| CGaudi::Tests::Histograms::MultiDimLayout::TestAlg | |
| CGaudiTestSuite::GaudiPPS | Small algorithm using Gaudi::ParticlePropertySvc |
| CGetIntView | |
| CGetStringView | |
| CContainedAccumulator | |
| CGaudi::Accumulators::Buffer< ContainedAccumulator, Atomicity, Args > | Buffer is a non atomic Accumulator which, when it goes out-of-scope, updates the underlying thread-safe Accumulator for all previous updates in one go |
| 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_type > | |
| CKeyedObject< int > | |
| CGaudi::TestSuite::MyTrack | |
| CGaudi::TestSuite::MyVertex | Simple class that represents a vertex for testing purposes |
| CGaudi::TestSuite::S | |
| CKeyedObject< KEY > | Definition of the templated KeyedObject class |
| CGaudi::details::container< CONTAINER > | Helper structure to get container type |
| CGaudi::ContainerSection | |
| 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::ContextSpecificPtr< T > | Simple implementation of a smart pointer with different values for different event contexts (slots) |
| Cconcurrency::ControlFlowNode | |
| Cconcurrency::AlgorithmNode | |
| Cconcurrency::DecisionNode | |
| CControlFlow.ControlFlowNode | (c) Copyright 1998-2026 CERN for the benefit of the LHCb and ATLAS collaborations # # This software is distributed under the terms of the Apache version 2 licence, # copied verbatim in the file "LICENSE" |
| CControlFlow.AndNode | |
| CControlFlow.ControlFlowLeaf | |
| CControlFlow.ControlFlowBool | |
| CControlFlow._TestAlgorithm | |
| CControlFlow.InvertNode | |
| CControlFlow.OrNode | |
| CControlFlow.OrderedNode | |
| CControlFlow.ignore | |
| CControlFlow.par | |
| CControlFlow.seq | |
| CControlFlowNode | |
| CGaudiKernel.Configurable.SuperAlgorithm | |
| CConfiguration.Gaudi_Test_MySuperAlg | |
| CSuperAlgDynamicGraph.MySuperAlg | Job options file |
| CConverterID | |
| CGaudiMP.GMPBase.Coord | |
| CCountAcc | |
| CGaudi::Accumulators::AccumulatorSet< Arithmetic, Atomicity, CountAcc< Atomicity, Arithmetic >::InputType, CountAcc, SumAcc > | |
| CGaudi::Accumulators::AveragingAccumulatorBase< Atomicity, Arithmetic, CountAcc, SumAcc > | AveragingAccumulatorBase |
| CGaudiKernel.Configurable.CreateSequencesVisitor | |
| Cprecedence.CruncherSequence | |
| CGaudi::Accumulators::CustomAxis | |
| Chivetimeline.Data | |
| CGaudi::DataHandle | |
| CDataObjectHandleBase | DataObjectHandleBase GaudiKernel/DataObjectHandleBase.h |
| CDataObjectHandle< Payload_t< Gaudi::DataHandle::Writer, T, U > > | |
| CDataObjectWriteHandle< View, Data > | |
| CDataObjectWriteHandle< OpaqueView, Data > | |
| CDataObjectWriteHandle< std::vector< int > > | |
| CDataObjectWriteHandle< int > | |
| CDataObjectWriteHandle< Gaudi::TestSuite::Collision > | |
| CDataObjectWriteHandle< T, U > | |
| CDataObjectHandle< Payload_t< Gaudi::DataHandle::Reader, T, U > > | |
| CDataObjectReadHandle< std::vector< int > > | |
| CDataObjectReadHandle< IDataStoreLeaves::LeavesList > | |
| CDataObjectReadHandle< float > | |
| CDataObjectReadHandle< Gaudi::TestSuite::Collision > | |
| CDataObjectReadHandle< T > | |
| CDataObjectHandle< DataObject > | |
| CDataObjectHandle< AnyDataWithViewWrapper< View, Owned > > | Specialization for AnyDataWithViewWrapper |
| CDataObjectHandle< AnyDataWrapper< T > > | Specialization for AnyDataWrapper |
| CDataObjectHandle< Gaudi::NamedRange_< T > > | Specialization for NamedRange_ |
| CDataObjectHandle< Gaudi::Range_< T > > | Specialization for Range_ |
| CDataObjectHandle< std::optional< Gaudi::NamedRange_< T > > > | Specialization for optional<NamedRange_> |
| CDataObjectHandle< T > | DataObjectHandle.h GaudiKernel/DataObjectHandle.h |
| CDataObjectHandle< AnyDataWithViewWrapper< View, Owned > > | Specialization for AnyDataWithViewWrapper |
| CDataObjectHandle< AnyDataWrapper< T > > | Specialization for AnyDataWrapper |
| CDataObjectHandle< Gaudi::NamedRange_< T > > | Specialization for NamedRange_ |
| CDataObjectHandle< Gaudi::Range_< T > > | Specialization for Range_ |
| CDataObjectHandle< std::optional< Gaudi::NamedRange_< T > > > | Specialization for optional<NamedRange_> |
| CGaudiKernel.DataHandle.DataHandle | |
| CDataHandleMixin | |
| CGaudi ::Functional::details::MultiTransformer< std::tuple< Out... >(const In &...), Traits_, false > | |
| CGaudi ::Functional::details::MultiTransformer< std::tuple< Out... >(const In &...), Traits_, true > | |
| CGaudi ::Functional::details::MultiTransformerFilter< std::tuple< Out... >(const In &...), Traits_ > | |
| CGaudi ::Functional::details::Transformer< Out(const In &...), Traits_, false > | |
| CGaudi ::Functional::details::Transformer< Out(const In &...), Traits_, true > | |
| CGaudi::Functional::details::DataHandleMixin< OutputSpec, InputSpec, Traits_ > | |
| CGaudi::Functional::details::DataHandleMixin< Outputs, type_list< handle_vector_input_t< Args >... >, Traits_ > | |
| CGaudi::Functional::MergingMultiTransformer< std::tuple< Outs... >(const Args &...), Traits_ > | |
| CGaudi::Functional::MergingMultiTransformerFilter< std::tuple< Outs... >(const Args &...), Traits_ > | |
| CGaudi::Functional::details::MergingTransformer< Out(const Args &...), Traits_, false > | |
| CGaudi::Functional::details::MergingTransformer< Out(const Args &...), Traits_, true > | |
| CGaudi::Functional::details::SplittingMergingTransformer< vector_of_< Out >(const Args &...), Traits_ > | |
| CGaudi::Functional::details::DataHandleMixin< type_list< details::vector_of_output_< Out > >, type_list< In... >, Traits_ > | |
| CGaudi::Functional::details::SplittingTransformer< vector_of_< Out >(const In &...), Traits_ > | |
| CGaudi::Functional::details::DataHandleMixin< type_list<>, InputSpec, Traits_ > | |
| CGaudi::Functional::details::DataHandleMixin< type_list< void >, InputSpec, Traits_ > | |
| CGaudi::Functional::details::DataHandleMixin< type_list<>, type_list< In... >, Traits_ > | |
| CGaudi::Functional::details::Consumer< void(const In &...), Traits_, false > | |
| CGaudi::Functional::details::Consumer< void(const In &...), Traits_, true > | |
| CGaudi::Functional::details::FilterPredicate< bool(const In &...), Traits_, false > | |
| CGaudi::Functional::details::FilterPredicate< bool(const In &...), Traits_, true > | |
| CGaudiKernel.DataHandle.DataHandleVector | |
| CGaudi::DataHandleVectorBase | Type-erased interface for a configurable sequence of data handles |
| CGaudi::DataHandleVector< OutputHandleFor< Tr, Default >::template type, T > | |
| CGaudi::DataHandleVector< InputHandleFor< Tr, Default >::template type, T > | |
| CGaudi::DataHandleVector< DataObjectReadHandle, Gaudi::TestSuite::Collision > | |
| CGaudi::DataHandleVector< DataObjectWriteHandle, Gaudi::TestSuite::Collision > | |
| CGaudi::DataHandleVector< Handle, T > | A configurable, dynamically sized sequence of homogeneous data handles |
| 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 | |
| Cconcurrency::ConditionNode | |
| CDataObject | A DataObject is the base class of any identifiable object on any data store |
| CAnyDataWrapperBase | |
| CAnyDataWrapper< ViewType > | |
| CAnyDataWithViewWrapper< ViewType, OwnedType > | |
| 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 |
| CGaudi::TestSuite::Collision | |
| CGaudi::TestSuite::Counter | Simple counter object |
| CGaudi::TestSuite::Event | Essential information of the event used in examples It can be identified by "/Event" |
| CHistoryObj | Base class for History Objects |
| CAlgToolHistory | AlgToolHistory class definition |
| CAlgorithmHistory | AlgorithmHistory 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< MyTrack, Containers::HashMap > | |
| CKeyedContainer< MyTrack > | |
| CKeyedContainer< MyVertex > | |
| CKeyedContainer< KeyedObject< int >, Containers::HashMap > | |
| CKeyedContainer< S, Containers::HashMap > | |
| CKeyedContainer< KeyedObject< std::size_t > > | |
| CKeyedContainer< DATATYPE, MAPPING > | |
| CKeyedContainer< Gaudi::TestSuite::MyTrack > | |
| CKeyedContainer< Gaudi::TestSuite::MyVertex > | |
| CObjectList< ContainedObject > | |
| CObjectVector< ContainedObject > | |
| CObjectVector< Gaudi::TestSuite::MyTrack > | |
| CObjectVector< Gaudi::TestSuite::MyVertex > | |
| CSharedObjectsContainer< MyTrack > | |
| CSharedObjectsContainer< S > | |
| 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 |
| CDataObjID | |
| CDataObjID_Hasher | |
| Cconcurrency::DataProps | |
| Cprecedence::CondDataProps | |
| Cprecedence::DataProps | |
| Cprecedence::CondDataProps | |
| CDataStoreItem | Description of the DataStoreItem class |
| CDataTypeInfo | Small class which allows access to internal type IDs |
| CGaudi::Decays::Decay | The simple representation of "simple 1-step" decay (there are no trees! |
| Cconcurrency::DecisionHubProps | |
| Cprecedence::DecisionHubProps | |
| Cprecedence::DecisionNegation | |
| CContainers::array::decrement | |
| Cdefaultdict | |
| Cfixtures.AlwaysTrueDefaultDict | |
| CGaudi::Functional::details::detail2::DefaultInputHandle< T > | |
| CGaudi::Functional::details::detail2::DefaultInputHandle< EventContext > | |
| CGaudi::Functional::details::detail2::DefaultInputHandle< T > | |
| CGaudiKernel.Configurable.Configurable.DefaultName | |
| CGaudi::Details::Property::DefaultStringConverterImpl< TYPE > | |
| CGaudi::Details::Property::DefaultStringConverter< TYPE > | |
| CGaudi::Details::Property::StringConverter< TYPE > | |
| CGaudi::Details::Property::DefaultStringConverter< TYPE > | |
| CGaudi::Details::Property::StringConverter< DataObjIDColl > | |
| CGaudi::Details::Property::StringConverter< DataObjIDVector > | |
| CGaudi::Details::Property::DefaultStringConverter< TYPE > | |
| CGaudi::Functional::details::deref_t | |
| CGaudi::cpp17::details::detector< Default, AlwaysVoid, Op, Args > | Implementation of the detection idiom (negative case) |
| CGaudi::cpp17::details::detector< Default, std::void_t< Op< Args... > >, Op, Args... > | Implementation of the detection idiom (positive case) |
| CGaudi::CUDA::DeviceArray< T > | |
| CGaudi::CUDA::DeviceArrayGlobalTag_t | |
| CDHH | |
| Cdict | |
| CGaudiKernel.ConfigurableDb._CfgDb | |
| CGaudiMP.FdsRegistry.FdsDict | |
| CDirSearchPath | Search for files in a list of directories |
| CROOT::Math::DisplacementVector3D< CoordSystem, Tag > | |
| CControlFlow.DotVisitor | |
| CGaudiKernel.Configurable.DummyDescriptor | |
| Cprecedence::Duration | |
| Cprecedence::EndTime | |
| CGaudi::Monitoring::Hub::Entity | Wrapper class for arbitrary monitoring objects |
| CGaudi::Monitoring::BaseSink::EntityOrder | List of entities we are dealing with |
| Cprecedence::EntityState | |
| CGaudi::IODataManager::Entry | |
| CDirSearchPath::eqPath | Name |
| CToolSvc::ToolList::Equal | |
| CGaudiMP.GMPBase.EventCommunicator | |
| CEventContext | This class represents an entry point to all the event specific data |
| CGaudi::Functional::details::EventContextHandle | |
| 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 > | |
| CEventSlot | Class representing an event slot |
| CGaudi::TestSuite::Eventually | |
| CException | |
| CGaudiTesting.FixtureResult.ExceededStreamError | |
| CGaudiTesting.FixtureResult.ProcessTimeoutError | |
| Cstd::exception | STL class |
| CGaudi::PluginService::v1::Exception | |
| CGaudiException | Define general base for Gaudi exception |
| CTimeException | Exception thrown by Gaudi::Time |
| Cstd::runtime_error | STL class |
| CGaudi::NTuple::DiskBuffer::Error | Any I/O or format problem, carrying the file it happened on |
| 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::Accumulators::ExtractWeight | A functor to extract weight, take a pair (valueTuple, weight) as input |
| CGaudi::Accumulators::Extremum< Arithmetic, Atomicity, Compare, Initial > | An Extremum ValueHandler, to be reused for Minimum and Maximum operator(a, b) means if (Compare(b,a)) a = b In case of full atomicity, compare_exchange_weak is used |
| CGaudi::PluginService::v1::Details::Factory< T > | Class providing default factory functions |
| CGaudi::PluginService::v1::Factory< R, Args > | Class wrapping the signature for a factory with any number of arguments |
| CGaudi::PluginService::v1::Details::Registry::FactoryInfo | |
| Cgaudirun.FakeModule | |
| Cstd::false_type | |
| CGaudi::Monitoring::details::has_mergeAndReset_method< Arg, std::void_t< decltype(mergeAndReset(std::declval< Arg & >(), std::declval< Arg & >()))> > | |
| CGaudi::Monitoring::details::has_reset_method< Arg, std::void_t< decltype(reset(std::declval< Arg & >()))> > | |
| CGaudi::Monitoring::details::has_mergeAndReset_method< Arg, typename > | |
| CGaudi::Monitoring::details::has_reset_method< Arg, typename > | |
| Cfmt::is_range< Gaudi::Property< T, V, H >, Char > | Definitions to allow use of Gaudi::Property<T> with fmtlib |
| Cis_StatusCode_enum< T > | |
| CGaudi::Accumulators::FalseTo1 | Helper functor for the FalseAccumulator |
| CFiberManager | The FiberManager manages a pool of threads used to run boost::fiber fibers |
| Cupdate_version.Fields | |
| CFileAttr | |
| CIo::FileAttr | |
| CGaudiPython.Persistency.FileDescription | |
| CFileHdlr | |
| CIo::FileHdlr | |
| CGaudiTesting.preprocessors.FilePreprocessor | |
| CGaudiTesting.preprocessors.BlockSkipper | |
| CGaudiTesting.preprocessors.FilePreprocessorSequence | |
| CGaudiTesting.preprocessors.LineSkipper | |
| CGaudiTesting.preprocessors.LineSorter | |
| CGaudiTesting.preprocessors.RegexpReplacer | |
| CGaudiTesting.preprocessors.SortGroupOfLines | |
| CGaudiMP.pTools.FileRecordsAgent | |
| Cupdate_version.FileUpdater | |
| Clogging.Filter | |
| CGaudiKernel.ProcessJobOptions.LogFilter | |
| CGaudi::Functional::details::FilterPredicate< T, Traits_, isLegacy > | |
| CGaudi::Functional::details::FilterPredicate< Signature, Traits_, details::isLegacy< Traits_ > > | |
| CGaudi::TestSuite::CountSelectedTracks | |
| CGaudi::TestSuite::Prescaler | |
| Cfinal_action< F > | |
| CContainers::find< CONT > | |
| CGaudi::Parsers::KeyValueGrammar< Iterator, Skipper >::first | |
| CGaudi::Functional::details::first_or_empty< Tuple > | |
| CGaudi::Functional::details::first_or_empty< std::tuple< First, Rest... > > | |
| CGaudiTesting.FixtureResult.FixtureResult | |
| CGaudi::TestSuite::Foo | |
| CGaudi::Accumulators::details::FormatCounterDefault | Default formating for counter names, only calling std::format on the text given at construction and passing the histo index as argument |
| CGaudi::Accumulators::details::FormatHistDefault | Default formating for histogram names and title, only calling fmt::format on the text given at construction and passing the histo index as argument |
| CGaudi::Accumulators::details::FormatHistDefaultT< Key > | Default formating for histogram names and title, only calling fmt::format on the text given at construction and passing the key as argument |
| Clogging.Formatter | |
| CGaudiKernel.ProcessJobOptions.LogFormatter | |
| Cfmt::formatter | |
| CEventContextFormatter< fmt::formatter< std::string_view > > | |
| Cfmt::formatter< EventContext > | |
| Cstd::formatter | |
| CEventContextFormatter< std::formatter< std::string_view > > | |
| Cstd::formatter< EventContext > | |
| Cfmt::formatter< Gaudi::Histograming::Sink::detail::IntWithFixedWidth > | Fmt dedicated formatter for IntWithFixedWidth |
| Cfmt::formatter< json_fmt_arg > | Fmt formatter function for json class able to handle 2 types of formats : {} : in this case the type entry of json is used to deduce what to print, looking into the registry {:name|fmt} : in this case, the entry 'name' of the json will be printed in given format |
| CGaudi::fullMatch_t | |
| CGaudi | This is a number of static methods for bootstrapping the Gaudi framework |
| CGaudiTesting::GaudiEnv | |
| CGaudiKernel.GaudiHandles.GaudiHandle | |
| CGaudiKernel.GaudiHandles.PrivateToolHandle | |
| CGaudiKernel.GaudiHandles.PublicToolHandle | |
| CGaudiKernel.GaudiHandles.ServiceHandle | |
| CGaudiHandleInfo | |
| CGaudiHandleArrayBase | Base class of array's of various gaudihandles |
| CGaudiHandleArray< ServiceHandle< T > > | |
| CServiceHandleArray< T > | Array of Handles to be used in lieu of vector of naked pointers to tools |
| CGaudiHandleArray< ToolHandle< T > > | |
| CToolHandleArray< T > | Array of Handles to be used in lieu of vector of naked pointers to tools |
| CPublicToolHandleArray< T > | Helper class to construct ToolHandle instances for public tools via the auto registering constructor |
| CGaudiHandleArray< ToolHandle< IMyTool > > | |
| CToolHandleArray< IMyTool > | |
| CPublicToolHandleArray< IMyTool > | |
| CGaudiHandleArray< ToolHandle< IThreadInitTool > > | |
| CToolHandleArray< IThreadInitTool > | |
| CGaudiHandleArray< T > | T is the concrete handle type, e.g |
| CGaudiHandleBase | Base class to handles to be used in lieu of naked pointers to various Gaudi components |
| CGaudiHandle< IAlgTool > | |
| CToolHandle< IAlgTool > | |
| CPublicToolHandle< IAlgTool > | |
| CToolHandle< Gaudi::Interface::Bind::IBinder< IFace > > | |
| CGaudiHandle< IToolSvc > | |
| CServiceHandle< IToolSvc > | |
| CGaudiHandle< IInterface > | |
| CServiceHandle< IInterface > | |
| CGaudiHandle< INTupleSvc > | |
| CServiceHandle< INTupleSvc > | |
| CGaudiHandle< IFileMgr > | |
| CServiceHandle< IFileMgr > | |
| CGaudiHandle< Gaudi::Example::TinyExperiment::IRandomGenSvc > | |
| CServiceHandle< Gaudi::Example::TinyExperiment::IRandomGenSvc > | |
| CGaudiHandle< Gaudi::Interfaces::IFileSvc > | |
| CServiceHandle< Gaudi::Interfaces::IFileSvc > | |
| CGaudiHandle< Gaudi::TestSuite::FloatTool > | |
| CToolHandle< Gaudi::TestSuite::FloatTool > | |
| CGaudiHandle< Gaudi::TestSuite::SvcWithoutInterface > | |
| CServiceHandle< Gaudi::TestSuite::SvcWithoutInterface > | |
| CGaudiHandle< Gaudi::Tests::Histograms::Directories::HistoGroupsTool > | |
| CToolHandle< Gaudi::Tests::Histograms::Directories::HistoGroupsTool > | |
| CGaudiHandle< IMyTool > | |
| CToolHandle< IMyTool > | |
| CPublicToolHandle< IMyTool > | |
| CGaudiHandle< GaudiTesting::ITestTool > | |
| CToolHandle< GaudiTesting::ITestTool > | |
| CGaudiHandle< IAlgContextSvc > | |
| CServiceHandle< IAlgContextSvc > | |
| CGaudiHandle< IWrongTool > | |
| CToolHandle< IWrongTool > | |
| CGaudiHandle< const IMyTool > | |
| CToolHandle< const IMyTool > | |
| CPublicToolHandle< const IMyTool > | |
| CGaudiHandle< IPartPropSvc > | |
| CServiceHandle< IPartPropSvc > | |
| CGaudiHandle< ITHistSvc > | |
| CServiceHandle< ITHistSvc > | |
| CGaudiHandle< IIncidentSvc > | |
| CServiceHandle< IIncidentSvc > | |
| CGaudiHandle< IThreadInitTool > | |
| CToolHandle< IThreadInitTool > | |
| CGaudiHandle< T > | Handle to be used in lieu of naked pointers to gaudis |
| CToolHandle< Gaudi::Interface::Bind::IBinder< std::decay_t< T > > > | |
| CToolHandle< Gaudi::Interface::Bind::IBinder< IFace > > | |
| 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 |
| CPublicToolHandle< T > | Helper class to construct ToolHandle instances for public tools via the auto registering constructor |
| CGaudi.Main.gaudimain | |
| CGaudi::TestSuite::GaudiObjectHandler< T > | |
| CRndm::Generator< TYPE > | |
| CGaudi::Accumulators::GenericAccumulator< InputTypeT, InnerType, Atomicity, InputTransform, OutputTransform, ValueHandler > | Generic Accumulator, templated by |
| CGaudi::Accumulators::GenericAccumulator< Args..., Args..., Atomicity, Identity > | |
| CGaudi::Accumulators::IntegralAccumulator< Atomicity, Args... > | |
| CGaudi::Accumulators::BufferableCounter< atomicity::full, IntegralAccumulator, unsigned long > | |
| CGaudi::Accumulators::Counter< Atomicity, Arithmetic > | A basic integral counter; |
| CGaudi::Accumulators::GenericAccumulator< Arithmetic, std::array< Arithmetic, 3 >, Atomicity, Identity, Identity, SigmasValueHandler< Arithmetic, Atomicity, 1 > > | |
| CGaudi::Accumulators::SigmaNAccumulator< Arithmetic, Atomicity, 1 > | Specialization for ND=1 to allow for better syntax |
| CGaudi::Accumulators::GenericAccumulator< Arithmetic, unsigned long, Atomicity, FalseTo1 > | |
| CGaudi::Accumulators::FalseAccumulator< Atomicity, Arithmetic > | FalseAccumulator |
| CGaudi::Accumulators::GenericAccumulator< Arithmetic, unsigned long, Atomicity, TrueTo1 > | |
| CGaudi::Accumulators::TrueAccumulator< Atomicity, Arithmetic > | TrueAccumulator |
| CGaudi::Accumulators::GenericAccumulator< bool, unsigned long, Atomicity, Identity, Identity, Handler< Atomicity > > | |
| CGaudi::Accumulators::MsgCounter< MSG::INFO > | |
| CGaudi::Accumulators::MsgCounter< MSG::ERROR > | |
| CGaudi::Accumulators::MsgCounter< MSG::WARNING > | |
| CGaudi::Accumulators::MsgCounter< level, Atomicity > | |
| CGaudi::Accumulators::GenericAccumulator< bool, unsigned long, Atomicity, TrueTo1 > | |
| CGaudi::Accumulators::TrueAccumulator< Atomicity, bool > | |
| CGaudi::Accumulators::AccumulatorSet< bool, Atomicity, bool, TrueAccumulator, FalseAccumulator > | |
| CGaudi::Accumulators::BinomialAccumulator< Gaudi::Accumulators::atomicity::full, double > | |
| CGaudi::Accumulators::BinomialAccumulator< Atomicity, Args... > | |
| CGaudi::Accumulators::BufferableCounter< atomicity::full, BinomialAccumulator, double > | |
| CGaudi::Accumulators::BinomialCounter< Arithmetic, Atomicity > | A counter dealing with binomial data |
| CGaudi::Accumulators::BinomialAccumulator< Atomicity, Arithmetic > | BinomialAccumulator |
| CGaudi::Accumulators::GenericAccumulator< double, double, Atomicity, Identity > | |
| CGaudi::Accumulators::SumAccumulator< Atomicity, Arithmetic > | SumAccumulator |
| CGaudi::Accumulators::GenericAccumulator< double, double, Atomicity, Identity, Identity, Maximum< double, Atomicity > > | |
| CGaudi::Accumulators::MaxAccumulator< Atomicity, Arithmetic > | MaxAccumulator |
| CGaudi::Accumulators::GenericAccumulator< double, double, Atomicity, Identity, Identity, Minimum< double, Atomicity > > | |
| CGaudi::Accumulators::MinAccumulator< Atomicity, Arithmetic > | MinAccumulator |
| CGaudi::Accumulators::GenericAccumulator< double, double, Atomicity, Square > | |
| CGaudi::Accumulators::SquareAccumulator< Atomicity, Arithmetic > | SquareAccumulator |
| CGaudi::Accumulators::GenericAccumulator< double, unsigned long, Atomicity, Constant< unsigned long, 1UL > > | |
| CGaudi::Accumulators::CountAccumulator< Atomicity, Arithmetic > | CountAccumulator |
| CGaudi::Accumulators::GenericAccumulator< std::array< Arithmetic, ND >, std::array< Arithmetic, NSUMS(ND)>, Atomicity, Identity, Identity, SigmasValueHandler< Arithmetic, Atomicity, ND > > | |
| CGaudi::Accumulators::SigmaNAccumulator< Arithmetic, Atomicity, 1 > | Specialization for ND=1 to allow for better syntax |
| CGaudi::Accumulators::SigmaNAccumulator< Arithmetic, Atomicity, ND > | |
| CGaudi::Accumulators::GenericAccumulator< std::pair< Arithmetic, Arithmetic >, Arithmetic, Atomicity, WeightedProduct > | |
| CGaudi::Accumulators::WeightedSumAccumulator< Atomicity, Arithmetic > | WeightedSumAccumulator |
| CGaudi::Accumulators::GenericAccumulator< std::pair< Arithmetic, Arithmetic >, std::pair< unsigned long, Arithmetic >, Atomicity, WeightedProfileTransform, ExtractWeight, WeightedAdder< Arithmetic, Atomicity > > | |
| CGaudi::Accumulators::WeightedCountAccumulator< Atomicity, Arithmetic > | WeightedCountAccumulator |
| CGaudi::Accumulators::GenericAccumulator< std::pair< double, double >, double, Atomicity, WeightedSquare > | |
| CGaudi::Accumulators::WeightedSquareAccumulator< Atomicity, Arithmetic > | WeightedSquareAccumulator |
| CGaudi::Accumulators::GenericAccumulator< unsigned long, unsigned long, Atomicity, Identity > | |
| CGaudi::Accumulators::IntegralAccumulator< Atomicity, Arithmetic > | IntegralAccumulator |
| CGaudiUtils::GenericHash< T > | Generic hash implementation (for easy migration to the new Hash class) |
| CGaudi::Timers::GenericTimer< Clock, Unit > | A generic timer based on std::chrono and Gaudi::Accumulators |
| CGaudi::Functional::details::details2::get_from_handle< In > | |
| CGlobalDirectoryRestore | |
| CTHistSvc::GlobalDirectoryRestore | Helper class that manages ROOts global directory and file |
| CGaudiMP.GMPBase.GMPComponent | |
| CGaudiMP.GMPBase.Reader | |
| CGaudiMP.GMPBase.Subworker | |
| CGaudiMP.GMPBase.Worker | |
| CGaudiMP.GMPBase.Writer | |
| Cqi::grammar | |
| CGaudi::Parsers::BoolGrammar< Iterator, Gaudi::Parsers::SkipperGrammar< IteratorT > > | |
| CGaudi::Parsers::BoolGrammar< Iterator, Gaudi::Parsers::SkipperGrammar< IteratorT > > | |
| CGaudi::Parsers::EdgeGrammar< Iterator, Gaudi::Parsers::SkipperGrammar< IteratorT > > | |
| CGaudi::Parsers::IdentifierGrammar< Iterator, Gaudi::Parsers::SkipperGrammar< IteratorT > > | |
| CGaudi::Parsers::IntGrammar< Iterator, T, Skipper > | |
| CGaudi::Parsers::IntGrammar< Iterator, unsigned int, Gaudi::Parsers::SkipperGrammar< IteratorT > > | |
| CGaudi::Parsers::MapGrammar< Iterator, std::map< KeyT, ValueT, KeyCompareT, AllocatorT >, Skipper > | |
| CGaudi::Parsers::MapGrammar< Iterator, std::unordered_map< KeyT, ValueT, HashT, KeyEqT, AllocatorT >, Skipper > | |
| CGaudi::Parsers::MapGrammar< Iterator, GaudiUtils::VectorMap< KeyT, ValueT, KeyCompareT, AllocatorT >, Skipper > | |
| CGaudi::Parsers::MapGrammar< Iterator, MyCustomType, Skipper > | |
| CGaudi::Parsers::PairGrammar< Iterator, std::pair< KeyT, ValueT >, Skipper > | |
| CGaudi::Parsers::Pnt3DGrammar< Iterator, ROOT::Math::PositionVector3D< T1, T2 >, Skipper > | |
| CGaudi::Parsers::Pnt3DGrammar< Iterator, ROOT::Math::DisplacementVector3D< T1, T2 >, Skipper > | |
| CGaudi::Parsers::Pnt4DGrammar< Iterator, ROOT::Math::LorentzVector< T1 >, Skipper > | |
| CGaudi::Parsers::RealGrammar< Iterator, T, Skipper > | |
| CGaudi::Parsers::RealGrammar< Iterator, double, Gaudi::Parsers::SkipperGrammar< IteratorT > > | |
| CGaudi::Parsers::RealGrammar< Iterator, Gaudi::Parsers::SkipperGrammar< IteratorT > > | |
| CGaudi::Parsers::RealGrammar< Iterator, T, Skipper > | |
| CGaudi::Parsers::RealGrammar< Iterator, double, Gaudi::Parsers::SkipperGrammar< IteratorT > > | |
| CGaudi::Parsers::RealGrammar< Iterator, Gaudi::Parsers::SkipperGrammar< IteratorT > > | |
| CGaudi::Parsers::SetGrammar< Iterator, std::unordered_set< InnerT, HashT, CompareT, AllocatorT >, Skipper > | |
| CGaudi::Parsers::SkipperGrammar< IteratorT > | |
| CGaudi::Parsers::SkipperGrammar< IteratorT > | |
| CGaudi::Parsers::StringGrammar< Iterator, Gaudi::Parsers::SkipperGrammar< IteratorT > > | |
| CGaudi::Parsers::StringGrammar< Iterator, Gaudi::Parsers::SkipperGrammar< IteratorT > > | |
| CGaudi::Parsers::TupleGrammar< Iterator, Skipper, Ts... > | |
| CGaudi::Parsers::VectorGrammar< Iterator, std::vector< InnerT, AllocatorT >, Skipper > | |
| CGaudi::Parsers::VectorGrammar< Iterator, std::list< InnerT, AllocatorT >, Skipper > | |
| CGaudi::Parsers::VectorGrammar< Iterator, std::set< InnerT, CompareT, AllocatorT >, Skipper > | |
| CGaudi::Parsers::VectorGrammar< Iterator, std::vector< double >, Gaudi::Parsers::SkipperGrammar< IteratorT > > | |
| CGaudi::Parsers::VectorGrammar< Iterator, std::vector< std::pair< double, double > >, Gaudi::Parsers::SkipperGrammar< IteratorT > > | |
| CGaudi::Parsers::VectorGrammar< Iterator, SetT, Gaudi::Parsers::SkipperGrammar< IteratorT > > | |
| CGaudi::Parsers::AxisGrammar< Iterator, Skipper, Arithmetic > | |
| CGaudi::Parsers::BoolGrammar< Iterator, Skipper > | |
| CGaudi::Parsers::BoolGrammar< Iterator, Skipper > | |
| CGaudi::Parsers::CharGrammar< Iterator, Skipper > | |
| CGaudi::Parsers::DataObjIDGrammar< Iterator, Skipper > | |
| CGaudi::Parsers::EdgeGrammar< Iterator, Skipper > | |
| CGaudi::Parsers::FileGrammar< Iterator, Skipper > | |
| CGaudi::Parsers::H1Grammar< Iterator, Skipper > | |
| CGaudi::Parsers::H2Grammar< Iterator, Skipper > | |
| CGaudi::Parsers::H3Grammar< 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< It, MapT, Skipper > | |
| CGaudi::Parsers::PairGrammar< Iterator, PairT, Skipper, Delim > | |
| CGaudi::Parsers::Pnt3DGrammar< Iterator, PointT, Skipper > | |
| CGaudi::Parsers::Pnt4DGrammar< Iterator, PointT, Skipper > | |
| CGaudi::Parsers::RealGrammar< Iterator, Skipper > | |
| CGaudi::Parsers::RealGrammar< Iterator, Skipper > | |
| CGaudi::Parsers::SetGrammar< Iterator, SetT, Skipper > | |
| CGaudi::Parsers::SkipperGrammar< Iterator > | |
| CGaudi::Parsers::SkipperGrammar< Iterator > | |
| CGaudi::Parsers::StringGrammar< Iterator, Skipper > | |
| CGaudi::Parsers::StringGrammar< Iterator, Skipper > | |
| CGaudi::Parsers::TupleGrammar< It, Skipper, Ts > | |
| CGaudi::Parsers::UnitsGrammar< Iterator, Skipper > | |
| CGaudi::Parsers::VectorGrammar< Iterator, VectorT, Skipper > | |
| CGaudi::Parsers::Grammar_< Iterator, T, Skipper, Enable > | |
| CGaudi::Parsers::Grammar_< Iterator, Gaudi::Accumulators::Axis< Arithmetic >, Skipper > | |
| CGaudi::Parsers::Grammar_< Iterator, GaudiUtils::VectorMap< KeyT, ValueT, KeyCompareT, AllocatorT >, Skipper > | |
| CGaudi::Parsers::Grammar_< Iterator, MyCustomType, 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, 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< Ts... >, Skipper > | |
| CGaudi::Parsers::Grammar_< Iterator, std::unordered_map< KeyT, ValueT, HashT, KeyEqT, AllocatorT >, Skipper > | |
| CGaudi::Parsers::Grammar_< Iterator, std::unordered_set< InnerT, HashT, CompareT, AllocatorT >, Skipper > | |
| CGaudi::Parsers::Grammar_< Iterator, std::vector< InnerT, AllocatorT >, Skipper > | |
| CGaudi::Parsers::Grammar_< Iterator, T, Skipper > | |
| CGaudi::Hive::Graph | Utilities to dump graphs in different formats |
| Cprecedence::GroupExit | |
| Cprecedence::GroupLogic | |
| Cprecedence::GroupMode | |
| CLockedHandle< T, MutexType >::Guard | |
| CGaudi::Functional::details::handle_vector_input< Arg > | |
| CGaudi::Functional::details::handle_vector_input< vector_of_const_< T > > | |
| CGaudiUtils::Hash< T > | Simple hash function |
| CGaudiUtils::Hash< T & > | Remove extra qualifiers: |
| CGaudiUtils::Hash< const T & > | Remove extra qualifiers: |
| CGaudiUtils::Hash< const T > | Remove extra qualifiers: |
| CToolSvc::ToolList::Hash | |
| CGaudiUtils::Hash< const Gaudi::ParticleID & > | |
| CGaudiUtils::Hash< const Gaudi::ParticleID > | |
| CGaudiUtils::Hash< const T(&)[N]> | Generic specialization for arrays |
| Cstd::hash< Gaudi::Details::PropertyId > | |
| CGaudiUtils::Hash< Gaudi::ParticleID & > | |
| CGaudiUtils::Hash< Gaudi::ParticleID > | |
| Cstd::hash< Gaudi::StringKey > | Specialization of hash function used in C++11 collections like std::unordered_map |
| CGaudiUtils::Hash< T * > | Partial specialization for pointers |
| CGaudiUtils::Hash< const T * > | Remove extra qualifiers: |
| CGaudiUtils::Hash< T(&)[N]> | Generic specialization for arrays |
| CExtendedProperties::HashFunction | |
| CContainers::hashmap | |
| CGaudiPython::Helper | |
| CHistogramSvc::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 | |
| CGaudi::Accumulators::HistogramArray< Histo, N, Seq > | Generic class implementing an array of histograms The only addition to a raw array is the constructor that allows to build names and titles for the histograms automatically from the index of the histogram in the array There are 2 possibilities : |
| CGaudi::HistogramBase | Common base class for all histograms Use is solely functional to minimize dynamic_casts inside HistogramSvc |
| CGaudi::Generic1D< AIDA::IHistogram1D, TH1D > | |
| CGaudi::Histogram1D | AIDA implementation for 1 D histograms using ROOT THD1 |
| CGaudi::Generic1D< AIDA::IProfile1D, TProfile > | |
| CGaudi::Profile1D | AIDA implementation for 1 D profiles using ROOT TProfile |
| CGaudi::Generic2D< AIDA::IHistogram2D, TH2D > | |
| CGaudi::Histogram2D | AIDA implementation for 2 D histograms using ROOT THD2 |
| CGaudi::Generic2D< AIDA::IProfile2D, TProfile2D > | |
| CGaudi::Profile2D | AIDA implementation for 2 D profiles using ROOT TProfile2D |
| CGaudi::Generic3D< AIDA::IHistogram3D, TH3D > | |
| CGaudi::Histogram3D | AIDA implementation for 3 D histograms using ROOT THD2 |
| 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 |
| CGaudi::Accumulators::HistogramingAccumulatorInternal< Atomicity, InputType, Arithmetic, BaseAccumulatorT, AxisTupleType > | Internal Accumulator class dealing with Histograming |
| CGaudi::Accumulators::HistogramingAccumulatorInternal< Atomicity, HistoInputType< AxisToArithmetic_t< AxisTupleType >, ND >, unsigned long, IntegralAccumulator, AxisTupleType > | |
| CGaudi::Accumulators::RootHistogramingAccumulatorInternal< Atomicity, Arithmetic, 1, AxisTupleType > | |
| CGaudi::Accumulators::RootHistogramingAccumulator< Atomicity, Arithmetic, std::integral_constant< unsigned int, 1 >, AxisTupleType > | |
| CGaudi::Accumulators::RootHistogramingAccumulatorInternal< Atomicity, Arithmetic, 2, AxisTupleType > | |
| CGaudi::Accumulators::RootHistogramingAccumulator< Atomicity, Arithmetic, std::integral_constant< unsigned int, 2 >, AxisTupleType > | |
| CGaudi::Accumulators::RootHistogramingAccumulatorInternal< Atomicity, Arithmetic, 3, AxisTupleType > | |
| CGaudi::Accumulators::RootHistogramingAccumulator< Atomicity, Arithmetic, std::integral_constant< unsigned int, 3 >, AxisTupleType > | |
| CGaudi::Accumulators::RootHistogramingAccumulatorInternal< Atomicity, Arithmetic, ND, AxisTupleType > | Internal Accumulator class dealing with RootHistograming |
| CGaudi::Accumulators::HistogramingCounterBase< ND, Atomicity, Arithmetic, Type, Accumulator, AxisTupleType > | A base counter dealing with Histograms |
| CGaudi::Accumulators::HistogramingCounterBase< 1, Atomicity, Arithmetic, Type, RootHistogramingAccumulator, AxisTupleType > | |
| CGaudi::Accumulators::RootHistogramingCounterBase< 1, Atomicity, Arithmetic, Type, AxisTupleType > | |
| CGaudi::Accumulators::HistogramingCounterBase< 2, Atomicity, Arithmetic, Type, RootHistogramingAccumulator, AxisTupleType > | |
| CGaudi::Accumulators::RootHistogramingCounterBase< 2, Atomicity, Arithmetic, Type, AxisTupleType > | |
| CGaudi::Accumulators::HistogramingCounterBase< 3, Atomicity, Arithmetic, Type, RootHistogramingAccumulator, AxisTupleType > | |
| CGaudi::Accumulators::RootHistogramingCounterBase< 3, Atomicity, Arithmetic, Type, AxisTupleType > | |
| CGaudi::Accumulators::HistogramMap< Key, Histo, Seq > | Generic class implementing a thread safe map of histograms |
| CGaudi::Accumulators::details::HistogramMapInternal< Key, Histo > | Internal class implementing a map of histograms |
| CGaudi::Accumulators::HistogramMap< Key, Histo, std::integer_sequence< unsigned int, ND... > > | |
| CGaudi::Accumulators::HistogramWrapperInternal< HistogramType, Seq > | A Wrapper of a static Histogram base class using Properties to define title and axis |
| CGaudi::Accumulators::HistogramWrapperInternal< HistogramType, std::integer_sequence< unsigned int, ND... > > | |
| CGaudi::Accumulators::HistoInputType< Arithmetic, NIndex > | Small class used as InputType for regular Histograms basically a tuple of the given values, specialized in case of a single entry so that the syntax is more natural |
| 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 |
| CGaudi::Example::TinyExperiment::Hit | Most simple Hit ever : in 2D space, and thus fully defined by x and y |
| CHiveRndm::HiveNumbers | |
| CGaudi::Monitoring::Hub | Central entity in a Gaudi application that manages monitoring objects (i.e |
| CIAnnotation | |
| CAIDA::Annotation | Implementation of the AIDA IAnnotation interface class |
| CAIDA::IAxis | |
| CGaudi::Axis | An IAxis represents a binned histogram axis |
| CIAxis | |
| CGaudi::Axis | An IAxis represents a binned histogram axis |
| CIClassInfo | Data base class allowing to store persistent type information |
| CGaudi::meta::id_< T > | |
| CGaudi::meta::id_< State > | |
| CGaudi::meta::detail::appendN< interface_list<>, State > | |
| CGaudi::meta::id_< std::conditional_t< std::is_base_of_v< id_< I >, inherit_from< id_< Is >... > >, interface_list< Is... >, interface_list< Is..., I > > > | |
| CGaudi::meta::detail::append1< interface_list< Is... >, I > | |
| CGaudi::IDataConnection | ABC describing basic data connection |
| CGaudi::RootDataConnection | Concrete implementation of the IDataConnection interface to access ROOT files |
| CIDataHandleVisitor | |
| CDHHVisitor | |
| CDataHandleFinder | Implements the IDataHandleVisitor interface Class used to explore heirarchy of nested IDataHandleHolders |
| CIDataStoreAgent | Generic data agent interface |
| CGaudiMP::TESSerializer | |
| CHistogramAgent | HistogramAgent base in charge of collecting all the references to DataObjects in a transient store that passes some selection criteria |
| Cdetails::GenericDataStoreAgent< F > | |
| CStreamBuffer::IdentifiedLink | Definition of the contained link set |
| CGaudi::Accumulators::Identity | An Identity functor |
| CGaudiUtils::details::IdentityOutputter | |
| CIFace | |
| CGaudi::Interface::Bind::AlgToolStub< IFace > | |
| Cconcurrency::IGraphVisitor | |
| Cconcurrency::ActiveLineageScout | |
| Cconcurrency::SubSlotScout | |
| Cconcurrency::ConditionalLineageFinder | |
| Cconcurrency::DataReadyPromoter | |
| Cconcurrency::DecisionUpdater | |
| Cconcurrency::NodePropertiesValidator | |
| Cconcurrency::ProductionAmbiguityFinder | |
| Cconcurrency::RankerByCummulativeOutDegree | |
| Cconcurrency::RankerByDataRealmEccentricity | |
| Cconcurrency::RankerByEccentricity | |
| Cconcurrency::RankerByProductConsumption | |
| Cconcurrency::RankerByTiming | |
| Cconcurrency::RunSimulator | |
| Cconcurrency::Supervisor | |
| Cconcurrency::TarjanSCCFinder | The visitor implements the Tarjan algorithm for searching strongly connected components in the data flow realm of precedence rules graph |
| CAIDA::IHistogram1D | |
| CGaudi::Generic1D< AIDA::IHistogram1D, TH1D > | |
| CIHistogram1D | |
| CGaudi::Generic1D< AIDA::IHistogram1D, TH1D > | |
| CAIDA::IHistogram2D | |
| CGaudi::Generic2D< AIDA::IHistogram2D, TH2D > | |
| CIHistogram2D | |
| CGaudi::Generic2D< AIDA::IHistogram2D, TH2D > | |
| CAIDA::IHistogram3D | |
| CGaudi::Generic3D< AIDA::IHistogram3D, TH3D > | |
| CIHistogram3D | |
| CGaudi::Generic3D< AIDA::IHistogram3D, TH3D > | |
| CAIDA::IHistogramFactory | |
| CHistogramSvc | HistogramSvc class definition |
| CIHistogramFactory | |
| CHistogramSvc | HistogramSvc class definition |
| CIInspectable | Interface definition of an inspectable object |
| CIInterface | Definition of the basic interface |
| CGaudi::Concurrency::ConcurrencyManager | Interface implemented by components that are allowed to set the concurrency flags of the running job |
| CGaudi::Example::TinyExperiment::IRandomGenSvc | |
| CGaudi::IFSMCallbackHolder | Interface defining a CallBack registration functionality based on the State Machine of Gaudi |
| 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 |
| CGaudi::Interfaces::IFileSvc | Interface for a component that manages file access within Gaudi applications |
| CGaudi::Interfaces::IOptionsSvc | Interface for a component that manages application configuration options |
| 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 | |
| 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 | Abstract interface for a DataSvc manipulating condition data (i.e |
| CIEventProcessor | The IEventProcessor is the interface to process events |
| CGaudi::Interfaces::IQueueingEventProcessor | Extend IEventProcessor for asynchronous scheduling of events via queue-like interface |
| 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 |
| CIInactiveMessageCounter | |
| CIIncidentAsyncTestSvc | |
| CIIncidentListener | The interface implemented by any class wanting to listen to Incidents |
| CReadAlg | ReadAlg class for the RootIOExample |
| CIIncidentSvc | The interface implemented by the IncidentSvc service |
| CIInspector | Inspector base class |
| 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 |
| CGaudi::IAuditor | The IAuditor is the interface implemented by the Auditor base class |
| CIAlgTool | The interface implemented by the AlgTool base class |
| CGaudiTesting::ITestTool | |
| 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 |
| CIDataStoreLeaves | Interface for a tool or service that returns a list of leaves (paths) in a transient store |
| CIDataStreamTool | |
| CIEventTimeDecoder | Interface that a Tool that decodes the event time has to implement |
| CIMyOtherTool | Second interface, to test multiple interface tools |
| CIMyTool | Example of an Interface of a Algorithm Tool |
| CITestTool | |
| CIThreadInitTool | Abstract interface for AlgTools to do thread local initialization |
| CIWrongTool | Interface (not implemented) to test attempts to retrieval of wrong interface |
| CIAppMgrUI | Application Manager User Interface |
| CIDataHandleHolder | |
| CIIoComponent | |
| CIIoComponentMgr | |
| CIPersistencySvc | Data persistency service interface |
| CIPrecedenceSvc | Abstract interface for a service that manages tasks' precedence |
| 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 |
| CISelectStatement | A select statement can either contain |
| CISerialize | Object serialization interface definition |
| CIStagerSvc | |
| CIStatSvc | "Stat"-related part of interface IChronoStatSvc |
| 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 |
| 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 | |
| CRenounceToolInputsVisitor::ILogger | Helper class interface to optionally log renounce operations |
| CGaudiTesting::TestTool::Logger | |
| CRenounceToolInputsVisitor::Logger | |
| CRenounceToolInputsVisitor::NoLogger | A do-nothing helper class which implements the logger interface |
| CIncident | Base class for all Incidents (computing events) |
| CContextIncident< std::string > | |
| CContextIncident< T > | |
| CFileIncident | This class is the FileIncident |
| CModuleIncident | Base class for Module-related incident |
| CModuleLoadedIncident | Fired when a module (DLL) is loaded |
| CIncidentRegistryTestListener | |
| CGaudi::Parsers::IncludedFiles | |
| CGaudi::Functional::details::details2::indirect_iterator< Iterator > | |
| CGaudi::Decays::iNode | The abstract class which represents the single "node" of decay tree |
| CGaudi::Decays::Node | The generic class to hold the pointer to other node |
| CGaudi::Decays::Nodes::And | Rather simple (but powerful) node in the decay tree: it matches .AND |
| CGaudi::Decays::Nodes::Any | Most simple node in the decay tree: it matches to all valid the Gaudi::Particles |
| CGaudi::Decays::Nodes::Charged | The trivial node : it match the Charged |
| CGaudi::Decays::Nodes::Negative | The trivial node : it match the negatively charged particles |
| CGaudi::Decays::Nodes::Neutral | The trivial node : it match the Neutral |
| CGaudi::Decays::Nodes::Positive | The trivial node : it match the positively charged particles |
| CGaudi::Decays::Nodes::Hadron | The trivial node : it match the Hadron |
| CGaudi::Decays::Nodes::Baryon | The trivial node : it match the Baryon |
| CGaudi::Decays::Nodes::Meson | The trivial node : it match the meson |
| CGaudi::Decays::Nodes::HasQuark | The trivial node : it match the quark content |
| CGaudi::Decays::Nodes::JSpin | The trivial node : it match the 2J+1 spin |
| CGaudi::Decays::Nodes::SSpin | The trivial node : it match the 2S+1 spin |
| CGaudi::Decays::Nodes::LSpin | The trivial node : it match the 2L+1 spin |
| CGaudi::Decays::Nodes::Lepton | The trivial node : it match the Lepton |
| CGaudi::Decays::Nodes::Ell | The trivial node : it match any charged lepton |
| CGaudi::Decays::Nodes::EllMinus | The trivial node : it match any negative lepton |
| CGaudi::Decays::Nodes::EllPlus | The trivial node : it match any positive lepton |
| CGaudi::Decays::Nodes::Nu | The trivial node : it match any neutral lepton |
| CGaudi::Decays::Nodes::Nucleus | The trivial node : it match the Nucleus |
| CGaudi::Decays::Nodes::CTau | Simple pid-checker for particle lifetime (in c*tau units) |
| CGaudi::Decays::Nodes::LongLived_ | Represent simple predicate for Long-lived particles |
| CGaudi::Decays::Nodes::Stable | Represent simple predicate for Stable particles |
| CGaudi::Decays::Nodes::StableCharged | Represent simple predicate for Stable+Charged particles |
| CGaudi::Decays::Nodes::Mass | Simple pid-checker for particle mass |
| CGaudi::Decays::Nodes::Heavy | Simple pid-checker for particle mass |
| CGaudi::Decays::Nodes::Light | Simple pid-checker for particle mass |
| CGaudi::Decays::Nodes::ShortLived_ | Represent simple predicate for short-lived particles |
| CGaudi::Decays::Nodes::Invalid | Most simple node to represent the invalid node it matches to all valid the Gaudi::Particles |
| CGaudi::Decays::Nodes::NegID | |
| CGaudi::Decays::Nodes::Not | Simple node which match "NOT" for the subnode |
| CGaudi::Decays::Nodes::Or | Rather simple (but powerful) node in the decay tree: it matches .OR |
| CGaudi::Decays::Nodes::Pid | The simple node in the decay tree: it matches to a certain particle ID |
| CGaudi::Decays::Nodes::CC | The simple node in the decay tree: it matches to a certain particle ID or its antiparticle |
| CGaudi::Decays::Nodes::PosID | |
| CGaudi::Decays::Nodes::Symbol | |
| CGaudi::Functional::details::detail2::InputHandle< T, Tr, Default > | |
| CGaudi::Functional::details::detail2::InputHandle< T, Tr, Default > | |
| CGaudi::Functional::details::detail2::InputHandle< vector_of_input_< T >, Tr, Default > | |
| CGaudi::Functional::Traits::InputHandle_t< Handle > | |
| CGaudi::Functional::details::detail2::InputHandleFor< Tr, Default > | |
| CGaudi::Functional::details::insert_t | |
| CIntEnum | |
| CGaudiKernel.Constants.MessageLevel | |
| 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 |
| CGaudiPython::Interface< TYPE > | Minor mofidication of original Pere's structure GaudiPython::Interface This helper class is nesessary to perform C++ castings from python |
| CGaudiPython::Interface< IInterface > | |
| CGaudi::interface_list< I > | |
| CGaudi::interface_list_append< I > | |
| CGaudi::interface_list_cat< I > | |
| CGaudi::interface_list_cat< interface_list< I1..., I2... >, Others... > | |
| CGaudi::interface_list_cat< interface_list< I1... >, interface_list< I2... >, Others... > | |
| CGaudi::interface_list_cat< interface_list< Is... >, interface_list< I > > | |
| CGaudi::interface_list_append< interface_list< Is... >, I > | |
| CGaudiPython.Bindings.InterfaceCast | |
| CGaudiPython.Bindings.Interface | |
| 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< I1 > | |
| Cextend_interfaces< I1, I2 > | |
| Cextend_interfaces< I1, I2, I3 > | |
| Cextend_interfaces< I1, I2, I3, I4 > | |
| Cextend_interfaces< Interfaces... > | |
| Cextends< BASE, IFSMCallbackHolder > | |
| Cextends< BASE, I1 > | |
| Cextends< BASE, I1, I2 > | |
| Cextends< BASE, I1, I2, I3 > | |
| Cextends< BASE, I1, I2, I3, I4 > | |
| Cextends< Service, IAlgContextSvc, IIncidentListener > | |
| Cextends< Service, IAlgExecStateSvc > | |
| Cextends< Service, IAlgResourcePool > | |
| Cextends< Gaudi::Auditor, IIncidentListener > | |
| Cextends< PropertyHolder< CommonMessaging< implements< IAlgTool, IDataHandleHolder, IProperty, IStateful > > >, IDataHandleHolder > | |
| Cextends< ComponentManager, IAlgManager > | |
| Cextends< Service, IRunable > | |
| Cextends< Service, IAuditorSvc > | |
| Cextends< Service, IScheduler > | |
| Cextends< Service, ICPUCrunchSvc > | |
| Cextends< Service, IChronoStatSvc, IIncidentListener > | |
| Cextends< Service, IConversionSvc, IAddressCreator > | |
| Cextends< AlgTool, IDODAlgMapper, IDODNodeMapper > | |
| Cextends< BASE, IDataHandleHolder > | |
| Cextends< Service, IIncidentListener > | |
| Cextends< AlgTool, IDataStreamTool > | |
| Cextends< Service, IDataProviderSvc, IDataManagerSvc > | |
| Cextends< AlgTool, IDataStoreLeaves, IIncidentListener > | |
| Cextends< TsDataSvc, IDetDataSvc, IIncidentListener > | |
| Cextends< Service, IEvtSelector > | |
| Cextends< Service, IDataProviderSvc, IDataManagerSvc, IHiveWhiteBoard, Gaudi::Concurrency::ConcurrencyManager > | |
| Cextends< Service, IExceptionSvc > | |
| Cextends< Service, IFileMgr, IIncidentListener > | |
| Cextends< AlgTool, IFileAccess > | |
| Cextends< Service, Gaudi::Interfaces::IFileSvc > | |
| Cextends< PropertyHolder< CommonMessaging< implements< IAlgorithm, IDataHandleHolder, IProperty, IStateful > > >, IDataHandleHolder > | |
| Cextends< Service, IRandomGenSvc > | |
| Cextends< details::BaseClass_t< Traits, AlgTool >, Gaudi::Interface::Bind::IBinder< IFace > > | |
| Cextends< Service, IIODataManager > | |
| Cextends< Service, IMetaDataSvc > | |
| Cextends< Service, IFileCatalog, IFileCatalogMgr > | |
| Cextends< Service, Gaudi::Interfaces::IParticlePropertySvc > | |
| Cextends< Service, ICondSvc > | |
| Cextends< Algorithm, IFSMCallbackHolder > | |
| Cextends< AlgTool, IMyTool > | |
| Cextends< MinimalEventLoopMgr, Gaudi::Interfaces::IQueueingEventProcessor > | |
| Cextends< Service, Gaudi::ISignalMonitor > | |
| Cextends< AlgTool, ITestTool > | |
| Cextends< DataSvc, IHistogramSvc > | |
| Cextends< Service, IHistorySvc, IIncidentListener > | |
| Cextends< Service, IDataBroker > | |
| Cextends< Service, IEventProcessor > | |
| Cextends< Service, IIncidentListener, IIncidentAsyncTestSvc > | |
| Cextends< Service, IIncidentSvc > | |
| Cextends< Service, IIoComponentMgr, IIncidentListener > | |
| Cextends< Service, Gaudi::Interfaces::IOptionsSvc > | |
| Cextends< Service, IMessageSvc, IInactiveMessageCounter > | |
| Cextends< AlgTool, IMyTool, IMyOtherTool > | |
| Cextends< DataSvc, INTupleSvc, IDataSourceMgr > | |
| Cextends< Service, IPartPropSvc > | |
| Cextends< Service, IConversionSvc, IPersistencySvc, IAddressCreator > | |
| Cextends< Service, IPrecedenceSvc > | |
| Cextends< DataSvc, IIncidentListener > | |
| Cextends< Service, IRndmEngine, ISerialize > | |
| Cextends< Service, IRndmGenSvc, IRndmEngine, ISerialize > | |
| Cextends< ComponentManager, ISvcManager, ISvcLocator > | |
| Cextends< Service, ITHistSvc, IIncidentListener, IIoComponent > | |
| Cextends< Service, IThreadPoolSvc, Gaudi::Concurrency::ConcurrencyManager > | |
| Cextends< Service, ITimelineSvc > | |
| Cextends< Service, IToolSvc > | |
| Cextends< Service, IFileAccess > | |
| Cimplements< Interfaces... > | |
| Cimplements< I1 > | |
| Cimplements< I1, I2 > | |
| Cimplements< I1, I2, I3 > | |
| Cimplements< I1, I2, I3, I4 > | |
| 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::RHistogramCnv< TProfile, TProfile, Gaudi::HistogramBase > | |
| CRootHistCnv::RHistogramCnv< TProfile2D, TProfile2D, Gaudi::HistogramBase > | |
| CRootHistCnv::RHistogramCnv< TH1D, TH1, Gaudi::HistogramBase > | |
| CRootHistCnv::RHistogramCnv< TH2D, TH2, Gaudi::HistogramBase > | |
| CRootHistCnv::RHistogramCnv< TH3D, TH3, Gaudi::HistogramBase > | |
| 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< IClassManager > | |
| CDLLClassManager | |
| Cimplements< IInterface > | |
| CEventSelectorDataStream | Definition of class EventSelectorDataStream |
| Cimplements< ISvcLocator > | |
| CGaudi::BootSvcLocator | A dual-stage boostrap mechanism is used to ensure an orderly startup of the ApplicationMgr |
| Cimplements< AlgToolStub< IFace > > | |
| CGaudi::Interface::Bind::Stub< IFace > | |
| Cimplements< AlgToolStub< IMyTool > > | |
| CGaudi::Interface::Bind::Stub< IMyTool > | |
| CGaudi::TestSuite::MyConsumerTool::BoundInstance | |
| Cimplements< IFileCatalog > | |
| CGaudi::XMLFileCatalog | This class constitutes the core of the XML based FileCatalog API |
| Cimplements< IIncidentListener > | |
| CIncidentListenerTest | |
| CMinimalEventLoopMgr::AbortEventListener | |
| Cimplements< IRndmGen > | |
| CRndmGen | Random Generator definition |
| CHepRndm::Generator< Rndm::DefinedPdf > | |
| CHepRndm::Generator< TYPE > | |
| CHepRndm::Generator< Rndm::DefinedPdf > | |
| Cimplements< ISelectStatement > | |
| CSelectStatement | Class of a selection statement |
| CNTuple::Selector | NTuple Selector class |
| CGaudi::TestSuite::EvtCollectionSelector | Definition of a small class for further pre-selections when reading an event collection |
| Cextends< BASE, Interfaces > | Base class used to extend a class implementing other interfaces |
| Cimplements< Interfaces > | Base class used to implement the interfaces |
| Cextend_interfaces< IAlgTool > | |
| CGaudi::Interface::Bind::IBinder< IFace > | |
| CGaudi::TestSuite::IMyTool | |
| Cextend_interfaces< IInterface > | |
| CGaudi::Interfaces::IParticlePropertySvc | The abstract interface to Particle Property Service |
| CIDataBroker | |
| CIDataManagerSvc | |
| CIHiveWhiteBoard | |
| Cextend_interfaces< INamedInterface, IStateful > | |
| CIAlgorithm | The IAlgorithm is the interface implemented by the Algorithm base class |
| CIService | General service interface definition |
| CICPUCrunchSvc | |
| CIClassIDSvc | Interface to the CLID database |
| CICondSvc | Interface for the Condition Service |
| CIFileMgr | |
| CIHistorySvc | Definition of the IHistorySvc interface class |
| CIMagneticFieldSvc | The interface to the MagneticFieldSvc |
| CIPartPropSvc | |
| CIRndmGenSvc | Random Generator service interface definition Definition of a interface for a service to access random generators according to predefined distributions: |
| CITHistSvc | |
| CITimelineSvc | |
| Cextend_interfaces< IService, Gaudi::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 |
| Cextend_interfaces< IService > | |
| CIMetaDataSvc | |
| Cextend_interfaces< Interfaces > | Base class to be used to extend an interface |
| 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< int > | |
| CNTuple::_Array< int > | |
| CNTuple::_Item< int > | |
| CNTuple::_Data< float > | |
| CNTuple::_Array< float > | |
| CNTuple::_Item< float > | |
| CNTuple::_Matrix< float > | |
| CNTuple::_Data< Gaudi::TestSuite::MyTrack * > | |
| CNTuple::_Item< Gaudi::TestSuite::MyTrack * > | |
| CNTuple::_Data< IOpaqueAddress * > | |
| CNTuple::_Item< IOpaqueAddress * > | |
| CNTuple::_Data< long > | |
| CNTuple::_Array< long > | |
| CNTuple::_Item< long > | |
| CNTuple::_Data< uint32_t > | |
| CNTuple::_Item< uint32_t > | |
| CNTuple::_Data< double > | |
| CNTuple::_Array< double > | |
| CNTuple::_Item< double > | |
| CNTuple::_Matrix< double > | |
| 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 |
| CGaudi::Histograming::Sink::detail::IntWithFixedWidth | Helper struct to print integers with fixed width |
| CGaudi::Functional::details::invoke_optionally_t | |
| CSystem::IO_COUNTERS | Process I/O Counters NtQueryInformationProcess using ProcessIoCounters |
| CIoComponentMgr::IoComponentEntry | |
| CIo::IoFlags | |
| CIoFlags | |
| CIIoComponentMgr::IoMode | |
| CIOpaqueAddress | Opaque address interface definition |
| CGenericAddress | Generic Transient Address |
| CGaudi::RootAddress | Description: |
| CRootHistCnv::RootObjAddress | |
| CGaudiMP.IoRegistry.IoRegistry | |
| Cconcurrency::IPrecedenceRulesGraph | |
| CAIDA::IProfile1D | |
| CGaudi::Generic1D< AIDA::IProfile1D, TProfile > | |
| CIProfile1D | |
| CGaudi::Generic1D< AIDA::IProfile1D, TProfile > | |
| CAIDA::IProfile2D | |
| CGaudi::Generic2D< AIDA::IProfile2D, TProfile2D > | |
| CIProfile2D | |
| CGaudi::Generic2D< AIDA::IProfile2D, TProfile2D > | |
| CGaudiPython.Bindings.iProperty | |
| CGaudiPython.Bindings.iAlgTool | |
| CGaudiPython.Bindings.iAlgorithm | |
| CGaudiPython.Bindings.iService | |
| CGaudiPython.Bindings.AppMgr | |
| CGaudiPython.Bindings.iDataSvc | |
| CGaudiPython.Bindings.iHistogramSvc | |
| CGaudiPython.Bindings.iNTupleSvc | |
| CGaudiPython.Bindings.iEventSelector | |
| CGaudiPython.Bindings.iToolSvc | |
| 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 |
| CIs... | |
| CGaudi::meta::detail::inherit_from< Is > | |
| CiService | |
| CGaudiPartProp.Service.iParticlePropertySvc | |
| CGaudi::Decays::Decay::Item | Helper representation of the item in the decay chain |
| CRootHistCnv::RCWNTupleCnv::Layout::Item | |
| CGaudi::Utils::AttribStringParser::Iterator | Iterator to loop over the tag/value pairs in the attribute string |
| Cstring::iterator | STL iterator class |
| Cvector< T >::iterator | STL iterator class |
| 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 |
| CAlgToolHistory | AlgToolHistory class definition |
| CAlgorithmHistory | AlgorithmHistory 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::traits< container_type, contained_type > | |
| 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 |
| CGaudi::Decays::Nodes::CTau::KnownPids | |
| Clambda_ts... | |
| CGaudi::details::overloaded_t< lambda_ts > | |
| CRootHistCnv::RCWNTupleCnv::Layout | How the items of a tuple map onto the staging buffer and the TTree branches |
| CDataOnDemandSvc::Leaf | |
| CStoreSnifferAlg::LeafInfo | |
| CGaudi::Parsers::Property::LessThen | |
| CControlFlow.line | |
| CLinkManager::Link | Embedded class defining a symbolic link Note: No explicit copy constructor; implicit compiler generated one 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 | |
| CGaudiConfig2.semantics._GaudiHandleArrayOptionValue | |
| CIIncidentSvc::Listener | Listener properties |
| CGaudi::Functional::details::LocationSpec | |
| CGaudi::Functional::details::LocationSpecFor< Arg > | |
| CGaudi::Functional::details::LocationSpecFor< EventContext > | |
| CGaudi::Functional::details::LocationSpecFor< vector_of_input_< T > > | |
| CGaudi::Functional::details::LocationSpecFor< vector_of_output_< T > > | |
| CGaudi::Functional::details::LocationSpecs< Tuple > | |
| 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::v1::Details::Logger | Simple logging class, just to provide a default implementation |
| CLoggingAuditor | Simple auditor that prints the event being audited |
| CGaudiMP.pTools.LumiFSR | |
| CGaudi::majorMatch_t | |
| CContainers::map | |
| CMap< Gaudi::StringKey, Leaf, std::unordered_map< Gaudi::StringKey, Leaf, Hash< Gaudi::StringKey > > > | |
| CGaudiUtils::HashMap< Gaudi::StringKey, Leaf > | |
| CMap< Gaudi::StringKey, Node, std::unordered_map< Gaudi::StringKey, Node, Hash< Gaudi::StringKey > > > | |
| CGaudiUtils::HashMap< Gaudi::StringKey, Node > | |
| CMap< Gaudi::StringKey, std::unique_ptr< ListenerList >, std::unordered_map< Gaudi::StringKey, std::unique_ptr< ListenerList >, Hash< Gaudi::StringKey > > > | |
| CGaudiUtils::HashMap< Gaudi::StringKey, std::unique_ptr< ListenerList > > | |
| CMap< K, T, std::unordered_map< K, T, Hash< K > > > | |
| CGaudiUtils::HashMap< K, T, H, M > | Common class providing an architecture-independent hash map |
| CMap< Key, Value, std::unordered_map< Key, Value, Hash< Key > > > | |
| CGaudiUtils::HashMap< Key, Value > | |
| CMap< long, void *, std::unordered_map< long, void *, Hash< long > > > | |
| CGaudiUtils::HashMap< long, void * > | |
| CMap< std::string, SmartIF< IAlgorithm >, std::unordered_map< std::string, SmartIF< IAlgorithm >, Hash< std::string > > > | |
| CGaudiUtils::HashMap< std::string, SmartIF< IAlgorithm > > | |
| CMap< std::string, std::vector< IFileAccess * >, std::unordered_map< std::string, std::vector< IFileAccess * >, Hash< std::string > > > | |
| CGaudiUtils::HashMap< std::string, std::vector< IFileAccess * > > | |
| CGaudi::Utils::MapBase | Helper base-class to allow the generic Python-decoration for all "map-like" classes in Gaudi |
| CGaudiUtils::Map< Key, Value > | |
| CGaudiUtils::Map< std::string, std::string > | |
| CGaudiUtils::Map< InterfaceID, SmartIF< IInterface > > | |
| CGaudiUtils::VectorMap< std::string, Decays::Nodes::_Node > | |
| CGaudiUtils::VectorMap< Key, Value > | |
| CGaudiUtils::Map< K, T, M > | Extension of the STL map |
| CGaudiUtils::VectorMap< KEY, VALUE, KEYCOMPARE, ALLOCATOR > | A bit modified version of 'Loki::AssocVector' associative vector from Loki library by Andrei Alexandrescu |
| CGaudi::Utils::RegEx::matchList | |
| CGaudi::Accumulators::detail::Max< Arithmetic > | Type trait providing the highest possible value (to be used as initial value for Minimum) |
| CGaudi::Example::TinyExperiment::MCHit | Most simple MC Hit ever : in 2D space, and thus fully defined by x and y |
| CGaudi::Example::TinyExperiment::MCTrack | Most simple MC Track ever : in 2D space, starting from the origin and thus fully defined by an angle theta |
| CMEMORY_MAPPED_FILE | |
| CGaudi::Functional::MergingMultiTransformer< Signature, Traits_ > | |
| Cis2ff_merger | |
| Cis2ff_merger_with_scalar | |
| CGaudi::Functional::MergingMultiTransformer< std::tuple< std::vector< int >, std::vector< double > >(const Gaudi::Functional::vector_of_const_< std::vector< int > > &, const Gaudi::Functional::vector_of_const_< std::vector< double > > &), BaseClass_t > | |
| CGaudi::TestSuite::TwoDMerger | Concatenates a list of input vectors into a single output vector |
| CGaudi::Functional::MergingMultiTransformerFilter< Signature, Traits_ > | |
| Cis2ff_merger_filter | |
| Cis2ff_merger_filter_with_scalar | |
| CGaudi::Functional::details::MergingTransformer< Signature, Traits_, isLegacy > | |
| CGaudi::Functional::details::MergingTransformer< Signature, Traits_, details::isLegacy< Traits_ > > | |
| CGaudi::TestSuite::IntVectorsMerger | |
| CGaudi::TestSuite::IntVectorsMergingConsumer | |
| CGaudi::TestSuite::IntVectorsToIntVector | Concatenates a list of input vectors into a single output vector |
| CGaudi::TestSuite::OptionalSRangesMerger | |
| CGaudi::TestSuite::PIntVectorsToIntVector | |
| CGaudi::TestSuite::SRangesToIntVector | |
| Cis2f_merger_with_scalar | |
| Cis_merger_consumer_with_scalar | |
| CMessage | The Message class |
| CGaudi::Parsers::Messages | |
| Cmetaclass | |
| CGaudiConfig2._configurables.Configurable | |
| CGaudiKernel.Configurable.Configurable | |
| CGaudiKernel.Configurable.ConfigurableAlgTool | |
| CGaudiKernel.Configurable.ConfigurableAlgorithm | |
| CGaudiKernel.Configurable.ConfigurableAuditor | |
| CGaudiKernel.Configurable.ConfigurableGeneric | |
| CGaudiKernel.Configurable.ConfigurableService | |
| CGaudiKernel.Configurable.ConfigurableUser | |
| CConfigurableUser.ExampleApplication | |
| CConfigurableUser.ExampleCommon | |
| CConfigurableUser.ExampleIO | |
| CConfiguration.GaudiTestSuiteCommonConf | |
| CGaudi.ConfUser.GaudiPersistency | |
| CGaudi::Accumulators::detail::Min< Arithmetic > | Type trait providing the lowest possible value (to be used as initial value for Maximum) |
| CGaudiMP.GMPBase.MiniWriter | |
| CGaudi::Arena::Monotonic< Alignment, UpstreamAllocator > | A fast memory arena that does not track deallocations |
| CMonotonicArena | Shorthand for Gaudi::Allocator::Arena with Gaudi::Arena::Monotonic resource |
| 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::MultiScalarTransformer< FrExpTransformer, std::tuple< std::vector< double >, std::vector< int > >(const std::vector< double > &), BaseClass_t > | |
| CGaudi::TestSuite::FrExpTransformer | |
| CGaudi::Functional::MultiScalarTransformer< OptFrExpTransformer, std::tuple< std::vector< double >, std::vector< int > >(const std::vector< double > &), BaseClass_t > | |
| CGaudi::TestSuite::OptFrExpTransformer | |
| CGaudi ::Functional::details::MultiTransformer< Signature, Traits_, isLegacy > | |
| CGaudi::Functional::MultiTransformer | |
| CGaudi::TestSuite::IntIntToFloatFloatData | |
| CMultiTransformer | |
| CGaudi::Functional::MultiScalarTransformer< ScalarOp, std::tuple< Out... >(const In &...), Traits_ > | |
| CGaudi::Functional::details::Producer< std::tuple< Out... >(), Traits_, legacy > | |
| CGaudi ::Functional::details::MultiTransformerFilter< Signature, Traits_ > | |
| CMutableMapping | |
| CGaudiConfig2.semantics._DictHelper | |
| CMutableSequence | |
| CGaudiConfig2.semantics._ListHelper | |
| CGaudiKernel.GaudiHandles.GaudiHandleArray | |
| CGaudiKernel.GaudiHandles.PrivateToolHandleArray | |
| CGaudiKernel.GaudiHandles.PublicToolHandleArray | |
| CGaudiKernel.GaudiHandles.ServiceHandleArray | |
| CMutableSet | |
| CGaudiConfig2.semantics._SetHelper | |
| CMyClass1 | Trivial "almost empty" class |
| CMyClass1A | Simple class, equipped with "Allocator", to be compared with class MyClass1 |
| CGaudi::TestSuite::MyData | |
| CGaudi::TestSuite::NTuple::MyStruct | |
| CMyTack | Simple class that represents a track for testing purposes |
| CNamedRange | New concept of "named" range : range with name |
| CDataOnDemandSvc::Node | Helper class of the DataOnDemandSvc |
| CGaudi::Parsers::Node | |
| CGaudi::Decays::NodeList | |
| CGaudi::Parsers::NodeOperations | |
| CGaudi::Details::Property::NoHandler | |
| CGaudi::Details::Property::ReadHandler | |
| CGaudi::Details::Property::ReadUpdateHandler | |
| CGaudi::Details::Property::UpdateHandler | |
| CGaudi::Details::Property::ReadUpdateHandler | |
| CNTupleItems | NTupleItems namespace parts definition This header file is not intended to be included by the public! |
| CGaudi::Details::Property::NullVerifier | |
| CRndm::Numbers | Random number accessor This small class encapsulates the use of the random number generator |
| 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 |
| CIScheduler::OccupancySnapshot | Sample occupancy at fixed interval (ms) Negative value to deactivate, 0 to snapshot every change Each sample, apply the callback function to the result |
| CGaudi::Functional::Traits::WriteOpaqueFor< Data >::OpaqueView | |
| CGaudi::Parsers::DataObjIDGrammar< Iterator, Skipper >::Operations | |
| Cprecedence::Operations | |
| Costream | STL class |
| CGaudi::Functional::details::detail2::OutputHandle< T, Tr, Default > | |
| CGaudi::Functional::details::detail2::OutputHandle< T, Tr, Default > | |
| CGaudi::Functional::details::detail2::OutputHandle< vector_of_output_< T >, Tr, Default > | |
| CGaudi::Functional::Traits::OutputHandle_t< Handle > | |
| CGaudi::Functional::details::detail2::OutputHandleFor< Tr, Default > | |
| CReplayOutputStream::OutStreamAdder | Helper class to fill the internal map of OutputStreams |
| CGaudiMP.pTools.PackedCaloHypo | |
| Cstd::pair< T1, T2 > | STL class |
| CGaudi::Accumulators::WeightedHistoInputType< ArithmeticTuple, NIndex, WArithmetic > | Small class used as InputType for weighted Histograms only a pair of the InnerType and the weight |
| 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 |
| CGaudi::ParticleID | Holds PDG + LHCb extension particle code, following the PDG particle numbering scheme (pdg.lbl.gov/2017/reviews/rpp2017-rev-monte-carlo-numbering.pdf) |
| CGaudi::ParticleProperty | A trivial class to hold information about a single particle properties |
| CParticleProperty | A trivial class to hold information about a single particle properties |
| CSystem::PathResolver | |
| Cdetails::Payload_helper< Mode, T, U > | |
| Cdetails::Payload_helper< Gaudi::DataHandle::Reader, Gaudi::NamedRange_< T >, U > | |
| Cdetails::Payload_helper< Gaudi::DataHandle::Reader, Gaudi::Range_< T >, U > | |
| Cdetails::Payload_helper< Gaudi::DataHandle::Reader, std::optional< Gaudi::NamedRange_< T > >, U > | |
| CGaudi::Utils::PeriodicAction | Helper to periodically run asynchronous tasks |
| CPeriodicAction | Helper to periodically run asynchronous tasks |
| CGaudiPython.Persistency.PersistencyHelper | |
| CGaudiPython.Persistency.RootPersistency | |
| CGaudi::Tr::PID | |
| CGaudiUtils::AllocatorPool::PoolChunk | |
| CSystem::POOLED_USAGE_AND_LIMITS | Process Pooled Quota Usage and Limits NtQueryInformationProcess using ProcessPooledUsageAndLimits |
| CPOOLIOTestDict__Instantiations | |
| CGaudiUtils::AllocatorPool::PoolLink | |
| CGaudi::Parsers::Position | |
| CROOT::Math::PositionVector3D< CoordSystem, Tag > | |
| CPOSIXFileHandler | |
| CGaudi::Parsers::PragmaOptions | |
| CGaudi::Accumulators::PrintableCounter | An empty ancester of all counters that knows how to print themselves |
| CGaudi::Accumulators::BufferableCounter< Atomicity, Accumulator, Arithmetic, NumberDimensions, AxisTupleType > | |
| CGaudi::Accumulators::BufferableCounter< atomicity::full, AveragingAccumulator, double > | |
| CGaudi::Accumulators::BufferableCounter< atomicity::full, BinomialAccumulator, double > | |
| CGaudi::Accumulators::BufferableCounter< atomicity::full, IntegralAccumulator, unsigned long > | |
| CGaudi::Accumulators::BufferableCounter< Atomicity, Accumulator, Arithmetic, std::integral_constant< unsigned int, ND >, std::tuple< AxisTypes... > > | |
| CGaudi::Accumulators::BufferableCounter< atomicity::full, SigmaAccumulator, double > | |
| CGaudi::Accumulators::BufferableCounter< atomicity::full, StatAccumulator, double > | |
| CGaudi::Accumulators::BufferableCounter< atomicity::full, AveragingAccumulator, unsigned int > | |
| CGaudi::Accumulators::BufferableCounter< Atomicity, AveragingAccumulator, double > | |
| CGaudi::Accumulators::BufferableCounter< atomicity::full, AveragingAccumulator, std::size_t > | |
| CGaudi::Accumulators::MsgCounter< MSG::INFO > | |
| CGaudi::Accumulators::MsgCounter< MSG::ERROR > | |
| CGaudi::Accumulators::MsgCounter< MSG::WARNING > | |
| CGaudi::Accumulators::BufferableCounter< Atomicity, Accumulator, Args > | An empty ancester of all counters that provides a buffer method that returns a buffer on itself Also registers the counter to its owner, with default type "counter" Due to this registration, move semantic is disabled |
| CGaudi::Accumulators::MsgCounter< level, Atomicity > | |
| CStatEntity | Backward compatible StatEntity class |
| CGaudiPython::Printer< TYPE > | |
| CGaudiPython::Printer< ContainedObject > | |
| CGaudiPython::Printer< DataObject > | |
| 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 |
| CProcessUnknownID | |
| CHepPDT::TestUnknownID | |
| CprocInfo | |
| CProcStats | |
| CGaudi::Functional::details::Producer< Signature, Traits_, isLegacy > | |
| CGaudi::Functional::details::Producer< Signature, Traits_, details::isLegacy< Traits_ > > | |
| CGaudi::Hive::FetchLeavesFromFile | |
| CGaudi::TestSuite::IntDataProducer | |
| CGaudi::TestSuite::KeyedDataProducer | |
| CGaudi::TestSuite::NTuple::CounterDataProducer | |
| CGaudi::TestSuite::NTuple::FloatDataProducer | |
| CGaudi::TestSuite::NTuple::IntVectorDataProducer | |
| CGaudi::TestSuite::NTuple::StrDataProducer | |
| CGaudi::TestSuite::NTuple::StructDataProducer | |
| CGaudi::TestSuite::OpaqueProducer | |
| CGaudi::TestSuite::RangeProducer | |
| CGaudi::TestSuite::SDataProducer | |
| CGaudi::TestSuite::ShrdPtrProducer | |
| CGaudi::TestSuite::StringDataProducer | |
| CGaudi::TestSuite::THDataProducer | |
| CGaudi::TestSuite::THDataProducer2 | |
| CGaudi::TestSuite::TestObjectVersion::CreateObject | |
| CGaudi::TestSuite::VectorDataProducer | |
| CGaudi::TestSuite::VectorDoubleProducer | |
| CProduceIntView | |
| CProduceStringView | |
| CGaudi.Main.BootstrapHelper.Property | |
| CGaudi::Parsers::Property | |
| CGaudiConfig2._configurables.Property | |
| CGaudi::Details::PropertyBase | PropertyBase base class allowing PropertyBase* collections to be "homogeneous" |
| CGaudi::Property< GaudiUtils::HashMap< std::string, T > > | |
| CGaudi::Property< TYPE & > | |
| CGaudi::Property< bool > | |
| CGaudi::Property< char > | |
| CGaudi::Property< signed char > | |
| CGaudi::Property< unsigned char > | |
| CGaudi::Property< short > | |
| CGaudi::Property< unsigned short > | |
| CGaudi::Property< int > | |
| CGaudi::Property< unsigned int > | |
| CGaudi::Property< long > | |
| CGaudi::Property< unsigned long > | |
| CGaudi::Property< long long > | |
| CGaudi::Property< unsigned long long > | |
| CGaudi::Property< float > | |
| CGaudi::Property< double > | |
| CGaudi::Property< long double > | |
| CGaudi::Property< std::string > | |
| CGaudi::Property< bool & > | |
| CGaudi::Property< char & > | |
| CGaudi::Property< signed char & > | |
| CGaudi::Property< unsigned char & > | |
| CGaudi::Property< short & > | |
| CGaudi::Property< unsigned short & > | |
| CGaudi::Property< int & > | |
| CGaudi::Property< unsigned int & > | |
| CGaudi::Property< long & > | |
| CGaudi::Property< unsigned long & > | |
| CGaudi::Property< long long & > | |
| CGaudi::Property< unsigned long long & > | |
| CGaudi::Property< float & > | |
| CGaudi::Property< double & > | |
| CGaudi::Property< long double & > | |
| CGaudi::Property< std::string & > | |
| CGaudi::Property< std::vector< bool > > | |
| CGaudi::Property< std::vector< char > > | |
| CGaudi::Property< std::vector< signed char > > | |
| CGaudi::Property< std::vector< unsigned char > > | |
| CGaudi::Property< std::vector< short > > | |
| CGaudi::Property< std::vector< unsigned short > > | |
| CGaudi::Property< std::vector< int > > | |
| CGaudi::Property< std::vector< unsigned int > > | |
| CGaudi::Property< std::vector< long > > | |
| CGaudi::Property< std::vector< unsigned long > > | |
| CGaudi::Property< std::vector< long long > > | |
| CGaudi::Property< std::vector< unsigned long long > > | |
| CGaudi::Property< std::vector< float > > | |
| CGaudi::Property< std::vector< double > > | |
| CGaudi::Property< std::vector< long double > > | |
| CGaudi::Property< std::vector< std::string > > | |
| CGaudi::Property< std::vector< bool > & > | |
| CGaudi::Property< std::vector< char > & > | |
| CGaudi::Property< std::vector< signed char > & > | |
| CGaudi::Property< std::vector< unsigned char > & > | |
| CGaudi::Property< std::vector< short > & > | |
| CGaudi::Property< std::vector< unsigned short > & > | |
| CGaudi::Property< std::vector< int > & > | |
| CGaudi::Property< std::vector< unsigned int > & > | |
| CGaudi::Property< std::vector< long > & > | |
| CGaudi::Property< std::vector< unsigned long > & > | |
| CGaudi::Property< std::vector< long long > & > | |
| CGaudi::Property< std::vector< unsigned long long > & > | |
| CGaudi::Property< std::vector< float > & > | |
| CGaudi::Property< std::vector< double > & > | |
| CGaudi::Property< std::vector< long double > & > | |
| CGaudi::Property< std::vector< std::string > & > | |
| CGaudi::Property< Gaudi::Histo1DDef > | |
| CGaudi::Property< Gaudi::Histo1DDef & > | |
| CGaudi::Property< DataObjIDColl > | |
| CGaudi::Property< IAlgorithm::AlgResources_t > | |
| CGaudi::Property< std::map< std::string, std::string > > | |
| CGaudi::Property< Setup > | |
| CGaudi::Property< Map > | |
| CGaudi::Property< CLID > | |
| CGaudi::Property< StreamSpecs > | |
| CGaudi::Property< size_t > | |
| CGaudi::Property< std::size_t > | |
| CGaudi::Property< std::pair< double, double > > | |
| CGaudi::Property< std::vector< std::pair< double, double > > > | |
| CGaudi::Property< std::vector< std::vector< std::string > > > | |
| CGaudi::Property< std::vector< std::vector< double > > > | |
| CGaudi::Property< std::map< int, double > > | |
| CGaudi::Property< std::map< std::string, int > > | |
| CGaudi::Property< std::map< std::string, double > > | |
| CGaudi::Property< std::map< std::string, std::vector< std::string > > > | |
| CGaudi::Property< std::pair< int, int > > | |
| CGaudi::Property< std::map< std::string, std::vector< double > > > | |
| CGaudi::Property< std::map< std::string, std::vector< int > > > | |
| CGaudi::Property< std::map< int, int > > | |
| CGaudi::Property< std::vector< std::pair< int, int > > > | |
| CGaudi::Property< std::map< int, std::string > > | |
| CGaudi::Property< std::map< unsigned int, std::string > > | |
| CGaudi::Property< std::tuple< std::string, int, double > > | |
| CGaudi::Property< std::tuple< std::string > > | |
| CGaudi::Property< std::unordered_set< int > > | |
| CGaudi::Property< std::unordered_set< std::string > > | |
| CGaudi::Property< std::array< double, 3 > > | |
| CGaudi::Property< std::array< int, 1 > > | |
| CGaudi::Property< GaudiUtils::Map< std::string, std::string > > | |
| CGaudi::Property< std::vector< Triplet > > | |
| CGaudi::Property< std::set< Triplet > > | |
| CGaudi::Property< std::unordered_set< Triplet, HashFunction > > | |
| CGaudi::Property< std::tuple< int, VS > > | |
| CGaudi::Property< std::tuple< int, SS > > | |
| CGaudi::Property< std::tuple< int, USS > > | |
| CGaudi::Property< AlgResources_t > | |
| CGaudi::Property< CatalogNames > | |
| CGaudi::Property< std::array< std::string, sizeof...(OUTPUTs)> > | |
| CGaudi::Property< Files > | |
| CGaudi::Property< Particles > | |
| CGaudi::Property< boost::array< double, 5 > > | |
| CGaudi::Property< boost::array< std::string, 4 > > | |
| CGaudi::Property< ConditionKey > | |
| CGaudi::Property< std::unordered_map< std::string, std::string > > | |
| CGaudi::Property< Gaudi::XYZPoint > | |
| CGaudi::Property< Gaudi::XYZVector > | |
| CGaudi::Property< Gaudi::LorentzVector > | |
| CGaudi::Property< Gaudi::Vector5 > | |
| CGaudi::Property< std::vector< Gaudi::XYZPoint > > | |
| CGaudi::Property< std::vector< Gaudi::XYZVector > > | |
| CGaudi::Property< std::vector< Gaudi::LorentzVector > > | |
| CGaudi::Property< Gaudi::StringKey > | |
| CGaudi::Property< Keys > | |
| CGaudi::Property< DBaseEntries > | |
| CGaudi::Property< Histo1DMap > | |
| CGaudi::Property< uint64_t > | |
| CGaudi::Property< nlohmann::json > | |
| CGaudi::Property< std::vector< std::pair< std::string, std::string > > > | |
| CGaudi::Property< std::map< std::string, std::string, std::less<> > > | |
| CGaudi::Property< ItemNames > | |
| CGaudi::Property< AlgDependentItemNames > | |
| CGaudi::Property< std::set< int > > | |
| CGaudi::Property< std::set< std::string > > | |
| CGaudi::Property< std::unordered_set< float > > | |
| CGaudi::Property< T > | |
| CGaudi::Property< R > | |
| CGaudi::Property< TYPE, VERIFIER, HANDLERS > | Implementation of property with value of concrete type |
| CPropertyWithHandlers< Handler > | Helper class to simplify the migration old properties deriving directly from PropertyBase |
| CDataHandleProperty | |
| CDataHandleVectorProperty | DataHandleProperty.h GaudiKernel/DataHandleProperty.h |
| CGaudiHandleArrayProperty | |
| CGaudiHandleProperty | |
| CPropertyBase | PropertyBase base class allowing PropertyBase* collections to be "homogeneous" |
| CGaudi::Property< GaudiUtils::HashMap< std::string, T > > | |
| CGaudi::Property< TYPE & > | |
| CGaudi::Property< bool > | |
| CGaudi::Property< char > | |
| CGaudi::Property< signed char > | |
| CGaudi::Property< unsigned char > | |
| CGaudi::Property< short > | |
| CGaudi::Property< unsigned short > | |
| CGaudi::Property< int > | |
| CGaudi::Property< unsigned int > | |
| CGaudi::Property< long > | |
| CGaudi::Property< unsigned long > | |
| CGaudi::Property< long long > | |
| CGaudi::Property< unsigned long long > | |
| CGaudi::Property< float > | |
| CGaudi::Property< double > | |
| CGaudi::Property< long double > | |
| CGaudi::Property< std::string > | |
| CGaudi::Property< bool & > | |
| CGaudi::Property< char & > | |
| CGaudi::Property< signed char & > | |
| CGaudi::Property< unsigned char & > | |
| CGaudi::Property< short & > | |
| CGaudi::Property< unsigned short & > | |
| CGaudi::Property< int & > | |
| CGaudi::Property< unsigned int & > | |
| CGaudi::Property< long & > | |
| CGaudi::Property< unsigned long & > | |
| CGaudi::Property< long long & > | |
| CGaudi::Property< unsigned long long & > | |
| CGaudi::Property< float & > | |
| CGaudi::Property< double & > | |
| CGaudi::Property< long double & > | |
| CGaudi::Property< std::string & > | |
| CGaudi::Property< std::vector< bool > > | |
| CGaudi::Property< std::vector< char > > | |
| CGaudi::Property< std::vector< signed char > > | |
| CGaudi::Property< std::vector< unsigned char > > | |
| CGaudi::Property< std::vector< short > > | |
| CGaudi::Property< std::vector< unsigned short > > | |
| CGaudi::Property< std::vector< int > > | |
| CGaudi::Property< std::vector< unsigned int > > | |
| CGaudi::Property< std::vector< long > > | |
| CGaudi::Property< std::vector< unsigned long > > | |
| CGaudi::Property< std::vector< long long > > | |
| CGaudi::Property< std::vector< unsigned long long > > | |
| CGaudi::Property< std::vector< float > > | |
| CGaudi::Property< std::vector< double > > | |
| CGaudi::Property< std::vector< long double > > | |
| CGaudi::Property< std::vector< std::string > > | |
| CGaudi::Property< std::vector< bool > & > | |
| CGaudi::Property< std::vector< char > & > | |
| CGaudi::Property< std::vector< signed char > & > | |
| CGaudi::Property< std::vector< unsigned char > & > | |
| CGaudi::Property< std::vector< short > & > | |
| CGaudi::Property< std::vector< unsigned short > & > | |
| CGaudi::Property< std::vector< int > & > | |
| CGaudi::Property< std::vector< unsigned int > & > | |
| CGaudi::Property< std::vector< long > & > | |
| CGaudi::Property< std::vector< unsigned long > & > | |
| CGaudi::Property< std::vector< long long > & > | |
| CGaudi::Property< std::vector< unsigned long long > & > | |
| CGaudi::Property< std::vector< float > & > | |
| CGaudi::Property< std::vector< double > & > | |
| CGaudi::Property< std::vector< long double > & > | |
| CGaudi::Property< std::vector< std::string > & > | |
| CGaudi::Property< Gaudi::Histo1DDef > | |
| CGaudi::Property< Gaudi::Histo1DDef & > | |
| CGaudi::Property< DataObjIDColl > | |
| CGaudi::Property< IAlgorithm::AlgResources_t > | |
| CGaudi::Property< std::map< std::string, std::string > > | |
| CGaudi::Property< Setup > | |
| CGaudi::Property< Map > | |
| CGaudi::Property< CLID > | |
| CGaudi::Property< StreamSpecs > | |
| CGaudi::Property< size_t > | |
| CGaudi::Property< std::size_t > | |
| CGaudi::Property< std::pair< double, double > > | |
| CGaudi::Property< std::vector< std::pair< double, double > > > | |
| CGaudi::Property< std::vector< std::vector< std::string > > > | |
| CGaudi::Property< std::vector< std::vector< double > > > | |
| CGaudi::Property< std::map< int, double > > | |
| CGaudi::Property< std::map< std::string, int > > | |
| CGaudi::Property< std::map< std::string, double > > | |
| CGaudi::Property< std::map< std::string, std::vector< std::string > > > | |
| CGaudi::Property< std::pair< int, int > > | |
| CGaudi::Property< std::map< std::string, std::vector< double > > > | |
| CGaudi::Property< std::map< std::string, std::vector< int > > > | |
| CGaudi::Property< std::map< int, int > > | |
| CGaudi::Property< std::vector< std::pair< int, int > > > | |
| CGaudi::Property< std::map< int, std::string > > | |
| CGaudi::Property< std::map< unsigned int, std::string > > | |
| CGaudi::Property< std::tuple< std::string, int, double > > | |
| CGaudi::Property< std::tuple< std::string > > | |
| CGaudi::Property< std::unordered_set< int > > | |
| CGaudi::Property< std::unordered_set< std::string > > | |
| CGaudi::Property< std::array< double, 3 > > | |
| CGaudi::Property< std::array< int, 1 > > | |
| CGaudi::Property< GaudiUtils::Map< std::string, std::string > > | |
| CGaudi::Property< std::vector< Triplet > > | |
| CGaudi::Property< std::set< Triplet > > | |
| CGaudi::Property< std::unordered_set< Triplet, HashFunction > > | |
| CGaudi::Property< std::tuple< int, VS > > | |
| CGaudi::Property< std::tuple< int, SS > > | |
| CGaudi::Property< std::tuple< int, USS > > | |
| CGaudi::Property< AlgResources_t > | |
| CGaudi::Property< CatalogNames > | |
| CGaudi::Property< std::array< std::string, sizeof...(OUTPUTs)> > | |
| CGaudi::Property< Files > | |
| CGaudi::Property< Particles > | |
| CGaudi::Property< boost::array< double, 5 > > | |
| CGaudi::Property< boost::array< std::string, 4 > > | |
| CGaudi::Property< ConditionKey > | |
| CGaudi::Property< std::unordered_map< std::string, std::string > > | |
| CGaudi::Property< Gaudi::XYZPoint > | |
| CGaudi::Property< Gaudi::XYZVector > | |
| CGaudi::Property< Gaudi::LorentzVector > | |
| CGaudi::Property< Gaudi::Vector5 > | |
| CGaudi::Property< std::vector< Gaudi::XYZPoint > > | |
| CGaudi::Property< std::vector< Gaudi::XYZVector > > | |
| CGaudi::Property< std::vector< Gaudi::LorentzVector > > | |
| CGaudi::Property< Gaudi::StringKey > | |
| CGaudi::Property< Keys > | |
| CGaudi::Property< DBaseEntries > | |
| CGaudi::Property< Histo1DMap > | |
| CGaudi::Property< uint64_t > | |
| CGaudi::Property< nlohmann::json > | |
| CGaudi::Property< std::vector< std::pair< std::string, std::string > > > | |
| CGaudi::Property< std::map< std::string, std::string, std::less<> > > | |
| CGaudi::Property< ItemNames > | |
| CGaudi::Property< AlgDependentItemNames > | |
| CGaudi::Property< std::set< int > > | |
| CGaudi::Property< std::set< std::string > > | |
| CGaudi::Property< std::unordered_set< float > > | |
| CGaudi::Property< T > | |
| CGaudi::Property< R > | |
| CGaudi::Property< TYPE, VERIFIER, HANDLERS > | Implementation of property with value of concrete type |
| CPropertyWithHandlers< Handler > | Helper class to simplify the migration old properties deriving directly from PropertyBase |
| CGaudiPython.Bindings.PropertyEntry | |
| CGaudi::Details::PropertyId | Helper to record a property identifier as a sequence of SharedString instances |
| CGaudi::Parsers::PropertyName | |
| CGaudiKernel.PropertyProxy.PropertyProxy | |
| CGaudiKernel.PropertyProxy.DataHandlePropertyProxy | |
| CGaudiKernel.PropertyProxy.DataHandleVectorPropertyProxy | |
| CGaudiKernel.PropertyProxy.GaudiHandlePropertyProxyBase | |
| CGaudiKernel.PropertyProxy.GaudiHandleArrayPropertyProxy | |
| CGaudiKernel.PropertyProxy.GaudiHandlePropertyProxy | |
| CGaudiKernel.Configurable.PropertyReference | |
| CGaudiConfig2.semantics.PropertySemantics | |
| CGaudiConfig2.semantics.BoolSemantics | |
| CGaudiConfig2.semantics.ComponentHandleSemantics | |
| CGaudiConfig2.semantics.ComponentSemantics | |
| CGaudiConfig2.semantics.DataHandleSemantics | |
| CGaudiConfig2.semantics.DefaultSemantics | |
| CGaudiConfig2.semantics.GaudiHandleArraySemantics | |
| CGaudiConfig2.semantics.FloatSemantics | |
| CGaudiConfig2.semantics.IntSemantics | |
| CGaudiConfig2.semantics.JSONSemantics | |
| CGaudiConfig2.semantics.MappingSemantics | |
| CGaudiConfig2.semantics.SequenceSemantics | |
| CGaudiConfig2.semantics.DataHandleVectorSemantics | |
| CGaudiConfig2.semantics.OrderedSetSemantics | |
| CGaudiConfig2.semantics.SetSemantics | |
| CGaudiConfig2.semantics.StringSemantics | |
| CGaudi::Parsers::PropertyValue | |
| CDataOnDemandSvc::Protection | Helper class of the DataOnDemandSvc |
| CGaudi::Accumulators::RootHistogramingAccumulatorInternal< Atomicity, Arithmetic, ND, AxisTupleType >::Proxy | Small procyclass allowing operator[] to work as expected on the RootHistogram that is to return something having an operator+= updating the histogram properly |
| CAnyDataWrapperBase::Ptr | |
| CGaudiPython::CallbackStreamBuf::PyObject_t | |
| CPythonAdaptor | |
| CPythonConfig | |
| CQotdAlg | Simple algorithm to output "famous" quotes of "famous" people into a MsgStream stream |
| 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_< T > | |
| CGaudi::NamedRange_< T > | |
| CGaudi::Range_< typename ValueType::ConstVector > | |
| CGaudi::NamedRange_< typename ValueType::ConstVector > | |
| CGaudi::Range_< MyData::ConstVector > | |
| CGaudi::Range_< CONTAINER > | Useful class for representation of "sequence" of the objects through the range of valid iterators |
| CGaudi::NamedRange_< CONTAINER > | |
| CGaudi::NTuple::DiskBuffer::Reader | |
| Cprecedence.RealTimeValue | |
| CGaudi::Allocator::Arena< Resource, T, DefaultResource >::rebind< U > | |
| CGaudiUtils::Allocator< Type >::rebind< U > | |
| CGaudiRoot::RefAccessor | |
| CGaudi::PluginService::v1::Details::Registry | In-memory database of the loaded factories |
| CPropertyHolder< BASE >::RemProperty | |
| CRenounceToolInputsVisitor | Helper class to be used in conjunction with the recursive tool visitor to renounce certain inputs |
| Cupdate_version.ReplacementRule | |
| CRetCodeGuard | Helper class to set the application return code in case of early exit (e.g |
| Cstring::reverse_iterator | STL iterator class |
| Cvector< T >::reverse_iterator | STL iterator class |
| Cdetails::reverse_wrapper< Iterable > | |
| CRichToolTest | |
| Cprecedence.RndBiasedBooleanValue | |
| 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 | |
| CGaudi::RootDatabaseMerger | |
| CGaudi::RootEventExtractor | |
| CRootFileHandler | |
| CRootHisto | |
| CGaudi::Histograming::Sink::details::ProfileWrapper< RootHisto > | |
| CGaudi::Accumulators::RootHistogramingAccumulator< Atomicity, Arithmetic, ND, AxisTupleType > | Class implementing a root histogram accumulator |
| CGaudi::Accumulators::RootHistogramingCounterBase< ND, Atomicity, Arithmetic, Type, AxisTupleType > | Extension of the standard Gaudi histogram to provide similar functionnality as ROOT |
| 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 | |
| CGaudi::Functional::ScalarTransformer< ScalarOp, TransformerSignature, Traits_ > | |
| CGaudi::Functional::ScalarTransformer< LdExpTransformer, std::vector< double >(const std::vector< double > &, const std::vector< int > &), BaseClass_t > | |
| CGaudi::TestSuite::LdExpTransformer | |
| CGaudi::Functional::ScalarTransformer< OptLdExpTransformer, std::vector< double >(const std::vector< double > &, const std::vector< int > &), BaseClass_t > | |
| CGaudi::TestSuite::OptLdExpTransformer | |
| CGaudi::Timers::GenericTimer< Clock, Unit >::ScopeTimer | A scoped timer that starts/stops on con/de-struction |
| CGaudi::Parsers::KeyValueGrammar< Iterator, Skipper >::second | |
| CPersistencySvc::ServiceEntry | |
| CServiceManager::ServiceItem | |
| CServiceLocatorHelper | Helper to share the implementation of service() among the various kernel base classes |
| CGaudi::Details::SharedString | Std::string wrapper for static strings where identical values actually share the memory |
| CGaudi::Accumulators::SigmasValueHandler< Arithmetic, Atomicity, ND > | |
| CGaudi::NTuple::SimpleWriter< Signature, Traits_ > | Base template for NTuple::Writer |
| CGaudi::NTuple::SimpleWriter< std::tuple< int, size_t, float >(const std::vector< int > &)> | |
| CGaudi::TestSuite::NTuple::NTupleSimpleWriter_V | |
| CGaudi::Monitoring::Hub::Sink | Interface reporting services must implement |
| CGaudi::Monitoring::BaseSink | Base class for all Sinks registering to the Monitoring Hub Should be extended by actual Sinks |
| CSmartDataObjectPtr | 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 |
| CSmartDataStorePtr< TYPE, LOADER > | A small class used to access easily (and efficiently) data items residing in data stores |
| CSmartDataPtr< NTuple::Tuple > | |
| CSmartDataPtr< NTuple::Directory > | |
| CSmartDataPtr< NTuple::File > | |
| CSmartIF< TYPE > | Small smart pointer class with automatic reference counting for IInterface |
| CSmartRef< TYPE > | Kernel objects: SmartRef |
| CSmartRefArray< TYPE > | |
| CSmartRefBase | User example objects: SmartRefBase |
| CSmartRefList< TYPE > | |
| CSmartRefMap< TYPE > | |
| CSmartRefVectorImpl::SmartRefVectorPythonizer | |
| CSmartRefVector< Gaudi::TestSuite::Collision > | |
| CSmartRefVector< Gaudi::TestSuite::MyVertex > | |
| CSmartRefVector< Gaudi::TestSuite::MyTrack > | |
| CSmartRefVector< TYPE > | Kernel objects: SmartRefVector |
| CGaudi::Functional::details::SplittingMergingTransformer< Signature, Traits_ > | |
| CGaudi::TestSuite::IntVectorsToInts | Transform a vector of vector of int to a vector of int, where the output vector of in is scattered into the TES |
| CGaudi::TestSuite::IntVectorsToIntsWithContextAndScale | |
| CGaudi::Functional::details::SplittingTransformer< Signature, Traits_ > | |
| CGaudi::Accumulators::Square | A Square functor |
| CGaudiMP.Parallel.SshSession | |
| Cprecedence::StartTime | |
| CStat | Small wrapper class for easy manipulation with generic counters and IStatSvc interface |
| Cboost::container::static_vector | |
| CGaudi::Accumulators::details::HistogramArrayInternal< Histo, N > | Internal class implementing an "array" of histograms |
| CGaudi::Accumulators::HistogramArray< Histo, N, std::integer_sequence< unsigned int, ND... > > | |
| CGaudiMP.Parallel.Statistics | |
| CAlgTimingAuditor::stats_t | |
| CGaudi.Main.BootstrapHelper.StatusCode | |
| CStatusCode | This class is used for returning status codes from appropriate routines |
| CGaudi::Parsers::AxisGrammar< Iterator, Skipper, Arithmetic >::StoreMaxValueOp | |
| CGaudi::Parsers::AxisGrammar< Iterator, Skipper, Arithmetic >::StoreMinValueOp | |
| CGaudi::Parsers::AxisGrammar< Iterator, Skipper, Arithmetic >::StoreNbinsOp | |
| CGaudi::Parsers::AxisGrammar< Iterator, Skipper, Arithmetic >::StoreTitleOp | |
| Cstr | |
| CGaudiConfig2.semantics._JSONOption | |
| CGaudi::CUDA::Stream | |
| CStreamBuffer | The stream buffer is a small object collecting object data |
| Clogging.StreamHandler | |
| CGaudiKernel.ProcessJobOptions.ConsoleHandler | |
| Cstd::stringbuf | |
| CGaudiPython::CallbackStreamBuf | |
| CGaudi::StringKey | Helper class for efficient "key" access for strings |
| CGaudi::StringKeyHash | Transparent hash operator for heterogeneous lookups |
| Cctypes.Structure | |
| CGaudi.c_opt_t | |
| Ccpluginsvc.Factory | |
| Ccpluginsvc.Property | |
| Ccpluginsvc.Registry | |
| CGaudiTesting.SubprocessBaseTest.SubprocessBaseTest | |
| CGaudiTesting.GaudiExeTest.GaudiExeTest | |
| CGaudi::Details::Property::SwapCall | Helper to disable a while triggering it, to avoid infinite recursion |
| CGaudi::Decays::Symbols | Helper class to obtain the information about the valid symbols for particles, decay descriptors and Nodes |
| CGaudiMP.pTools.Syncer | |
| CGaudi::cxx::SynchronizedValue< Value, Mutex, ReadLock, WriteLock > | |
| CGaudiMP.pTools.SyncMini | |
| CGaudi::SysProcStat | |
| CGaudi::Utils::Histos::Table | Simple class for the customizeble printout of the histogram tables |
| CIInspector::Tag | |
| CIInspector::_TT< T > | |
| CGaudi::tagged_bool< Tag > | |
| CGaudi::tagged_bool_ns::tagged_bool< Tag > | |
| CGaudi::Functional::details::TailLocationSpecs< Args > | |
| CGaudi::Functional::details::TailLocationSpecs< First, Rest... > | |
| CGaudiMP.Parallel.Task | |
| CAvalancheSchedulerSvc::TaskSpec | Struct to hold entries in the alg queues |
| CTClassStreamer | |
| CGaudiRoot::IOHandler< T > | |
| CTemplateAlg | Trivial Algorithm for tutotial purposes |
| CGaudiMP.GMPBase.TESSerializer | |
| CTHistSvc::THistID | Helper struct that bundles the histogram ID with a mutex, TFile and TObject* |
| CThreadInitTask | Special TBB task used by ThreadPoolSvc to wrap execution of IThreadInitTools |
| CGaudi::Time | Based on seal::Time |
| CTimelineEvent | |
| CITimelineSvc::TimelineRecorder | RAII helper to record timeline events |
| CGaudi::TimeSpan | Based on seal::TimeSpan |
| CmakePlots.TimingInfo | |
| CGaudi::RootDataConnection::Tool | Abstraction layer probably not needed anymore as the only implementation if RootTool |
| CGaudi::RootTool | Description: |
| CGaudi::Functional::details::ToolBinder< Signature, Traits > | |
| CGaudi::Functional::details::ToolBinder< Signature, Traits_ > | |
| CGaudi::TestSuite::MyConsumerTool | |
| CToolHandleInfo | General info and helper functions for toolhandles and arrays |
| CToolHandleArray< IMyTool > | |
| CToolHandleArray< IThreadInitTool > | |
| CBaseToolHandle | Non-templated base class for actual ToolHandle<T> |
| CToolHandle< Gaudi::Interface::Bind::IBinder< std::decay_t< T > > > | |
| CToolHandle< IAlgTool > | |
| CToolHandle< Gaudi::TestSuite::FloatTool > | |
| CToolHandle< Gaudi::Tests::Histograms::Directories::HistoGroupsTool > | |
| CToolHandle< IMyTool > | |
| CToolHandle< GaudiTesting::ITestTool > | |
| CToolHandle< IWrongTool > | |
| CToolHandle< const IMyTool > | |
| CToolHandle< IThreadInitTool > | |
| CToolHandle< Gaudi::Interface::Bind::IBinder< IFace > > | |
| CToolHandle< T > | Handle to be used in lieu of naked pointers to tools |
| CToolHandleArray< T > | Array of Handles to be used in lieu of vector of naked pointers to tools |
| CToolSvc::ToolList | Common Tools |
| CTP | |
| CGaudi::Histograming::Sink::details::ProfileWrapper< TP > | Helper Wrapper around TProfileX to be able to fill it |
| CGaudi::Example::TinyExperiment::Track | Most simple Track ever : in 2D space, starting from the origin and thus fully defined by an angle theta |
| CGaudi::Histograming::Sink::Traits< isProfile, RootHisto, N > | Templated Traits dealing with Root Histogram filling for standard histograms |
| CGaudi::Histograming::Sink::details::TraitsBase< RootHisto, N > | Common base for Traits dealing with Histogram conversions to Root Provides generic implementation for creating the histogram and filling meta data The filling (method fill) is not implemented |
| CGaudi::Histograming::Sink::Traits< false, RootHisto, N > | Specialization of Traits dealing with non profile Root Histograms |
| CGaudi::Histograming::Sink::details::TraitsBase< details::ProfileWrapper< RootHisto >, N > | |
| CGaudi::Histograming::Sink::Traits< true, RootHisto, N > | Specialization of Traits dealing with profile Root Histograms |
| CGaudi ::Functional::details::Transformer< Signature, Traits_, isLegacy > | |
| CGaudi::Functional::Transformer | |
| CGaudi::EventWatchdogAlg | Add to the transient store a tracker that detects events that are taking too long |
| CGaudi::Example::TinyExperiment::DigitizationAlg | Digitization algorithm returning a set of hits from MCHits, basically adding noise |
| CGaudi::Example::TinyExperiment::GeneratorAlg | Generator algorithm returning a set of random tracks |
| CGaudi::Example::TinyExperiment::SimulationAlg | Simulation algorithm creating MC Hits from a set of tracks |
| CGaudi::Example::TinyExperiment::TrackingAlg | Tracking algorithm building tracks from hits using a simplified Hough transform |
| CGaudi::Functional::ScalarTransformer< ScalarOp, Out(const In &...), Traits_ > | |
| CGaudi::Functional::details::Producer< Out(), Traits_, legacy > | |
| CGaudi::TestSuite::ContextTransformer | |
| CGaudi::TestSuite::IntFloatToFloatData | |
| CGaudi::TestSuite::IntToFloatData | |
| CGaudi::TestSuite::SelectTracks | |
| Cstd::true_type | |
| CGaudi::Monitoring::details::has_mergeAndReset_method< Arg, std::void_t< decltype(mergeAndReset(std::declval< Arg & >(), std::declval< Arg & >()))> > | |
| CGaudi::Monitoring::details::has_reset_method< Arg, std::void_t< decltype(reset(std::declval< Arg & >()))> > | |
| CGaudi::Accumulators::TrueTo1 | Helper functor for the TrueAccumulator |
| CRootHistCnv::RHistogramCnv< T, S, Q >::TTH< CLASS > | |
| Cstd::tuple | |
| CGaudi::Accumulators::HistoInputType< std::tuple< Elements... >, NIndex > | |
| CGaudi::Utils::TuplePrinter< Tuple, N > | |
| CGaudi::Utils::TuplePrinter< Tuple, 1 > | |
| Ctype | |
| CGaudiConfig2._configurables.ConfigurableMeta | |
| CGaudiConfig2._configurables.Configurable | |
| CGaudiKernel.ConfigurableMeta.ConfigurableMeta | |
| CGaudiKernel.Configurable.Configurable | |
| CGaudi::Functional::details::type_list< T > | |
| CGaudi::Utils::TypeNameString | Helper class to parse a string of format "type/name" |
| Cprecedence.UniformBooleanValue | |
| Cprecedence.UniformTimeValue | |
| CProcStats::unique_fd | |
| CGaudi::Parsers::Units | |
| CGaudi::RootDatabaseMerger::uuid_data | |
| CGaudi::Parsers::NodeOperations::value | |
| CGaudi::Functional::details::details2::value_type_of< T > | |
| CGaudi::Functional::details::details2::value_type_of< T > | |
| CContainers::vector | |
| Cstd::vector< T > | STL class |
| CSmartRefVector< Gaudi::TestSuite::Collision > | |
| CSmartRefVector< Gaudi::TestSuite::MyVertex > | |
| CSmartRefVector< Gaudi::TestSuite::MyTrack > | |
| CSmartRefVector< TYPE > | Kernel objects: SmartRefVector |
| Cvector< T > | STL class |
| CSmartRefVector< Gaudi::TestSuite::Collision > | |
| CSmartRefVector< Gaudi::TestSuite::MyVertex > | |
| CSmartRefVector< Gaudi::TestSuite::MyTrack > | |
| CSmartRefVector< TYPE > | Kernel objects: SmartRefVector |
| CGaudi::Functional::details::vector_of_const_< Container > | |
| CGaudi::Functional::vector_of_const_< Container > | |
| CGaudi::Functional::details::vector_of_input_< T > | |
| CGaudi::Functional::details::vector_of_output_< T > | |
| Cprecedence::VertexName | |
| CViewTester | |
| CSystem::VM_COUNTERS | Process Virtual Memory Counters NtQueryInformationProcess using ProcessVmCounters |
| CGaudi::Details::WeakPropertyRef | Optional reference to a property that can be used to refer to a sting or to the string representation of a property instance value |
| CGaudi::Accumulators::WeightedAdder< Arithmetic, Atomicity > | An Adder ValueHandler, taking weight into account and computing a count plus the sum of the weights In case of full atomicity, fetch_add or compare_exchange_weak are used for each element, that is we do not have full atomicity accross the two elements |
| CGaudi::Accumulators::WeightedProduct | A Product functor, take a pair (value, weight) as input |
| CGaudi::Accumulators::WeightedProfileTransform | An inputTransform for WeightedProfile histograms, keeping weight and replacing value by 1 |
| CGaudi::Accumulators::WeightedSquare | A WeightedSquare functor, take a pair (value, weight) as input |
| CWidget | |
| CConversionSvc::WorkerEntry | |
| CGaudiMP.Parallel.WorkManager | |
| CGaudi::NTuple::Wrapper< COLUMNS > | Wrapper around a given NTuple |
| CGaudi::Functional::Traits::WriteOpaqueFor< Data > | |
| CGaudi::NTuple::DiskBuffer::Writer | |
| CGaudi::NTuple::Writer< Signature, Traits_ > | Base template for NTuple::Writer |
| CGaudi::NTuple::Writer< std::tuple< int, size_t, float >(const std::vector< int > &)> | |
| CGaudi::TestSuite::NTuple::NTupleWriter_V | |
| CGaudi::Functional::Traits::writeViewFor< Data, View > | |
1.17.0