| # Gaudi Framework, version v22r2 |

Home |  | Generated: Tue May 10 2011

# Class List

Here are the classes, structs, unions and interfaces with brief descriptions:

__longlong |
NTuple::_Accessor< TYP > | Class acting as a smart pointer holding a N tuple entry
NTuple::_Array< TYP > | Abstract class describing a column-array in a N tuple
NTuple::_ArrayImp< TYP > | Concrete class discribing a column-array in a N tuple
ConfigurableDb::_CfgDb |
GaudiUtils::VectorMap< KEY, VALUE, KEYCOMPARE, ALLOCATOR >::_compare_type | The actual structure used to compare the elements Only "key" is important for comparison
Gaudi::_ConfigurablesModule | Small class that allows to access all the configurables as attributes of the instance
NTuple::_Data< TYP > | Abstract class describing basic data in an Ntuple
NTuple::_DataImp< TYP > | Concrete class discribing basic data items in an N tuple
Genfun::GaudiMathImplementation::NumericalDefiniteIntegral::_Function |
Genfun::GaudiMathImplementation::NumericalIndefiniteIntegral::_Function |
Gaudi::Utils::_GetType< TYPE > | Helper structure to define the proper return type for "get"-functions
Gaudi::Utils::_GetType< Gaudi::NamedRange_< CONTAINER > > | Template specialization for "named ranges"
Gaudi::Utils::_GetType< Gaudi::Range_< CONTAINER > > | Template specialization for "ranges"
Gaudi::Utils::_GetType< TYPE & > | Template specialization for references
Gaudi::Utils::_GetType< TYPE * > | Template specialization for pointers
GaudiPython::_identity< TYPE > | It is here due to 'missing'(?) std::identity
KeyedContainer< DATATYPE, MAPPING >::_InsertRelease | Internal functor for insertion of objects
NTuple::_Item< TYP > | Abstract class describing a column in a N tuple
NTuple::_ItemImp< TYP > | Concrete class discribing a column in a N tuple
NTuple::_Matrix< TYP > | Abstract class describing a matrix column in a N tuple
NTuple::_MatrixImp< TYP > | Concrete class discribing a matrix column in a N tuple
Gaudi::Parsers::_NoCaseCmp_ | Case-insensitive comparison criteria for strings
KeyedContainer< DATATYPE, MAPPING >::_RemoveRelease | Internal functor for insertion of objects
ConfigurableDb::_Singleton |
ProcessJobOptions::_TempSysPath |
IInspector::_TT< T > |
Tuples::_TupAdapter< OBJECT, ARGUMENT, RESULT > | Trivial adapter to avoid the GCC problem (pointer to the function is never evaluated as "const TYPE&" )
IInspector::_V< T > |
Genfun::GaudiMathImplementation::NumericalDefiniteIntegral::_Workspace |
Genfun::GaudiMathImplementation::NumericalIndefiniteIntegral::_Workspace |
Genfun::GaudiMathImplementation::Adapter2DoubleFunction | Constructor from the trivial function with two argument
Genfun::GaudiMathImplementation::Adapter3DoubleFunction | Constructor from the trivial function with two argument
Genfun::GaudiMathImplementation::AdapterIFunction | Constructor from the IFunction ( see AIDA/IFunction.h)
Gaudi::Utils::Aida2ROOT | Accessor to underlying ROOT-representation of transient histograms The actual code is imported from Bender project
AIDATuple |
AIDATupleSvc | AIDATupleSvc class definition
AlgContexSvc | Simple implementation of interface IAlgContextSvc for Algorithm Context Service
Gaudi::Utils::AlgContext | Helper "sentry" class to automatize the safe register/unregister the algorithm's context
AlgContextAuditor | Description: Register/Unregister the AlgContext of each algorithm before entering the algorithm and after leaving it
AlgContextSvc |
GaudiPython::AlgDecorator |
AlgErrorAuditor | Monitors the cpu time usage of each algorithm
AlgFactory< T > |
Gaudi::Utils::AlgNameSelector | The trivial selector of algorithm by type
Algorithm | Base class from which all concrete algorithm classes should be derived
GaudiSequencer::AlgorithmEntry |
AlgorithmHistory | AlgorithmHistory class definition
AlgorithmManager::AlgorithmItem |
AlgorithmManager | In charge of the creation of concrete instances of Algorithms
Gaudi::Utils::AlgSelector | Simple interface class for selection of algorithms
AlgTool | Base class from which all the concrete tool classes should be derived
AlgToolHistory | AlgToolHistory class definition
Gaudi::Utils::AlgTypeSelector< TYPE > | The trivial selector of algorithm by type
Gaudi::Utils::AlgTypeSelector< const TYPE & > |
Gaudi::Utils::AlgTypeSelector< const TYPE * > |
Gaudi::Utils::AlgTypeSelector< const TYPE > |
Gaudi::Utils::AlgTypeSelector< TYPE & > |
Gaudi::Utils::AlgTypeSelector< TYPE * > |
GaudiUtils::Allocator< Type > | Allocator
GaudiUtils::AllocatorPool | Allocator pool
AIDA::Annotation | Implementation of the AIDA IAnnotation interface class
AIDA::Annotation::AnnotationItem | Internal private annotation item class
ApMon | Data structure used for sending monitoring data to a MonaLisa module
AppendInterfaceName | Helper class for the cast used in the MPL for_each algorithm in the implementation of query_interface
ApplicationMgr | The Application Manager class
GaudiPython::Bindings::AppMgr |
AppMgrRunable | Class definition of AppMgrRunable
NTuple::Array< TYP > | Class acting as a smart pointer holding a N tuple _Item
Containers::array |
NTuple::Array< IOpaqueAddress * > |
Gaudi::Parsers::AssignBoolToStringImpl< T > |
Gaudi::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`
Auditor | Base class from which all concrete auditor classes should be derived
Gaudi::Guards::AuditorGuard | It is a simple guard, which "locks" the scope for the Auditor Service is am exception-safe way
AuditorSvc |
Gaudi::Axis | An IAxis represents a binned histogram axis
HepRndm::BaseEngine |
BaseObjectMemberFunction | Base class of ObjectMemberFunction
BasePtrSetter | Base class to set the pointer to an object of a class derived from DataObject in a generic way
GaudiTest::BasicOutputValidator | Output Validation Classes
Rndm::Binomial | Parameters for the Binomial distributed random number generation
Rndm::Bit | Parameters for the bit value generation: returns values 0 and 1
GaudiTest::BlockSkipper |
Gaudi::Parsers::BoolGrammar | The valid represenation of boolean values are:
Gaudi::BootSvcLocator | A dual-stage boostrap mechanism is used to ensure an orderly startup of the ApplicationMgr
BoundedVerifier< T > |
BoundedVerifier< T[N]> | Specialization of Bounded verifier for for C-arrays
Rndm::BreitWigner | Parameters for the BreitWigner distributed random number generation
Rndm::BreitWignerCutOff | Parameters for the BreitWigner distributed random number generation with cut off;
FileInfo::CacheItem |
FileInfo::CacheItemComparator |
GaudiPython::CallbackStreamBuf |
GaudiPython::Bindings::CallbackStreamBuf |
Gaudi::Parsers::Catalogue | Catalogue of PropertyEntry
Gaudi::Parsers::CharGrammar< RT > | The valid represenation of char values are:
check_cast< THIS > | Helper class for the cast used in the MPL for_each algorithm in the implementation of i_cast
Gaudi::Utils::CheckData< TYPE > | Helper structure for implementation of "exists"-functions for GaudiCommon<BASE>
Gaudi::Utils::CheckData< const TYPE > | Template specialization for 'const'-type
Gaudi::Utils::CheckData< Gaudi::NamedRange_< std::vector< const TYPE * > > > | Template specialization for ranges
Gaudi::Utils::CheckData< Gaudi::Range_< std::vector< const TYPE * > > > | Template specialization for ranges
Gaudi::Utils::CheckData< TYPE & > | Template specialization for reference types
Gaudi::Utils::CheckData< TYPE * > | Template specialization for pointer types
Rndm::Chi2 | Parameters for the Chi2 distributed random number generation
Chrono | A small utility class for chronometry of user codes
ChronoAuditor | Monitors the cpu time usage of each algorithm
ChronoEntity | Small helper class for implementation of ChronoStatSvc service, It also could be used as some local timer
ChronoStatSvc | The Chrono & Stat Sservice: service implements the IChronoStatSvc interface and provides the basic chronometry and some statistical counts needed by all applications
ProcStats::cleanup |
Gaudi::Parsers::ClosureGrammar< T > | Grammar or grammar rule which derive from this struct will have attribute of type `T` and name `val`
GaudiTest::CMT |
CnvFactory< T > |
ConversionSvc::CnvTest |
GaudiMP::GMPBase::CollectHistograms |
CollectionCloneAlg | Small algorithm, which allows to merge N-tuples in a generic way
CollectionMerge::CollectionMerge |
NTuple::ColumnWiseTuple |
CommandProperty | Command property base class (abstract)
CommonAuditor | Base class with common functionalities shared by few auditor implementations
CommonMessaging< BASE > | Templated class to add the standard messaging functionalities
ComparePairOfChronoEntityAndChronoTag |
ComparePairOfStatEntityAndStatTag |
ComponentManager | Base class for a component manager
configGenerator |
Configurable::Configurable |
Configurable::ConfigurableAlgorithm |
Configurable::ConfigurableAlgTool |
Configurable::ConfigurableAuditor |
Configurable::ConfigurableGeneric |
ConfigurableMeta::ConfigurableMeta | This metaclass installs PropertyProxy descriptors for Gaudi properties
Configurable::ConfigurableService |
Configurable::ConfigurableUser |
ConfURLs | Data structure which holds the configuration URLs
NTupleSvc::Connection |
ProcessJobOptions::ConsoleHandler |
Genfun::GaudiMathImplementation::Constant | Fixed constant function
StreamBuffer::ContainedLink | Definition of the contained link set
ContainedObject | All classes that their objects may be contained in an LHCb ObjectContainer (e.g
IEvtSelector::Context |
ContextIncident< T > |
ConversionSvc | Base class for all conversion services
Converter | Converter base class
ConverterID |
GaudiMP::GMPBase::Coord |
Tuples::Local::Counter |
GaudiToolLocal::Counter | Simple local counter
IgHookTrace::Counter | Nearly dummy object type to identify a counter
CounterSvc | Simple imeplementation of the abstract interface ICounterSvc
IgHookTrace::CounterValue | Value for a counter chained from a trace
DataHistory | DataHistory class definition
DataHistory::DataHistoryOrder |
DataIncident | Data service incident class
StreamBuffer::DataIO | A small base class to handle generic data streaming
DataListenerSvc | DataListenerSvc inherits from IMonitorSvc and allows the GAUDI user to monitor variables declared in an algorithm
DataObject | A DataObject is the base class of any identifiable object on any data store
DataOnDemandSvc | The DataOnDemandSvc listens to incidents typically triggered by the data service of the configurable name "IncidentName"
DataSelectionAgent | DataSelectionAgent base in charge of collecting all the refereces to DataObjects in a transient store that passes some selection criteria
DataStoreItem | Description of the DataStoreItem class
DataStreamTool |
DataSvc | Data service base class
DataSvcFileEntriesTool | Tool to scan a transient store branch that collects all the objects that belong to the same source (file)
DataTypeInfo | Small class which allows access to internal type IDs
PoolDbCnvSvc::DbH |
AlgTool::declareInterface< I > |
Decorator | Simple class with allows to "decorate" the python algorithm with 'basic' funtionality from class GaudiAlgorithm
Containers::array::decrement |
Configurable::Configurable::DefaultName | For detecting the default name
DefaultObjectCleaner< T > | Basic implementation for the object cleaner functor used by TransientFastContainer when returning a recycled object
Rndm::DefinedPdf | Generate a random number Generator following generally distributed random values, given a user-defined probability distribution function
Gaudi::Parsers::BoolGrammar::definition< ScannerT > |
Gaudi::Parsers::CharGrammar< RT >::definition< ScannerT > |
Gaudi::Parsers::IntGrammar< RT >::definition< ScannerT > |
Gaudi::Parsers::RealGrammar< RT >::definition< ScannerT > |
Gaudi::Parsers::StringGrammar::definition< ScannerT > |
Gaudi::Parsers::SkipperGrammar::definition< ScannerT > |
Gaudi::Parsers::PairGrammar< KeyGrammarT, ValueGrammarT >::definition< ScannerT > |
Gaudi::Parsers::VectorGrammar< GrammarT >::definition< ScannerT > |
Gaudi::Parsers::MapGrammar< KeyGrammarT, ValueGrammarT >::definition< ScannerT > |
Gaudi::Parsers::Pnt3DGrammar< ScalarGrammarT, POINT >::definition< ScannerT > |
Gaudi::Parsers::Pnt4DGrammar< ScalarGrammarT, POINT >::definition< ScannerT > |
Gaudi::Parsers::Histo1DGrammar::definition< ScannerT > |
Gaudi::Parsers::IdentifierGrammar::definition< ScannerT > |
Gaudi::Parsers::PropertyGrammar::definition< ScannerT > |
Gaudi::Parsers::RealUnitsGrammar::definition< ScannerT > |
Gaudi::Parsers::UnitsFileGrammar::definition< ScannerT > |
Gaudi::Parsers::ValueGrammar::definition< ScannerT > |
Gaudi::Parsers::ParserGrammar::definition< ScannerT > |
DetDataSvc | ---------------------------------------------------------------------------
DetPersistencySvc |
DHH |
NTuple::Directory | Small class representing an N tuple directory in the transient store
RootHistCnv::DirectoryCnv |
DirSearchPath | Search for files in a list of directories
DLLClassManager |
Configurable::DummyDescriptor | If isinstance(v,Configurable) and not v.isPublic(): rep += v.__str__( indent + 1 ) + os.linesep elif isinstance(v,GaudiHandleArray): for vi in v: if isinstance(vi,Configurable) and not vi.isPublic(): rep += vi.__str__( indent + 1 ) + os.linesep
HepRndm::Engine< TYPE > |
Gaudi::IODataManager::Entry |
DirSearchPath::eqPath | Name
EqSolver | The simplest concrete implementation of IEqSolver interface
EqSolver::EqSolverMisc |
Configurable::Error |
Tuples::detail::ErrorHandler< OBJECT, FUNCTION > | Concrete error handlers for dealing with classes, which supports member functions Error,Warning and Print ( e.g
ErrorTool |
EventCollectionContext |
EventCollectionSelector | Definition of class EventCollectionSelector
GaudiMP::GMPBase::EventCommunicator |
EventCounter |
EventLoopMgr | Class definition of EventLoopMgr
EventNodeKiller | Algorithm to kill nodes in the event data store
EventSelector | Definition of class EventSelector
EventSelectorDataStream | Definition of class EventSelectorDataStream
EvtCollectionStream | A small to stream Data I/O
EvtDataSvc | A EvtDataSvc is the base class for event services
EvtPersistencySvc | EvtPersistencySvc class implementation definition
EvtSelectorContext | Definition of class EventIterator
ExcelPlotter::Excel |
Gaudi::Guards::ExceptionGuard | The most simple guard - it execute the certain code withing typical "try {} catch" clause, used in Auditor, Algorithm, AlgTool, etc
ExceptionSvc | Simple implementation of IExceptionSvc abstract interface
Rndm::Exponential | Parameters for the Gauss random number generation
extend_interfaces1< I1 > | Base class to be used to extend an interface
extend_interfaces2< I1, I2 > | Base class to be used to extend an interface
extend_interfaces3< I1, I2, I3 > | Base class to be used to extend an interface
extend_interfaces4< I1, I2, I3, I4 > | Base class to be used to extend an interface
extends1< BASE, I1 > | Base class used to extend a class implementing other interfaces
extends2< BASE, I1, I2 > | Base class used to extend a class implementing other interfaces
extends3< BASE, I1, I2, I3 > | Base class used to extend a class implementing other interfaces
FastContainersSvc | Data service for objects of type TransientFastContainer
NTuple::File | Small class representing an N tuple file in the transient store
FileIncident | This class is the FileIncident
FileInfo |
GaudiTest::FilePreprocessor |
GaudiTest::FilePreprocessorSequence |
FileReadTool | Basic implementation of the IFileAccess interface
FileRecordDataSvc | A FileRecordDataSvc is the base class for event services
GaudiMP::pTools::FileRecordsAgent |
Containers::find< CONT > |
FindByMassRange | The function object must be derived from std::unary_function< IParticlePropertySvc::value_type ,bool > IParticlePropertySvc::value_type is a typedef that defines the internal service storage type that is returned when an iterator is dereferenced
Rndm::Flat | Parameters for the flat random number generation within boundaries [minimum, maximum]
FuncMinimum | The simplest concrete implementation of IFuncMinimum interface
FuncMinimum::FuncMinimumMisc |
Rndm::Gamma | Parameters for the Gamma distributed random number generation
Gaudi | This is a number of static methods for bootstrapping the Gaudi framework
GaudiPython::GaudiAlgs::GaudiAlgo | Base class for all algorithm Python-image of C++ clkass GaudiAlgorithm
GaudiAlgorithm | The useful base class for data processing algorithms
GaudiCommon< PBASE > | Implements the common functionality between GaudiTools and GaudiAlgorithms
GaudiDll |
GaudiException | Define general base for Gaudi exception
GaudiTest::GaudiExeTest |
GaudiTest::GaudiFilterExecutable |
GaudiGSL | Helper class to get (static) access to Gaudi GSL Service General users are not supposed to use it
GaudiHandle< T > | Handle to be used in lieu of naked pointers to gaudis
GaudiHandles::GaudiHandle |
GaudiHandleArray< T > | T is the concrete handle type, e.g
GaudiHandles::GaudiHandleArray |
GaudiHandleArrayBase | Base class of array's of various gaudihandles
GaudiHandleArrayProperty |
PropertyProxy::GaudiHandleArrayPropertyProxy |
GaudiHandleBase | Base class to handles to be used in lieu of naked pointers to various Gaudi components
GaudiHandleInfo |
GaudiHandleProperty |
PropertyProxy::GaudiHandlePropertyProxy |
PropertyProxy::GaudiHandlePropertyProxyBase |
GaudiHistoAlg | Simple class to extend the functionality of class GaudiAlgorithm
GaudiHistos< PBASE > | Templated base class providing common histogramming methods for GaudiAlgorithm and GaudiTool like classes
GaudiHistoTool | Simple class to extend the functionality of class GaudiTool
Gaudi::Main::gaudimain |
GaudiSequencer | Sequencer for executing several algorithms, stopping when one is faulty
GaudiTool | The useful base class for tools
GaudiTupleAlg | Simple class to extend the functionality of class GaudiHistoAlg
GaudiTuples< PBASE > | Templated base class providing common 'ntupling' methods
GaudiTupleTool | Simple class to extend the functionality of class GaudiHistoTool
Rndm::Gauss | Parameters for the Gauss random number generation
Rndm::GaussianTail | Parameters for the Gaussian tail number generation
HepRndm::Generator< TYPE > |
HepRndm::Generator< Rndm::DefinedPdf > |
Gaudi::Generic1D< INTERFACE, IMPLEMENTATION > | Common AIDA implementation stuff for histograms and profiles using ROOT implementations
Gaudi::Generic2D< INTERFACE, IMPLEMENTATION > | Common AIDA implementation stuff for histograms and profiles using ROOT implementations
Gaudi::Generic3D< INTERFACE, IMPLEMENTATION > | Common AIDA implementation stuff for histograms and profiles using ROOT implementations
GenericAddress | Generic Transient Address
GaudiUtils::GenericHash< T > | Generic hash implementation (for easy migration to the new Hash class)
Gaudi::Utils::GetData< TYPE > | Helper structure for implementation of "get"-functions for GaudiCommon<BASE>
Gaudi::Utils::GetData< const TYPE > | Template specialization for const types
Gaudi::Utils::GetData< Gaudi::NamedRange_< std::vector< const TYPE * > > > | Template specialization for named ranges
Gaudi::Utils::GetData< Gaudi::Range_< std::vector< const TYPE * > > > | Template specialization for ranges
Gaudi::Utils::GetData< TYPE & > | Template specialization for reference types
Gaudi::Utils::GetData< TYPE * > | Template specialization for pointer types
Gaudi::Utils::GetOrCreateData< TYPE, TYPE2 > | Helper structure for implementation of "getOrCreate"-functions for GaudiCommon<BASE>
Gaudi::Utils::GetOrCreateData< const TYPE, const TYPE2 > |
Gaudi::Utils::GetOrCreateData< const TYPE, TYPE2 > |
Gaudi::Utils::GetOrCreateData< Gaudi::NamedRange_< std::vector< const TYPE * > >, TYPE2 > |
Gaudi::Utils::GetOrCreateData< Gaudi::Range_< std::vector< const TYPE * > >, TYPE2 > |
Gaudi::Utils::GetOrCreateData< TYPE &, TYPE2 & > |
Gaudi::Utils::GetOrCreateData< TYPE &, TYPE2 > |
Gaudi::Utils::GetOrCreateData< TYPE *, TYPE2 * > |
Gaudi::Utils::GetOrCreateData< TYPE *, TYPE2 > |
Gaudi::Utils::GetOrCreateData< TYPE, const TYPE2 > |
Gaudi::Utils::GetOrCreateData< TYPE, TYPE2 & > |
Gaudi::Utils::GetOrCreateData< TYPE, TYPE2 * > |
THistSvc::GlobalDirectoryRestore |
GlobalDirectoryRestore |
GaudiMP::GMPBase::GMPComponent |
grammar |
Genfun::GaudiMathImplementation::GSL_Helper | Simple structure to be used for adaption interface `Genfun::AbsFunction` to `gsl_function` structure
GslError | Helper class to represent GSL errors
GslErrorCount | Concrete GSL error handler It is just counts number of GSL errors
GslErrorException | Concrete GSL eror handler It is just thrown the exception
GslErrorPrint | Concrete GSL eror handler It is just prints the GSL errors
Genfun::GaudiMathImplementation::GSLFunctionWithError |
Genfun::GaudiMathImplementation::GSLFunctionWithMode |
Genfun::GaudiMathImplementation::GSLFunctionWithModeAndError |
Genfun::GaudiMathImplementation::GSLSpline |
Genfun::GaudiMathImplementation::GSLSplineDeriv |
Genfun::GaudiMathImplementation::GSLSplineDeriv2 |
Genfun::GaudiMathImplementation::GSLSplineInteg |
GslSvc | The implementation of IGslSvc interface
GaudiUtils::Hash< T > | Simple hash function
GaudiUtils::Hash< const T & > | Remove extra qualifiers:
GaudiUtils::Hash< const T * > | Remove extra qualifiers:
GaudiUtils::Hash< const T > | Remove extra qualifiers:
GaudiUtils::Hash< const T(&)[N]> | Generic specialization for arrays
GaudiUtils::Hash< T & > | Remove extra qualifiers:
GaudiUtils::Hash< T * > | Partial specialization for pointers
GaudiUtils::Hash< T(&)[N]> | Generic specialization for arrays
GaudiUtils::HashMap< K, T, H, M > | Common class providing an architecture-independent hash map
Containers::hashmap |
GaudiPython::Helper |
HistogramSvc::Helper |
Gaudi::Histo1DDef | Simple helper class for description of 1D-histogram The class is targeted to act as the primary "histogram property", but clearly have significantly wider application range
Gaudi::Parsers::Histo1DGrammar | The simple grammar for histogram description/definition:
GaudiMP::pTools::HistoAgent |
GaudiPython::GaudiAlgs::HistoAlgo | The base class for easy histogramming
GaudiPython::HistoDecorator | Simple decorator class to allow to reuse the functionality of GaudiHistos<TYPE> class in pythin
GaudiPython::HistoUtils::HistoFile |
Gaudi::Histogram1D | AIDA implementation for 1 D histograms using ROOT THD1
Gaudi::Histogram2D | AIDA implementation for 2 D histograms using ROOT THD2
Gaudi::Histogram3D | AIDA implementation for 2 D histograms using ROOT THD2
HistogramAgent | HistogramAgent base in charge of collecting all the refereces to DataObjects in a transient store that passes some selection criteria
Gaudi::HistogramBase | Common base class for all histograms Use is solely functional to minimize dynamic_casts inside HistogramSvc
HistogramPersistencySvc | HistogramPersistencySvc class implementation definition
HistogramSvc | HistogramSvc class definition
HistoryObj | Base class for History Objects
HistorySvc | HistorySvc class definition
Gaudi::Utils::HistoStats | The collection of trivial functions to access the statistical information for the histograms
HistoTool | Simple tool for histogramming (component)
GaudiTest::HTMLResultStream |
IAddressCreator | IAddressCreator interface definition
IAIDATupleSvc | Definition of the IAIDATupleSvc interface class
IAlgContextSvc | An abstract interface for Algorithm Context Service
IAlgManager | The IAlgManager is the interface implemented by the Algorithm Factory in the Application Manager to support management functions
IAlgorithm | The IAlgorithm is the interface implemented by the Algorithm base class
GaudiPython::Bindings::iAlgorithm |
IAlgTool | The interface implemented by the AlgTool base class
GaudiPython::Bindings::iAlgTool |
IAppMgrUI | Application Manager User Interface
IAuditor | The IAuditor is the interface implmented by the AlgAuditor base class
IAuditorSvc | The interface implemented by the IAuditorSvc base class
ibs_param_t |
ibsfetchctl_t |
ibsopctl_t |
ibsopdata2_t |
ibsopdata3_t |
ibsopdata_t |
IChronoStatSvc | The IChronoStatSvc is the interface implemented by the ChronoStatService
IChronoSvc | "Chrono"-related part of interface IChronoStatSvc
IClassInfo | Data base class allowing to store persistent type information
IClassManager | The IClassManager is the interface implemented by the generic Factory in the Application Manager to support class management functions
ICnvFactory |
IComponentManager |
IConversionSvc |
IConverter | The data converters are responsible to translate data from one representation into another
ICounterSummarySvc | Simple service interface to collect counters to persist in a summary file
ICounterSvc | Create / access multi purpose counters
GaudiAlg::ID | ID class for Histogram and Ntuples
Gaudi::IDataConnection | ABC describing basic data connection
IDataManagerSvc |
IDataProviderSvc | Data provider interface definition
IDataSelector | This is only a placeholder to allow me compiling until the responsible guy does his work! M.Frank
IDataSourceMgr | IDataSourceMgr interface definition
IDataStoreAgent | Generic data agent interface
IDataStoreLeaves | Interface for a tool or service that returns a list of leaves (paths) in a transient store
IDataStreamTool |
GaudiPython::Bindings::iDataSvc |
StreamBuffer::IdentifiedLink | Definition of the contained link set
Gaudi::Parsers::IdentifierGrammar | Recognize alphanumeric strings and _ starting with alpha: Example, abc, ab_cd123, a_12
IDetDataSvc | ---------------------------------------------------------------------------
IEqSolver | Interface file for multidimensional root-finding (solving nonlinear system with n equations in n unknowns)
IErrorTool |
IEventProcessor | The IEventProcessor is the interface to process events
GaudiPython::Bindings::iEventSelector |
IEventTimeDecoder | Interface that a Tool that decodes the event time has to implement
IEvtSelector | The Event Selector Interface
IExceptionSvc | The abstract interface for exception handling service
IFactory | The IFactory is the interface used to create contrete instances of Objectes
IFileAccess | Abstract interface for a service or tool implementing a read access to files
IFileCatalog |
Gaudi::IFileCatalog | File catalog interface
IFileCatalogMgr |
Gaudi::IFileCatalogMgr | File catalog manager
IFuncMinimum | Interface file to find minimum of the function and compute covariance matrix (matrix of error)
IGenericTool | General purpose interface class for tools that "do something"
IgHookTrace |
IgHookTraceAlloc |
IgnoreError |
IGslErrorHandler | The abstract interface for arbitrary GSL error handler
IGslSvc | The abstract interface to "deal" with GNU Scientific Library (GLS) The main task is the error handling
IHistogram1D |
IHistogram3D |
GaudiPython::Bindings::iHistogramSvc |
IHistogramSvc | Definition of the IHistogramSvc interface class
IHistorySvc | Definition of the IHistorySvc interface class
IHistoTool | An abstract interface for "histogramming tool"
IInactiveMessageCounter |
IIncidentListener | The interface implemented by any class wanting to listen to Incidents
IIncidentSvc | The interface implemented by the IncidentSvc service
IInspectable | Interface definition of an inspectable object
IInspector | Inspector base class
IInterface | Definition of the basic interface
Gaudi::IIODataManager |
IIODataManager |
IIssueLogger |
IJobOptionsSvc | Main interface for the JobOptions service
GaudiPython::Bindings::iJobOptSvc |
IMagneticFieldSvc | The interface to the MagneticFieldSvc
IMessageSvc | The IMessage is the interface implemented by the message service
IMonitorSvc | Definition of the IMonitorSvc interface, which publishes Gaudi variables to outside monitoring processes
implements1< I1 > | Base class used to implement the interfaces
implements2< I1, I2 > | Base class used to implement the interfaces
implements3< I1, I2, I3 > | Base class used to implement the interfaces
implements4< I1, I2, I3, I4 > | Base class used to implement the interfaces
INamedInterface | IInterface compliant class extending IInterface with the name() method
Incident | Base class for all Incidents (computing events)
IncidentSvc | Default implementation of the IIncidentSvc interface
IndefiniteIntegral |
InputCopyStream | Extension of OutputStream to copy the content of the main input file
Integration | Collection of common types for classes NumericalIndefiniteIntegral and NumericalDefiniteIntegral
GaudiPython::Interface< TYPE > | Minor mofidication of original Pere's structure GaudiPython::Interface This helper class is nesessary to perform C++ castings from python
GaudiPython::Bindings::Interface |
GaudiPython::Interface< IInterface > |
GaudiPython::Bindings::InterfaceCast |
InterfaceID | Interface ID class
Gaudi::InterfaceId< INTERFACE, majVers, minVers > | Class to handle automatically the versioning of the interfaces when they are inheriting from other interfaces
interfaceMatch< THIS > | Helper class for the cast used in the MPL for_each algorithm in the implementation of queryInterface
Gaudi::Parsers::IntGrammar< RT > | The valid representation of integers values are:
INTuple | NTuple interface class definition
INTupleItem | NTuple interface class definition
GaudiPython::Bindings::iNTupleSvc |
INTupleSvc |
System::IO_COUNTERS | Process I/O Counters NtQueryInformationProcess using ProcessIoCounters
Gaudi::IODataManager |
IOpaqueAddress | Opaque address interface definition
IParticlePropertySvc | This class is an interface to the ParticlePropertySvc
IPartitionControl | Create / access partitions
IPartPropSvc |
IPersistencySvc | Data persistency service interface
IPoolCacheSvc | Description:
IPoolDbCnvFactory | Description: Interface definition for POOL converter factories
IPoolDbMgr | Description:
IProfile1D |
IProfile2D |
GaudiPython::Bindings::iProperty |
IProperty | The IProperty is the basic interface for all components which have properties that can be set or get
IRegistry | The IRegistry represents the entry door to the environment any data object residing in a transient data store is embedded
IRndmEngine | Definition of a interface for a generic random number generator giving randomly distributed numbers in the range [0...1] number generators
IRndmGen | Definition of a interface for a generic random number generators
IRndmGenSvc | Random Generator service interface definition Definition of a interface for a service to access random generators according to predefined distributions:
IRunable | Runable interface definition
ISelectStatement | A select statement can either contain a string e.g
ISequencerTimerTool | Implements the time measurement inside a sequencer
ISerialize | Object serialization interface definition
IService | General service interface definition
GaudiPython::Bindings::iService |
Gaudi::ISignalMonitor | Interface for the service that monitors the occurrences of system signals
IssueLogger |
IssueSeverity |
IStagerSvc |
IStateful | Interface for classes that implement the Gaudi State Machine
IStatSvc | "Stat"-related part of interface IChronoStatSvc
IStatusCodeSvc |
StreamBuffer::Istream | Reader for standard input streams
ISvcLocator | The ISvcLocator is the interface implemented by the Service Factory in the Application Manager to locate services in the framework
ISvcManager | The ISvcManager is the interface implemented by the Service Factory in the Application Manager to support management functions
NTuple::Item< TYP > | Class acting as a smart pointer holding a N tuple _Item
NTuple::Item< bool > | Specialization acting as a smart pointer holding a N tuple _Item
Tuples::ItemStore< VALUE > | Simple class, which represents the local storage of N-tuple items of the given type
ITHistSvc |
GaudiPython::Bindings::iToolSvc |
IToolSvc | The interface implemented by the IToolSvc base class
ITupleTool |
IUpdateable | Object update interface definition
IUpdateableIF |
IUpdateableInterface | Component interface counterpart to the above ABC
IUpdateManagerSvc | Interface class to the Update Manager service
IValidity | Interface for objects with a validity
IInspector::IValue |
apmon_mon_utils::JobDirInfo | Structure that holds information about the disk usage for a job
JobHistory | JobHistory class definition
JobOptionsCatalogue |
JobOptionsSvc |
ProcessJobOptions::JobOptsParser |
System::KERNEL_USER_TIMES | Process/Thread System and User Time NtQueryInformationProcess using ProcessTimes NtQueryInformationThread using ThreadTimes
Containers::key_traits< KEY > | Definition of the key traits class
KeyedContainer< DATATYPE, MAPPING > | Template class KeyedContainer, KeyedContainer.h
KeyedObject< KEY > | Definition of the templated KeyedObject class
Containers::KeyedObjectManager< SETUP > | KeyedObjectManager Class to manage keyed objects
Rndm::Landau | Parameters for the Landau distributed random number generation
DataOnDemandSvc::Leaf |
StoreSnifferAlg::LeafInfo |
GaudiTest::LineSkipper |
GaudiTest::LineSorter | Special preprocessor sorting the list of strings (whitespace separated) that follow a signature on a single line
LinkManager::Link | Embedded class defining a symbolic link Note: No copy constructor; bitwise copy (done by the compiler) is just fine
LinkManager | A LinkManager is the object aggregated into a DataObject, which is responsible for the handling of non-tree like links
linux_proc |
IncidentSvc::Listener |
Gaudi::Utils::LockedChrono | Helper object, useful for measurement of CPU-performance of highly-recursive structures, e.g
locker::LockFile | Lock a file
install::LogFile |
ProcessJobOptions::LogFilter |
ProcessJobOptions::LogFormatter |
Lomont | The equality comparison of double numbers using as the metric the maximal number of Units in the Last Place (ULP)
Gaudi::Math::Lomont< double > | Specialization for double numbers
Gaudi::Math::Lomont< float > | Specialization for float numbers
GaudiMP::pTools::LumiFSR |
GaudiUtils::Map< K, T, M > | Extension of the STL map
Containers::map |
Gaudi::Utils::MapBase | Helper base-class to allow the generic Python-decoration for all "map-like" classes in Gaudi
Gaudi::Parsers::MapGrammar< KeyGrammarT, ValueGrammarT > | The valid represenation of map are: {"file1":"path1","something":"nothing"} {"file1"="path1","something"="nothing"} ["file1":10,"something":20] ["file1"=30,"something"=40] Inner key type depends on KeyGrammarT grammar Inner value type depends on ValueGrammarT grammar
NTuple::Matrix< TYP > | Class acting as a smart pointer holding a N tuple _Item
NTuple::Matrix< IOpaqueAddress * > |
MemoryAuditor | Monitors the memory use of each algorithm
MemStatAuditor | Just a minor modification of MemoryAuditor to allow the output memory statistics table to be printed
Message | The Message class
Gaudi::Parsers::Message | Parser message interface
MessageSvc |
MinimalEventLoopMgr | This is the default processing manager of the application manager
GaudiMP::GMPBase::MiniWriter |
ModuleIncident | Base class for Module-related incident
ModuleLoadedIncident | Fired when a module (DLL) is loaded
MonitoredJob | Data structure which holds information about a job monitored by ApMon
MessageSvc::MsgAry | Private helper class to keep the count of messages of a type (MSG::LEVEL)
MsgReporter | Default reporter implementation
MsgStream | Definition of the MsgStream class used to transmit messages
Gaudi::MultiFileCatalog | This class constitutes the core of the XML based FileCatalog API for using POOL within Gaudi
MultiStoreSvc | Data service base class
EventCollectionSelector::MyContextType |
NameAuditor | Prints the name of each algorithm before entering the algorithm and after leaving it
NamedRange | New concept of "named" range : range with name
Gaudi::NamedRange_< TYPE > |
DataOnDemandSvc::Node | Helper class of the DataOnDemandSvc
NTupleItems | NTupleItems namespace parts definition This header file is not intended to be included by the public! It's only used for the ntuple service
NTupleSvc | NTuple service
NullVerifier< T > | Default, always true verifier
Rndm::Numbers | Random number accessor This small class encapsulates the use of the random number generator
Genfun::GaudiMathImplementation::NumericalDefiniteIntegral | This class allows the numerical evaluation of the following functions:
Genfun::GaudiMathImplementation::NumericalDerivative | Numerical derivative (using GSL adaptive numerical differentiation)
Genfun::GaudiMathImplementation::NumericalIndefiniteIntegral | The simple class for numerical integrations
ObjectContainerBase | ObjectContainerBase is the base class for Gaudi container classes
SmartDataObjectPtr::ObjectFinder | Helper class to configure smart pointer functionality
ObjectList< TYPE > | ObjectList is one of the basic Gaudi container classes capable of being registered in Data Stores
SmartDataObjectPtr::ObjectLoader | Helper class to configure smart pointer functionality
ObjectMemberFunction< CallerClass > | This class is used by IUpdateManagerSvc to keep pairs made of a member function and a pointer to the object for which that member function has to be called
GaudiPython::GaudiAlgs::objectmethod |
ObjectVector< TYPE > | ObjectVector is one of the basic Gaudi container classes capable of being registered in Data Stores
IToolSvc::Observer | Allow call-backs when a tool is a created or retrieved
run_qmtest::Options |
StreamBuffer::Ostream | Writer for standard output streams
OutputStream | A small to stream Data I/O
OutputStreamAgent |
GaudiMP::pTools::PackedCaloHypo |
Gaudi::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
IRndmGen::Param |
Gaudi::Parsers::Parser | Parser controller
ProcessJobOptions::ParserError |
Gaudi::Parsers::ParserGrammar | Grammar recognize job options file `Grammar's EBNF: `job_options_file ::= (platform_statement | platform_dependency)*``
ParticleProperty | A trivial class to hold information about a single particle properties
ParticlePropertySvc | This service provides access to particle properties
PartitionSwitchAlg | Small algorith, which switches the partition of a configurable multi-service
PartitionSwitchTool |
PartPropSvc |
validate_patch::PatchData |
System::PathResolver |
pentium4_cccr_value_t | Pentium4_cccr_value_t
pentium4_escr_value_t |
PerfMonAuditor | Performance Monitoring Auditor that uses Perfmon2 library to monitor algorithms
PersistencySvc | PersistencySvc class implementation definition
RootHistCnv::PersSvc | Persistency service - to store histograms in ROOT format
pfarg_ctx_t |
pfarg_load_t |
pfarg_msg_t |
pfarg_ovfl_msg_t |
pfarg_pmc_t |
pfarg_pmd_attr_t |
pfarg_pmd_t |
pfarg_pmr_t |
pfarg_set_desc_t |
pfarg_set_info_t |
pfarg_setdesc_t |
pfarg_setinfo_t |
pfarg_sinfo_t |
pfarg_start_t |
pfm_amd64_ctr_reg_t |
pfm_amd64_sel_reg_t |
pfm_core_sel_reg_t |
pfm_coreduo_counter_t |
pfm_coreduo_sel_reg_t |
pfm_dfl_smpl_arg_t |
pfm_dfl_smpl_entry_t |
pfm_dfl_smpl_hdr_t |
pfm_ds_area_core_t |
pfm_ds_area_p4_t |
pfm_gen_ia32_sel_reg_t |
pfm_i386_p6_ctr_reg_t |
pfm_i386_p6_sel_reg_t |
pfm_intel_atom_sel_reg_t |
pfm_nhm_sel_reg_t |
pfm_pebs_core_smpl_arg_t |
pfm_pebs_core_smpl_entry_t |
pfm_pebs_core_smpl_hdr_t |
pfm_pebs_nhm_smpl_entry_t |
pfm_pebs_p4_smpl_arg_t |
pfm_pebs_p4_smpl_entry_t |
pfm_pebs_p4_smpl_hdr_t |
pfm_pebs_smpl_arg_t |
pfm_pebs_smpl_hdr_t |
PfmCodeAnalyser |
pfmlib_amd64_counter_t |
pfmlib_amd64_input_param_t |
pfmlib_amd64_output_param_t |
pfmlib_core_counter_t |
pfmlib_core_input_param_t |
pfmlib_core_output_param_t |
pfmlib_core_pebs_t |
pfmlib_coreduo_input_param_t |
pfmlib_event_t |
pfmlib_gen_ia32_counter_t |
pfmlib_gen_ia32_input_param_t |
pfmlib_gen_ia32_output_param_t |
pfmlib_i386_p6_counter_t |
pfmlib_i386_p6_input_param_t |
pfmlib_i386_p6_output_param_t |
pfmlib_input_param_t |
pfmlib_intel_atom_counter_t |
pfmlib_intel_atom_input_param_t |
pfmlib_nhm_counter_t |
pfmlib_nhm_input_param_t |
pfmlib_nhm_lbr_t |
pfmlib_nhm_pebs_t |
pfmlib_options_t |
pfmlib_output_param_t |
pfmlib_reg_t |
pfmlib_regmask_t |
AnalysisInit::PhysAnalAlg |
Test::PhysAnalAlg |
PipeReader |
Gaudi::Parsers::Pnt3DGrammar< ScalarGrammarT, POINT > | The grammar for 3D-point
Gaudi::Parsers::Pnt4DGrammar< ScalarGrammarT, POINT > | The grammar for 4D-point
Rndm::Poisson | Parameters for the Poisson distributed random number generation with a given mean
GaudiUtils::AllocatorPool::PoolChunk |
PoolDbAddress | Description:
PoolDbBaseCnv | Description: Definition of the generic Db data converter
PoolDbCacheSvc | Description:
PoolDbCnvFactory< ConcreteConverter, i > | Description: Implementation definition for POOL converter factories
PoolDbCnvSvc | Description:
PoolDbContext |
PoolDbDatabaseCnv | Statistics file converter class definition
PoolDbDataConnection | The DataConnection incanation for the usage in GaudiPoolDb
PoolDbDataObjectHandler |
PoolDbDirectoryCnv | Description: NTuple directory converter class definition Definition of the converter to manage the directories in an database representing N-Tuples
PoolDbEvtSelector |
PoolDbIOHandler< T > |
PoolDbLinkManager | Description: PoolDbLinkManager class implementation definition
PoolDbMsgReporter |
PoolDbNTupleCnv | NTuple converter class definition
PoolDbNTupleDescriptor | Description:
PoolDbObjectContext |
PoolDbStatCnv | Description: NTuple directory converter class definition Definition of the converter to manage the directories in an database representing N-Tuples
PoolDbTokenWrap | Description:
PoolDbTupleCallback | Description: Specialized callback to handle N-tuple interactions while saving and lodaing POOL data
System::POOLED_USAGE_AND_LIMITS | Process Pooled Quota Usage and Limits NtQueryInformationProcess using ProcessPooledUsageAndLimits
GaudiUtils::AllocatorPool::PoolLink |
Gaudi::Parsers::Position | Parser position entity
Prescaler |
GaudiAlg::Print | Collection of useful utilities to print IHistogram1D (currently used for implementation of class GaudiHistoAlg and class GaudiHistoTool)
GaudiAlg::Print1D | Collection of useful utilities to print IHistogram1D (currently used for implementation of class GaudiHistoAlg and class GaudiHistoTool)
GaudiAlg::Print1DProf | Collection of useful utilities to print IProfile1D (currently used for implementation of class GaudiHistoAlg and class GaudiHistoTool)
GaudiAlg::Print2D | Collection of useful utilities to print IHistogram1D (currently used for implementation of class GaudiHistoAlg and class GaudiHistoTool)
GaudiAlg::Print2DProf | Collection of useful utilities to print IProfile2D (currently used for implementation of class GaudiHistoAlg and class GaudiHistoTool)
GaudiAlg::Print3D | Collection of useful utilities to print IHistogram1D (currently used for implementation of class GaudiHistoAlg and class GaudiHistoTool)
GaudiPython::Printer< TYPE > |
GaudiPython::Printer< ContainedObject > |
GaudiPython::Printer< DataObject > |
ICounterSvc::Printout | Print counters for each element in the range [first, last) e.g
GaudiAlg::PrintStat | Collection of useful utilities to print StatEntity (currently used for implementation of class GaudiAlgorithm and class GaudiTool)
GaudiAlg::PrintTuple | Collection of useful utilities to print INTuple object (currently used for implementation of class GaudiTupleAlg and class GaudiTupleTool)
GaudiHandles::PrivateToolHandle |
GaudiHandles::PrivateToolHandleArray |
System::PROCESS_BASIC_INFORMATION |
System::ProcessDescriptor | Provides access to process information
System::ProcessDescriptor::ProcessHandle |
procInfo |
ProcStats |
ProcUtils |
procutils_error | Used when throwing exceptions from the proc_utils functions
Gaudi::Profile1D | AIDA implementation for 1 D profiles using ROOT TProfile
Gaudi::Profile2D | AIDA implementation for 2 D profiles using ROOT TProfile2D
Property | Property base class allowing Property* collections to be "homogeneous"
PropertyCallbackFunctor |
PropertyCallbackMemberFunctor< T > |
PropertyCallbackPointerFunctor |
GaudiPython::Bindings::PropertyEntry |
Gaudi::Parsers::PropertyEntry |
Gaudi::Parsers::PropertyGrammar | Recognize property Example, A.B, A::B::C.D, A::B.C::D.E
PropertyList | List of properties
PropertyMgr | Property manager helper class
PropertyProxy::PropertyProxy |
Configurable::PropertyReference | Allow references to options as in old style
Gaudi::Utils::PropertyTypeTraits< TYPE > | Helper structure to define the types for properties
Gaudi::Utils::PropertyTypeTraits< boost::array< T, N > > | Specialization of property-traits for class boost::array to take care the non-trivial assignements and constructors for this class
Gaudi::Utils::PropertyTypeTraits< char(&)[N]> | Specialisation for C-strings
Gaudi::Utils::PropertyTypeTraits< const T(&)[N]> | Specialiation for const-arrays
Gaudi::Utils::PropertyTypeTraits< T(&)[N]> |
Gaudi::Utils::PropertyTypeTraits< T[N]> | Specialization for arrays
PropertyVerifier< T > | Templated Verifier base class
PropertyWithValue< TYPE > | Helper intermediate class which represent partly implemented property with value of concrete type
PropertyWithVerifier< TYPE, VERIFIER > | Helper intermediate class which represent partly implemented property with value of concrete type and concrete verifier
DataOnDemandSvc::Protection | Helper class of the DataOnDemandSvc
apmon_mon_utils::PsInfo | Structure that holds information about a job, as obtained from the ps command
PtrSetter< ActualType > | Templated specialization of BasePtrSetter
GaudiHandles::PublicToolHandle |
GaudiHandles::PublicToolHandleArray |
Gaudi::Parsers::PushBackImpl< T > |
Gaudi::Parsers::PushBackRefImpl< T, IT > |
GaudiPython::PyAlg< ALGORITHM > | General class to embed the existing algorithm/base class into the python
GaudiPython::PyAlgorithm | Python Algorithm base class
GaudiPython::Bindings::PyAlgorithm |
GaudiMP::PyROOTPickle |
IUpdateManagerSvc::PythonHelper | Helper class implemented in the python dictionary to allow access from python to template member functions
PythonScriptingSvc | This service handles scripting implemented using Python
System::QUOTA_LIMITS | Process Quotas NtQueryInformationProcess using ProcessQuotaLimits NtQueryInformationProcess using ProcessPooledQuotaLimits NtSetInformationProcess using ProcessQuotaLimits
NTuple::Range< TYP > | Class defining a range
NTuple::Range< bool > |
Gaudi::Range_< CONTAINER > | Useful class for representation of "sequence" of the objects through the range of valid iterators
Gaudi::RangeBase_ | Helper class to simplify the dealing with ranges in Python
RootHistCnv::RConverter | Root Converter
RootHistCnv::RCWNTupleCnv | Converter of Column-wise NTuple into ROOT format
RootHistCnv::RDirectoryCnv | Create persistent and transient representations of data store directories
GaudiMP::GMPBase::Reader |
Gaudi::Parsers::RealGrammar< RT > | The valid represenation of real values are:
Gaudi::Parsers::RealUnitsGrammar | The valid represenation of reals with units are 1, 1.0, 1.0e+2, 1e-2, 0.5mm, 0.5 mm, 0.5*mm
GaudiUtils::Allocator< Type >::rebind< U > |
RecordDataSvc | A RecordDataSvc is the base class for event services
RecordStream | Extension of OutputStream to write run records after last event
GaudiTest::ReferenceFileValidator |
RefTable1to1< FROM, TO > |
RefTable1toN< FROM, TO > |
RefTableBase< FROM, MAPENTRY > | Template <class FROM, class TO, class MAPENTRY> class RefTable
GaudiTest::RegexpReplacer |
DataSvcHelpers::RegistryEntry | Definition of an entry in the transient data store
Gaudi::Parsers::PushBackImpl< T >::result< Arg > |
Gaudi::Parsers::PushBackRefImpl< T, IT >::result< Arg > |
Gaudi::Parsers::AssignBoolToStringImpl< T >::result< Arg > |
RootHistCnv::RFileCnv | NTuple converter class definition
RootHistCnv::RHistogramCnv< T, S, Q > | Generic converter to save/read AIDA_ROOT histograms using ROOT
RndmEngine | Random Generator engine definition
RndmGen | Random Generator definition
RndmGenSvc | Random Generator service definition
RootHistCnv::RNTupleCnv | NTuple converter class definition
RootHistCnv::RootObjAddress |
NTuple::RowWiseTuple |
RootHistCnv::RRWNTupleCnv | Row wise NTuple converter class definition
RunRecordDataSvc | A RunRecordDataSvc is the base class for event services
RunRecordStream | Extension of OutputStream to write run records after last event
S_module |
validate_patch::SavannahParser | Parse the
NTuple::Selector | NTuple Selector class
SelectStatement | Class of a selection statement
Sequencer | ClassName: Sequencer
SequencerTimerTool | Implements the time measurement inside a sequencer
SequentialOutputStream | Extension of OutputStream to write run records after last event
Service | Base class for all services
PersistencySvc::ServiceEntry |
ServiceHandle< T > | Handle to be used in lieu of naked pointers to services
GaudiHandles::ServiceHandle |
ServiceHandleArray< T > | Array of Handles to be used in lieu of vector of naked pointers to tools
GaudiHandles::ServiceHandleArray |
ServiceHistory | ServiceHistory class definition
ServiceManager::ServiceItem |
ServiceLocatorHelper | Helper to share the implementation of service() among the various kernel base classes $Id:
ServiceManager | In charge of the creation of concrete instances of Services
SharedObjectsContainer< TYPE > | Very simple class to represent the container of objects which are not ownered by the container
Gaudi::Utils::SignalMonitorSvc | Implementation of Gaudi::ISignalMonitor
Genfun::GaudiMathImplementation::SimpleFunction |
SimpleProperty< TYPE, VERIFIER > | SimpleProperty concrete class which implements the full Property interface
SimplePropertyRef< TYPE, VERIFIER > | SimplePropertyRef templated class
Gaudi::Parsers::SkipperGrammar | Skipping spaces and comments
SmartDataLocator< TYPE > | A small class used to access easily (and efficiently) data items residing in data stores
SmartDataObjectPtr | A small class used to access easily (and efficiently) data items residing in data stores
SmartDataPtr< TYPE > | A small class used to access easily (and efficiently) data items residing in data stores
SmartDataStorePtr< TYPE, LOADER > | A small class used to access easily (and efficiently) data items residing in data stores
SmartIF< TYPE > | Small smart pointer class with automatic reference counting for IInterface
SmartRef< TYPE > | Kernel objects: SmartRef
SmartRefBase | User example objects: SmartRefBase
SmartRefVector< TYPE > | Kernel objects: SmartRefVector
Genfun::GaudiMathImplementation::SplineBase |
GaudiMP::Parallel::SshSession |
StalledEventMonitor | Service that monitor the time taken by processing of single events using a separate thread
Stat | Small wrapper class for easy manipulation with generic counters and IStatSvc&ICounterSvc interface
StatusCodeSvc::StatCodeDat |
StatEntity | The basic counter used for Monitoring purposes
GaudiMP::Parallel::Statistics |
StatusCode | This class is used for returning status codes from appropriate routines
StatusCodeSvc |
Gaudi::Utils::StopSignalHandler | Service that stop the processing if a signal is received
StoreExplorerAlg | Small algorith, which traverses the data store and prints generic information about all leaves, which can be loaded/accessed
FastContainersSvc::StoreResetter | Internal data store agent used to find and clear objects of type TransientFastContainerBase
StoreSnifferAlg | Small algorithm, which traverses the data store and prints a summary of the leafs accessed during the run
StreamBuffer | The stream buffer is a small object collecting object data
StreamLogger |
Gaudi::Parsers::StringGrammar | The valid represenation of string values are:
Gaudi::StringKey | The helper class to represent the efficient "key" for access
Rndm::StudentT | Parameters for the StudentT distributed random number generation
SvcFactory< T > |
GaudiMP::pTools::Syncer |
GaudiMP::pTools::SyncMini |
Gaudi::Utils::Histos::Table | Simple class for the customizeble printout of the histogram tables
IInspector::Tag |
TagCollectionStream | Specialized output stream class for event tag collections, where the basic Event entry point should be placed as well into the collection itself
TagCollectionSvc | Gaudi tag collection service definition
MultiStoreSvc::tagROOT |
GaudiMP::Parallel::Task |
GaudiTest::TempDir |
validate_patch::TempDir |
GaudiTest::TempFile |
GaudiTest::TemporaryEnvironment | Utility Classes
GaudiMP::GMPBase::TESSerializer |
GaudiMP::TESSerializer |
THistSvc::THistID |
THistSvc |
ThreadGaudi | Singleton mapping the pthread ID to the Gaudi thread ID
Gaudi::Time | Based on seal::Time
TimeException | Exception thrown by Gaudi::Time
TimerForSequencer | Auxilliary class
Gaudi::TimeSpan | Based on seal::TimeSpan
TimingAuditor | Simple auditor which uses SequencerTimerTool for *ALL* algorithms, including the algorithm from main Gaudi "TopAlg" list and algorithms managed by Data-On-Demand Service
Tokenizer::Token | Definition of the sub-class Token
Tokenizer | STL Include files
ToolFactory< T > |
ToolHandle< T > | Handle to be used in lieu of naked pointers to tools
ToolHandleArray< T > | Array of Handles to be used in lieu of vector of naked pointers to tools
ToolHandleInfo | General info and helper functions for toolhandles and arrays
ToolSvc | This service manages tools
Containers::traits< CONTAINER, DATATYPE > | Definition of the container traits class
TransientFastContainer< T, CLEANER > | Container providing internal memory management
TransientFastContainerBase | Base class for TransientFastContainer
RootHistCnv::RHistogramCnv< T, S, Q >::TTH< CLASS > |
NTuple::Tuple | Abstract base class which allows the user to interact with the actual N tuple implementation
Tuples::Tuple | A simple wrapper class over standard Gaudi NTuple::Tuple facility
GaudiPython::TupleAlgDecorator | Simple class to perform the "decoration" of Tuples in Python/Reflex
GaudiPython::GaudiAlgs::TupleAlgo | The base class for easy manupulations with N-Tuples
Tuples::TupleColumn< ITEM > | Helper class which allows to extend the functionality of Tuple with possibility to use your own representation of complex objects
GaudiPython::TupleDecorator | Simple class which performs the decoration of the standard N-Tuple
NTuple::TupleImp |
Tuples::TupleObj | A simple wrapper class over standard Gaudi NTuple::Tuple facility
Tuples::detail::TupleObjImp< HANDLER1, HANDLER2 > | The simplest concrete implementation of class TupleObj with 3 arbitrary error handlers Any types (classes, functions, etc.) which supports the semantics
TupleTool |
GaudiPython::TupleToolDecorator | Simple class to perform the "decoration" of Tuples in Python/Reflex
Gaudi::Utils::TypeNameString | Helper class to parse a string of format "type/name"
Gaudi::Parsers::UnitsFileGrammar | The valid represenation units file: `1 cm = 10 1 m = 1000`
UpdateManagerException | Exception thrown by the UpdateManagerSvc when something goes wrong
Gaudi::Parsers::ValueGrammar | Grammar recognize value that can appear in right side of '=' operator in job options file
ValueMap | ValueMap is used in conjunction with Scouter and MLSender to carry the information declared by IMonitorSvc's declareInfo
Containers::vector |
Gaudi::Parsers::VectorGrammar< GrammarT > | The valid represenation of vector are: {"abc","defj","i"} or {1,2,3,4,5} ["abc","defj","i"] or [1,2,3,4,5] Inner type depends on GrammarT grammar
GaudiUtils::VectorMap< KEY, VALUE, KEYCOMPARE, ALLOCATOR > | A bit modified version of 'LokiAssocVector' associative vector from Loki library by Andrei Alexandrescu
VFSSvc | Simple service that allows to read files independently from the storage
System::VM_COUNTERS | Process Virtual Memory Counters NtQueryInformationProcess using ProcessVmCounters
WatchdogThread | Simple class for asynchronous check of time-out
GaudiMP::GMPBase::Worker |
ConversionSvc::WorkerEntry |
GaudiMP::Parallel::WorkManager |
GaudiMP::GMPBase::Writer |
XmlCode | XmlCode contains methods to write out XML tags
GaudiProfiling::GenerateGaudiOpts::XmlDictObject |
Gaudi::XMLFileCatalog | This class constitutes the core of the XML based FileCatalog API for POOL
ZipPythonDir::ZipdirError | Class for generic exception coming from the zipdir() function

All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Properties Friends Defines