Class Hierarchy

Go to the graphical class hierarchy

This inheritance list is sorted roughly, but not completely, alphabetically:

[detail level 12345678910111213]

C__cxxabiv1::__class_type_info::__dyncast_result
C__Instantiations
C__longlong
C__cxxabiv1::__class_type_info::__upcast_result
CNTuple::_Accessor< TYP >	Class acting as a smart pointer holding a N tuple entry
►CNTuple::_Accessor< _Array< TYP > >
CNTuple::Array< TYP >	Class acting as a smart pointer holding a N tuple _Item
►CNTuple::_Accessor< _Item< bool > >
CNTuple::Item< bool >	Specialization acting as a smart pointer holding a N tuple _Item
►CNTuple::_Accessor< _Item< IOpaqueAddress * > >
CNTuple::Item< IOpaqueAddress * >
►CNTuple::_Accessor< _Item< TYP > >
CNTuple::Item< TYP >	Class acting as a smart pointer holding a N tuple _Item
►CNTuple::_Accessor< _Matrix< TYP > >
CNTuple::Matrix< TYP >	Class acting as a smart pointer holding a N tuple _Item
►C_CallbackStreamBufBase
CGaudiPython.Bindings.CallbackStreamBuf
CGenfun::GaudiMathImplementation::NumericalDefiniteIntegral::_Function
CGenfun::GaudiMathImplementation::NumericalIndefiniteIntegral::_Function
►C_GaudiAlgorithm
CGaudiPython.GaudiAlgs.GaudiAlgo	Base class for all algorithm Python-image of C++ clkass GaudiAlgorithm
►C_GaudiHistoAlg
CGaudiPython.GaudiAlgs.HistoAlgo	The base class for easy histogramming
►C_GaudiTupleAlg
CGaudiPython.GaudiAlgs.TupleAlgo	The base class for easy manupulations with N-Tuples
CGaudi::Utils::_GetType< TYPE >	Helper structure to define the proper return type for "get"-functions
CGaudi::Utils::_GetType< Gaudi::NamedRange_< CONTAINER > >	Template specialization for "named ranges"
CGaudi::Utils::_GetType< Gaudi::Range_< CONTAINER > >	Template specialization for "ranges"
CGaudi::Utils::_GetType< TYPE & >	Template specialization for references
CGaudi::Utils::_GetType< TYPE * >	Template specialization for pointers
CKeyedContainer< DATATYPE, MAPPING >::_InsertRelease	Internal functor for insertion of objects
►C_PyAlgorithm
CGaudiPython.Bindings.PyAlgorithm
CKeyedContainer< DATATYPE, MAPPING >::_RemoveRelease	Internal functor for insertion of objects
CGaudiKernel.ProcessJobOptions._TempSysPath
CGenfun::GaudiMathImplementation::NumericalDefiniteIntegral::_Workspace
CGenfun::GaudiMathImplementation::NumericalIndefiniteIntegral::_Workspace
►CAbsFunction
CGenfun::GaudiMathImplementation::Adapter2DoubleFunction	Constructor from the trivial function with two argument
CGenfun::GaudiMathImplementation::Adapter3DoubleFunction	Constructor from the trivial function with two argument
CGenfun::GaudiMathImplementation::AdapterIFunction	Constructor from the IFunction ( see AIDA/IFunction.h)
CGenfun::GaudiMathImplementation::Constant	Fixed constant function
CGenfun::GaudiMathImplementation::GSLFunctionWithError
CGenfun::GaudiMathImplementation::GSLFunctionWithMode
CGenfun::GaudiMathImplementation::GSLFunctionWithModeAndError
CGenfun::GaudiMathImplementation::GSLSpline
CGenfun::GaudiMathImplementation::GSLSplineDeriv
CGenfun::GaudiMathImplementation::GSLSplineDeriv2
CGenfun::GaudiMathImplementation::GSLSplineInteg
CGenfun::GaudiMathImplementation::NumericalDefiniteIntegral	This class allows the numerical evaluation of the following functions:
CGenfun::GaudiMathImplementation::NumericalDerivative	Numerical derivative (using GSL adaptive numerical differentiation)
CGenfun::GaudiMathImplementation::NumericalIndefiniteIntegral	The simple class for numerical integrations
CGenfun::GaudiMathImplementation::SimpleFunction
CGaudi::Utils::Aida2ROOT	Accessor to underlying ROOT-representation of transient histograms The actual code is imported from Bender project
CAlgContexSvc	Simple implementation of interface IAlgContextSvc for Algorithm Context Service
CGaudi::Utils::AlgContext	Helper "sentry" class to automatize the safe register/unregister the algorithm's context
CGaudiPython::AlgDecorator
CAlgFactory< T >
►CALGORITHM
CGaudiPython::PyAlg< ALGORITHM >	General class to embed the existing algorithm/base class into the python
CGaudiSequencer::AlgorithmEntry
CAlgorithmManager::AlgorithmItem
►CGaudi::Utils::AlgSelector	Simple interface class for selection of algorithms
CGaudi::Utils::AlgNameSelector	The trivial selector of algorithm by type
►CGaudi::Utils::AlgTypeSelector< TYPE >	The trivial selector of algorithm by type
CGaudi::Utils::AlgTypeSelector< const TYPE & >
CGaudi::Utils::AlgTypeSelector< const TYPE * >
CGaudi::Utils::AlgTypeSelector< const TYPE >
CGaudi::Utils::AlgTypeSelector< TYPE & >
CGaudi::Utils::AlgTypeSelector< TYPE * >
CGaudiUtils::Allocator< Type >	Allocator
CGaudiUtils::AllocatorPool	Allocator pool
CAIDA::Annotation::AnnotationItem	Internal private annotation item class
CAppendInterfaceName	Helper class for the cast used in the MPL for_each algorithm in the implementation of query_interface
CContainers::array
CNTuple::Array< IOpaqueAddress * >
Cboost::spirit::repository::qi::iter_pos_parser::attribute< Context, Iterator >
CAudFactory< T >
CGaudi::Guards::AuditorGuard	It is a simple guard, which "locks" the scope for the Auditor Service is am exception-safe way
►CBaseObjectMemberFunction	Base class of ObjectMemberFunction
CObjectMemberFunction< CallerClass >	This class is used by IUpdateManagerSvc to keep pairs made of a member function and a pointer to the object for which that member function has to be called
►CBasePtrSetter	Base class to set the pointer to an object of a class derived from DataObject in a generic way
CPtrSetter< ActualType >	Templated specialization of BasePtrSetter
CGaudiTesting.BaseTest.BasicOutputValidator
CGaudiTest.BasicOutputValidator	Output Validation Classes
►Cbinary_function
CComparePairOfChronoEntityAndChronoTag
CComparePairOfStatEntityAndStatTag
CGaudi::Math::Lomont< double >	Specialization for double numbers
CGaudi::Math::Lomont< float >	Specialization for float numbers
CGaudi::Parsers::Property::LessThen
CC_dict
CFileInfo::CacheItem
CFileInfo::CacheItemComparator
CROOT::Math::Cartesian3D< T >
CGaudi::Parsers::Catalog
Ccgaudi_factory_t
Ccgaudi_pluginsvc_t
Ccgaudi_property_t
►CGaudi::Utils::CheckData< TYPE >	Helper structure for implementation of "exists"-functions for GaudiCommon<BASE>
CGaudi::Utils::CheckData< const TYPE >	Template specialization for 'const'-type
CGaudi::Utils::CheckData< TYPE & >	Template specialization for reference types
CGaudi::Utils::CheckData< TYPE * >	Template specialization for pointer types
►CGaudi::Utils::CheckData< Gaudi::Range_< std::vector< const TYPE * > > >	Template specialization for ranges
CGaudi::Utils::CheckData< Gaudi::NamedRange_< std::vector< const TYPE * > > >	Template specialization for ranges
CChrono	A small utility class for chronometry of user codes
CChronoEntity	Small helper class for implementation of ChronoStatSvc service, It also could be used as some local timer
►CCLASS
CRootHistCnv::RHistogramCnv< T, S, Q >::TTH< CLASS >
CProcStats::cleanup
CCLibSymbolInfo
►Cclosure
CGaudi::Parsers::AttributesClosureGrammar< T1, T2 >	Grammar or grammar rule which derive from this struct will have two attributes: type T1 and name val, type T2 and name attrs
CGaudi::Parsers::ClosureGrammar< T >	Grammar or grammar rule which derive from this struct will have attribute of type T and name val
CGaudiTest.CMT
CCnvFactory< T >
CconfigGenerator
CNTupleSvc::Connection
CConst_int_t< n >
CConst_uint_t< n >
CStreamBuffer::ContainedLink	Definition of the contained link set
►CContainedObject	All classes that their objects may be contained in an LHCb ObjectContainer (e.g
CKeyedObject< KEY >	Definition of the templated KeyedObject class
►CKeyedObject< int >
CMyTrack
CMyVertex	Simple class that represents a vertex for testing purposes
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
CConverterID
CGaudiToolLocal::Counter	Simple local counter
CTuples::Local::Counter
CIgHookTrace::Counter	Nearly dummy object type to identify a counter
CIgHookTrace::CounterValue	Value for a counter chained from a trace
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 >
►CDataObject	A DataObject is the base class of any identifiable object on any data store
CEvent	Essential information of the event used in examples It can be identified by "/Event"
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 2 D histograms using ROOT THD2
CGaudi::Profile1D	AIDA implementation for 1 D profiles using ROOT TProfile
CGaudi::Profile2D	AIDA implementation for 2 D profiles using ROOT TProfile2D
►CHistoryObj	Base class for History Objects
CAlgorithmHistory	AlgorithmHistory class definition
CAlgToolHistory	AlgToolHistory class definition
CDataHistory	DataHistory class definition
CJobHistory	JobHistory class definition
CServiceHistory	ServiceHistory class definition
►CNTuple::Directory	Small class representing an N tuple directory in the transient store
CNTuple::File	Small class representing an N tuple file in the transient store
►CNTuple::Tuple	Abstract base class which allows the user to interact with the actual N tuple implementation
►CNTuple::TupleImp
CNTuple::ColumnWiseTuple
CNTuple::RowWiseTuple
►CObjectContainerBase	ObjectContainerBase is the base class for Gaudi container classes
CKeyedContainer< DATATYPE, MAPPING >	Template class KeyedContainer, KeyedContainer.h
CKeyedContainer< MyTrack >
CKeyedContainer< MyVertex >
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 ownered by the container
CRefTableBase< FROM, MAPENTRY >	Template <class FROM, class TO, class MAPENTRY> class RefTable
►CRefTableBase< FROM, SmartRef< TO > >
CRefTable1to1< FROM, TO >
►CRefTableBase< FROM, SmartRefVector< TO > >
CRefTable1toN< FROM, TO >
CDataStoreItem	Description of the DataStoreItem class
CDataTypeInfo	Small class which allows access to internal type IDs
CAlgTool::declareInterface< I >
CDecorator	Simple class with allows to "decorate" the python algorithm with 'basic' funtionality from class GaudiAlgorithm
CContainers::array::decrement
CGaudiKernel.Configurable.Configurable.DefaultName	For detecting the default name
CGaudi::Parsers::BoolGrammar< Iterator, Skipper >::definition
CGaudi::Parsers::CharGrammar< RT >::definition< ScannerT >
CGaudi::Parsers::IntGrammar< RT >::definition< ScannerT >
CGaudi::Parsers::RealGrammar< Iterator, Skipper >::definition< ScannerT >
CGaudi::Parsers::StringGrammar< Iterator, Skipper >::definition
CGaudi::Parsers::SkipperGrammar< Iterator >::definition
CGaudi::Parsers::PairGrammar< KeyGrammarT, ValueGrammarT >::definition< ScannerT >
CGaudi::Parsers::VectorGrammar< GrammarT >::definition< ScannerT >
CGaudi::Parsers::MapGrammar< KeyGrammarT, ValueGrammarT >::definition< ScannerT >
CDHH
►Cdict
CGaudiKernel.ConfigurableDb._CfgDb
CGaudiMP.FdsRegistry.FdsDict
CGaudiProfiling.GenerateGaudiOpts.XmlDictObject
CDirSearchPath	Search for files in a list of directories
CROOT::Math::DisplacementVector3D< CoordSystem, Tag >
CGaudi::IODataManager::Entry
CEqSolver::EqSolverMisc
CTuples::detail::ErrorHandler< OBJECT, FUNCTION >	Concrete error handlers for dealing with classes, which supports member functions Error,Warning and Print ( e.g
CEventIterator< TYPE >
CExcelPlotter.Excel
►Cstd::exception	STL class
CGaudi::PluginService::Exception
►CGaudiException	Define general base for Gaudi exception
CTimeException	Exception thrown by Gaudi::Time
CUpdateManagerException	Exception thrown by the UpdateManagerSvc when something goes wrong
►Cstd::runtime_error	STL class
CGaudi::Parsers::PositionalPropertyValueException
CGaudi::Parsers::PropertyValueException
CGaudi::Guards::ExceptionGuard	The most simple guard - it execute the certain code withing typical "try {} catch" clause, used in Auditor, Algorithm, AlgTool, etc
CGaudi::PluginService::Details::Factory< T >	Class providing default factory functions
CGaudi::PluginService::Factory< R, Args >	Class wrapping the signature for a factory with any number of arguments
CGaudi::PluginService::Details::Registry::FactoryInfo
CIo::FileAttr
CIo::FileHdlr
CFileInfo
►CGaudiTesting.BaseTest.FilePreprocessor
CGaudiTesting.BaseTest.BlockSkipper
CGaudiTesting.BaseTest.FilePreprocessorSequence
CGaudiTesting.BaseTest.LineSkipper
CGaudiTesting.BaseTest.LineSorter	Special preprocessor sorting the list of strings (whitespace separated) that follow a signature on a single line
CGaudiTesting.BaseTest.RegexpReplacer
►CGaudiTest.FilePreprocessor
CGaudiTest.BlockSkipper
CGaudiTest.FilePreprocessorSequence
CGaudiTest.LineSkipper
CGaudiTest.LineSorter	Special preprocessor sorting the list of strings (whitespace separated) that follow a signature on a single line
CGaudiTest.RegexpReplacer
CGaudiMP.pTools.FileRecordsAgent
►CFilter
CGaudiTest.GaudiFilterExecutable
►CFilter
CGaudiKernel.ProcessJobOptions.LogFilter
CContainers::find< CONT >
CGaudi::Parsers::PairGrammar< KeyGrammarT, ValueGrammarT >::first
CGaudi::Parsers::KeyValueGrammar< Iterator, Skipper >::first
Cana.FirstSummary
►CFormatter
CGaudiKernel.ProcessJobOptions.LogFormatter
CFuncMinimum::FuncMinimumMisc
CGaudi	This is a number of static methods for bootstrapping the Gaudi framework
CGaudiDll
CGaudiGSL	Helper class to get (static) access to Gaudi GSL Service General users are not supposed to use it
►CGaudiHandleInfo
►CGaudiHandleArrayBase	Base class of array's of various gaudihandles
CGaudiHandleArray< T >	T is the concrete handle type, e.g
►CGaudiHandleArray< ServiceHandle< T > >
CServiceHandleArray< T >	Array of Handles to be used in lieu of vector of naked pointers to tools
►CGaudiHandleArray< ToolHandle< T > >
CToolHandleArray< T >	Array of Handles to be used in lieu of vector of naked pointers to tools
►CGaudiHandleBase	Base class to handles to be used in lieu of naked pointers to various Gaudi components
►CGaudiHandle< T >	Handle to be used in lieu of naked pointers to gaudis
CServiceHandle< T >	Handle to be used in lieu of naked pointers to services
CToolHandle< T >	Handle to be used in lieu of naked pointers to tools
►CGaudiHandle< IToolSvc >
CServiceHandle< IToolSvc >
CRndm::Generator< TYPE >
►CGaudi::Utils::GetData< TYPE >	Helper structure for implementation of "get"-functions for GaudiCommon<BASE>
CGaudi::Utils::GetData< const TYPE >	Template specialization for const types
CGaudi::Utils::GetData< TYPE & >	Template specialization for reference types
CGaudi::Utils::GetData< TYPE * >	Template specialization for pointer types
CGaudi::Utils::GetData< Gaudi::Gaudi::Range_< std::vector< const TYPE * > > >
CGaudi::Utils::GetData< Gaudi::NamedRange_< std::vector< const TYPE * > > >	Template specialization for named ranges
CGaudi::Utils::GetData< Gaudi::Range_< std::vector< const TYPE * > > >	Template specialization for ranges
CGaudi::Utils::GetData< Range >
►CGaudi::Utils::GetOrCreateData< TYPE, TYPE2 >	Helper structure for implementation of "getOrCreate"-functions for GaudiCommon<BASE>
CGaudi::Utils::GetOrCreateData< const TYPE, const TYPE2 >
CGaudi::Utils::GetOrCreateData< const TYPE, TYPE2 >
CGaudi::Utils::GetOrCreateData< TYPE &, TYPE2 & >
CGaudi::Utils::GetOrCreateData< TYPE &, TYPE2 >
CGaudi::Utils::GetOrCreateData< TYPE *, TYPE2 * >
CGaudi::Utils::GetOrCreateData< TYPE *, TYPE2 >
CGaudi::Utils::GetOrCreateData< TYPE, const TYPE2 >
CGaudi::Utils::GetOrCreateData< TYPE, TYPE2 & >
CGaudi::Utils::GetOrCreateData< TYPE, TYPE2 * >
CGaudi::Utils::GetOrCreateData< Gaudi::NamedRange_< std::vector< const TYPE * > >, TYPE2 >
CGaudi::Utils::GetOrCreateData< Gaudi::Range_< std::vector< const TYPE * > >, TYPE2 >
CGaudi::Utils::GetOrCreateData< Range_, TYPE2 >
CTHistSvc::GlobalDirectoryRestore
CGlobalDirectoryRestore
►Cgrammar
CGaudi::Parsers::BoolGrammar< Iterator, Gaudi::Parsers::SkipperGrammar >
CGaudi::Parsers::BoolGrammar< Iterator, Gaudi::Parsers::SkipperGrammar >
CGaudi::Parsers::BoolGrammar< Iterator, Gaudi::Parsers::SkipperGrammar >
CGaudi::Parsers::EdgeGrammar< Iterator, Gaudi::Parsers::SkipperGrammar >
CGaudi::Parsers::BoolGrammar< Iterator, Skipper >	The valid represenation of boolean values are:
CGaudi::Parsers::BoolGrammar< Iterator, Skipper >	The valid represenation of boolean values are:
CGaudi::Parsers::BoolGrammar< Iterator, Skipper >	The valid represenation of boolean values are:
CGaudi::Parsers::CharGrammar< RT >	The valid represenation of char values are:
CGaudi::Parsers::CharGrammar< RT >	The valid represenation of char values are:
CGaudi::Parsers::EdgeGrammar< Iterator, Skipper >
CGaudi::Parsers::FileGrammar< Iterator, Skipper >
CGaudi::Parsers::H1Grammar< Iterator, Skipper >
CGaudi::Parsers::H2Grammar< Iterator, Skipper >
CGaudi::Parsers::Histo1DGrammar< Iterator, Skipper >
CGaudi::Parsers::IdentifierGrammar< Iterator, Skipper >
CGaudi::Parsers::IntGrammar< RT >	The valid representation of integers values are:
CGaudi::Parsers::IntGrammar< RT >	The valid representation of integers values are:
CGaudi::Parsers::KeyValueGrammar< Iterator, Skipper >
CGaudi::Parsers::MapGrammar< KeyGrammarT, ValueGrammarT >	The valid represenation of map are:
CGaudi::Parsers::MapGrammar< KeyGrammarT, ValueGrammarT >	The valid represenation of map are:
CGaudi::Parsers::PairGrammar< KeyGrammarT, ValueGrammarT >	The valid represenation of pairs are: ("abc",123) or ("abc","def") Inner types of pair depends on KeyGrammarT and ValueGrammarT grammars
CGaudi::Parsers::PairGrammar< KeyGrammarT, ValueGrammarT >	The valid represenation of pairs are: ("abc",123) or ("abc","def") Inner types of pair depends on KeyGrammarT and ValueGrammarT grammars
CGaudi::Parsers::Pnt3DGrammar< Iterator, PointT, Skipper >
CGaudi::Parsers::Pnt4DGrammar< Iterator, PointT, Skipper >
CGaudi::Parsers::RealGrammar< Iterator, Skipper >	The valid represenation of real values are:
CGaudi::Parsers::RealGrammar< Iterator, Skipper >	The valid represenation of real values are:
CGaudi::Parsers::RealGrammar< Iterator, Skipper >	The valid represenation of real values are:
CGaudi::Parsers::SkipperGrammar< Iterator >	Skipping spaces and comments
CGaudi::Parsers::SkipperGrammar< Iterator >	Skipping spaces and comments
CGaudi::Parsers::SkipperGrammar< Iterator >	Skipping spaces and comments
CGaudi::Parsers::StringGrammar< Iterator, Skipper >	The valid represenation of string values are:
CGaudi::Parsers::StringGrammar< Iterator, Skipper >	The valid represenation of string values are:
CGaudi::Parsers::StringGrammar< Iterator, Skipper >	The valid represenation of string values are:
CGaudi::Parsers::TupleGrammar< Iterator, TupleT, N, Skipper >
CGaudi::Parsers::TupleInnerGrammar< Iterator, TupleT, N, Skipper >
CGaudi::Parsers::TupleInnerGrammar< Iterator, TupleT, 1, Skipper >
CGaudi::Parsers::UnitsGrammar< Iterator, Skipper >
CGaudi::Parsers::VectorGrammar< GrammarT >	The valid represenation of vector are:
CGaudi::Parsers::VectorGrammar< GrammarT >	The valid represenation of vector are:
CGaudi::Parsers::IdentifierGrammar< Iterator, double >
CGaudi::Parsers::IdentifierGrammar< Iterator, Gaudi::Parsers::SkipperGrammar >
CGaudi::Parsers::IntGrammar< Iterator, unsigned int, Gaudi::Parsers::SkipperGrammar >
CGaudi::Parsers::IntGrammar< Iterator, unsigned int, Gaudi::Parsers::SkipperGrammar >
CGaudi::Parsers::IntGrammar< Iterator, unsigned int, Skipper >
CGaudi::Parsers::IntGrammar< Iterator, unsigned int, Skipper >
CGaudi::Parsers::RealGrammar< Iterator, double, Gaudi::Parsers::SkipperGrammar >
CGaudi::Parsers::RealGrammar< Iterator, double, Gaudi::Parsers::SkipperGrammar >
CGaudi::Parsers::RealGrammar< Iterator, double, Gaudi::Parsers::SkipperGrammar >
CGaudi::Parsers::RealGrammar< Iterator, double, Skipper >
CGaudi::Parsers::RealGrammar< Iterator, double, Skipper >
CGaudi::Parsers::RealGrammar< Iterator, double, Skipper >
CGaudi::Parsers::RealGrammar< Iterator, Gaudi::Parsers::SkipperGrammar >
CGaudi::Parsers::RealGrammar< Iterator, Gaudi::Parsers::SkipperGrammar >
CGaudi::Parsers::RealGrammar< Iterator, Gaudi::Parsers::SkipperGrammar >
CGaudi::Parsers::StringGrammar< Iterator, Gaudi::Parsers::SkipperGrammar >
CGaudi::Parsers::StringGrammar< Iterator, Gaudi::Parsers::SkipperGrammar >
CGaudi::Parsers::StringGrammar< Iterator, Gaudi::Parsers::SkipperGrammar >
CGaudi::Parsers::TupleInnerGrammar< Iterator, TupleT, N, Gaudi::Parsers::SkipperGrammar >
CGaudi::Parsers::VectorGrammar< Iterator, std::vector< double >, Gaudi::Parsers::SkipperGrammar >
CGaudi::Parsers::VectorGrammar< Iterator, std::vector< double >, Gaudi::Parsers::SkipperGrammar >
CGaudi::Parsers::VectorGrammar< Iterator, std::vector< double >, Skipper >
CGaudi::Parsers::VectorGrammar< Iterator, std::vector< double >, Skipper >
CGaudi::Parsers::VectorGrammar< Iterator, std::vector< std::pair< double, double > >, Gaudi::Parsers::SkipperGrammar >
CGaudi::Parsers::VectorGrammar< Iterator, std::vector< std::pair< double, double > >, Gaudi::Parsers::SkipperGrammar >
CGaudi::Parsers::Grammar_< Iterator, T, Skipper, Enable >
CGaudi::Parsers::Grammar_< Iterator, GaudiUtils::VectorMap< KeyT, ValueT, KeyCompareT, AllocatorT >, Skipper >
CGaudi::Parsers::Grammar_< Iterator, HeadT, Gaudi::Parsers::SkipperGrammar >
CGaudi::Parsers::Grammar_< Iterator, HeadT, Skipper >
CGaudi::Parsers::Grammar_< Iterator, ROOT::Math::DisplacementVector3D< T1, T2 >, Skipper >
CGaudi::Parsers::Grammar_< Iterator, ROOT::Math::LorentzVector< T1 >, Skipper >
CGaudi::Parsers::Grammar_< Iterator, ROOT::Math::PositionVector3D< T1, T2 >, Skipper >
CGaudi::Parsers::Grammar_< Iterator, Scalar, Gaudi::Parsers::SkipperGrammar >
CGaudi::Parsers::Grammar_< Iterator, ScalarT, Gaudi::Parsers::SkipperGrammar >
CGaudi::Parsers::Grammar_< Iterator, std::list< InnerT, AllocatorT >, Skipper >
CGaudi::Parsers::Grammar_< Iterator, std::map< KeyT, ValueT, KeyCompareT, AllocatorT >, Skipper >
CGaudi::Parsers::Grammar_< Iterator, std::pair< KeyT, ValueT >, Skipper >
CGaudi::Parsers::Grammar_< Iterator, std::set< InnerT, CompareT, AllocatorT >, Skipper >
CGaudi::Parsers::Grammar_< Iterator, std::tuple< Args...>, Skipper >
CGaudi::Parsers::Grammar_< Iterator, std::vector< InnerT, AllocatorT >, Skipper >
CGaudi::Parsers::Grammar_< Iterator, T, Skipper, typename boost::enable_if< boost::is_floating_point< T > >::type >
CGaudi::Parsers::Grammar_< Iterator, T, Skipper, typename boost::enable_if< boost::is_integral< T > >::type >
CGaudi::Parsers::Grammar_< Iterator, typename MapT::key_type, Gaudi::Parsers::SkipperGrammar >
CGaudi::Parsers::Grammar_< Iterator, typename MapT::mapped_type, Gaudi::Parsers::SkipperGrammar >
CGaudi::Parsers::Grammar_< Iterator, typename PairT::first_type, Gaudi::Parsers::SkipperGrammar >
CGaudi::Parsers::Grammar_< Iterator, typename PairT::second_type, Gaudi::Parsers::SkipperGrammar >
CGaudi::Parsers::Grammar_< Iterator, typename std::tuple_element< 0, ResultT >::type, Gaudi::Parsers::SkipperGrammar >
CGaudi::Parsers::Grammar_< Iterator, typename VectorT::value_type, Gaudi::Parsers::SkipperGrammar >
CGenfun::GaudiMathImplementation::GSL_Helper	Simple structure to be used for adaption interface Genfun::AbsFunction to gsl_function structure
CGslError	Helper class to represent GSL errors
Cpool::Guid
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
CGaudiPython::HistoDecorator	Simple decorator class to allow to reuse the functionality of GaudiHistos<TYPE> class in pythin
CGaudiPython.HistoUtils.HistoFile
►CGaudi::HistogramBase	Common base class for all histograms Use is solely functional to minimize dynamic_casts inside HistogramSvc
►CGaudi::Generic1D< INTERFACE, IMPLEMENTATION >	Common AIDA implementation stuff for histograms and profiles using ROOT implementations
CGaudi::Histogram1D	AIDA implementation for 1 D histograms using ROOT THD1
CGaudi::Profile1D	AIDA implementation for 1 D profiles using ROOT TProfile
►CGaudi::Generic2D< INTERFACE, IMPLEMENTATION >	Common AIDA implementation stuff for histograms and profiles using ROOT implementations
CGaudi::Histogram2D	AIDA implementation for 2 D histograms using ROOT THD2
CGaudi::Profile2D	AIDA implementation for 2 D profiles using ROOT TProfile2D
►CGaudi::Generic3D< INTERFACE, IMPLEMENTATION >	Common AIDA implementation stuff for histograms and profiles using ROOT implementations
CGaudi::Histogram3D	AIDA implementation for 2 D histograms using ROOT THD2
CGaudi::Generic1D< AIDA::IHistogram1D, TH1D >
CGaudi::Generic1D< AIDA::IProfile1D, TProfile >
CGaudi::Generic2D< AIDA::IProfile2D, TProfile2D >
CGaudi::Generic2D< IHistogram2D, TH2D >
CGaudi::Generic3D< AIDA::IHistogram3D, TH3D >
CGaudi::Utils::HistoStats	The collection of trivial functions to access the statistical information for the histograms
CGaudi::Utils::Histos::HistoStrings	Helper class to produce "good" dictionaries
►CIAxis
CGaudi::Axis	An IAxis represents a binned histogram axis
Cibs_param_t
Cibsfetchctl_t
Cibsopctl_t
Cibsopdata2_t
Cibsopdata3_t
Cibsopdata_t
CIClassInfo	Data base class allowing to store persistent type information
CGaudiAlg::ID	ID class for Histogram and Ntuples
►CGaudi::IDataConnection	ABC describing basic data connection
CGaudi::RootDataConnection	Concrete implementation of the IDataConnection interface to access ROOT files
►CIDataStoreAgent	Generic data agent interface
CDataSelectionAgent	DataSelectionAgent base in charge of collecting all the refereces to DataObjects in a transient store that passes some selection criteria
CGaudiMP::TESSerializer
CHistogramAgent	HistogramAgent base in charge of collecting all the refereces to DataObjects in a transient store that passes some selection criteria
COutputStreamAgent
CStreamBuffer::IdentifiedLink	Definition of the contained link set
►CIFileCatalog
►Cextend_interfaces1< IFileCatalog >
►Cimplements1< IFileCatalog >
CGaudi::XMLFileCatalog	This class constitutes the core of the XML based FileCatalog API for POOL
►Cextend_interfaces2< IFileCatalog, IFileCatalogMgr >
►Cextends2< Service, IFileCatalog, IFileCatalogMgr >
CGaudi::MultiFileCatalog	This class constitutes the core of the XML based FileCatalog API for using POOL within Gaudi
►CIFileCatalogMgr
Cextend_interfaces2< IFileCatalog, IFileCatalogMgr >
CIgHookTrace
CIgHookTraceAlloc
CIgnoreError
►CIHistogram1D
CGaudi::Generic1D< AIDA::IHistogram1D, TH1D >
►CIHistogram3D
CGaudi::Generic3D< AIDA::IHistogram3D, TH3D >
►CIHistogramFactory
CHistogramSvc	HistogramSvc class definition
CIInspectable	Interface definition of an inspectable object
►CIInterface	Definition of the basic interface
►Cextend_interfaces1< IInterface >
►Cimplements1< IInterface >
CEventSelectorDataStream	Definition of class EventSelectorDataStream
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
►Cextend_interfaces1< Gaudi::ISignalMonitor >
►Cextends1< Service, Gaudi::ISignalMonitor >
CGaudi::Utils::SignalMonitorSvc	Implementation of Gaudi::ISignalMonitor
►CIAddressCreator	IAddressCreator interface definition
►Cextend_interfaces2< IConversionSvc, IAddressCreator >
►Cextends2< Service, IConversionSvc, IAddressCreator >
►CConversionSvc	Base class for all conversion services
CGaudi::RootCnvSvc	Description:
CRootHistCnv::PersSvc	Persistency service - to store histograms in ROOT format
►Cextend_interfaces3< IConversionSvc, IPersistencySvc, IAddressCreator >
►Cextends3< Service, IConversionSvc, IPersistencySvc, IAddressCreator >
►CPersistencySvc	PersistencySvc class implementation definition
CDetPersistencySvc
CEvtPersistencySvc	EvtPersistencySvc class implementation definition
CHistogramPersistencySvc	HistogramPersistencySvc class implementation definition
►CIAlgContextSvc	An abstract interface for Algorithm Context Service
►Cextend_interfaces2< IAlgContextSvc, IIncidentListener >
►Cextends2< Service, IAlgContextSvc, IIncidentListener >
CAlgContextSvc
►CIAppMgrUI	Application Manager User Interface
►Cextend_interfaces4< IAppMgrUI, IEventProcessor, IService, IStateful >
►Cimplements4< IAppMgrUI, IEventProcessor, IService, IStateful >
►CCommonMessaging< implements4< IAppMgrUI, IEventProcessor, IService, IStateful > >
CApplicationMgr	The Application Manager class
►CIChronoSvc	"Chrono"-related part of interface IChronoStatSvc
►Cextend_interfaces3< IService, IChronoSvc, IStatSvc >
►CIChronoStatSvc	The IChronoStatSvc is the interface implemented by the ChronoStatService
►Cextend_interfaces2< IChronoStatSvc, IIncidentListener >
►Cextends2< 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
►CIClassManager	The IClassManager is the interface implemented by the generic Factory in the Application Manager to support class management functions
►Cextend_interfaces1< IClassManager >
►Cimplements1< IClassManager >
CDLLClassManager
►CIConverter	The data converters are responsible to translate data from one representation into another
►Cextend_interfaces1< IConverter >
►Cimplements1< IConverter >
►CConverter	Converter base class
►CGaudi::RootConverter	Description: Definition of the ROOT data converter
►CGaudi::RootStatCnv	Description: Base class converter for N-tuples and related classes
►CGaudi::RootDirectoryCnv	Description: NTuple directory converter class definition Definition of the converter to manage the directories in an database representing N-Tuples
CGaudi::RootDatabaseCnv	Statistics file converter class definition
CGaudi::RootNTupleCnv	NTuple converter class definition for NTuples writted/read using ROOT
►CRootHistCnv::RConverter	Root Converter
CRootHistCnv::DirectoryCnv
►CRootHistCnv::RDirectoryCnv	Create persistent and transient representations of data store directories
CRootHistCnv::RFileCnv	NTuple converter class definition
CRootHistCnv::RHistogramCnv< T, S, Q >	Generic converter to save/read AIDA_ROOT histograms using ROOT
►CRootHistCnv::RNTupleCnv	NTuple converter class definition
CRootHistCnv::RCWNTupleCnv	Converter of Column-wise NTuple into ROOT format
CRootHistCnv::RRWNTupleCnv	Row wise NTuple converter class definition
►CIConversionSvc
Cextend_interfaces2< IConversionSvc, IAddressCreator >
Cextend_interfaces3< IConversionSvc, IPersistencySvc, IAddressCreator >
►CICounterSvc	Create / access multi purpose counters
►Cextend_interfaces1< ICounterSvc >
►Cextends1< Service, ICounterSvc >
CCounterSvc	Simple implementation of the abstract interface ICounterSvc
►CIDataManagerSvc
►Cextend_interfaces2< IDataProviderSvc, IDataManagerSvc >
►Cextends2< Service, IDataProviderSvc, IDataManagerSvc >
►CDataSvc	Data service base class
CEvtDataSvc	A EvtDataSvc is the base class for event services
►Cextends1< DataSvc, IHistogramSvc >
CHistogramSvc	HistogramSvc class definition
►Cextends1< 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
►Cextends2< DataSvc, IDetDataSvc, IIncidentListener >
CDetDataSvc
►Cextends2< DataSvc, INTupleSvc, IDataSourceMgr >
►CNTupleSvc	NTuple service
CTagCollectionSvc	Gaudi tag collection service definition
►Cextend_interfaces3< IDataProviderSvc, IDataManagerSvc, IPartitionControl >
►Cextends3< Service, IDataProviderSvc, IDataManagerSvc, IPartitionControl >
CMultiStoreSvc	Data service base class
►CIDataProviderSvc	Data provider interface definition
Cextend_interfaces2< IDataProviderSvc, IDataManagerSvc >
Cextend_interfaces3< IDataProviderSvc, IDataManagerSvc, IPartitionControl >
CIAIDATupleSvc	Definition of the IAIDATupleSvc interface class
►CIHistogramSvc	Definition of the IHistogramSvc interface class
►Cextend_interfaces1< IHistogramSvc >
Cextends1< DataSvc, IHistogramSvc >
►CINTupleSvc
►Cextend_interfaces2< INTupleSvc, IDataSourceMgr >
Cextends2< DataSvc, INTupleSvc, IDataSourceMgr >
►CIDataSourceMgr	IDataSourceMgr interface definition
Cextend_interfaces2< INTupleSvc, IDataSourceMgr >
►CIDetDataSvc
►Cextend_interfaces2< IDetDataSvc, IIncidentListener >
Cextends2< DataSvc, IDetDataSvc, IIncidentListener >
►CIEventProcessor	The IEventProcessor is the interface to process events
►Cextend_interfaces1< IEventProcessor >
►Cextends1< Service, IEventProcessor >
►CMinimalEventLoopMgr	This is the default processing manager of the application manager
CEventLoopMgr	Class definition of EventLoopMgr
Cextend_interfaces4< IAppMgrUI, IEventProcessor, IService, IStateful >
►CIEvtSelector	The Event Selector Interface
►Cextend_interfaces1< IEvtSelector >
►Cextends1< Service, IEvtSelector >
CEventCollectionSelector	Definition of class EventCollectionSelector
CEventSelector	Definition of class EventSelector
CGaudi::RootEvtSelector	Concrete event selector implementation to access ROOT files
►CIExceptionSvc	The abstract interface for exception handling service
►Cextend_interfaces1< IExceptionSvc >
►Cextends1< Service, IExceptionSvc >
CExceptionSvc	Simple implementation of IExceptionSvc abstract interface
►CIFileAccess	Abstract interface for a service or tool implementing a read access to files
►Cextend_interfaces1< IFileAccess >
►Cextends1< AlgTool, IFileAccess >
CFileReadTool	Basic implementation of the IFileAccess interface
►Cextends1< Service, IFileAccess >
CVFSSvc	Simple service that allows to read files independently from the storage
►CIInactiveMessageCounter
►Cextend_interfaces2< IMessageSvc, IInactiveMessageCounter >
►Cextends2< Service, IMessageSvc, IInactiveMessageCounter >
CMessageSvc
►CIIncidentListener	The interface implemented by any class wanting to listen to Incidents
►Cextend_interfaces1< IIncidentListener >
►Cextends1< Auditor, IIncidentListener >
►CGoogle::AuditorBase	Base for Google Auditors
CGoogle::CPUProfiler	Auditor using the Google CPU Profiler
CGoogle::HeapChecker	Auditor using the Google Heap Checker
CGoogle::HeapProfiler	Auditor based on the Google Heap Profiler
CTimingAuditor	Simple auditor which uses SequencerTimerTool for ALL algorithms, including the algorithm from main Gaudi "TopAlg" list and algorithms managed by Data-On-Demand Service
Cextends1< DataSvc, IIncidentListener >
►Cextends1< Service, IIncidentListener >
CDataOnDemandSvc	The DataOnDemandSvc listens to incidents typically triggered by the data service of the configurable name "IncidentName"
CGaudi::Utils::StopSignalHandler	Service that stop the processing if a signal is received
CStalledEventMonitor	Service that monitor the time taken by processing of single events using a separate thread
Cextend_interfaces2< IAlgContextSvc, IIncidentListener >
Cextend_interfaces2< IChronoStatSvc, IIncidentListener >
►Cextend_interfaces2< IDataStoreLeaves, IIncidentListener >
►Cextends2< AlgTool, IDataStoreLeaves, IIncidentListener >
CDataSvcFileEntriesTool	Tool to scan a transient store branch that collects all the objects that belong to the same source (file)
Cextend_interfaces2< IDetDataSvc, IIncidentListener >
►Cextend_interfaces2< IFileMgr, IIncidentListener >
►Cextends2< Service, IFileMgr, IIncidentListener >
CFileMgr
►Cextend_interfaces2< IHistorySvc, IIncidentListener >
►Cextends2< Service, IHistorySvc, IIncidentListener >
CHistorySvc	HistorySvc class definition
►Cextend_interfaces2< IIoComponentMgr, IIncidentListener >
►Cextends2< Service, IIoComponentMgr, IIncidentListener >
CIoComponentMgr
►Cextend_interfaces3< IRndmEngine, ISerialize, IIncidentListener >
►Cextends3< Service, IRndmEngine, ISerialize, IIncidentListener >
►CRndmEngine	Random Generator engine definition
►CHepRndm::BaseEngine
CHepRndm::Engine< TYPE >
►Cextend_interfaces3< ITHistSvc, IIncidentListener, IIoComponent >
►Cextends3< Service, ITHistSvc, IIncidentListener, IIoComponent >
CTHistSvc
CGaudi::RootPerfMonSvc	Description:
CIntelProfilerAuditor
►CIIncidentSvc	The interface implemented by the IncidentSvc service
►Cextend_interfaces1< IIncidentSvc >
►Cextends1< Service, IIncidentSvc >
CIncidentSvc	Default implementation of the IIncidentSvc interface
CIInspector	Inspector base class
►CIJobOptionsSvc	Main interface for the JobOptions service
►Cextend_interfaces2< IProperty, IJobOptionsSvc >
►Cextends2< Service, IProperty, IJobOptionsSvc >
CJobOptionsSvc
►CIMessageSvc	The IMessage is the interface implemented by the message service
Cextend_interfaces2< IMessageSvc, IInactiveMessageCounter >
CIMonitorSvc	Definition of the IMonitorSvc interface, which publishes Gaudi variables to outside monitoring processes
►CINamedInterface	IInterface compliant class extending IInterface with the name() method
►CIAlgorithm	The IAlgorithm is the interface implemented by the Algorithm base class
►Cextend_interfaces3< IAlgorithm, IProperty, IStateful >
►Cimplements3< IAlgorithm, IProperty, IStateful >
►CAlgorithm	Base class from which all concrete algorithm classes should be derived
CCollectionCloneAlg	Small algorithm, which allows to merge N-tuples in a generic way
CEventCounter
CEvtCollectionStream	A small to stream Data I/O
►Cextends1< Algorithm, IPartitionControl >
CPartitionSwitchAlg	Small algorith, which switches the partition of a configurable multi-service
►CGaudiCommon< Algorithm >
►CGaudiAlgorithm	The useful base class for data processing algorithms
CCallgrindProfile	Algorithm to enable/disable the profiling by Callgrind at given events
CEventNodeKiller	Algorithm to kill nodes in the event data store
►CGaudiHistos< GaudiAlgorithm >
►CGaudiHistoAlg	Simple class to extend the functionality of class GaudiAlgorithm
►CGaudiTuples< GaudiHistoAlg >
CGaudiTupleAlg	Simple class to extend the functionality of class GaudiHistoAlg
CGaudiSequencer	Sequencer for executing several algorithms, stopping when one is faulty
CPrescaler
CRecordOutputStream	Simple class that adds an entry to the Transient Event Store to record that the processing flow triggered its execution
CReplayOutputStream
►CGaudiPython::PyAlgorithm	Python Algorithm base class
CGaudiMP.GMPBase.CollectHistograms
Cread_lhcb_event_file.DumpAlg
CHelloWorld	Trivial Algorithm for tutotial purposes
►COutputStream	A small to stream Data I/O
CInputCopyStream	Extension of OutputStream to copy the content of the main input file
CRecordStream	Extension of OutputStream to write run records after last event
CRunRecordStream	Extension of OutputStream to write run records after last event
CSequentialOutputStream	Extension of OutputStream to write run records after last event
CTagCollectionStream	Specialized output stream class for event tag collections, where the basic Event entry point should be placed as well into the collection itself
CPropertyAlg	Trivial Algorithm for tutotial purposes
CRandomNumberAlg	A small algorithm class using the random number service
CSequencer	ClassName: Sequencer
CStoreExplorerAlg	Small algorith, which traverses the data store and prints generic information about all leaves, which can be loaded/accessed
CStoreSnifferAlg	Small algorithm, which traverses the data store and prints a summary of the leafs accessed during the run
CWriteAlg	WriteAlg class for the RootIOExample
►CIAlgTool	The interface implemented by the AlgTool base class
►Cextend_interfaces3< IAlgTool, IProperty, IStateful >
►Cimplements3< IAlgTool, IProperty, IStateful >
►CAlgTool	Base class from which all the concrete tool classes should be derived
►Cextends1< AlgTool, IDataStreamTool >
CDataStreamTool
Cextends1< AlgTool, IFileAccess >
►Cextends1< AlgTool, IGslErrorHandler >
CGslErrorCount	Concrete GSL error handler It is just counts number of GSL errors
CGslErrorException	Concrete GSL eror handler It is just thrown the exception
CGslErrorPrint	Concrete GSL eror handler It is just prints the GSL errors
►Cextends1< AlgTool, IPartitionControl >
CPartitionSwitchTool
Cextends2< AlgTool, IDataStoreLeaves, IIncidentListener >
►Cextends2< AlgTool, IDODAlgMapper, IDODNodeMapper >
CDODBasicMapper	Default implementation of a DataOnDemand mapper
►CGaudiCommon< AlgTool >
►CGaudiTool	The useful base class for tools
CErrorTool
►Cextends1< GaudiTool, IEqSolver >
CEqSolver	The simplest concrete implementation of IEqSolver interface
►Cextends1< GaudiTool, IFuncMinimum >
CFuncMinimum	The simplest concrete implementation of IFuncMinimum interface
►CGaudiHistos< GaudiTool >
►CGaudiHistoTool	Simple class to extend the functionality of class GaudiTool
►CGaudiTuples< GaudiHistoTool >
►CGaudiTupleTool	Simple class to extend the functionality of class GaudiHistoTool
CTupleTool
CHistoTool	Simple tool for histogramming (component)
CSequencerTimerTool	Implements the time measurement inside a sequencer
►CIDataStoreLeaves	Interface for a tool or service that returns a list of leaves (paths) in a transient store
Cextend_interfaces2< IDataStoreLeaves, IIncidentListener >
►CIDataStreamTool
►Cextend_interfaces1< IDataStreamTool >
Cextends1< AlgTool, IDataStreamTool >
►CIDODAlgMapper	Interface of tools used by the DataOnDemandSvc to choose the algorithm to be run to produce the data at a path
►Cextend_interfaces2< IDODAlgMapper, IDODNodeMapper >
Cextends2< AlgTool, IDODAlgMapper, IDODNodeMapper >
►CIDODNodeMapper	Interface of tools used by the DataOnDemandSvc to choose the type of node to be created at a path
Cextend_interfaces2< IDODAlgMapper, IDODNodeMapper >
►CIEqSolver	Interface file for multidimensional root-finding (solving nonlinear system with n equations in n unknowns)
►Cextend_interfaces1< IEqSolver >
Cextends1< GaudiTool, IEqSolver >
►CIErrorTool
CErrorTool
CIEventTimeDecoder	Interface that a Tool that decodes the event time has to implement
►CIFuncMinimum	Interface file to find minimum of the function and compute covariance matrix (matrix of error)
►Cextend_interfaces1< IFuncMinimum >
Cextends1< GaudiTool, IFuncMinimum >
CIGenericTool	General purpose interface class for tools that "do something"
►CIGslErrorHandler	The abstract interface for arbitrary GSL error handler
►Cextend_interfaces1< IGslErrorHandler >
Cextends1< AlgTool, IGslErrorHandler >
►CIHistoTool	An abstract interface for "histogramming tool"
CHistoTool	Simple tool for histogramming (component)
►CISequencerTimerTool	Implements the time measurement inside a sequencer
CSequencerTimerTool	Implements the time measurement inside a sequencer
►CITupleTool
CTupleTool
►CIAuditor	The IAuditor is the interface implmented by the AlgAuditor base class
►Cextend_interfaces2< IAuditor, IProperty >
►Cimplements2< IAuditor, IProperty >
►CAuditor	Base class from which all concrete auditor classes should be derived
CAlgContextAuditor	Description: Register/Unregister the AlgContext of each algorithm before entering the algorithm and after leaving it
CAlgErrorAuditor	Monitors the cpu time usage of each algorithm
►CCommonAuditor	Base class with common functionalities shared by few auditor implementations
CChronoAuditor	Monitors the cpu time usage of each algorithm
►CMemoryAuditor	Monitors the memory use of each algorithm
CMemStatAuditor	Just a minor modification of MemoryAuditor to allow the output memory statistics table to be printed
CNameAuditor	Prints the name of each algorithm before entering the algorithm and after leaving it
Cextends1< Auditor, IIncidentListener >
CIntelProfilerAuditor
CPerfMonAuditor	Performance Monitoring Auditor that uses Perfmon2 library to monitor algorithms
►Cextend_interfaces2< IService, IAuditor >
►CIAuditorSvc	The interface implemented by the IAuditorSvc base class
►Cextend_interfaces1< IAuditorSvc >
►Cextends1< Service, IAuditorSvc >
CAuditorSvc
►CIIoComponent
Cextend_interfaces3< ITHistSvc, IIncidentListener, IIoComponent >
►CIIoComponentMgr
Cextend_interfaces2< IIoComponentMgr, IIncidentListener >
►CIService	General service interface definition
Cextend_interfaces2< IService, IAuditor >
Cextend_interfaces3< IService, IChronoSvc, IStatSvc >
►Cextend_interfaces3< IService, IProperty, IStateful >
►Cimplements3< IService, IProperty, IStateful >
►CCommonMessaging< implements3< IService, IProperty, IStateful > >
►CService	Base class for all services
Cextends1< Service, Gaudi::ISignalMonitor >
Cextends1< Service, IAuditorSvc >
Cextends1< Service, ICounterSvc >
Cextends1< Service, IEventProcessor >
Cextends1< Service, IEvtSelector >
Cextends1< Service, IExceptionSvc >
Cextends1< Service, IFileAccess >
►Cextends1< Service, IGslSvc >
CGslSvc	The implementation of IGslSvc interface
Cextends1< Service, IIncidentListener >
Cextends1< Service, IIncidentSvc >
►Cextends1< Service, IIODataManager >
CGaudi::IODataManager
►Cextends1< Service, IIssueLogger >
CIssueLogger
►Cextends1< Service, IParticlePropertySvc >
CGaudi::ParticlePropertySvc	This service provides access to particle properties
►Cextends1< Service, IPartPropSvc >
CPartPropSvc
►Cextends1< Service, IRunable >
CAppMgrRunable	Class definition of AppMgrRunable
CPythonScriptingSvc	This service handles scripting implemented using Python
►Cextends1< Service, IStatusCodeSvc >
CStatusCodeSvc
►Cextends1< Service, IToolSvc >
CToolSvc	This service manages tools
Cextends2< Service, IAlgContextSvc, IIncidentListener >
Cextends2< Service, IChronoStatSvc, IIncidentListener >
Cextends2< Service, IConversionSvc, IAddressCreator >
Cextends2< Service, IDataProviderSvc, IDataManagerSvc >
Cextends2< Service, IFileCatalog, IFileCatalogMgr >
Cextends2< Service, IFileMgr, IIncidentListener >
Cextends2< Service, IHistorySvc, IIncidentListener >
Cextends2< Service, IIoComponentMgr, IIncidentListener >
Cextends2< Service, IMessageSvc, IInactiveMessageCounter >
Cextends2< Service, IProperty, IJobOptionsSvc >
Cextends3< Service, IConversionSvc, IPersistencySvc, IAddressCreator >
Cextends3< Service, IDataProviderSvc, IDataManagerSvc, IPartitionControl >
Cextends3< Service, IRndmEngine, ISerialize, IIncidentListener >
►Cextends3< Service, IRndmGenSvc, IRndmEngine, ISerialize >
CRndmGenSvc	Random Generator service definition
Cextends3< Service, ITHistSvc, IIncidentListener, IIoComponent >
CGaudi::RootPerfMonSvc	Description:
Cextend_interfaces4< IAppMgrUI, IEventProcessor, IService, IStateful >
CICounterSummarySvc	Simple service interface to collect counters to persist in a summary file
►CIFileMgr
Cextend_interfaces2< IFileMgr, IIncidentListener >
►CIGslSvc	The abstract interface to "deal" with GNU Scientific Library (GLS) The main task is the error handling
►Cextend_interfaces1< IGslSvc >
Cextends1< Service, IGslSvc >
►CIHistorySvc	Definition of the IHistorySvc interface class
Cextend_interfaces2< IHistorySvc, IIncidentListener >
►CIIssueLogger
►Cextend_interfaces1< IIssueLogger >
Cextends1< Service, IIssueLogger >
CIMagneticFieldSvc	The interface to the MagneticFieldSvc
►CIParticlePropertySvc	This class is an interface to the ParticlePropertySvc
►Cextend_interfaces1< IParticlePropertySvc >
Cextends1< Service, IParticlePropertySvc >
►CIPartPropSvc
►Cextend_interfaces1< IPartPropSvc >
Cextends1< Service, IPartPropSvc >
►CIRndmGenSvc	Random Generator service interface definition Definition of a interface for a service to access random generators according to predefined distributions:
►Cextend_interfaces3< IRndmGenSvc, IRndmEngine, ISerialize >
Cextends3< Service, IRndmGenSvc, IRndmEngine, ISerialize >
►CIStatusCodeSvc
►Cextend_interfaces1< IStatusCodeSvc >
Cextends1< Service, IStatusCodeSvc >
►CITHistSvc
Cextend_interfaces3< ITHistSvc, IIncidentListener, IIoComponent >
►CIPartitionControl	Create / access partitions
►Cextend_interfaces1< IPartitionControl >
Cextends1< Algorithm, IPartitionControl >
Cextends1< AlgTool, IPartitionControl >
Cextend_interfaces3< IDataProviderSvc, IDataManagerSvc, IPartitionControl >
►CIPersistencySvc	Data persistency service interface
Cextend_interfaces3< IConversionSvc, IPersistencySvc, IAddressCreator >
►CIProperty	The IProperty is the basic interface for all components which have properties that can be set or get
►Cextend_interfaces1< IProperty >
►Cimplements1< IProperty >
CPropertyMgr	Property manager helper class
Cextend_interfaces2< IAuditor, IProperty >
Cextend_interfaces2< IProperty, IJobOptionsSvc >
Cextend_interfaces3< IAlgorithm, IProperty, IStateful >
Cextend_interfaces3< IAlgTool, IProperty, IStateful >
Cextend_interfaces3< IService, IProperty, IStateful >
CIPublishSvc	Definition of the IPublishSvc interface, which publishes Gaudi 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
Cextend_interfaces3< IRndmEngine, ISerialize, IIncidentListener >
Cextend_interfaces3< IRndmGenSvc, IRndmEngine, ISerialize >
►CIRndmGen	Definition of a interface for a generic random number generators
►Cextend_interfaces1< IRndmGen >
►Cimplements1< IRndmGen >
►CRndmGen	Random Generator definition
CHepRndm::Generator< TYPE >
CHepRndm::Generator< Rndm::DefinedPdf >
►CIRunable	Runable interface definition
►Cextend_interfaces1< IRunable >
Cextends1< Service, IRunable >
►CISelectStatement	A select statement can either contain
►Cextend_interfaces1< ISelectStatement >
►Cimplements1< ISelectStatement >
►CSelectStatement	Class of a selection statement
CNTuple::Selector	NTuple Selector class
►CISerialize	Object serialization interface definition
Cextend_interfaces3< IRndmEngine, ISerialize, IIncidentListener >
Cextend_interfaces3< IRndmGenSvc, IRndmEngine, ISerialize >
CIStagerSvc
►CIStateful	Interface for classes that implement the Gaudi State Machine
Cextend_interfaces3< IAlgorithm, IProperty, IStateful >
Cextend_interfaces3< IAlgTool, IProperty, IStateful >
Cextend_interfaces3< IService, IProperty, IStateful >
Cextend_interfaces4< IAppMgrUI, IEventProcessor, IService, IStateful >
►CIComponentManager
►Cextend_interfaces1< IComponentManager >
►Cimplements1< IComponentManager >
►CCommonMessaging< implements1< IComponentManager > >
►CComponentManager	Base class for a component manager
►Cextends1< ComponentManager, IAlgManager >
CAlgorithmManager	In charge of the creation of concrete instances of Algorithms
►Cextends2< ComponentManager, ISvcManager, ISvcLocator >
CServiceManager	In charge of the creation of concrete instances of Services
►CIAlgManager	The IAlgManager is the interface implemented by the Algorithm Factory in the Application Manager to support management functions
►Cextend_interfaces1< IAlgManager >
Cextends1< ComponentManager, IAlgManager >
►CISvcManager	The ISvcManager is the interface implemented by the Service Factory in the Application Manager to support management functions
►Cextend_interfaces2< ISvcManager, ISvcLocator >
Cextends2< ComponentManager, ISvcManager, ISvcLocator >
►CIStatSvc	"Stat"-related part of interface IChronoStatSvc
Cextend_interfaces3< IService, IChronoSvc, IStatSvc >
►CISvcLocator	The ISvcLocator is the interface implemented by the Service Factory in the Application Manager to locate services in the framework
►Cextend_interfaces1< ISvcLocator >
►Cimplements1< ISvcLocator >
CGaudi::BootSvcLocator	A dual-stage boostrap mechanism is used to ensure an orderly startup of the ApplicationMgr
Cextend_interfaces2< ISvcManager, ISvcLocator >
►CIToolSvc	The interface implemented by the IToolSvc base class
►Cextend_interfaces1< IToolSvc >
Cextends1< Service, IToolSvc >
CIUpdateableIF
CIUpdateManagerSvc	Interface class to the Update Manager service
►CIIODataManager
►Cextend_interfaces1< IIODataManager >
Cextends1< Service, IIODataManager >
►CIncident	Base class for all Incidents (computing events)
CContextIncident< T >
CFileIncident	This class is the FileIncident
►CModuleIncident	Base class for Module-related incident
CModuleLoadedIncident	Fired when a module (DLL) is loaded
CGaudi::Parsers::IncludedFiles
CIndefiniteIntegral
CIntegration	Collection of common types for classes NumericalIndefiniteIntegral and NumericalDefiniteIntegral
CGaudiPython::Interface< TYPE >	Minor mofidication of original Pere's structure GaudiPython::Interface This helper class is nesessary to perform C++ castings from python
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
CinterfaceMatch< T >	Helper class for the cast used in the MPL for_each algorithm in the implementation of queryInterface
►CINTuple	NTuple interface class definition
CNTuple::Tuple	Abstract base class which allows the user to interact with the actual N tuple implementation
►CINTupleItem	NTuple interface class definition
►CNTuple::_Data< bool >
CNTuple::_Item< bool >
►CNTuple::_Data< IOpaqueAddress * >
CNTuple::_Item< IOpaqueAddress * >
►CNTuple::_Data< TYP >	Abstract class describing basic data in an Ntuple
►CNTuple::_Array< TYP >	Abstract class describing a column-array in a N tuple
CNTuple::_ArrayImp< TYP >	Concrete class discribing a column-array in a N tuple
►CNTuple::_DataImp< TYP >	Concrete class discribing basic data items in an N tuple
CNTuple::_ArrayImp< TYP >	Concrete class discribing a column-array in a N tuple
CNTuple::_ItemImp< TYP >	Concrete class discribing a column in a N tuple
CNTuple::_MatrixImp< TYP >	Concrete class discribing a matrix column in a N tuple
►CNTuple::_Item< TYP >	Abstract class describing a column in a N tuple
CNTuple::_ItemImp< TYP >	Concrete class discribing a column in a N tuple
►CNTuple::_Matrix< TYP >	Abstract class describing a matrix column in a N tuple
CNTuple::_MatrixImp< TYP >	Concrete class discribing a matrix column in a N tuple
CSystem::IO_COUNTERS	Process I/O Counters NtQueryInformationProcess using ProcessIoCounters
CIoComponentMgr::IoComponentEntry
CIo::IoFlags
CIIoComponentMgr::IoMode
►CIOpaqueAddress	Opaque address interface definition
►CGenericAddress	Generic Transient Address
CGaudi::RootAddress	Description:
CRootHistCnv::RootObjAddress
►CIProfile1D
CGaudi::Generic1D< AIDA::IProfile1D, TProfile >
►CIProfile2D
CGaudi::Generic2D< AIDA::IProfile2D, TProfile2D >
►CIRegistry	The IRegistry represents the entry door to the environment any data object residing in a transient data store is embedded
CDataSvcHelpers::RegistryEntry	Definition of an entry in the transient data store
CIssueSeverity
CTuples::ItemStore< VALUE >	Simple class, which represents the local storage of N-tuple items of the given type
►CIUpdateable	Object update interface definition
CIUpdateableIF
CIUpdateableInterface	Component interface counterpart to the above ABC
CIValidity	Interface for objects with a validity
►CIInspector::IValue
CIInspector::_V< T >
►CIVersHistoryObj	Interface for Versioned History Objects
CAlgorithmHistory	AlgorithmHistory class definition
CAlgToolHistory	AlgToolHistory class definition
CJobHistory	JobHistory class definition
CServiceHistory	ServiceHistory class definition
CGaudiKernel.ProcessJobOptions.JobOptsParser
CSystem::KERNEL_USER_TIMES	Process/Thread System and User Time NtQueryInformationProcess using ProcessTimes NtQueryInformationThread using ThreadTimes
►Ckey_compare
CGaudiUtils::VectorMap< KEY, VALUE, KEYCOMPARE, ALLOCATOR >::_compare_type	The actual structure used to compare the elements Only "key" is important for comparison
CContainers::key_traits< KEY >	Key traits class
►CContainers::key_traits< DATATYPE::key_type >
CContainers::traits< CONTAINER, DATATYPE >	Container traits class
CGaudiDict::KeyedContainerDict< T >
CGaudiDict::KeyedObjectDict< T >
CContainers::KeyedObjectManager< SETUP >	KeyedObjectManager Class to manage keyed objects
CDataOnDemandSvc::Leaf
CStoreSnifferAlg::LeafInfo
CLinkManager::Link	Embedded class defining a symbolic link Note: No copy constructor; bitwise copy (done by the compiler) is just fine
CLinkManager	A LinkManager is the object aggregated into a DataObject, which is responsible for the handling of non-tree like links
Clinux_proc
►Clist
►CGaudiKernel.GaudiHandles.GaudiHandleArray
CGaudiKernel.GaudiHandles.PrivateToolHandleArray
CGaudiKernel.GaudiHandles.PublicToolHandleArray
CGaudiKernel.GaudiHandles.ServiceHandleArray
CIncidentSvc::Listener
CGaudi::Utils::LockedChrono	Helper object, useful for measurement of CPU-performance of highly-recursive structures, e.g
Cinstall.LogFile
CGaudi::PluginService::Details::Logger	Simple logging class, just to provide a default implementation
CGaudi::Math::Lomont< TYPE >	The equality comparison of double numbers using as the metric the maximal number of Units in the Last Place (ULP)
CGaudiMP.pTools.LumiFSR
Cboost::spirit::qi::make_primitive< repository::qi::tag::iter_pos, Modifiers >
CContainers::map
►CGaudi::Utils::MapBase	Helper base-class to allow the generic Python-decoration for all "map-like" classes in Gaudi
►CGaudiUtils::Map< K, T, M >	Extension of the STL map
CGaudiUtils::HashMap< K, T, H, M >	Common class providing an architecture-independent hash map
CGaudiUtils::HashMap< const void *, EntryType >
CGaudiUtils::HashMap< Gaudi::StringKey, Leaf >
CGaudiUtils::HashMap< Gaudi::StringKey, ListenerList * >
CGaudiUtils::HashMap< Gaudi::StringKey, Node >
CGaudiUtils::HashMap< long, void * >
CGaudiUtils::HashMap< std::string, Address * >
CGaudiUtils::HashMap< std::string, Bool * >
CGaudiUtils::HashMap< std::string, Char * >
CGaudiUtils::HashMap< std::string, Double * >
CGaudiUtils::HashMap< std::string, FArray * >
CGaudiUtils::HashMap< std::string, Float * >
CGaudiUtils::HashMap< std::string, FMatrix * >
CGaudiUtils::HashMap< std::string, Gaudi::Utils::TypeNameString >
CGaudiUtils::HashMap< std::string, IFileAccess * >
CGaudiUtils::HashMap< std::string, Int * >
CGaudiUtils::HashMap< std::string, int >
CGaudiUtils::HashMap< std::string, LongLong * >
CGaudiUtils::HashMap< std::string, NameMap >
CGaudiUtils::HashMap< std::string, NTuple::Item< VALUE > * >
CGaudiUtils::HashMap< std::string, Short * >
CGaudiUtils::HashMap< std::string, SmartIF< IAlgorithm > >
CGaudiUtils::HashMap< std::string, SmartIF< IService > >
CGaudiUtils::HashMap< std::string, std::string >
CGaudiUtils::HashMap< std::string, UChar * >
CGaudiUtils::HashMap< std::string, UInt * >
CGaudiUtils::HashMap< std::string, ULongLong * >
CGaudiUtils::HashMap< std::string, UShort * >
CGaudiUtils::VectorMap< KEY, VALUE, KEYCOMPARE, ALLOCATOR >	A bit modified version of 'Loki::AssocVector' associative vector from Loki library by Andrei Alexandrescu
CGaudiUtils::Map< const void *, EntryType, __gnu_cxx::hash_map< const void *, EntryType, Hash< const void * > > >
CGaudiUtils::Map< Gaudi::StringKey, Leaf, __gnu_cxx::hash_map< Gaudi::StringKey, Leaf, Hash< Gaudi::StringKey > > >
CGaudiUtils::Map< Gaudi::StringKey, ListenerList *, __gnu_cxx::hash_map< Gaudi::StringKey, ListenerList *, Hash< Gaudi::StringKey > > >
CGaudiUtils::Map< Gaudi::StringKey, Node, __gnu_cxx::hash_map< Gaudi::StringKey, Node, Hash< Gaudi::StringKey > > >
CGaudiUtils::Map< InterfaceID, SmartIF< IInterface > >
CGaudiUtils::Map< long, void *, __gnu_cxx::hash_map< long, void *, Hash< long > > >
CGaudiUtils::Map< std::string, Address *, __gnu_cxx::hash_map< std::string, Address *, Hash< std::string > > >
CGaudiUtils::Map< std::string, Bool *, __gnu_cxx::hash_map< std::string, Bool *, Hash< std::string > > >
CGaudiUtils::Map< std::string, Char *, __gnu_cxx::hash_map< std::string, Char *, Hash< std::string > > >
CGaudiUtils::Map< std::string, Double *, __gnu_cxx::hash_map< std::string, Double *, Hash< std::string > > >
CGaudiUtils::Map< std::string, FArray *, __gnu_cxx::hash_map< std::string, FArray *, Hash< std::string > > >
CGaudiUtils::Map< std::string, Float *, __gnu_cxx::hash_map< std::string, Float *, Hash< std::string > > >
CGaudiUtils::Map< std::string, FMatrix *, __gnu_cxx::hash_map< std::string, FMatrix *, Hash< std::string > > >
CGaudiUtils::Map< std::string, Gaudi::Utils::TypeNameString, __gnu_cxx::hash_map< std::string, Gaudi::Utils::TypeNameString, Hash< std::string > > >
CGaudiUtils::Map< std::string, IFileAccess *, __gnu_cxx::hash_map< std::string, IFileAccess *, Hash< std::string > > >
CGaudiUtils::Map< std::string, Int *, __gnu_cxx::hash_map< std::string, Int *, Hash< std::string > > >
CGaudiUtils::Map< std::string, int, __gnu_cxx::hash_map< std::string, int, Hash< std::string > > >
CGaudiUtils::Map< std::string, LongLong *, __gnu_cxx::hash_map< std::string, LongLong *, Hash< std::string > > >
CGaudiUtils::Map< std::string, NameMap, __gnu_cxx::hash_map< std::string, NameMap, Hash< std::string > > >
CGaudiUtils::Map< std::string, NTuple::Item< VALUE > *, __gnu_cxx::hash_map< std::string, NTuple::Item< VALUE > *, Hash< std::string > > >
CGaudiUtils::Map< std::string, Short *, __gnu_cxx::hash_map< std::string, Short *, Hash< std::string > > >
CGaudiUtils::Map< std::string, SmartIF< IAlgorithm >, __gnu_cxx::hash_map< std::string, SmartIF< IAlgorithm >, Hash< std::string > > >
CGaudiUtils::Map< std::string, SmartIF< IService >, __gnu_cxx::hash_map< std::string, SmartIF< IService >, Hash< std::string > > >
CGaudiUtils::Map< std::string, std::string >
CGaudiUtils::Map< std::string, std::string, __gnu_cxx::hash_map< std::string, std::string, Hash< std::string > > >
CGaudiUtils::Map< std::string, UChar *, __gnu_cxx::hash_map< std::string, UChar *, Hash< std::string > > >
CGaudiUtils::Map< std::string, UInt *, __gnu_cxx::hash_map< std::string, UInt *, Hash< std::string > > >
CGaudiUtils::Map< std::string, ULongLong *, __gnu_cxx::hash_map< std::string, ULongLong *, Hash< std::string > > >
CGaudiUtils::Map< std::string, UShort *, __gnu_cxx::hash_map< std::string, UShort *, Hash< std::string > > >
CGaudiUtils::VectorMap< const INamedInterface *, int >
CNTuple::Matrix< IOpaqueAddress * >
CMEMORY_MAPPED_FILE
CMessage	The Message class
CGaudi::Parsers::Messages
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
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::Parsers::NodeOperations
CNTupleItems	NTupleItems namespace parts definition This header file is not intended to be included by the public! It's only used for the ntuple service
CRndm::Numbers	Random number accessor This small class encapsulates the use of the random number generator
►Cobject
CGaudi._ConfigurablesModule	Small class that allows to access all the configurables as attributes of the instance
CGaudi.Main.BootstrapHelper
CGaudi.Main.BootstrapHelper.AppMgr
CGaudi.Main.BootstrapHelper.Property
CGaudi.Main.BootstrapHelper.StatusCode
CGaudi.Main.gaudimain
►CGaudiKernel.Configurable.Configurable
CGaudiKernel.Configurable.ConfigurableAlgorithm
CGaudiKernel.Configurable.ConfigurableAlgTool
CGaudiKernel.Configurable.ConfigurableAuditor
CGaudiKernel.Configurable.ConfigurableGeneric
CGaudiKernel.Configurable.ConfigurableService
►CGaudiKernel.Configurable.ConfigurableUser
CGaudi.Configuration.GaudiPersistency
CGaudiKernel.Configurable.DummyDescriptor	Classes for generic Gaudi component ===========
CGaudiKernel.Configurable.PropertyReference	Allow references to options as in old style
CGaudiKernel.ConfigurableDb._Singleton
►CGaudiKernel.GaudiHandles.GaudiHandle
CGaudiKernel.GaudiHandles.PrivateToolHandle
CGaudiKernel.GaudiHandles.PublicToolHandle
CGaudiKernel.GaudiHandles.ServiceHandle
►CGaudiKernel.PropertyProxy.PropertyProxy
►CGaudiKernel.PropertyProxy.GaudiHandlePropertyProxyBase
CGaudiKernel.PropertyProxy.GaudiHandleArrayPropertyProxy
CGaudiKernel.PropertyProxy.GaudiHandlePropertyProxy
CGaudiMP.GMPBase.Coord
CGaudiMP.GMPBase.EventCommunicator
►CGaudiMP.GMPBase.GMPComponent
CGaudiMP.GMPBase.Reader
CGaudiMP.GMPBase.Subworker
CGaudiMP.GMPBase.Worker
CGaudiMP.GMPBase.Writer
CGaudiMP.GMPBase.MiniWriter
CGaudiMP.GMPBase.TESSerializer
CGaudiMP.IoRegistry.IoRegistry
CGaudiMP.Parallel.SshSession
CGaudiMP.Parallel.Statistics
CGaudiMP.Parallel.Task
CGaudiMP.Parallel.WorkManager
CGaudiMP.pTools.Syncer
CGaudiMP.pTools.SyncMini
►CGaudiPython.Bindings.InterfaceCast
CGaudiPython.Bindings.Interface
►CGaudiPython.Bindings.iProperty
►CGaudiPython.Bindings.iAlgorithm
CGaudiPython.GaudiAlgs.GaudiAlgo	Base class for all algorithm Python-image of C++ clkass GaudiAlgorithm
CGaudiPython.GaudiAlgs.HistoAlgo	The base class for easy histogramming
CGaudiPython.GaudiAlgs.TupleAlgo	The base class for easy manupulations with N-Tuples
CGaudiPython.Bindings.iAlgTool
►CGaudiPython.Bindings.iService
CGaudiPython.Bindings.AppMgr
►CGaudiPython.Bindings.iDataSvc
CGaudiPython.Bindings.iHistogramSvc
CGaudiPython.Bindings.iNTupleSvc
CGaudiPython.Bindings.iEventSelector
CGaudiPython.Bindings.iJobOptSvc
CGaudiPython.Bindings.iToolSvc
CGaudiPython.Bindings.PropertyEntry
CGaudiPython.GaudiAlgs.objectmethod
CGaudiPython.GaudiAlgs.TupleDecColumnDispatcher
CGaudiPython.Persistency.FileDescription
►CGaudiPython.Persistency.PersistencyHelper
CGaudiPython.Persistency.RootPersistency
Cgaudirun.FakeModule
►CGaudiTesting.BaseTest.BaseTest
CGaudiTesting.QMTTest.QMTTest
Clocker.LockFile	Lock a file
Crun_qmtest.Options
Cvalidate_patch.PatchData
Cvalidate_patch.TempDir
CSmartDataObjectPtr::ObjectFinder	Helper class to configure smart pointer functionality
CSmartDataObjectPtr::ObjectLoader	Helper class to configure smart pointer functionality
CIToolSvc::Observer	Allow call-backs when a tool is a created or retrieved
CGaudi::Parsers::TupleInnerGrammar< Iterator, TupleT, N, Skipper >::Operations
CGaudi::Parsers::TupleInnerGrammar< Iterator, TupleT, 1, Skipper >::Operations
CGaudi::Parsers::MapGrammar< KeyGrammarT, ValueGrammarT >::Operations
CGaudi::Parsers::Pnt3DGrammar< Iterator, PointT, Skipper >::Operations
CGaudi::Parsers::Pnt4DGrammar< Iterator, PointT, Skipper >::Operations
CGaudi::Parsers::Histo1DGrammar< Iterator, Skipper >::Operations
CReplayOutputStream::OutStreamAdder	Helper class to fill the internal map of OutputStreams
CReplayOutputStream::OutStreamTrigger	Helper class to call the required OutputStream
CGaudiMP.pTools.PackedCaloHypo
►CIRndmGen::Param
CRndm::Binomial	Parameters for the Binomial distributed random number generation
CRndm::Bit	Parameters for the bit value generation: returns values 0 and 1
CRndm::BreitWigner	Parameters for the BreitWigner distributed random number generation
CRndm::BreitWignerCutOff	Parameters for the BreitWigner distributed random number generation with cut off;
CRndm::Chi2	Parameters for the Chi2 distributed random number generation
CRndm::DefinedPdf	Generate a random number Generator following generally distributed random values, given a user-defined probability distribution function
CRndm::Exponential	Parameters for the Gauss random number generation
CRndm::Flat	Parameters for the flat random number generation within boundaries [minimum, maximum]
CRndm::Gamma	Parameters for the Gamma distributed random number generation
CRndm::Gauss	Parameters for the Gauss random number generation
CRndm::GaussianTail	Parameters for the Gaussian tail number generation
CRndm::Landau	Parameters for the Landau distributed random number generation
CRndm::Poisson	Parameters for the Poisson distributed random number generation with a given mean
CRndm::StudentT	Parameters for the StudentT distributed random number generation
CParticleProperty	A trivial class to hold information about a single particle properties
CSystem::PathResolver
Cpentium4_cccr_value_t	Pentium4_cccr_value_t
Cpentium4_escr_value_t
Cpfarg_ctx_t
Cpfarg_load_t
Cpfarg_msg_t
Cpfarg_ovfl_msg_t
Cpfarg_pmc_t
Cpfarg_pmd_attr_t
Cpfarg_pmd_t
Cpfarg_pmr_t
Cpfarg_set_desc_t
Cpfarg_set_info_t
Cpfarg_setdesc_t
Cpfarg_setinfo_t
Cpfarg_sinfo_t
Cpfarg_start_t
Cpfm_amd64_ctr_reg_t
Cpfm_amd64_sel_reg_t
Cpfm_core_sel_reg_t
Cpfm_coreduo_counter_t
Cpfm_coreduo_sel_reg_t
Cpfm_dfl_smpl_arg_t
Cpfm_dfl_smpl_entry_t
Cpfm_dfl_smpl_hdr_t
Cpfm_ds_area_core_t
Cpfm_ds_area_p4_t
Cpfm_gen_ia32_sel_reg_t
Cpfm_i386_p6_ctr_reg_t
Cpfm_i386_p6_sel_reg_t
Cpfm_intel_atom_sel_reg_t
Cpfm_nhm_sel_reg_t
Cpfm_pebs_core_smpl_arg_t
Cpfm_pebs_core_smpl_entry_t
Cpfm_pebs_core_smpl_hdr_t
Cpfm_pebs_nhm_smpl_entry_t
Cpfm_pebs_p4_smpl_arg_t
Cpfm_pebs_p4_smpl_entry_t
Cpfm_pebs_p4_smpl_hdr_t
Cpfm_pebs_smpl_arg_t
Cpfm_pebs_smpl_hdr_t
CPfmCodeAnalyser
Cpfmlib_amd64_counter_t
Cpfmlib_amd64_input_param_t
Cpfmlib_amd64_output_param_t
Cpfmlib_core_counter_t
Cpfmlib_core_input_param_t
Cpfmlib_core_output_param_t
Cpfmlib_core_pebs_t
Cpfmlib_coreduo_input_param_t
Cpfmlib_event_t
Cpfmlib_gen_ia32_counter_t
Cpfmlib_gen_ia32_input_param_t
Cpfmlib_gen_ia32_output_param_t
Cpfmlib_i386_p6_counter_t
Cpfmlib_i386_p6_input_param_t
Cpfmlib_i386_p6_output_param_t
Cpfmlib_input_param_t
Cpfmlib_intel_atom_counter_t
Cpfmlib_intel_atom_input_param_t
Cpfmlib_nhm_counter_t
Cpfmlib_nhm_input_param_t
Cpfmlib_nhm_lbr_t
Cpfmlib_nhm_pebs_t
Cpfmlib_options_t
Cpfmlib_output_param_t
Cpfmlib_reg_t
Cpfmlib_regmask_t
CPipeReader
CGaudiUtils::AllocatorPool::PoolChunk
CPoolDbLinkManager	Description: PoolDbLinkManager class implementation definition
CPoolDbTokenWrap	Description:
CSystem::POOLED_USAGE_AND_LIMITS	Process Pooled Quota Usage and Limits NtQueryInformationProcess using ProcessPooledUsageAndLimits
CGaudiUtils::AllocatorPool::PoolLink
CGaudi::Parsers::Position
CROOT::Math::PositionVector3D< CoordSystem, Tag >
CPOSIXFileHandler
CGaudi::Parsers::PragmaOptions
►Cprimitive_parser
Cboost::spirit::repository::qi::iter_pos_parser
CGaudiAlg::Print	Collection of useful utilities to print IHistogram1D (currently used for implementation of class GaudiHistoAlg and class GaudiHistoTool)
CGaudiAlg::Print1D	Collection of useful utilities to print IHistogram1D (currently used for implementation of class GaudiHistoAlg and class GaudiHistoTool)
CGaudiAlg::Print1DProf	Collection of useful utilities to print IProfile1D (currently used for implementation of class GaudiHistoAlg and class GaudiHistoTool)
CGaudiAlg::Print2D	Collection of useful utilities to print IHistogram1D (currently used for implementation of class GaudiHistoAlg and class GaudiHistoTool)
CGaudiAlg::Print2DProf	Collection of useful utilities to print IProfile2D (currently used for implementation of class GaudiHistoAlg and class GaudiHistoTool)
CGaudiAlg::Print3D	Collection of useful utilities to print IHistogram1D (currently used for implementation of class GaudiHistoAlg and class GaudiHistoTool)
CGaudiPython::Printer< TYPE >
CGaudiPython::Printer< ContainedObject >
CGaudiPython::Printer< DataObject >
CICounterSvc::Printout	Print counters for each element in the range [first, last) e.g
CGaudiAlg::PrintStat	Collection of useful utilities to print StatEntity (currently used for implementation of class GaudiAlgorithm and class GaudiTool)
CGaudiAlg::PrintTuple	Collection of useful utilities to print INTuple object (currently used for implementation of class GaudiTupleAlg and class GaudiTupleTool)
CSystem::PROCESS_BASIC_INFORMATION
CSystem::ProcessDescriptor	Provides access to process information
CSystem::ProcessDescriptor::ProcessHandle
CSystem::ProcessTime	Simple class to hold the time information of a process
CprocInfo
CProcStats
CGaudi::Parsers::Property
►CProperty	Property base class allowing Property* collections to be "homogeneous"
CGaudiHandleArrayProperty
CGaudiHandleProperty
CPropertyList	List of properties
►CPropertyWithValue< TYPE >	Helper intermediate class which represent partly implemented property with value of concrete type
►CPropertyWithVerifier< TYPE, VERIFIER >	Helper intermediate class which represent partly implemented property with value of concrete type and concrete verifier
CSimpleProperty< TYPE, VERIFIER >	SimpleProperty concrete class which implements the full Property interface
CSimplePropertyRef< TYPE, VERIFIER >	SimplePropertyRef templated class
►CPropertyWithValue< bool >
►CPropertyWithVerifier< bool, BoundedVerifier< bool > >
CSimpleProperty< bool >
►CPropertyWithValue< double >
►CPropertyWithVerifier< double, BoundedVerifier< double > >
CSimpleProperty< double >
►CPropertyWithValue< int >
►CPropertyWithVerifier< int, BoundedVerifier< int > >
CSimpleProperty< int >
►CPropertyWithValue< std::string >
►CPropertyWithVerifier< std::string, BoundedVerifier< std::string > >
►CSimpleProperty< std::string >
CCommandProperty	Command property base class (abstract)
►CPropertyWithValue< std::vector< std::string > >
►CPropertyWithVerifier< std::vector< std::string >, BoundedVerifier< std::vector< std::string > > >
CSimpleProperty< std::vector< std::string > >
►CPropertyWithValue< unsigned int >
►CPropertyWithVerifier< unsigned int, BoundedVerifier< unsigned int > >
CSimpleProperty< unsigned int >
►CPropertyCallbackFunctor
CPropertyCallbackMemberFunctor< T >
CPropertyCallbackPointerFunctor
CGaudi::Parsers::PropertyName
CGaudi::Utils::PropertyTypeTraits< TYPE >	Helper structure to define the types for properties
CGaudi::Utils::PropertyTypeTraits< boost::array< T, N > >	Specialization of property-traits for class boost::array to take care the non-trivial assignements and constructors for this class
CGaudi::Utils::PropertyTypeTraits< char(&)[N]>	Specialisation for C-strings
CGaudi::Utils::PropertyTypeTraits< const T(&)[N]>	Specialiation for const-arrays
CGaudi::Utils::PropertyTypeTraits< std::array< T, N > >	Specialization of property-traits for class std::array to take care the non-trivial assignements and constructors for this class
►CGaudi::Utils::PropertyTypeTraits< T(&)[N]>
CGaudi::Utils::PropertyTypeTraits< T[N]>	Specialization for arrays
CGaudi::Parsers::PropertyValue
►CPropertyVerifier< T >	Templated Verifier base class
CBoundedVerifier< T >
CNullVerifier< T >	Default, always true verifier
►CPropertyVerifier< bool >
CBoundedVerifier< bool >
►CPropertyVerifier< double >
CBoundedVerifier< double >
►CPropertyVerifier< int >
CBoundedVerifier< int >
►CPropertyVerifier< std::string >
CBoundedVerifier< std::string >
►CPropertyVerifier< std::vector< std::string > >
CBoundedVerifier< std::vector< std::string > >
►CPropertyVerifier< T[N]>
CBoundedVerifier< T[N]>	Specialization of Bounded verifier for for C-arrays
►CPropertyVerifier< unsigned int >
CBoundedVerifier< unsigned int >
CDataOnDemandSvc::Protection	Helper class of the DataOnDemandSvc
►CPyAlgorithm
CAnalysisInit.PhysAnalAlg
►CPyAlgorithm
CTest.PhysAnalAlg
CGaudiMP::PyROOTPickle
CIUpdateManagerSvc::PythonHelper	Helper class implemented in the python dictionary to allow access from python to template member functions
CSystem::QUOTA_LIMITS	Process Quotas NtQueryInformationProcess using ProcessQuotaLimits NtQueryInformationProcess using ProcessPooledQuotaLimits NtSetInformationProcess using ProcessQuotaLimits
CNTuple::Range< TYP >	Class defining a range
CNTuple::Range< bool >
►CGaudi::RangeBase_	Helper class to simplify the dealing with ranges in Python
►CGaudi::Range_< CONTAINER >	Useful class for representation of "sequence" of the objects through the range of valid iterators
CGaudi::NamedRange_< TYPE >
CGaudi::Range_< TYPE >
CGaudiUtils::Allocator< Type >::rebind< U >
CGaudiRoot::RefAccessor
CGaudiTesting.BaseTest.ReferenceFileValidator
CGaudiTest.ReferenceFileValidator
CGaudi::PluginService::Details::Registry	In-memory database of the loaded factories
CGaudi::Parsers::MapGrammar< KeyGrammarT, ValueGrammarT >::Operations::result< A, B, C, D >
CGaudi::Parsers::Histo1DGrammar< Iterator, Skipper >::Operations::result< A, B, C, D >
CGaudi::Parsers::NodeOperations::result< A, B, C, D >
CGaudiTesting.BaseTest.Result
CGaudi::Parsers::TupleInnerGrammar< Iterator, TupleT, 1, Skipper >::Operations::result< A, B, C, D >
CGaudi::Parsers::TupleInnerGrammar< Iterator, TupleT, N, Skipper >::Operations::result< A, B, C, D >
CGaudi::Parsers::Pnt3DGrammar< Iterator, PointT, Skipper >::Operations::result< A, B, C, D >
CGaudi::Parsers::Pnt4DGrammar< Iterator, PointT, Skipper >::Operations::result< A, B, C, D >
CRootHistCnv::RootCompressionSettings	Simple class to decode a ROOT compression settings string, of the form '<Alg>:<level>' into the integer code to pass to ROOT
CRootConnectionSet	Class describing the setup parameters of a ROOT data connection
CGaudi::RootConnectionSetup
CRootFileHandler
CGaudi::RootNTupleDescriptor	Description:
CGaudi::RootObjectRefs	Persistent reference object containing all leafs and links corresponding to a Gaudi DataObject
CGaudi::RootRef	Persistent reference object
►CRuntimeError
CGaudiKernel.Configurable.Error
CGaudiKernel.ProcessJobOptions.ParserError
►CGaudiPython.Persistency.PersistencyError
CGaudiPython.Persistency.UnknownPersistency
CZipPythonDir.ZipdirError	Class for generic exception coming from the zipdir() function
CS_module
CStatusCode::ScopedDisableChecking	Simple RAII class to ignore unchecked StatusCode instances in a scope
CGaudi::Parsers::KeyValueGrammar< Iterator, Skipper >::second
CGaudi::Parsers::PairGrammar< KeyGrammarT, ValueGrammarT >::second
CPersistencySvc::ServiceEntry
CServiceManager::ServiceItem
CServiceLocatorHelper	Helper to share the implementation of service() among the various kernel base classes $Id:
►CSmartDataObjectPtr	A small class used to access easily (and efficiently) data items residing in data stores
CSmartDataStorePtr< TYPE, LOADER >	A small class used to access easily (and efficiently) data items residing in data stores
►CSmartDataStorePtr< TYPE, SmartDataObjectPtr::ObjectLoader >
CSmartDataLocator< TYPE >	A small class used to access easily (and efficiently) data items residing in data stores
CSmartDataPtr< TYPE >	A small class used to access easily (and efficiently) data items residing in data stores
CSmartIF< TYPE >	Small smart pointer class with automatic reference counting for IInterface
CSmartIF< Gaudi::Gaudi::ISignalMonitor >
CSmartIF< Gaudi::IFileCatalog >
CSmartIF< IAddressCreator >
CSmartIF< IAlgContextSvc >
CSmartIF< IAlgManager >
CSmartIF< IAlgorithm >
CSmartIF< IAppMgrUI >
CSmartIF< IAuditorSvc >
CSmartIF< IChronoStatSvc >
CSmartIF< IComponentManager >
CSmartIF< IConversionSvc >
CSmartIF< IDataManagerSvc >
CSmartIF< IDataProviderSvc >
CSmartIF< IEventProcessor >
CSmartIF< IEvtSelector >
CSmartIF< IExceptionSvc >
CSmartIF< IHistogramSvc >
CSmartIF< IIncidentListener >
CSmartIF< IIncidentSvc >
CSmartIF< IInterface >
CSmartIF< IJobOptionsSvc >
CSmartIF< IMessageSvc >
CSmartIF< IMonitorSvc >
CSmartIF< INTupleSvc >
CSmartIF< IPartitionControl >
CSmartIF< IProperty >
CSmartIF< IRndmGenSvc >
CSmartIF< IRunable >
CSmartIF< IService >
CSmartIF< IStateful >
CSmartIF< ISvcLocator >
CSmartIF< ISvcManager >
CSmartIF< IToolSvc >
CSmartRef< TYPE >	Kernel objects: SmartRef
CSmartRef< ContainedObject >
CSmartRef< DataObject >
CSmartRef< Event >
CSmartRef< KeyType >
CSmartRef< MyTrack >
CSmartRef< MyVertex >
CSmartRefArray< TYPE >
CSmartRefBase	User example objects: SmartRefBase
CSmartRefList< TYPE >
CSmartRefMap< TYPE >
CGenfun::GaudiMathImplementation::SplineBase
CIntelProfilerAuditor::stack_entity
CStat	Small wrapper class for easy manipulation with generic counters and IStatSvc&ICounterSvc interface
CStatusCodeSvc::StatCodeDat
CStatEntity	The basic counter used for Monitoring purposes
CStatic_error_check< bool >
CStatic_error_check< false >
CStatusCode	This class is used for returning status codes from appropriate routines
Cana.Step
CStreamBuffer	The stream buffer is a small object collecting object data
►CStreamHandler
CGaudiKernel.ProcessJobOptions.ConsoleHandler
CStreamLogger
►Cstringbuf
CGaudiPython::CallbackStreamBuf
CGaudi::StringKey	The helper class to represent the efficient "key" for access
►CStructure
CGaudiPluginService.cpluginsvc.Factory
CGaudiPluginService.cpluginsvc.Property
CGaudiPluginService.cpluginsvc.Registry
Cana.Summary
CSvcCatalog
CSvcFactory< T >
CGaudi::SysProcStat
CGaudi::Utils::Histos::Table	Simple class for the customizeble printout of the histogram tables
►CIInspector::Tag
CIInspector::_TT< T >
CGaudi::Parsers::MapGrammar< KeyGrammarT, ValueGrammarT >::tag_key
CGaudi::Parsers::MapGrammar< KeyGrammarT, ValueGrammarT >::tag_mapped
CMultiStoreSvc::tagROOT
►CTClassStreamer
CGaudiRoot::IOHandler< T >
CGaudiTest.TempDir
CGaudiTest.TempFile
CGaudiTest.TemporaryEnvironment	Utility Classes
CTHistSvc::THistID
CThreadGaudi	Singleton mapping the pthread ID to the Gaudi thread ID
CGaudi::Time	Based on seal::Time
CTimerForSequencer	Auxilliary class
CGaudi::TimeSpan	Based on seal::TimeSpan
Cpool::Token	Shadow class to mimik POOL tokens
CTokenizer::Token	Definition of the sub-class Token
CTokenizer	STL Include files
►CGaudi::RootDataConnection::Tool	Helper class to facilitate an abstraction layer for reading POOL style files with this package
CGaudi::PoolTool
CGaudi::RootTool	Description:
CToolFactory< T >
►CToolHandleInfo	General info and helper functions for toolhandles and arrays
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
►Ctrue_
Cboost::spirit::use_terminal< qi::domain, repository::qi::tag::iter_pos >
CTuples::Tuple	A simple wrapper class over standard Gaudi NTuple::Tuple facility
CGaudi::Parsers::tuple_get_first_type< T >
CGaudi::Parsers::tuple_get_first_type< std::tuple< T, Ts...> >
CGaudi::Parsers::tuple_remove_first_type< T >
CGaudi::Parsers::tuple_remove_first_type< std::tuple< T, Ts...> >
CGaudiPython::TupleAlgDecorator	Simple class to perform the "decoration" of Tuples in Python/ROOT
CTuples::TupleColumn< ITEM >	Helper class which allows to extend the functionality of Tuple with possibility to use your own representation of complex objects
CGaudiPython::TupleDecorator	Simple class which performs the decoration of the standard N-Tuple
CTuples::TupleItem< ITEM >
►CTuples::TupleObj	A simple wrapper class over standard Gaudi NTuple::Tuple facility
CTuples::detail::TupleObjImp< HANDLER1, HANDLER2 >	The simplest concrete implementation of class TupleObj with 3 arbitrary error handlers Any types (classes, functions, etc.) which supports the semantics
CGaudi::Utils::TuplePrinter< Tuple, N >
CGaudi::Utils::TuplePrinter< Tuple, 1 >
CGaudiPython::TupleToolDecorator	Simple class to perform the "decoration" of Tuples in Python/ROOT
►Ctype
CGaudiKernel.ConfigurableMeta.ConfigurableMeta	This metaclass installs PropertyProxy descriptors for Gaudi properties
CGaudi::Utils::TypeNameString	Helper class to parse a string of format "type/name"
CUCharDbArray	Shadow class to mimik POOL blobs
►Cunary_function
CConversionSvc::CnvTest
CDirSearchPath::eqPath	Name
CFindByMassRange	The function object must be derived from std::unary_function< IParticlePropertySvc::value_type ,bool > IParticlePropertySvc::value_type is a typedef that defines the internal service storage type that is returned when an iterator is dereferenced
CGaudi::Parsers::Property::Equal
CGaudiPython::_identity< TYPE >	It is here due to 'missing'(?) std::identity
CGaudiPython::Interface< IInterface >
CGaudiUtils::GenericHash< T >	Generic hash implementation (for easy migration to the new Hash class)
►CGaudiUtils::Hash< T >	Simple hash function
CGaudiUtils::Hash< const T & >	Remove extra qualifiers:
CGaudiUtils::Hash< const T >	Remove extra qualifiers:
CGaudiUtils::Hash< T & >	Remove extra qualifiers:
CGaudiUtils::Hash< const T(&)[N]>	Generic specialization for arrays
►CGaudiUtils::Hash< T * >	Partial specialization for pointers
CGaudiUtils::Hash< const T * >	Remove extra qualifiers:
CGaudiUtils::Hash< T(&)[N]>	Generic specialization for arrays
CTuples::_TupAdapter< OBJECT, ARGUMENT, RESULT >	Trivial adapter to avoid the GCC problem (pointer to the function is never evaluated as "const TYPE&" )
CGaudi::Parsers::Units
CGaudi::Parsers::NodeOperations::value
►Cstd::vector< T >	STL class
CSmartRefVector< TYPE >	Kernel objects: SmartRefVector
CSmartRefVector< MyTrack >
CContainers::vector
CSystem::VM_COUNTERS	Process Virtual Memory Counters NtQueryInformationProcess using ProcessVmCounters
CWatchdogThread	Simple class for asynchronous check of time-out
CConversionSvc::WorkerEntry
►CBASE
CCommonMessaging< BASE >	Templated class to add the standard messaging functionalities
Cextends1< BASE, I1 >	Base class used to extend a class implementing other interfaces
Cextends2< BASE, I1, I2 >	Base class used to extend a class implementing other interfaces
Cextends3< BASE, I1, I2, I3 >	Base class used to extend a class implementing other interfaces
►CExecTestBase
CGaudiTest.GaudiExeTest
►CHTMLParser
Cvalidate_patch.SavannahParser	Parse the
►CI1
►Cextend_interfaces1< I1 >	Base class to be used to extend an interface
Cextends1< BASE, I1 >	Base class used to extend a class implementing other interfaces
Cimplements1< I1 >	Base class used to implement the interfaces
►Cextend_interfaces2< I1, I2 >	Base class to be used to extend an interface
Cextends2< BASE, I1, I2 >	Base class used to extend a class implementing other interfaces
Cimplements2< I1, I2 >	Base class used to implement the interfaces
►Cextend_interfaces3< I1, I2, I3 >	Base class to be used to extend an interface
Cextends3< BASE, I1, I2, I3 >	Base class used to extend a class implementing other interfaces
Cimplements3< I1, I2, I3 >	Base class used to implement the interfaces
►Cextend_interfaces4< I1, I2, I3, I4 >	Base class to be used to extend an interface
Cimplements4< I1, I2, I3, I4 >	Base class used to implement the interfaces
►CI2
Cextend_interfaces2< I1, I2 >	Base class to be used to extend an interface
Cextend_interfaces3< I1, I2, I3 >	Base class to be used to extend an interface
Cextend_interfaces4< I1, I2, I3, I4 >	Base class to be used to extend an interface
►CI3
Cextend_interfaces3< I1, I2, I3 >	Base class to be used to extend an interface
Cextend_interfaces4< I1, I2, I3, I4 >	Base class to be used to extend an interface
►CI4
Cextend_interfaces4< I1, I2, I3, I4 >	Base class to be used to extend an interface
►CIAnnotation
CAIDA::Annotation	Implementation of the AIDA IAnnotation interface class
►CIHistogram2D
CGaudi::Generic2D< IHistogram2D, TH2D >
►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
►CPBASE
CGaudiCommon< PBASE >	Implements the common functionality between GaudiTools and GaudiAlgorithms
CGaudiHistos< PBASE >	Templated base class providing common histogramming methods for GaudiAlgorithm and GaudiTool like classes
CGaudiTuples< PBASE >	Templated base class providing common 'ntupling' methods
►CResultStream
CGaudiTest.HTMLResultStream
CGaudiTest.XMLResultStream