| NAIDA | |
| CAnnotation | Implementation of the AIDA IAnnotation interface class |
| CAnnotationItem | Internal private annotation item class |
| Nbug_34121 | |
| CMyAlgorithm | |
| CTool | |
| Nconcurrency | |
| CActiveLineageScout | |
| CAlgoProps | |
| CAlgorithmNode | |
| CCompareNodes | |
| CCondDataProps | |
| CConditionalLineageFinder | |
| CConditionNode | |
| CControlFlowNode | |
| CDataNode | |
| CDataProps | |
| CDataReadyPromoter | |
| CDecisionHubProps | |
| CDecisionNode | |
| CDecisionUpdater | |
| CIGraphVisitor | |
| CIPrecedenceRulesGraph | |
| CNodePropertiesValidator | |
| CPrecedenceRulesGraph | |
| CProductionAmbiguityFinder | |
| CRankerByCummulativeOutDegree | |
| CRankerByDataRealmEccentricity | |
| CRankerByEccentricity | |
| CRankerByProductConsumption | |
| CRankerByTiming | |
| CRunSimulator | |
| CSubSlotScout | |
| CSupervisor | |
| CTarjanSCCFinder | The visitor implements the Tarjan algorithm for searching strongly connected components in the data flow realm of precedence rules graph |
| NConfigurableUser | |
| CExampleIO | |
| CExampleCommon | |
| CExampleApplication | |
| NConfiguration | |
| CGaudiTestSuiteCommonConf | |
| CGaudi_Test_MySuperAlg | |
| NContainers | |
| Carray | |
| Cdecrement | |
| Cfind | |
| Chashmap | |
| Ckey_traits | Key traits class |
| CKeyedObjectManager | KeyedObjectManager Class to manage keyed objects |
| Cmap | |
| Ctraits | Container traits class |
| Cvector | |
| NControlFlow | |
| CControlFlowNode | (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" |
| CControlFlowLeaf | |
| CControlFlowBool | |
| COrderedNode | |
| CAndNode | |
| COrNode | |
| CInvertNode | |
| Cignore | |
| Cpar | |
| Cseq | |
| Cline | |
| C_TestVisitor | |
| C_TestAlgorithm | |
| CDotVisitor | |
| Ncpluginsvc | |
| CRegistry | |
| CFactory | |
| CProperty | |
| NDataSvcHelpers | |
| CRegistryEntry | Definition of an entry in the transient data store |
| Ndetails | |
| Carg_helper | |
| Carg_helper< Ret(T::*)(Arg) const > | |
| CGenericDataStoreAgent | |
| CPayload_helper | |
| CPayload_helper< Gaudi::DataHandle::Reader, Gaudi::NamedRange_< T >, U > | |
| CPayload_helper< Gaudi::DataHandle::Reader, Gaudi::Range_< T >, U > | |
| CPayload_helper< Gaudi::DataHandle::Reader, std::optional< Gaudi::NamedRange_< T > >, U > | |
| Creverse_wrapper | |
| NExtendedProperties | |
| CHashFunction | |
| Nfixtures | |
| CAlwaysTrueDefaultDict | |
| Nfmt | |
| Cformatter< EventContext > | |
| Cformatter< Gaudi::Histograming::Sink::detail::IntWithFixedWidth > | Fmt dedicated formatter for IntWithFixedWidth |
| Cformatter< 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 |
| Cis_range< Gaudi::Property< T, V, H >, Char > | Definitions to allow use of Gaudi::Property<T> with fmtlib |
| NGaudi | This file provides a Grammar for the type Gaudi::Accumulators::Axis It allows to use that type from python with a format liks : ( nbins, min, max, title ) where title can be ommited |
| NAccumulators | Efficient counter implementations for Gaudi |
| Ndetail | |
| CMin | Type trait providing the lowest possible value (to be used as initial value for Maximum) |
| CMax | Type trait providing the highest possible value (to be used as initial value for Minimum) |
| Ndetails | |
| NMsgCounter | |
| CHandler | |
| CCounterArrayInternal | Internal class implementing an array of counters |
| CFormatCounterDefault | Default formating for counter names, only calling std::format on the text given at construction and passing the histo index as argument |
| CFormatHistDefault | Default formating for histogram names and title, only calling fmt::format on the text given at construction and passing the histo index as argument |
| CFormatHistDefaultT | Default formating for histogram names and title, only calling fmt::format on the text given at construction and passing the key as argument |
| CHistogramArrayInternal | Internal class implementing an "array" of histograms |
| CHistogramMapInternal | Internal class implementing a map of histograms |
| CAccumulatorSet | AccumulatorSet is an Accumulator that holds a set of Accumulators templated by same Arithmetic and Atomicity and increase them altogether |
| CAdder | An Adder ValueHandler operator(a, b) means a += b |
| CAdder< Arithmetic, atomicity::full > | Adder specialization in the case of atomicity full |
| CAdder< Arithmetic, atomicity::none > | Adder specialization in the case of atomicity none |
| CAveragingAccumulatorBase | AveragingAccumulatorBase |
| CAveragingCounter | A counter aiming at computing sum and average |
| CAxis | 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 |
| CBaseValueHandler | Base type for all functors used as ValuesHandler |
| CBaseValueHandler< Arithmetic, atomicity::full > | BaseValueHandler specialization in the case of atomicity full |
| CBaseValueHandler< Arithmetic, atomicity::none > | BaseValueHandler specialization in the case of atomicity none |
| CBinomialAccumulator | BinomialAccumulator |
| Cbinomial_t | |
| CBinomialCounter | A counter dealing with binomial data |
| CBuffer | 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 |
| CBufferableCounter | 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 |
| CConstant | A functor always returning the value N |
| Cconstruct_empty_t | Constant used to disambiguate construction of an empty Accumulator versus the copy constructor |
| CCountAccumulator | CountAccumulator |
| CCounter | A basic integral counter; |
| CCounterArray | 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 : |
| CCustomAxis | |
| CExtractWeight | A functor to extract weight, take a pair (valueTuple, weight) as input |
| CExtremum | 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 |
| CExtremum< Arithmetic, atomicity::full, Compare, Initial > | Extremum specialization in the case of atomicity full |
| CExtremum< Arithmetic, atomicity::none, Compare, Initial > | Extremum specialization in the case of atomicity none |
| CFalseAccumulator | FalseAccumulator |
| CFalseTo1 | Helper functor for the FalseAccumulator |
| CGenericAccumulator | Generic Accumulator, templated by |
| CHistogramArray | 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 : |
| CHistogramArray< Histo, N, std::integer_sequence< unsigned int, ND... > > | |
| CHistogramingAccumulatorInternal | Internal Accumulator class dealing with Histograming |
| CHistogramingCounterBase | A base counter dealing with Histograms |
| CHistogramingCounterBase< ND, Atomicity, Arithmetic, Type, Accumulator, std::tuple< AxisTypes... > > | |
| CHistogramMap | Generic class implementing a thread safe map of histograms |
| CHistogramMap< Key, Histo, std::integer_sequence< unsigned int, ND... > > | |
| CHistogramWrapperInternal | A Wrapper of a static Histogram base class using Properties to define title and axis |
| CHistogramWrapperInternal< HistogramType, std::integer_sequence< unsigned int, ND... > > | |
| CHistoInputType | 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 |
| CHistoInputType< std::tuple< Elements... >, NIndex > | |
| CIdentity | An Identity functor |
| CIntegralAccumulator | IntegralAccumulator |
| CMaxAccumulator | MaxAccumulator |
| CMinAccumulator | MinAccumulator |
| CMsgCounter | |
| CPrintableCounter | An empty ancester of all counters that knows how to print themselves |
| CRootHistogramingAccumulator | Class implementing a root histogram accumulator |
| CRootHistogramingAccumulator< Atomicity, Arithmetic, std::integral_constant< unsigned int, 1 >, AxisTupleType > | |
| CRootHistogramingAccumulator< Atomicity, Arithmetic, std::integral_constant< unsigned int, 2 >, AxisTupleType > | |
| CRootHistogramingAccumulator< Atomicity, Arithmetic, std::integral_constant< unsigned int, 3 >, AxisTupleType > | |
| CRootHistogramingAccumulatorInternal | Internal Accumulator class dealing with RootHistograming |
| CProxy | Small procyclass allowing operator[] to work as expected on the RootHistogram that is to return something having an operator+= updating the histogram properly |
| CRootHistogramingCounterBase | Extension of the standard Gaudi histogram to provide similar functionnality as ROOT |
| CRootHistogramingCounterBase< 1, Atomicity, Arithmetic, Type, AxisTupleType > | |
| CRootHistogramingCounterBase< 2, Atomicity, Arithmetic, Type, AxisTupleType > | |
| CRootHistogramingCounterBase< 3, Atomicity, Arithmetic, Type, AxisTupleType > | |
| CSigmaAccumulatorBase | SigmaAccumulatorBase |
| CSigmaCounter | A counter aiming at computing average and sum2 / variance / standard deviation |
| CSigmaNAccumulator | |
| CSigmaNAccumulator< Arithmetic, Atomicity, 1 > | Specialization for ND=1 to allow for better syntax |
| CSigmasValueHandler | |
| COutputTypeTS | |
| CSquare | A Square functor |
| CSquareAccumulator | SquareAccumulator |
| CStatCounter | A counter aiming at computing average and sum2 / variance / standard deviation |
| CSumAccumulator | SumAccumulator |
| CTrueAccumulator | TrueAccumulator |
| CTrueTo1 | Helper functor for the TrueAccumulator |
| CWeightedAdder | 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 |
| CWeightedCountAccumulator | WeightedCountAccumulator |
| CWeightedHistoInputType | Small class used as InputType for weighted Histograms only a pair of the InnerType and the weight |
| CWeightedProduct | A Product functor, take a pair (value, weight) as input |
| CWeightedProfileTransform | An inputTransform for WeightedProfile histograms, keeping weight and replacing value by 1 |
| CWeightedSquare | A WeightedSquare functor, take a pair (value, weight) as input |
| CWeightedSquareAccumulator | WeightedSquareAccumulator |
| CWeightedSumAccumulator | WeightedSumAccumulator |
| NAllocator | |
| CArena | Custom allocator holding a pointer to a generic memory resource |
| Crebind | |
| NArena | |
| CMonotonic | A fast memory arena that does not track deallocations |
| NConcurrency | |
| CConcurrencyFlags | |
| CConcurrencyManager | Interface implemented by components that are allowed to set the concurrency flags of the running job |
| NConfUser | |
| CGaudiPersistency | |
| Ncpp17 | |
| Ndetails | |
| Cdetector | Implementation of the detection idiom (negative case) |
| Cdetector< Default, std::void_t< Op< Args... > >, Op, Args... > | Implementation of the detection idiom (positive case) |
| NCUDA | |
| CDeviceArray | |
| CDeviceArrayGlobalTag_t | |
| CStream | |
| Ncxx | |
| CSynchronizedValue | |
| NDecays | |
| NCC | |
| CCmpCC | Bit specific comparison of strings, useful for ordering according to the length as the primary parameter |
| NNodes | |
| C_Node | Helper structure (especially it is light version node-holder the default constructor |
| CAnd | Rather simple (but powerful) node in the decay tree: it matches .AND |
| CAny | Most simple node in the decay tree: it matches to all valid the Gaudi::Particles |
| CBaryon | The trivial node : it match the Baryon |
| CCC | The simple node in the decay tree: it matches to a certain particle ID or its antiparticle |
| CCharged | The trivial node : it match the Charged |
| CCTau | Simple pid-checker for particle lifetime (in c*tau units) |
| CKnownPids | |
| CEll | The trivial node : it match any charged lepton |
| CEllMinus | The trivial node : it match any negative lepton |
| CEllPlus | The trivial node : it match any positive lepton |
| CHadron | The trivial node : it match the Hadron |
| CHasQuark | The trivial node : it match the quark content |
| CHeavy | Simple pid-checker for particle mass |
| CInvalid | Most simple node to represent the invalid node it matches to all valid the Gaudi::Particles |
| CJSpin | The trivial node : it match the 2J+1 spin |
| CLepton | The trivial node : it match the Lepton |
| CLight | Simple pid-checker for particle mass |
| CLongLived_ | Represent simple predicate for Long-lived particles |
| CLSpin | The trivial node : it match the 2L+1 spin |
| CMass | Simple pid-checker for particle mass |
| CMeson | The trivial node : it match the meson |
| CNegative | The trivial node : it match the negatively charged particles |
| CNegID | |
| CNeutral | The trivial node : it match the Neutral |
| CNot | Simple node which match "NOT" for the subnode |
| CNu | The trivial node : it match any neutral lepton |
| CNucleus | The trivial node : it match the Nucleus |
| COr | Rather simple (but powerful) node in the decay tree: it matches .OR |
| CPid | The simple node in the decay tree: it matches to a certain particle ID |
| CPosID | |
| CPositive | The trivial node : it match the positively charged particles |
| CShortLived_ | Represent simple predicate for short-lived particles |
| CSSpin | The trivial node : it match the 2S+1 spin |
| CStable | Represent simple predicate for Stable particles |
| CStableCharged | Represent simple predicate for Stable+Charged particles |
| CSymbol | |
| CDecay | The simple representation of "simple 1-step" decay (there are no trees! |
| CItem | Helper representation of the item in the decay chain |
| CiNode | The abstract class which represents the single "node" of decay tree |
| CNode | The generic class to hold the pointer to other node |
| CNodeList | |
| CSymbols | Helper class to obtain the information about the valid symbols for particles, decay descriptors and Nodes |
| NDetails | |
| NProperty | |
| CBoundedVerifier | |
| CDefaultStringConverter | |
| CDefaultStringConverter< TYPE > | |
| CDefaultStringConverterImpl | |
| CNoHandler | |
| CNullVerifier | |
| CReadHandler | |
| CReadUpdateHandler | |
| CStringConverter | |
| CStringConverter< DataObjIDColl > | |
| CStringConverter< DataObjIDVector > | |
| CSwapCall | Helper to disable a while triggering it, to avoid infinite recursion |
| CUpdateHandler | |
| CPropertyBase | PropertyBase base class allowing PropertyBase* collections to be "homogeneous" |
| CPropertyId | Helper to record a property identifier as a sequence of SharedString instances |
| CSharedString | Std::string wrapper for static strings where identical values actually share the memory |
| CWeakPropertyRef | Optional reference to a property that can be used to refer to a sting or to the string representation of a property instance value |
| Ndetails | Helper for type agnostic reading of data in branches |
| CBranchReadHelper | |
| CBranchWrapper | Encapsulates a branch within a ROOT TTree, managing the data and interaction with the TTree |
| Ccontainer | Helper structure to get container type |
| CLegacyAlgorithmAdapter | |
| Coverloaded_t | |
| NExample | |
| NTinyExperiment | |
| CCheckerAlg | Comparison of Reconstructed Tracks and MCTracks |
| CDigitizationAlg | Digitization algorithm returning a set of hits from MCHits, basically adding noise |
| CGeneratorAlg | Generator algorithm returning a set of random tracks |
| CHit | Most simple Hit ever : in 2D space, and thus fully defined by x and y |
| CIRandomGenSvc | |
| CMCHit | Most simple MC Hit ever : in 2D space, and thus fully defined by x and y |
| CMCTrack | Most simple MC Track ever : in 2D space, starting from the origin and thus fully defined by an angle theta |
| CRandomGenSvc | |
| CSimulationAlg | Simulation algorithm creating MC Hits from a set of tracks |
| CTrack | Most simple Track ever : in 2D space, starting from the origin and thus fully defined by an angle theta |
| CTrackingAlg | Tracking algorithm building tracks from hits using a simplified Hough transform |
| NFunctional | |
| Ndetails | |
| Ndetail2 | |
| CBaseClass | |
| CBaseClass< Tr, Default > | |
| COutputHandle | |
| COutputHandle< T, Tr, Default > | |
| COutputHandleFor | |
| COutputHandle< vector_of_output_< T >, Tr, Default > | |
| CInputHandle | |
| CInputHandle< T, Tr, Default > | |
| CInputHandleFor | |
| CInputHandle< vector_of_input_< T >, Tr, Default > | |
| CDefaultInputHandle | |
| CDefaultInputHandle< T > | |
| CDefaultInputHandle< EventContext > | |
| Ndetails2 | |
| Cvalue_type_of | |
| Cvalue_type_of< T > | |
| Cget_from_handle | |
| Cindirect_iterator | |
| CConsumer | |
| CConsumer< void(const In &...), Traits_, false > | |
| CConsumer< void(const In &...), Traits_, true > | |
| CDataHandleMixin | |
| CDataHandleMixin< std::tuple< Out... >, std::tuple< In... >, Traits_ > | |
| CDataHandleMixin< type_list< Out... >, type_list< In... >, Traits_ > | |
| CDataHandleMixin< type_list< void >, InputSpec, Traits_ > | |
| Cderef_t | |
| CEventContextHandle | |
| CFilterPredicate | |
| CFilterPredicate< bool(const In &...), Traits_, false > | |
| CFilterPredicate< bool(const In &...), Traits_, true > | |
| Cfirst_or_empty | |
| Cfirst_or_empty< std::tuple< First, Rest... > > | |
| Chandle_vector_input | |
| Chandle_vector_input< vector_of_const_< T > > | |
| Cinsert_t | |
| Cinvoke_optionally_t | |
| CLocationSpec | |
| CLocationSpecFor | |
| CLocationSpecFor< EventContext > | |
| CLocationSpecFor< vector_of_input_< T > > | |
| CLocationSpecFor< vector_of_output_< T > > | |
| CLocationSpecs | |
| CMergingTransformer | |
| CMergingTransformer< Out(const Args &...), Traits_, false > | |
| CMergingTransformer< Out(const Args &...), Traits_, true > | |
| CProducer | |
| CProducer< Out(), Traits_, legacy > | |
| CProducer< std::tuple< Out... >(), Traits_, legacy > | |
| CSplittingMergingTransformer | |
| CSplittingMergingTransformer< vector_of_< Out >(const Args &...), Traits_ > | |
| CSplittingTransformer | |
| CSplittingTransformer< vector_of_< Out >(const In &...), Traits_ > | |
| CTailLocationSpecs | |
| CTailLocationSpecs< First, Rest... > | |
| CToolBinder | |
| CToolBinder< Gaudi::Interface::Bind::Box< IFace >(Args const &...), Traits > | |
| Ctype_list | |
| Cvector_of_const_ | |
| Cvector_of_input_ | |
| Cvector_of_output_ | |
| NTraits | |
| Cuse_ | |
| CBaseClass_t | |
| CInputHandle_t | |
| COutputHandle_t | |
| CwriteViewFor | |
| CWriteOpaqueFor | |
| COpaqueView | |
| CFilterDecisionErrorCategory | |
| CMergingMultiTransformer | |
| CMergingMultiTransformer< std::tuple< Outs... >(const Args &...), Traits_ > | |
| CMergingMultiTransformerFilter | |
| CMergingMultiTransformerFilter< std::tuple< Outs... >(const Args &...), Traits_ > | |
| CMultiScalarTransformer | |
| CMultiScalarTransformer< ScalarOp, std::tuple< Out... >(const In &...), Traits_ > | |
| CScalarTransformer | |
| CScalarTransformer< ScalarOp, Out(const In &...), Traits_ > | |
| Cvector_of_const_ | |
| NGuards | Guards.h GaudiKernel/Guards.h Collection of very simple classes which allows to execution of some functions within the given well-defined and exception-safe context |
| CExceptionGuard | The most simple guard - it execute the certain code withing typical "try {} catch" clause, used in Auditor, Algorithm, AlgTool, etc |
| CAuditorGuard | It is a simple guard, which "locks" the scope for the Auditor Service is am exception-safe way |
| NHistograming | |
| NSink | |
| Ndetail | |
| CIntWithFixedWidth | Helper struct to print integers with fixed width |
| Ndetails | |
| CAxis | Small helper struct representing the Axis of an Histogram |
| CTraitsBase | 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 |
| CProfileWrapper | Helper Wrapper around TProfileX to be able to fill it |
| CBinAvValue | |
| CArthTypeAccessor | |
| CBase | |
| CBinAccessor | |
| CRoot | |
| CTraits | Templated Traits dealing with Root Histogram filling for standard histograms |
| CTraits< false, RootHisto, N > | Specialization of Traits dealing with non profile Root Histograms |
| CTraits< true, RootHisto, N > | Specialization of Traits dealing with profile Root Histograms |
| NHive | |
| CContextSpecificData | Implementation of a context specific storage accessible as a sort of smart reference class |
| CContextSpecificPtr | Simple implementation of a smart pointer with different values for different event contexts (slots) |
| CFetchDataFromFile | |
| CFetchLeavesFromFile | |
| CGraph | Utilities to dump graphs in different formats |
| NInterface | |
| NBind | |
| CBox | |
| CIBinder | |
| CAlgToolStub | |
| CStub | |
| NInterfaces | |
| CIFileSvc | Interface for a component that manages file access within Gaudi applications |
| CIOptionsSvc | Interface for a component that manages application configuration options |
| CIParticlePropertySvc | The abstract interface to Particle Property Service |
| CIQueueingEventProcessor | Extend IEventProcessor for asynchronous scheduling of events via queue-like interface |
| NMain | |
| CBootstrapHelper | |
| CStatusCode | |
| CProperty | |
| CAppMgr | |
| Cgaudimain | |
| Nmeta | |
| Ndetail | |
| Cinherit_from | |
| Cappend1 | |
| Cappend1< interface_list< Is... >, I > | |
| CappendN | |
| CappendN< interface_list<>, State > | |
| CappendN< interface_list< I, Is... >, List > | |
| Cid_ | |
| NMonitoring | |
| Ndetails | |
| Chas_reset_method | |
| Chas_reset_method< Arg, std::void_t< decltype(reset(std::declval< Arg & >()))> > | |
| Chas_mergeAndReset_method | |
| Chas_mergeAndReset_method< Arg, std::void_t< decltype(mergeAndReset(std::declval< Arg & >(), std::declval< Arg & >()))> > | |
| CBaseSink | Base class for all Sinks registering to the Monitoring Hub Should be extended by actual Sinks |
| CEntityOrder | List of entities we are dealing with |
| CHub | Central entity in a Gaudi application that manages monitoring objects (i.e |
| CEntity | Wrapper class for arbitrary monitoring objects |
| CSink | Interface reporting services must implement |
| CJSONSink | |
| CMessageSvcSink | Sink dedicated to printing messages to the MessageSvc |
| NNTuple | |
| NDiskBuffer | Append-only file of length-prefixed records, used to park ntuple rows on disk during the event loop and replay them at finalize |
| Ndetails | |
| CClose | |
| CError | Any I/O or format problem, carrying the file it happened on |
| CWriter | |
| CReader | |
| CFileHolder | Small class wrapping an algorithm and adding management of a Root File via the FileSvc |
| CGenericReader | |
| CGenericWriter | A Gaudi algorithm for writing data of any type from N locations in the event store to a TTree |
| CSimpleWriter | Base template for NTuple::Writer |
| CSimpleWriter< std::tuple< OUTPUTs... >(const INPUTs &...), Traits_ > | Specialized Algorithm for NTuple writing |
| CWrapper | Wrapper around a given NTuple |
| CWriter | Base template for NTuple::Writer |
| CWriter< 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 |
| NParsers | |
| CAxisGrammar | |
| CStoreNbinsOp | |
| CStoreMinValueOp | |
| CStoreMaxValueOp | |
| CStoreTitleOp | |
| CBoolGrammar | |
| CCatalog | |
| CCharGrammar | |
| CDataObjIDGrammar | |
| COperations | |
| CEdgeGrammar | |
| CFileGrammar | |
| CGrammar_ | |
| CGrammar_< Iterator, Gaudi::Accumulators::Axis< Arithmetic >, Skipper > | |
| CGrammar_< Iterator, GaudiUtils::VectorMap< KeyT, ValueT, KeyCompareT, AllocatorT >, Skipper > | |
| CGrammar_< Iterator, MyCustomType, Skipper > | |
| CGrammar_< Iterator, ROOT::Math::DisplacementVector3D< T1, T2 >, Skipper > | |
| CGrammar_< Iterator, ROOT::Math::LorentzVector< T1 >, Skipper > | |
| CGrammar_< Iterator, ROOT::Math::PositionVector3D< T1, T2 >, Skipper > | |
| CGrammar_< Iterator, std::list< InnerT, AllocatorT >, Skipper > | |
| CGrammar_< Iterator, std::map< KeyT, ValueT, KeyCompareT, AllocatorT >, Skipper > | |
| CGrammar_< Iterator, std::pair< KeyT, ValueT >, Skipper > | |
| CGrammar_< Iterator, std::set< InnerT, CompareT, AllocatorT >, Skipper > | |
| CGrammar_< Iterator, std::tuple< Ts... >, Skipper > | |
| CGrammar_< Iterator, std::unordered_map< KeyT, ValueT, HashT, KeyEqT, AllocatorT >, Skipper > | |
| CGrammar_< Iterator, std::unordered_set< InnerT, HashT, CompareT, AllocatorT >, Skipper > | |
| CGrammar_< Iterator, std::vector< InnerT, AllocatorT >, Skipper > | |
| CGrammar_< Iterator, T, Skipper > | |
| CH1Grammar | |
| CH2Grammar | |
| CH3Grammar | |
| CHisto1DGrammar | |
| CIdentifierGrammar | |
| CIncludedFiles | |
| CInputData | Helper class to enable ADL for parsers |
| CIntGrammar | |
| CKeyValueGrammar | |
| Cfirst | |
| Csecond | |
| CMapGrammar | |
| CMessages | |
| CNode | |
| CNodeOperations | |
| Cvalue | |
| CPairGrammar | |
| CPnt3DGrammar | |
| CPnt4DGrammar | |
| CPosition | |
| CPositionalPropertyValueException | |
| CPragmaOptions | |
| CProperty | |
| CLessThen | |
| CPropertyName | |
| CPropertyValue | |
| CPropertyValueException | |
| CRealGrammar | |
| CSetGrammar | |
| CSkipperGrammar | |
| CStringGrammar | |
| CTupleGrammar | |
| CUnits | |
| CUnitsGrammar | |
| CVectorGrammar | |
| NPluginService | |
| Nv1 | |
| NDetails | |
| CFactory | Class providing default factory functions |
| CRegistry | In-memory database of the loaded factories |
| CFactoryInfo | |
| CLogger | Simple logging class, just to provide a default implementation |
| CFactory | Class wrapping the signature for a factory with any number of arguments |
| CException | |
| Ntagged_bool_ns | |
| Ctagged_bool | |
| NTests | |
| NHistograms | |
| NCustomAxis | |
| CEnumAxisAlg | |
| NDirectories | |
| CHistoGroupsTool | |
| CHistoGroupsAlg | |
| NAxesLabels | |
| CHistWithLabelsAlg | |
| NMultiDimLayout | |
| CTestAlg | |
| NTestSuite | |
| NConditions | |
| Ndetails | |
| CConditionsStore | Example class to implement an actual backend for Gaudi::TestSuite::Conditions::ConditionAccessorHolder |
| CConditionAccessorHolder | Example of a ConditionAccessorHolder implementation |
| CConditionAccessor | Class wrapping the communication between condition users and conditions backend |
| CCondSvc | 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 |
| CUserAlg | Example of a simple algorithm using conditions via the ConditionAccessorHolder pattern |
| NCounter | |
| CHistoTimingAlg | Simple timing of counter based histograms filling |
| CGaudiHistoAlgorithm | Example of algorithm using histograms accumulators |
| CGaudiRootHistoAlgorithm | Example of algorithm using root histograms accumulators |
| NFileSvc | |
| CHistogramWriterAlg | |
| CNTupleWriterAlg | |
| NMultiInput | |
| CDumpAddress | Write the content of the RootAddress of a data object |
| CReadAlg | Simple algorithm used to read data from two files |
| CWriteAlg | Simple algorithm used to produce dummy data in the transient store |
| NNTuple | |
| CCounterDataConsumer | |
| CCounterDataProducer | |
| CFloatDataConsumer | |
| CFloatDataProducer | |
| CIntVectorDataConsumer | |
| CIntVectorDataProducer | |
| CMyStruct | |
| CNTupleSimpleWriter_V | |
| CNTupleWriter_V | |
| CStrDataConsumer | |
| CStrDataProducer | |
| CStructDataConsumer | |
| CStructDataProducer | |
| NTestObjectVersion | |
| CCreateObject | |
| CUseObject | |
| CAsyncSleeperAlg | |
| CBoostArrayProperties | |
| CCollision | |
| CContextConsumer | |
| CContextIntConsumer | |
| CContextTransformer | |
| CCounter | Simple counter object |
| CCountingConsumer | |
| CCountSelectedTracks | |
| CCustomPropertiesAlg | Example on how to use custom property types |
| CEvent | Essential information of the event used in examples It can be identified by "/Event" |
| CEventCounter | |
| CEventually | |
| CEvtCollectionSelector | Definition of a small class for further pre-selections when reading an event collection |
| CExtendedProperties2 | Simple DEMO-file for "extended vector properties", |
| CFloatDataConsumer | |
| CFloatTool | |
| CFoo | |
| CFrExpTransformer | |
| CFSMCallbackTestAlgo | Example of usage of callbacks, when using CallbackHolder |
| CGaudiObjectHandler | |
| CHistoProps | Simple example, which illustrates the usage of "histogram properties" DO NOT USE |
| CIMyTool | |
| CIntDataConsumer | |
| CIntDataProducer | |
| CIntFloatToFloatData | |
| CIntIntToFloatFloatData | |
| CIntToFloatData | |
| CIntVectorsMerger | |
| CIntVectorsMergingConsumer | |
| CIntVectorsToInts | Transform a vector of vector of int to a vector of int, where the output vector of in is scattered into the TES |
| CIntVectorsToIntsWithContextAndScale | |
| CIntVectorsToIntVector | Concatenates a list of input vectors into a single output vector |
| CKeyedDataProducer | |
| CLdExpTransformer | |
| CMyConsumerTool | |
| CBoundInstance | |
| CMyData | |
| CMyExampleTool | |
| CMyTrack | |
| CMyVertex | Simple class that represents a vertex for testing purposes |
| COpaqueProducer | |
| COptFrExpTransformer | |
| COptionalSRangesMerger | |
| COptLdExpTransformer | |
| CPartPropAlg | Algorithm to test the particle property service |
| CPIntVectorsToIntVector | |
| CPrescaler | |
| CQueueingApplication | |
| CQueueingEventLoopMgr | |
| CRangeProducer | |
| CReadHandleAlg | |
| CS | |
| CSDataProducer | |
| CSelectTracks | |
| CShrdPtrConsumer | |
| CShrdPtrProducer | |
| CSRangesToIntVector | |
| CStringDataConsumer | |
| CStringDataProducer | |
| CStringKeyEx | Simple example which illustrate the usage of class StringKey |
| CSvcWithoutInterface | |
| CTestAlg | Simple algorithm useful as base class for tests |
| CTHDataConsumer | |
| CTHDataProducer | |
| CTHDataProducer2 | |
| CToolConsumer | |
| CTwoDMerger | Concatenates a list of input vectors into a single output vector |
| CUseSvcWithoutInterface | |
| CVectorDataProducer | |
| CVectorDoubleProducer | |
| CVoidConsumer | |
| CWriteHandleAlg | |
| NTimers | |
| CGenericTimer | A generic timer based on std::chrono and Gaudi::Accumulators |
| CScopeTimer | A scoped timer that starts/stops on con/de-struction |
| NTr | |
| CPID | |
| NUtils | |
| NHistos | Collection of useful utilities for manipulations with AIDA hisgograms |
| CHistoStrings | Helper class to produce "good" dictionaries |
| CTable | Simple class for the customizeble printout of the histogram tables |
| NRegEx | RegeEx: nemspace to hold gaudi regular expression checking |
| CmatchList | |
| CAida2ROOT | Accessor to underlying ROOT-representation of transient histograms The actual code is imported from Bender project |
| CAlgContext | Helper "sentry" class to automatize the safe register/unregister the algorithm's context |
| CAttribStringParser | Parse attribute strings allowing iteration over the various attributes |
| CAttrib | Simple class to wrap tag/value pairs |
| CIterator | Iterator to loop over the tag/value pairs in the attribute string |
| CHistoStats | The collection of trivial functions to access the statistical information for the histograms |
| CLockedChrono | Helper object, useful for measurement of CPU-performance of highly-recursive structures, e.g |
| CMapBase | Helper base-class to allow the generic Python-decoration for all "map-like" classes in Gaudi |
| CPeriodicAction | Helper to periodically run asynchronous tasks |
| CSignalMonitorSvc | Implementation of Gaudi::ISignalMonitor |
| CStopSignalHandler | Service that stop the processing if a signal is received |
| CTuplePrinter | |
| CTuplePrinter< Tuple, 1 > | |
| CTypeNameString | Helper class to parse a string of format "type/name" |
| C_ConfigurablesModule | |
| CAlgorithm | Base class from which all concrete algorithm classes should be derived |
| CApplication | Gaudi application entry point |
| CAsynchronousAlgorithm | Base class for asynchronous algorithms |
| CAuditor | Base class from which all concrete auditor classes should be derived |
| CAxis | An IAxis represents a binned histogram axis |
| CBootSvcLocator | A dual-stage boostrap mechanism is used to ensure an orderly startup of the ApplicationMgr |
| Cc_opt_t | |
| CContainerSection | |
| CDataHandle | |
| CDataHandleVector | A configurable, dynamically sized sequence of homogeneous data handles |
| CDataHandleVectorBase | Type-erased interface for a configurable sequence of data handles |
| CEventWatchdogAlg | Add to the transient store a tracker that detects events that are taking too long |
| CFSMCallbackHolder | Helper class to implement the IFSMCallbackHolder interface |
| CfullMatch_t | |
| CGeneric1D | Common AIDA implementation stuff for histograms and profiles using ROOT implementations |
| CGeneric2D | Common AIDA implementation stuff for histograms and profiles using ROOT implementations |
| CGeneric3D | Common AIDA implementation stuff for histograms and profiles using ROOT implementations |
| CHisto1DDef | 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 |
| CHistogram1D | AIDA implementation for 1 D histograms using ROOT THD1 |
| CHistogram2D | AIDA implementation for 2 D histograms using ROOT THD2 |
| CHistogram3D | AIDA implementation for 3 D histograms using ROOT THD2 |
| CHistogramBase | Common base class for all histograms Use is solely functional to minimize dynamic_casts inside HistogramSvc |
| CIAuditor | The IAuditor is the interface implemented by the Auditor base class |
| CIDataConnection | ABC describing basic data connection |
| CIFileCatalog | File catalog interface |
| CIFileCatalogMgr | File catalog manager |
| CIFSMCallbackHolder | Interface defining a CallBack registration functionality based on the State Machine of Gaudi |
| CIIODataManager | |
| Cinterface_list | |
| Cinterface_list_append | |
| Cinterface_list_append< interface_list< Is... >, I > | |
| Cinterface_list_cat | |
| Cinterface_list_cat< interface_list< I... > > | |
| Cinterface_list_cat< interface_list< I1... >, interface_list< I2... > > | |
| Cinterface_list_cat< interface_list< I1... >, interface_list< I2... >, Others... > | |
| CInterfaceId | Class to handle automatically the versioning of the interfaces when they are inheriting from other interfaces |
| CIODataManager | |
| CEntry | |
| CISignalMonitor | Interface for the service that monitors the occurrences of system signals |
| CmajorMatch_t | |
| CMetaDataSvc | |
| CMultiFileCatalog | This class constitutes the core of the XML based FileCatalog API within Gaudi |
| CNamedRange_ | |
| CParticleID | Holds PDG + LHCb extension particle code, following the PDG particle numbering scheme (pdg.lbl.gov/2017/reviews/rpp2017-rev-monte-carlo-numbering.pdf) |
| CParticleProperty | A trivial class to hold information about a single particle properties |
| CCompare | The comparison criteria for particle properties |
| CParticlePropertySvc | This service provides access to particle properties |
| CProfile1D | AIDA implementation for 1 D profiles using ROOT TProfile |
| CProfile2D | AIDA implementation for 2 D profiles using ROOT TProfile2D |
| CProperty | Implementation of property with value of concrete type |
| CRange_ | Useful class for representation of "sequence" of the objects through the range of valid iterators |
| CRangeBase_ | Helper class to simplify the dealing with ranges in Python |
| CRootAddress | Description: |
| CRootCnvSvc | Description: |
| CRootConnectionSetup | |
| CRootConverter | Description: Definition of the ROOT data converter |
| CRootDatabaseCnv | Statistics file converter class definition |
| CRootDatabaseMerger | |
| Cuuid_data | |
| CRootDataConnection | Concrete implementation of the IDataConnection interface to access ROOT files |
| CContainerSection | Internal helper class, which described a TBranch section in a ROOT file |
| CTool | Abstraction layer probably not needed anymore as the only implementation if RootTool |
| CRootDirectoryCnv | Description: NTuple directory converter class definition Definition of the converter to manage the directories in an database representing N-Tuples |
| CRootEventExtractor | |
| CRootEvtSelector | Concrete event selector implementation to access ROOT files |
| CRootEvtSelectorContext | ROOT specific event selector context |
| CRootNTupleCnv | NTuple converter class definition for NTuples writted/read using ROOT |
| CRootNTupleDescriptor | Description: |
| CRootObjectRefs | Persistent reference object containing all leafs and links corresponding to a Gaudi DataObject |
| CRootPerfMonSvc | Description: |
| CRootRef | Persistent reference object |
| CRootStatCnv | Description: Base class converter for N-tuples and related classes |
| CRootTool | Description: |
| CSequence | |
| CSequencer | A Sequencer is essentially a list of Algorithms and is responsible for their management |
| CStringKey | Helper class for efficient "key" access for strings |
| CStringKeyHash | Transparent hash operator for heterogeneous lookups |
| CSysProcStat | |
| Ctagged_bool | |
| CTime | Based on seal::Time |
| CTimeSpan | Based on seal::TimeSpan |
| CXMLFileCatalog | This class constitutes the core of the XML based FileCatalog API |
| NGaudi | |
| NFunctional | |
| Ndetails | |
| CTransformer | |
| CMultiTransformer | |
| CTransformer< Out(const In &...), Traits_, true > | |
| CTransformer< Out(const In &...), Traits_, false > | |
| CMultiTransformer< std::tuple< Out... >(const In &...), Traits_, true > | |
| CMultiTransformer< std::tuple< Out... >(const In &...), Traits_, false > | |
| CMultiTransformerFilter | |
| CMultiTransformerFilter< std::tuple< Out... >(const In &...), Traits_ > | |
| NGaudiConfig2 | |
| N_configurables | |
| CProperty | |
| CConfigurableMeta | |
| CConfigurable | |
| N_db | |
| CConfDB2 | |
| CConfigurablesDB | |
| Nsemantics | |
| CPropertySemantics | |
| CDefaultSemantics | |
| C_JSONValue | |
| C_JSONOption | |
| CJSONSemantics | |
| CStringSemantics | |
| CBoolSemantics | |
| CFloatSemantics | |
| CIntSemantics | |
| CComponentSemantics | |
| CComponentHandleSemantics | |
| C_GaudiHandleArrayOptionValue | |
| CGaudiHandleArraySemantics | |
| CDataHandleSemantics | |
| C_ListHelper | |
| CSequenceSemantics | |
| CDataHandleVectorSemantics | |
| C_SetHelper | |
| CSetSemantics | |
| COrderedSetSemantics | |
| C_DictHelper | |
| CMappingSemantics | |
| NGaudiDict | |
| CKeyedContainerDict | |
| CKeyedObjectDict | |
| NGaudiEx | |
| CQotdAlg | |
| NGaudiKernel | |
| NConfigurable | |
| C_DefaultPropertiesCollectorHelper | |
| CError | |
| CPropertyReference | |
| CConfigurable | |
| CDefaultName | |
| CDummyDescriptor | |
| CConfigurableGeneric | |
| CConfigurableAlgorithm | |
| CConfigurableService | |
| CConfigurableAlgTool | |
| CConfigurableAuditor | |
| CConfigurableUser | |
| CCreateSequencesVisitor | |
| CSuperAlgorithm | |
| NConfigurableDb | |
| C_CfgDb | |
| C_Singleton | |
| NConfigurableMeta | |
| CConfigurableMeta | |
| NConstants | |
| CMessageLevel | |
| NDataHandle | |
| CDataHandle | |
| CDataHandleVector | |
| NGaudiHandles | |
| CGaudiHandle | |
| CPublicToolHandle | |
| CPrivateToolHandle | |
| CServiceHandle | |
| CGaudiHandleArray | |
| CServiceHandleArray | |
| CPublicToolHandleArray | |
| CPrivateToolHandleArray | |
| NProcessJobOptions | |
| CLogFormatter | |
| CLogFilter | |
| CConsoleHandler | |
| CParserError | |
| CJobOptsParser | |
| C_TempSysPath | |
| NPropertyProxy | |
| CPropertyProxy | |
| CGaudiHandlePropertyProxyBase | |
| CGaudiHandlePropertyProxy | |
| CGaudiHandleArrayPropertyProxy | |
| CDataHandlePropertyProxy | |
| CDataHandleVectorPropertyProxy | |
| NGaudiMP | A class to serialize/deserialize TES objects to and from a TBufferFile Author: P |
| NFdsRegistry | |
| CFdsDict | |
| NGMPBase | |
| CMiniWriter | |
| CCollectHistograms | |
| CEventCommunicator | |
| CTESSerializer | |
| CGMPComponent | |
| CReader | |
| CSubworker | |
| CWorker | |
| CWriter | |
| CCoord | |
| NIoRegistry | |
| CIoRegistry | |
| NParallel | |
| CStatistics | |
| CTask | |
| CWorkManager | |
| CSshSession | |
| NpTools | |
| CHistoAgent | |
| CFileRecordsAgent | |
| CLumiFSR | |
| CPackedCaloHypo | |
| CSyncMini | |
| CSyncer | |
| CTESSerializer | |
| NGaudiPartProp | |
| NService | |
| CiParticlePropertySvc | |
| NGaudiPython | GaudiPython.h GaudiPython/GaudiPython.h |
| NBindings | |
| CInterfaceCast | |
| CInterface | |
| CPropertyEntry | |
| CiProperty | |
| CiService | |
| CiAlgorithm | |
| CiAlgTool | |
| CiDataSvc | |
| CiHistogramSvc | |
| CiNTupleSvc | |
| CiToolSvc | |
| CiEventSelector | |
| CAppMgr | |
| CCallbackStreamBuf | |
| CPyAlgorithm | |
| NPersistency | |
| CPersistencyError | |
| CUnknownPersistency | |
| CFileDescription | |
| CPersistencyHelper | |
| CRootPersistency | |
| C_identity | It is here due to 'missing'(?) std::identity |
| CCallbackStreamBuf | |
| CPyObject_t | |
| CHelper | |
| CInterface | Minor mofidication of original Pere's structure GaudiPython::Interface This helper class is nesessary to perform C++ castings from python |
| CInterface< IInterface > | |
| CPrinter | |
| CPrinter< ContainedObject > | |
| CPrinter< DataObject > | |
| CPyAlgorithm | Python Algorithm base class |
| NGaudiRoot | |
| CRefAccessor | |
| CIOHandler | |
| Ngaudirun | |
| CArgProcessor | |
| CFakeModule | |
| NGaudiTesting | |
| NFixtureResult | |
| CProcessTimeoutError | |
| CExceededStreamError | |
| CFixtureResult | |
| NGaudiExeTest | |
| CGaudiExeTest | |
| NJIRA | |
| CGAUDI_1185 | Special service to expose GAUDI-1185 |
| Npreprocessors | |
| CFilePreprocessor | |
| CFilePreprocessorSequence | |
| CLineSkipper | |
| CBlockSkipper | |
| CRegexpReplacer | |
| CLineSorter | |
| CSortGroupOfLines | |
| NSubprocessBaseTest | |
| CSubprocessBaseTest | |
| Nutils | |
| CCodeWrapper | |
| CCustomIncidentAlg | |
| CDestructorCheckAlg | |
| CEvenEventsFilter | |
| CFailingSvc | Special service that issue a failure in one of the transitions (for testing) |
| CGaudiEnv | |
| CGetDataObjectAlg | Simple algorithm that retrieves objects from the transient store |
| CITestTool | |
| CListTools | Simple algorithm that creates dummy objects in the transient store |
| COddEventsFilter | |
| CPrintMemoryUsage | Simple algorithm that prints the memory usage every N events (property "Frequency") |
| CPutDataObjectAlg | Simple algorithm that creates dummy objects in the transient store |
| CSignallingAlg | Simple algorithm that raise a signal after N events |
| CSleepyAlg | |
| CStopLoopAlg | |
| CSvcWithTool | Special service that issue a failure in one of the transitions (for testing) |
| CTestAlg | |
| CTestTool | |
| CLogger | |
| NGaudiTestSuite | |
| CCounterSvcAlg | Simple algorithm use for test case bug_30209_namespace_in_sequencer.qmt nothing to do anymore with ICounterSvc |
| CGaudiPPS | Small algorithm using Gaudi::ParticlePropertySvc |
| CLoggingAuditor | |
| CStatSvcAlg | Simple algorithm to illustrate the statistical abilities of "Stat"-part of Chrono&Stat Service |
| CTimingAlg | The primitive class to illustrate the usage of IChronoSvc , ChronoEntity & Chrono objects |
| NGaudiUtils | |
| Ndetails | |
| CIdentityOutputter | |
| CAllocator | Allocator |
| Crebind | |
| CAllocatorPool | Allocator pool |
| CPoolLink | |
| CPoolChunk | |
| CGenericHash | Generic hash implementation (for easy migration to the new Hash class) |
| CHash | Simple hash function |
| CHash< const Gaudi::ParticleID & > | |
| CHash< const Gaudi::ParticleID > | |
| CHash< const T & > | Remove extra qualifiers: |
| CHash< const T * > | Remove extra qualifiers: |
| CHash< const T > | Remove extra qualifiers: |
| CHash< const T(&)[N]> | Generic specialization for arrays |
| CHash< Gaudi::ParticleID & > | |
| CHash< Gaudi::ParticleID > | |
| CHash< T & > | Remove extra qualifiers: |
| CHash< T * > | Partial specialization for pointers |
| CHash< T(&)[N]> | Generic specialization for arrays |
| CHashMap | Common class providing an architecture-independent hash map |
| CMap | Extension of the STL map |
| CVectorMap | A bit modified version of 'Loki::AssocVector' associative vector from Loki library by Andrei Alexandrescu |
| C_compare_type | The actual structure used to compare the elements Only "key" is important for comparison |
| NHepPDT | |
| CTestUnknownID | |
| NHepRndm | |
| CBaseEngine | |
| CEngine | |
| CGenerator | |
| CGenerator< Rndm::DefinedPdf > | |
| CSynchronizedEngine | |
| NHiveRndm | |
| CHiveNumbers | |
| Nhivetimeline | |
| CData | |
| Nimplementation_detail | Templated class to add the standard messaging functionalities |
| Cadd_name | |
| Cadd_serviceLocator | |
| NIo | |
| CIoFlags | |
| CFileAttr | |
| CFileHdlr | |
| NmakePlots | |
| CTimingInfo | |
| Nnlohmann | |
| Cadl_serializer< std::chrono::duration< Rep, Period > > | |
| NNTuple | NTuple name space |
| C_Accessor | Class acting as a smart pointer holding a N tuple entry |
| C_Array | Abstract class describing a column-array in a N tuple |
| C_ArrayImp | Concrete class discribing a column-array in a N tuple |
| C_Data | Abstract class describing basic data in an Ntuple |
| C_DataImp | Concrete class discribing basic data items in an N tuple |
| C_Item | Abstract class describing a column in a N tuple |
| C_ItemImp | Concrete class discribing a column in a N tuple |
| C_Matrix | Abstract class describing a matrix column in a N tuple |
| C_MatrixImp | Concrete class discribing a matrix column in a N tuple |
| CArray | Class acting as a smart pointer holding a N tuple _Item |
| CArray< IOpaqueAddress * > | |
| CColumnWiseTuple | |
| CDataItem | |
| CDirectory | Small class representing an N tuple directory in the transient store |
| CFile | Small class representing an N tuple file in the transient store |
| CItem | Class acting as a smart pointer holding a N tuple _Item |
| CItem< bool > | Specialization acting as a smart pointer holding a N tuple _Item |
| CMatrix | Class acting as a smart pointer holding a N tuple _Item |
| CMatrix< IOpaqueAddress * > | |
| CRange | Class defining a range |
| CRange< bool > | |
| CRowWiseTuple | |
| CSelector | NTuple Selector class |
| CTuple | Abstract base class which allows the user to interact with the actual N tuple implementation |
| CTupleImp | |
| NPluginServiceTest | Test file used to check if the new Plugin Service is able to handle the strings used in the old one |
| CCustomFactoryAlgorithm | |
| CMyAlg | |
| CMyTemplatedAlg | |
| Nprecedence | |
| CAlgoProps | |
| CAlgoTraceProps | |
| CAllPass | |
| CCFDecision | |
| CCondDataProps | |
| CCruncherSequence | |
| CDataProps | |
| CDecisionHubProps | |
| CDecisionNegation | |
| CDuration | |
| CEndTime | |
| CEntityState | |
| CGroupExit | |
| CGroupLogic | |
| CGroupMode | |
| COperations | |
| CRealTimeValue | |
| CRndBiasedBooleanValue | |
| CStartTime | |
| CUniformBooleanValue | |
| CUniformTimeValue | |
| CVertexName | |
| NRndm | |
| CGenerator | |
| CGauss | Parameters for the Gauss random number generation |
| CExponential | Parameters for the Gauss random number generation |
| CChi2 | Parameters for the Chi2 distributed random number generation |
| CBreitWigner | Parameters for the BreitWigner distributed random number generation |
| CLandau | Parameters for the Landau distributed random number generation |
| CBreitWignerCutOff | Parameters for the BreitWigner distributed random number generation with cut off; |
| CStudentT | Parameters for the StudentT distributed random number generation |
| CGamma | Parameters for the Gamma distributed random number generation |
| CPoisson | Parameters for the Poisson distributed random number generation with a given mean |
| CBinomial | Parameters for the Binomial distributed random number generation |
| CFlat | Parameters for the flat random number generation within boundaries [minimum, maximum] |
| CBit | Parameters for the bit value generation: returns values 0 and 1 |
| CDefinedPdf | Generate a random number Generator following generally distributed random values, given a user-defined probability distribution function |
| CGaussianTail | Parameters for the Gaussian tail number generation |
| CNumbers | Random number accessor This small class encapsulates the use of the random number generator |
| NROOT | |
| NMath | |
| CPositionVector3D | |
| CDisplacementVector3D | |
| CCartesian3D | |
| NRootHistCnv | |
| CDirectoryCnv | |
| CPersSvc | Persistency service - to store histograms in ROOT format |
| CRConverter | Root Converter |
| CRCWNTupleCnv | Converter of Column-wise NTuple into ROOT format |
| CLayout | How the items of a tuple map onto the staging buffer and the TTree branches |
| CItem | |
| CBuffered | |
| CRDirectoryCnv | Create persistent and transient representations of data store directories |
| CRFileCnv | NTuple converter class definition |
| CRHistogramCnv | Generic converter to save/read AIDA_ROOT histograms using ROOT |
| CTTH | |
| CRNTupleCnv | NTuple converter class definition |
| CRootCompressionSettings | Simple class to decode a ROOT compression settings string, of the form '<Alg>:<level>' into the integer code to pass to ROOT |
| CRootObjAddress | |
| CRRWNTupleCnv | Row wise NTuple converter class definition |
| NSmartRefVectorImpl | |
| CSmartRefVectorPythonizer | |
| Nstd | STL namespace |
| Cformatter< EventContext > | |
| Chash< Gaudi::Details::PropertyId > | |
| Chash< Gaudi::StringKey > | Specialization of hash function used in C++11 collections like std::unordered_map |
| NSuperAlgDynamicGraph | |
| CMySuperAlg | Job options file |
| NSystem | Note: OS specific details for environment resolution |
| CIO_COUNTERS | Process I/O Counters NtQueryInformationProcess using ProcessIoCounters |
| CKERNEL_USER_TIMES | Process/Thread System and User Time NtQueryInformationProcess using ProcessTimes NtQueryInformationThread using ThreadTimes |
| CPathResolver | |
| CPOOLED_USAGE_AND_LIMITS | Process Pooled Quota Usage and Limits NtQueryInformationProcess using ProcessPooledUsageAndLimits |
| CPROCESS_BASIC_INFORMATION | |
| CProcessDescriptor | Provides access to process information |
| CProcessHandle | |
| CProcessTime | Simple class to hold the time information of a process |
| CQUOTA_LIMITS | Process Quotas NtQueryInformationProcess using ProcessQuotaLimits NtQueryInformationProcess using ProcessPooledQuotaLimits NtSetInformationProcess using ProcessQuotaLimits |
| CVM_COUNTERS | Process Virtual Memory Counters NtQueryInformationProcess using ProcessVmCounters |
| NTest | |
| CViewTester | |
| Nupdate_version | |
| CFields | |
| CReplacementRule | |
| CFileUpdater | |
| CAbortEventAlg | Small algorithm that after a given number of events triggers an AbortEvent |
| CAIDATupleAlgorithmRead | |
| CAIDATupleAlgorithmWrite | |
| CAlgContextAuditor | Description: Register/Unregister the AlgContext of each algorithm before entering the algorithm and after leaving it |
| CAlgContextSvc | Simple implementation of interface IAlgContextSvc for Algorithm Context Service |
| CAlgExecStateRef | Wrapper on an Algorithm state |
| CAlgExecStateRefConst | Wrapper on an Algorithm state, const version |
| CAlgExecStateSvc | A service that keeps track of the execution state of Algorithm |
| CAlgExecStateInternal | Internal state of an algorithm |
| CAlgorithm | Alias for backward compatibility |
| CAlgorithmHistory | AlgorithmHistory class definition |
| CAlgorithmManager | In charge of the creation of concrete instances of Algorithms |
| CAlgorithmItem | |
| CAlgResourcePool | The AlgResourcePool is a concrete implementation of the IAlgResourcePool interface |
| CAlgsExecutionStates | The AlgsExecutionStates encodes the state machine for the execution of algorithms within a single event |
| CAlgTask | |
| CAlgTimingAuditor | |
| Cstats_t | |
| CAlgTool | Base class from which all the concrete tool classes should be derived |
| CAlgToolHistory | AlgToolHistory class definition |
| CAnyDataGetAlgorithm | |
| CAnyDataPutAlgorithm | |
| CAnyDataWithViewWrapper | |
| CAnyDataWrapper | |
| CAnyDataWrapperBase | |
| CPtr | |
| CApplicationMgr | The Application Manager class |
| CAppMgrRunable | Class definition of AppMgrRunable |
| CAuditorSvc | This service manages Auditors |
| CAuditorTestAlg | |
| CAvalancheSchedulerSvc | |
| CTaskSpec | Struct to hold entries in the alg queues |
| CAlgQueueSort | Comparison operator to sort the queues |
| Cbackwards_compatibility_hack_time_timespan | |
| CBaseToolHandle | Non-templated base class for actual ToolHandle<T> |
| CBoostArrayProperties | The Factory |
| CBootSvcLocator | A dual-stage boostrap mechanism is used to ensure an orderly startup of the ApplicationMgr |
| CCause | |
| Ccgaudi_factory_t | |
| Ccgaudi_pluginsvc_t | |
| Ccgaudi_property_t | |
| CChrono | A small utility class for chronometry of user codes |
| CChronoAuditor | Monitors the cpu time usage of each algorithm |
| CChronoEntity | Small helper class for implementation of ChronoStatSvc service, It also could be used as some local timer |
| CChronoStatSvc | The Chrono & Stat Sservice: service implements the IChronoStatSvc interface and provides the basic chronometry and some statistical counts needed by all applications |
| CCLibSymbolInfo | |
| CCollectionCloneAlg | Small algorithm, which allows to merge N-tuples in a generic way |
| CColorMgs | Algorithm to test the color setting options of MsgService |
| CColorMsgAlg | |
| CCommonMessaging | |
| CCommonMessagingBase | |
| CCompareFirstOfPointerPair_t | |
| CComponentManager | Base class for a component manager |
| CConcurrencyFlags | Provides information about the level of concurrency of the currently executing job |
| CconfigGenerator | |
| CContainedObject | All classes that their objects may be contained in an LHCb ObjectContainer (e.g |
| CContextEventCounter | |
| CContextEventCounterData | |
| CContextEventCounterPtr | |
| CContextIncident | |
| CConversionSvc | Base class for all conversion services |
| CWorkerEntry | |
| CConverter | Converter base class |
| CConverterID | |
| CCopyInputStream | |
| CCounterAlg | Simple algorithm illustrating the usage of different "counters" |
| CCPUCruncher | A class that implements a search for prime numbers |
| CCPUCrunchSvc | |
| CDataCreator | Trivial Algorithm for test purposes |
| CDataHandleFinder | Implements the IDataHandleVisitor interface Class used to explore heirarchy of nested IDataHandleHolders |
| CDataHandleHolderBase | |
| CDataHandleProperty | |
| CDataHandleVectorProperty | DataHandleProperty.h GaudiKernel/DataHandleProperty.h |
| CDataHistory | DataHistory class definition |
| CDataHistoryOrder | |
| CDataIncident | Data service incident class |
| CDataObject | A DataObject is the base class of any identifiable object on any data store |
| CDataObjectHandle | 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_> |
| CDataObjectHandleBase | DataObjectHandleBase GaudiKernel/DataObjectHandleBase.h |
| CDataObjectReadHandle | |
| CDataObjectWriteHandle | |
| CDataObjID | |
| CDataObjID_Hasher | |
| CDataOnDemandSvc | The DataOnDemandSvc listens to incidents typically triggered by the data service of the configurable name "IncidentName" |
| CProtection | Helper class of the DataOnDemandSvc |
| CNode | Helper class of the DataOnDemandSvc |
| CLeaf | |
| CDataStoreItem | Description of the DataStoreItem class |
| CDataStreamTool | |
| CDataSvc | Data service base class |
| CDataSvcFileEntriesTool | Tool to scan a transient store branch that collects all the objects that belong to the same source (file) |
| CDataTypeInfo | Small class which allows access to internal type IDs |
| CDetDataSvc | A DataSvc specialized in detector data |
| CDetPersistencySvc | |
| CDHH | |
| CDHHVisitor | |
| CDirSearchPath | Search for files in a list of directories |
| CeqPath | Name |
| CDLLClassManager | |
| CDODBasicMapper | Default implementation of a DataOnDemand mapper |
| CEventCollectionContext | |
| CEventCollectionSelector | Definition of class EventCollectionSelector |
| CMyContextType | |
| CEventContext | This class represents an entry point to all the event specific data |
| CEventContextFormatter | Custom formatter for EventContext to support std::format and fmt |
| 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 | |
| CEventLoopMgr | Class definition of EventLoopMgr |
| CEventSelector | Definition of class EventSelector |
| CEventSelectorDataStream | Definition of class EventSelectorDataStream |
| CEventSlot | Class representing an event slot |
| CEvtCollectionStream | A small to stream Data I/O |
| CEvtCollectionWrite | User example objects: EvtCollectionWrite |
| CEvtDataSvc | A EvtDataSvc is the base class for event services |
| CEvtPersistencySvc | EvtPersistencySvc class implementation definition |
| CEvtSelectorContext | Definition of class EventIterator |
| 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.. |
| CExceptionSvc | Simple implementation of IExceptionSvc abstract interface |
| Cextend_interfaces | Base class to be used to extend an interface |
| CExtendedProperties | Simple DEMO-file for "extended properties", implementation file for class ExtendedProperties |
| CExtendedProperties2 | Simple DEMO-file for "extended vector properties", |
| Cextends | Base class used to extend a class implementing other interfaces |
| CFetchDataFromFile | |
| CFiberManager | The FiberManager manages a pool of threads used to run boost::fiber fibers |
| CFileAttr | |
| CFileHdlr | |
| CFileIncident | This class is the FileIncident |
| CFileMgr | |
| CFileMgrTest | Algorithm to test the FileMgr |
| CFileReadTool | Basic implementation of the IFileAccess interface |
| CFileRecordDataSvc | A FileRecordDataSvc is the base class for event services |
| 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 |
| Cfinal_action | |
| CGaudi | This is a number of static methods for bootstrapping the Gaudi framework |
| CGaudiException | Define general base for Gaudi exception |
| CGaudiHandle | Handle to be used in lieu of naked pointers to gaudis |
| CGaudiHandleArray | T is the concrete handle type, e.g |
| CGaudiHandleArrayBase | Base class of array's of various gaudihandles |
| CGaudiHandleArrayProperty | |
| CGaudiHandleBase | Base class to handles to be used in lieu of naked pointers to various Gaudi components |
| CGaudiHandleInfo | |
| CGaudiHandleProperty | |
| CGenericAddress | Generic Transient Address |
| CGetIntView | |
| CGetStringView | |
| CGlobalDirectoryRestore | |
| CGPUCruncher | A test asynchronous algorithm on the GPU |
| CHelloWorld | Trivial Algorithm for tutotial purposes |
| CHistoAlgorithm | |
| CHistogramAgent | HistogramAgent base in charge of collecting all the references to DataObjects in a transient store that passes some selection criteria |
| CHistogramPersistencySvc | HistogramPersistencySvc class implementation definition |
| CHistogramSvc | HistogramSvc class definition |
| CHelper | |
| CHistory | |
| CHistoryObj | Base class for History Objects |
| CHistorySvc | HistorySvc class definition |
| CHiveDataBrokerSvc | |
| CHiveReadAlgorithm | |
| CHiveSlimEventLoopMgr | |
| CHiveTestAlgorithm | |
| CHiveWhiteBoard | Data service base class |
| CIAddressCreator | IAddressCreator interface definition |
| CIAIDATupleSvc | Definition of the IAIDATupleSvc interface class |
| CIAlgContextSvc | An abstract interface for Algorithm Context Service |
| CIAlgExecStateSvc | Abstract interface for a service that manages the Algorithm execution states |
| CIAlgManager | The IAlgManager is the interface implemented by the Algorithm Factory in the Application Manager to support management functions |
| CIAlgorithm | The IAlgorithm is the interface implemented by the Algorithm base class |
| CIAlgResourcePool | The IAlgResourcePool is the interface for managing algorithm instances, in particular if clones of the same algorithm exist |
| CIAlgTool | The interface implemented by the AlgTool base class |
| CIAppMgrUI | Application Manager User Interface |
| CIAuditorSvc | The interface implemented by the IAuditorSvc base class |
| CIAxis | |
| CIChronoStatSvc | The IChronoStatSvc is the interface implemented by the ChronoStatService |
| CIChronoSvc | "Chrono"-related part of interface IChronoStatSvc |
| CIClassIDSvc | Interface to the CLID database |
| CIClassInfo | Data base class allowing to store persistent type information |
| CIClassManager | The IClassManager is the interface implemented by the generic Factory in the Application Manager to support class management functions |
| CIComponentManager | |
| CICondSvc | Interface for the Condition Service |
| CIConversionSvc | |
| CIConverter | The data converters are responsible to translate data from one representation into another |
| CICPUCrunchSvc | |
| CIDataBroker | |
| CIDataHandleHolder | |
| CIDataHandleVisitor | |
| CIDataManagerSvc | |
| CIDataProviderSvc | Data provider interface definition |
| CIDataSourceMgr | IDataSourceMgr interface definition |
| CIDataStoreAgent | Generic data agent interface |
| CIDataStoreLeaves | Interface for a tool or service that returns a list of leaves (paths) in a transient store |
| CIDataStreamTool | |
| CIDetDataSvc | Abstract interface for a DataSvc manipulating condition data (i.e |
| 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 |
| CIEventProcessor | The IEventProcessor is the interface to process events |
| CIEventTimeDecoder | Interface that a Tool that decodes the event time has to implement |
| CIEvtSelector | The Event Selector Interface |
| CContext | |
| CIExceptionSvc | The abstract interface for exception handling service |
| CIFileAccess | Abstract interface for a service or tool implementing a read access to files |
| CIFileMgr | |
| CIHistogram1D | |
| CIHistogram2D | |
| CIHistogram3D | |
| CIHistogramFactory | |
| CIHistogramSvc | Definition of the IHistogramSvc interface class |
| CIHistorySvc | Definition of the IHistorySvc interface class |
| CIHiveWhiteBoard | |
| CIInactiveMessageCounter | |
| CIIncidentAsyncTestSvc | |
| CIIncidentListener | The interface implemented by any class wanting to listen to Incidents |
| CIIncidentSvc | The interface implemented by the IncidentSvc service |
| CListener | Listener properties |
| CIInspectable | Interface definition of an inspectable object |
| CIInspector | Inspector base class |
| CIValue | |
| CTag | |
| C_V | |
| C_TT | |
| CIInterface | Definition of the basic interface |
| CIIoComponent | |
| CIIoComponentMgr | |
| CIoMode | |
| CIMagneticFieldSvc | The interface to the MagneticFieldSvc |
| CIMessageSvc | The IMessage is the interface implemented by the message service |
| CIMetaDataSvc | |
| CIMonitorSvc | Definition of the IMonitorSvc interface, which publishes Gaudi variables to outside monitoring processes |
| Cimplements | Base class used to implement the interfaces |
| CIMyOtherTool | Second interface, to test multiple interface tools |
| CIMyTool | Example of an Interface of a Algorithm Tool |
| CINamedInterface | IInterface compliant class extending IInterface with the name() method |
| CIncident | Base class for all Incidents (computing events) |
| CIncidentAsyncTestAlg | |
| CIncidentAsyncTestSvc | |
| CIncidentListenerTest | |
| CIncidentListenerTestAlg | |
| CIncidentProcAlg | |
| CIncidentRegistryTestListener | |
| CIncidentSvc | Default implementation of the IIncidentSvc interface |
| CInertMessageSvc | Thread safe extension to the standard MessageSvc |
| CInputCopyStream | Extension of OutputStream to copy the content of the main input file |
| CInterfaceID | Interface ID class |
| CINTuple | NTuple interface class definition |
| CINTupleItem | NTuple interface class definition |
| CINTupleSvc | |
| CIoComponentMgr | |
| CIoComponentEntry | |
| CIoFlags | |
| CIOpaqueAddress | Opaque address interface definition |
| CIPartPropSvc | |
| CIPersistencySvc | Data persistency service interface |
| CIPrecedenceSvc | Abstract interface for a service that manages tasks' precedence |
| CIProfile1D | |
| CIProfile2D | |
| 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 |
| CIRegistry | The IRegistry represents the entry door to the environment any data object residing in a transient data store is embedded |
| 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 |
| CParam | |
| CIRndmGenSvc | Random Generator service interface definition Definition of a interface for a service to access random generators according to predefined distributions: |
| CIRunable | Runable interface definition |
| Cis2f_merger_with_scalar | |
| Cis2ff_merger | |
| Cis2ff_merger_filter | |
| Cis2ff_merger_filter_with_scalar | |
| Cis2ff_merger_with_scalar | |
| Cis_merger_consumer_with_scalar | |
| Cis_StatusCode_enum | |
| CIScheduler | General interface for algorithm scheduler |
| COccupancySnapshot | Sample occupancy at fixed interval (ms) Negative value to deactivate, 0 to snapshot every change Each sample, apply the callback function to the result |
| CISelectStatement | A select statement can either contain |
| CISerialize | Object serialization interface definition |
| CIService | General service interface definition |
| CIStagerSvc | |
| CIStateful | Interface for classes that implement the Gaudi State Machine |
| CIStatSvc | "Stat"-related part of interface IChronoStatSvc |
| CISvcLocator | The ISvcLocator is the interface implemented by the Service Factory in the Application Manager to locate services in the framework |
| CISvcManager | The ISvcManager is the interface implemented by the Service Factory in the Application Manager to support management functions |
| CITestTool | |
| CITHistSvc | |
| CIThreadInitTool | Abstract interface for AlgTools to do thread local initialization |
| CIThreadPoolSvc | Abstract interface for a service that manages a thread pool |
| CITimelineSvc | |
| CTimelineRecorder | RAII helper to record timeline events |
| CIToolSvc | The interface implemented by the IToolSvc base class |
| CObserver | Allow call-backs when a tool is a created or retrieved |
| CIUpdateable | Object update interface definition |
| CIUpdateableIF | |
| CIUpdateableInterface | Component interface counterpart to the above ABC |
| CIValidity | Interface for objects with a validity |
| CIVersHistoryObj | Interface for Versioned History Objects |
| CIWrongTool | Interface (not implemented) to test attempts to retrieval of wrong interface |
| CJobHistory | JobHistory class definition |
| CJobOptionsSvc | |
| CJSONPropertyAlg | |
| CKeyedContainer | Template class KeyedContainer, KeyedContainer.h |
| C_InsertRelease | Internal functor for insertion of objects |
| C_RemoveRelease | Internal functor for insertion of objects |
| CKeyedObject | Definition of the templated KeyedObject class |
| CLinkManager | A LinkManager is the object aggregated into a DataObject, which is responsible for the handling of non-tree like links |
| CLink | Embedded class defining a symbolic link Note: No explicit copy constructor; implicit compiler generated one is just fine |
| Clinux_proc | |
| CLockedHandle | Provides automatic lock/unlock access to a class upon deref of ptr |
| CGuard | |
| CConstGuard | |
| CLoggingAuditor | Simple auditor that prints the event being audited |
| CLoopAlg | |
| CMapAlg | Simple algorithm which shows various "map-like" containers available in Gaudi |
| CMEMORY_MAPPED_FILE | |
| CMemoryAuditor | Monitors the memory use of each algorithm |
| CMemStatAuditor | Just a minor modification of MemoryAuditor to allow the output memory statistics table to be printed |
| CMessage | The Message class |
| CMessageSvc | |
| CMsgAry | Private helper class to keep the count of messages of a type (MSG::LEVEL) |
| CMetaDataSvc | |
| CMinimalEventLoopMgr | This is the default processing manager of the application manager |
| CAbortEventListener | |
| CModuleIncident | Base class for Module-related incident |
| CModuleLoadedIncident | Fired when a module (DLL) is loaded |
| CMonotonicArena | Shorthand for Gaudi::Allocator::Arena with Gaudi::Arena::Monotonic resource |
| CMsgStream | Definition of the MsgStream class used to transmit messages |
| CMyAlgorithm | Trivial Algorithm for tutorial purposes |
| CMyClass1 | Trivial "almost empty" class |
| CMyClass1A | Simple class, equipped with "Allocator", to be compared with class MyClass1 |
| CMyDataAlgorithm | Trivial Algorithm for tutotial purposes |
| CMyObject | |
| CMyTack | Simple class that represents a track for testing purposes |
| CMyTool | This is an interface class for a example tool |
| CNameAuditor | Prints the name of each algorithm before entering the algorithm and after leaving it |
| CNamedRange | New concept of "named" range : range with name |
| CNTupleAlgorithm | |
| CNTupleItems | NTupleItems namespace parts definition This header file is not intended to be included by the public! |
| CNTupleSvc | NTuple service |
| CConnection | |
| CNVTXAuditor | Auditor that uses NVTX to annotate ranges and incidents for profiling with NVIDIA tools |
| CObjectContainerBase | ObjectContainerBase is the base class for Gaudi container classes |
| CObjectList | ObjectList is one of the basic Gaudi container classes capable of being registered in Data Stores |
| CObjectVector | ObjectVector is one of the basic Gaudi container classes capable of being registered in Data Stores |
| Costream | STL class |
| COutputStream | A small to stream Data I/O |
| CParentAlg | Trivial Algorithm for tutotial purposes |
| CParticleProperty | A trivial class to hold information about a single particle properties |
| CCompare | The comparison criteria for particle properties |
| CPartPropExa | |
| CPartPropSvc | |
| CPeriodicAction | Helper to periodically run asynchronous tasks |
| CPersistencySvc | PersistencySvc class implementation definition |
| CServiceEntry | |
| CPersSvc | Persistency service - to store histograms in ROOT format |
| CPOOLIOTestDict__Instantiations | |
| CPOSIXFileHandler | |
| CPrecedenceSvc | A service to resolve the task execution precedence |
| CprocInfo | |
| CProcStats | |
| Cunique_fd | |
| CProduceIntView | |
| CProduceStringView | |
| CPropertyAlg | Trivial Algorithm for tutorial purposes |
| CPropertyBase | PropertyBase base class allowing PropertyBase* collections to be "homogeneous" |
| CPropertyHolder | Helper class to implement the IProperty interface |
| CRemProperty | |
| CPropertyProxy | Trivial Algorithm for tutotial purposes |
| CPropertyWithHandlers | Helper class to simplify the migration old properties deriving directly from PropertyBase |
| CPublicToolHandle | Helper class to construct ToolHandle instances for public tools via the auto registering constructor |
| CPublicToolHandleArray | Helper class to construct ToolHandle instances for public tools via the auto registering constructor |
| CPythonAdaptor | |
| CPythonConfig | |
| CPythonScriptingSvc | This service handles scripting implemented using Python |
| CQotdAlg | Simple algorithm to output "famous" quotes of "famous" people into a MsgStream stream |
| CRandomNumberAlg | A small algorithm class using the random number service |
| CReadAlg | ReadAlg class for the RootIOExample |
| CReadTES | |
| CRecordDataSvc | A RecordDataSvc is the base class for event services |
| CRecordOutputStream | Simple class that adds an entry to the Transient Event Store to record that the processing flow triggered its execution |
| CRecordStream | Extension of OutputStream to write run records after last event |
| CReEntAlg | Algorithm to test reentrant Algorithms |
| CRenounceToolInputsVisitor | Helper class to be used in conjunction with the recursive tool visitor to renounce certain inputs |
| CILogger | Helper class interface to optionally log renounce operations |
| CNoLogger | A do-nothing helper class which implements the logger interface |
| CLogger | |
| CReplayOutputStream | |
| COutStreamAdder | Helper class to fill the internal map of OutputStreams |
| CRetCodeGuard | Helper class to set the application return code in case of early exit (e.g |
| CRichToolTest | |
| CRndmEngine | Random Generator engine definition |
| CRndmGen | Random Generator definition |
| CRndmGenSvc | Random Generator service definition |
| CRootConnectionSet | Class describing the setup parameters of a ROOT data connection |
| CRootFileHandler | |
| CRunRecordDataSvc | A RunRecordDataSvc is the base class for event services |
| CRunRecordStream | Extension of OutputStream to write run records after last event |
| CSelectStatement | Class of a selection statement |
| CSequence | |
| CSequentialOutputStream | Extension of OutputStream to write run records after last event |
| CService | Base class for all services |
| CServiceA | |
| CServiceB | |
| CServiceHandle | Handle to be used in lieu of naked pointers to services |
| CServiceHandleArray | Array of Handles to be used in lieu of vector of naked pointers to tools |
| CServiceHistory | ServiceHistory class definition |
| CServiceLocatorHelper | Helper to share the implementation of service() among the various kernel base classes |
| CServiceManager | In charge of the creation of concrete instances of Services |
| CServiceItem | |
| CSharedObjectsContainer | Very simple class to represent the container of objects which are not owned by this container |
| CSmartDataLocator | A small class used to access easily (and efficiently) data items residing in data stores |
| CSmartDataObjectPtr | A small class used to access easily (and efficiently) data items residing in data stores |
| CObjectLoader | Helper class to configure smart pointer functionality |
| CObjectFinder | Helper class to configure smart pointer functionality |
| CSmartDataPtr | A small class used to access easily (and efficiently) data items residing in data stores |
| CSmartDataStorePtr | A small class used to access easily (and efficiently) data items residing in data stores |
| CSmartIF | Small smart pointer class with automatic reference counting for IInterface |
| CSmartRef | Kernel objects: SmartRef |
| CSmartRefArray | |
| CSmartRefBase | User example objects: SmartRefBase |
| CSmartRefList | |
| CSmartRefMap | |
| CSmartRefVector | Kernel objects: SmartRefVector |
| CStat | Small wrapper class for easy manipulation with generic counters and IStatSvc interface |
| CStatEntity | Backward compatible StatEntity class |
| CStatSvcAlg | Simple algorithm to illustrate the statistical abilities of "Stat"-part of Chrono&Stat Service |
| CStatusCode | This class is used for returning status codes from appropriate routines |
| CCategory | The category assigned to a StatusCode |
| CStopperAlg | |
| 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 |
| CLeafInfo | |
| CStreamBuffer | The stream buffer is a small object collecting object data |
| CDataIO | A small base class to handle generic data streaming |
| CIstream | Reader for standard input streams |
| COstream | Writer for standard output streams |
| CContainedLink | Definition of the contained link set |
| CIdentifiedLink | Definition of the contained link set |
| Cstring | STL class |
| Citerator | STL iterator class |
| Cconst_iterator | STL iterator class |
| Creverse_iterator | STL iterator class |
| Cconst_reverse_iterator | STL iterator class |
| CStringKeyEx | Simple example which illustrate the usage of class StringKey |
| CSubAlg | Trivial Algorithm for tutotial purposes |
| CTagCollectionStream | Specialized output stream class for event tag collections, where the basic Event entry point should be placed as well into the collection itself |
| CTagCollectionSvc | Gaudi tag collection service definition |
| CTemplateAlg | Trivial Algorithm for tutotial purposes |
| CTemplatedAlg | |
| CTestAlg | Simple algorithm useful as base class for tests |
| CTestTool | |
| CTestToolAlg | |
| CTestToolAlgFailure | Retrieve tools ignoring errors |
| CTestToolFailing | |
| CTHistRead | |
| CTHistSvc | |
| CGlobalDirectoryRestore | Helper class that manages ROOts global directory and file |
| CTHistID | Helper struct that bundles the histogram ID with a mutex, TFile and TObject* |
| CTHistWrite | |
| CThreadInitTask | Special TBB task used by ThreadPoolSvc to wrap execution of IThreadInitTools |
| CThreadPoolSvc | A service which initializes a TBB thread pool |
| CTimeException | Exception thrown by Gaudi::Time |
| CTimelineEvent | |
| CTimelineSvc | |
| CToolHandle | Handle to be used in lieu of naked pointers to tools |
| CToolHandle< Gaudi::Interface::Bind::IBinder< IFace > > | |
| CToolHandleArray | Array of Handles to be used in lieu of vector of naked pointers to tools |
| CToolHandleInfo | General info and helper functions for toolhandles and arrays |
| CToolSvc | This service manages tools |
| CToolList | Common Tools |
| CHash | |
| CEqual | |
| CTsDataSvc | Data service base class |
| Cvector | STL class |
| Citerator | STL iterator class |
| Cconst_iterator | STL iterator class |
| Creverse_iterator | STL iterator class |
| Cconst_reverse_iterator | STL iterator class |
| CVFSSvc | Simple service that allows to read files independently from the storage |
| CViewTester | |
| CWideNTupleAlgorithm | Books a configurable grid of column-wise tuples: many trees, many columns, few entries |
| CBlock | One booked tuple and everything written into it |
| CWidget | |
| CWriteAlg | WriteAlg class for the RootIOExample |
1.17.0