| # Gaudi Framework, version v25r0 |

Home |  | Generated: Mon Feb 17 2014

- Main Page
- Related Pages
- Modules
- Namespaces
- Classes
- Files

- Class List
- Class Index
- Class Hierarchy
- Class Members

All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Properties Friends Macros Groups Pages
Class Hierarchy

Go to the graphical class hierarchy

This inheritance list is sorted roughly, but not completely, alphabetically:
[detail level 1 2 3 4 5 6 7 8 9 10 11]

__longlong |
__Longs< I > |
_Accessor< TYP > |
NTuple::_Accessor< TYP > | Class acting as a smart pointer holding a N tuple entry
NTuple::_Accessor< _Array< TYP > > |
NTuple::Array< TYP > | Class acting as a smart pointer holding a N tuple _Item
NTuple::_Accessor< _Item< bool > > |
NTuple::Item< bool > | Specialization acting as a smart pointer holding a N tuple _Item
NTuple::_Accessor< _Item< IOpaqueAddress * > > |
NTuple::Item< IOpaqueAddress * > |
NTuple::_Accessor< _Item< TYP > > |
NTuple::Item< TYP > | Class acting as a smart pointer holding a N tuple _Item
NTuple::_Accessor< _Matrix< TYP > > |
NTuple::Matrix< TYP > | Class acting as a smart pointer holding a N tuple _Item
_Array< TYP > |
_ArrayImp< TYP > |
_CallbackStreamBufBase |
GaudiPython.Bindings.CallbackStreamBuf |
_Data< TYP > |
_DataImp< TYP > |
Genfun::GaudiMathImplementation::NumericalDefiniteIntegral::_Function |
Genfun::GaudiMathImplementation::NumericalIndefiniteIntegral::_Function |
_GaudiAlgorithm |
GaudiPython.GaudiAlgs.GaudiAlgo | Base class for all algorithm Python-image of C++ clkass GaudiAlgorithm
_GaudiHistoAlg |
GaudiPython.GaudiAlgs.HistoAlgo | The base class for easy histogramming
_GaudiTupleAlg |
GaudiPython.GaudiAlgs.TupleAlgo | The base class for easy manupulations with N-Tuples
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
KeyedContainer< DATATYPE, MAPPING >::_InsertRelease | Internal functor for insertion of objects
_Item< TYP > |
_ItemImp< TYP > |
_Matrix< TYP > |
_MatrixImp< TYP > |
_PyAlgorithm |
GaudiPython.Bindings.PyAlgorithm |
KeyedContainer< DATATYPE, MAPPING >::_RemoveRelease | Internal functor for insertion of objects
GaudiKernel.ProcessJobOptions._TempSysPath |
std::_Vector_base< _Tp, _Alloc > [external] |
std::vector< SmartRef< TYPE > > [external] |
SmartRefVector< TYPE > | Kernel objects: SmartRefVector
Genfun::GaudiMathImplementation::NumericalDefiniteIntegral::_Workspace |
Genfun::GaudiMathImplementation::NumericalIndefiniteIntegral::_Workspace |
AbsFunction |
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)
Genfun::GaudiMathImplementation::Constant | Fixed constant function
Genfun::GaudiMathImplementation::GSLFunctionWithError |
Genfun::GaudiMathImplementation::GSLFunctionWithMode |
Genfun::GaudiMathImplementation::GSLFunctionWithModeAndError |
Genfun::GaudiMathImplementation::GSLSpline |
Genfun::GaudiMathImplementation::GSLSplineDeriv |
Genfun::GaudiMathImplementation::GSLSplineDeriv2 |
Genfun::GaudiMathImplementation::GSLSplineInteg |
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
Genfun::GaudiMathImplementation::SimpleFunction |
Gaudi::Utils::Aida2ROOT | Accessor to underlying ROOT-representation of transient histograms The actual code is imported from Bender project
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
GaudiPython::AlgDecorator |
AlgFactory< T > |
ALGORITHM |
GaudiPython::PyAlg< ALGORITHM > | General class to embed the existing algorithm/base class into the python
GaudiSequencer::AlgorithmEntry |
AlgorithmManager::AlgorithmItem |
Gaudi::Utils::AlgSelector | Simple interface class for selection of algorithms
Gaudi::Utils::AlgNameSelector | The trivial selector of algorithm by type
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::AnnotationItem | Internal private annotation item class
AppendInterfaceName | Helper class for the cast used in the MPL for_each algorithm in the implementation of query_interface
Containers::array |
Array< TYP > |
NTuple::Array< IOpaqueAddress * > |
AudFactory< T > |
Gaudi::Guards::AuditorGuard | It is a simple guard, which "locks" the scope for the Auditor Service is am exception-safe way
BaseObjectMemberFunction | Base class of ObjectMemberFunction
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
BasePtrSetter | Base class to set the pointer to an object of a class derived from DataObject in a generic way
PtrSetter< ActualType > | Templated specialization of BasePtrSetter
std::basic_streambuf< _CharT, _Traits > [external] |
std::basic_stringbuf< _CharT, _Traits, _Alloc > [external] |
GaudiPython::CallbackStreamBuf |
GaudiTest.BasicOutputValidator | Output Validation Classes
std::binary_function< const std::pair< ChronoEntity *, const IChronoStatSvc::ChronoTag * >, const std::pair< ChronoEntity *, const IChronoStatSvc::ChronoTag * >, bool > [external] |
ComparePairOfChronoEntityAndChronoTag |
std::binary_function< const std::pair< const StatEntity *, const IChronoStatSvc::StatTag * >, const std::pair< const StatEntity *, const IChronoStatSvc::StatTag * >, bool > [external] |
ComparePairOfStatEntityAndStatTag |
std::binary_function< double, double, bool > [external] |
Gaudi::Math::Lomont< double > | Specialization for double numbers
std::binary_function< float, float, bool > [external] |
Gaudi::Math::Lomont< float > | Specialization for float numbers
std::binary_function< Property, Property, bool > [external] |
Gaudi::Parsers::Property::LessThen |
FileInfo::CacheItem |
FileInfo::CacheItemComparator |
Cartesian3D< T > |
Gaudi::Parsers::Catalog |
cgaudi_factory_t |
cgaudi_pluginsvc_t |
cgaudi_property_t |
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< TYPE & > | Template specialization for reference types
Gaudi::Utils::CheckData< TYPE * > | Template specialization for pointer types
Gaudi::Utils::CheckData< Gaudi::Range_< std::vector< const TYPE * > > > |
Gaudi::Utils::CheckData< Gaudi::Range_< std::vector< const TYPE * > > > | Template specialization for ranges
Chrono | A small utility class for chronometry of user codes
ChronoEntity | Small helper class for implementation of ChronoStatSvc service, It also could be used as some local timer
CLASS |
RootHistCnv::RHistogramCnv< T, S, Q >::TTH< CLASS > |
ProcStats::cleanup |
CLibSymbolInfo |
closure |
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`
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 > |
configGenerator |
NTupleSvc::Connection |
StreamBuffer::ContainedLink | Definition of the contained link set
ContainedObject | All classes that their objects may be contained in an LHCb ObjectContainer (e.g
KeyedObject< KEY > | Definition of the templated KeyedObject class
Gaudi::RootDataConnection::ContainerSection | Internal helper class, which described a TBranch section in a ROOT file
IEvtSelector::Context |
EventCollectionContext |
EventCollectionSelector::MyContextType |
EvtSelectorContext | Definition of class EventIterator
Gaudi::RootEvtSelectorContext | ROOT specific event selector context
ConverterID |
IgHookTrace::Counter | Nearly dummy object type to identify a counter
GaudiToolLocal::Counter | Simple local counter
Tuples::Local::Counter |
IgHookTrace::CounterValue | Value for a counter chained from a trace
DataHistory::DataHistoryOrder |
DataIncident | Data service incident class
StreamBuffer::DataIO | A small base class to handle generic data streaming
StreamBuffer::Istream | Reader for standard input streams
StreamBuffer::Ostream | Writer for standard output streams
DataItem< TYP > |
DataObject | A DataObject is the base class of any identifiable object on any data store
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
Gaudi::Profile1D | AIDA implementation for 1 D profiles using ROOT TProfile
Gaudi::Profile2D | AIDA implementation for 2 D profiles using ROOT TProfile2D
HistoryObj | Base class for History Objects
AlgorithmHistory | AlgorithmHistory class definition
AlgToolHistory | AlgToolHistory class definition
DataHistory | DataHistory class definition
JobHistory | JobHistory class definition
ServiceHistory | ServiceHistory class definition
NTuple::Directory | Small class representing an N tuple directory in the transient store
NTuple::File | Small class representing an N tuple file in the transient store
NTuple::Tuple | Abstract base class which allows the user to interact with the actual N tuple implementation
NTuple::TupleImp |
NTuple::ColumnWiseTuple |
NTuple::RowWiseTuple |
ObjectContainerBase | ObjectContainerBase is the base class for Gaudi container classes
KeyedContainer< DATATYPE, MAPPING > | Template class KeyedContainer, KeyedContainer.h
ObjectList< TYPE > | ObjectList is one of the basic Gaudi container classes capable of being registered in Data Stores
ObjectVector< TYPE > | ObjectVector is one of the basic Gaudi container classes capable of being registered in Data Stores
SharedObjectsContainer< TYPE > | Very simple class to represent the container of objects which are not ownered by the container
RefTableBase< FROM, MAPENTRY > | Template <class FROM, class TO, class MAPENTRY> class RefTable
RefTableBase< FROM, SmartRef< TO > > |
RefTable1to1< FROM, TO > |
RefTableBase< FROM, SmartRefVector< TO > > |
RefTable1toN< FROM, TO > |
DataStoreItem | Description of the DataStoreItem class
DataTypeInfo | Small class which allows access to internal type IDs
AlgTool::declareInterface< I > |
Decorator | Simple class with allows to "decorate" the python algorithm with 'basic' funtionality from class GaudiAlgorithm
Containers::array::decrement |
GaudiKernel.Configurable.Configurable.DefaultName | For detecting the default name
Gaudi::Parsers::BoolGrammar< Iterator, Skipper >::definition |
Gaudi::Parsers::CharGrammar< RT >::definition< ScannerT > |
Gaudi::Parsers::IntGrammar< RT >::definition< ScannerT > |
Gaudi::Parsers::RealGrammar< Iterator, Skipper >::definition< ScannerT > |
Gaudi::Parsers::StringGrammar< Iterator, Skipper >::definition |
Gaudi::Parsers::SkipperGrammar< Iterator >::definition |
Gaudi::Parsers::PairGrammar< KeyGrammarT, ValueGrammarT >::definition< ScannerT > |
Gaudi::Parsers::VectorGrammar< GrammarT >::definition< ScannerT > |
Gaudi::Parsers::MapGrammar< KeyGrammarT, ValueGrammarT >::definition< ScannerT > |
DHH |
dict |
GaudiKernel.ConfigurableDb._CfgDb |
GaudiMP.FdsRegistry.FdsDict |
GaudiProfiling.GenerateGaudiOpts.XmlDictObject |
DirSearchPath | Search for files in a list of directories
DisplacementVector3D< CoordSystem, Tag > |
Gaudi::IODataManager::Entry |
EqSolver::EqSolverMisc |
Tuples::detail::ErrorHandler< OBJECT, FUNCTION > | Concrete error handlers for dealing with classes, which supports member functions Error,Warning and Print ( e.g
EventIterator< TYPE > |
ExcelPlotter.Excel |
Exception |
EnvConfig.Variable.EnvError |
pyparsing.ParseBaseException |
pyparsing.ParseException |
pyparsing.ParseFatalException |
pyparsing.ParseSyntaxException |
pyparsing.RecursiveGrammarException |
std::exception [external] | STL class
Gaudi::PluginService::Exception |
GaudiException | Define general base for Gaudi exception
TimeException | Exception thrown by Gaudi::Time
UpdateManagerException | Exception thrown by the UpdateManagerSvc when something goes wrong
std::runtime_error [external] | STL class
Gaudi::Parsers::PositionalPropertyValueException |
Gaudi::Parsers::PropertyValueException |
std::runtime_error [external] | STL class
Gaudi::Guards::ExceptionGuard | The most simple guard - it execute the certain code withing typical "try {} catch" clause, used in Auditor, Algorithm, AlgTool, etc
Gaudi::PluginService::Details::Factory< T > | Class providing default factory functions
Gaudi::PluginService::Factory0< R > | Class wrapping the signature for a factory without arguments
Gaudi::PluginService::Factory1< R, A1 > | Class wrapping the signature for a factory with 1 argument
Gaudi::PluginService::Factory2< R, A1, A2 > | Class wrapping the signature for a factory with 2 arguments
Gaudi::PluginService::Factory3< R, A1, A2, A3 > | Class wrapping the signature for a factory with 3 arguments
Gaudi::PluginService::Details::Registry::FactoryInfo |
Io::FileAttr |
Io::FileHdlr |
FileInfo |
GaudiTest.FilePreprocessor |
GaudiTest.BlockSkipper |
GaudiTest.FilePreprocessorSequence |
GaudiTest.LineSkipper |
GaudiTest.LineSorter | Special preprocessor sorting the list of strings (whitespace separated) that follow a signature on a single line
GaudiTest.RegexpReplacer |
GaudiMP.pTools.FileRecordsAgent |
Filter |
GaudiKernel.ProcessJobOptions.LogFilter |
Filter |
GaudiTest.GaudiFilterExecutable |
Containers::find< CONT > |
Gaudi::Parsers::PairGrammar< KeyGrammarT, ValueGrammarT >::first |
Gaudi::Parsers::KeyValueGrammar< Iterator, Skipper >::first |
ana.FirstSummary |
Formatter |
GaudiKernel.ProcessJobOptions.LogFormatter |
FuncMinimum::FuncMinimumMisc |
Gaudi | This is a number of static methods for bootstrapping the Gaudi framework
GaudiDll |
GaudiGSL | Helper class to get (static) access to Gaudi GSL Service General users are not supposed to use it
GaudiHandleInfo |
GaudiHandleArrayBase | Base class of array's of various gaudihandles
GaudiHandleArray< T > | T is the concrete handle type, e.g
GaudiHandleArray< ServiceHandle< T > > |
ServiceHandleArray< T > | Array of Handles to be used in lieu of vector of naked pointers to tools
GaudiHandleArray< ToolHandle< T > > |
ToolHandleArray< T > | Array of Handles to be used in lieu of vector of naked pointers to tools
GaudiHandleBase | Base class to handles to be used in lieu of naked pointers to various Gaudi components
GaudiHandle< T > | Handle to be used in lieu of naked pointers to gaudis
ServiceHandle< T > | Handle to be used in lieu of naked pointers to services
ToolHandle< T > | Handle to be used in lieu of naked pointers to tools
GaudiHandle< IToolSvc > |
ServiceHandle< IToolSvc > |
Generator< TYPE > |
GetData< TYPE > |
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< TYPE & > | Template specialization for reference types
Gaudi::Utils::GetData< TYPE * > | Template specialization for pointer 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< Gaudi::Range_< std::vector< const TYPE * > > > |
Gaudi::Utils::GetData< Range > |
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< 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 * > |
Gaudi::Utils::GetOrCreateData< Gaudi::NamedRange_< std::vector< const TYPE * > >, TYPE2 > |
Gaudi::Utils::GetOrCreateData< Gaudi::Range_< std::vector< const TYPE * > >, TYPE2 > |
Gaudi::Utils::GetOrCreateData< Range_, TYPE2 > |
THistSvc::GlobalDirectoryRestore |
GlobalDirectoryRestore |
grammar |
Gaudi::Parsers::BoolGrammar< Iterator, Skipper > | The valid represenation of boolean values are:
Gaudi::Parsers::BoolGrammar< Iterator, Skipper > | The valid represenation of boolean values are:
Gaudi::Parsers::BoolGrammar< Iterator, Skipper > | The valid represenation of boolean values are:
Gaudi::Parsers::CharGrammar< RT > | The valid represenation of char values are:
Gaudi::Parsers::CharGrammar< RT > | The valid represenation of char values are:
Gaudi::Parsers::EdgeGrammar< Iterator, Skipper > |
Gaudi::Parsers::FileGrammar< Iterator, Skipper > |
Gaudi::Parsers::H1Grammar< Iterator, Skipper > |
Gaudi::Parsers::H2Grammar< Iterator, Skipper > |
Gaudi::Parsers::Histo1DGrammar< Iterator, Skipper > |
Gaudi::Parsers::IdentifierGrammar< Iterator, Skipper > |
Gaudi::Parsers::IntGrammar< RT > | The valid representation of integers values are:
Gaudi::Parsers::IntGrammar< RT > | The valid representation of integers values are:
Gaudi::Parsers::KeyValueGrammar< Iterator, Skipper > |
Gaudi::Parsers::MapGrammar< KeyGrammarT, ValueGrammarT > | The valid represenation of map are:
Gaudi::Parsers::MapGrammar< KeyGrammarT, ValueGrammarT > | The valid represenation of map are:
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
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
Gaudi::Parsers::Pnt3DGrammar< Iterator, PointT, Skipper > |
Gaudi::Parsers::Pnt4DGrammar< Iterator, PointT, Skipper > |
Gaudi::Parsers::RealGrammar< Iterator, Skipper > | The valid represenation of real values are:
Gaudi::Parsers::RealGrammar< Iterator, Skipper > | The valid represenation of real values are:
Gaudi::Parsers::RealGrammar< Iterator, Skipper > | The valid represenation of real values are:
Gaudi::Parsers::SkipperGrammar< Iterator > | Skipping spaces and comments
Gaudi::Parsers::SkipperGrammar< Iterator > | Skipping spaces and comments
Gaudi::Parsers::SkipperGrammar< Iterator > | Skipping spaces and comments
Gaudi::Parsers::StringGrammar< Iterator, Skipper > | The valid represenation of string values are:
Gaudi::Parsers::StringGrammar< Iterator, Skipper > | The valid represenation of string values are:
Gaudi::Parsers::StringGrammar< Iterator, Skipper > | The valid represenation of string values are:
Gaudi::Parsers::UnitsGrammar< Iterator, Skipper > |
Gaudi::Parsers::VectorGrammar< GrammarT > | The valid represenation of vector are:
Gaudi::Parsers::VectorGrammar< GrammarT > | The valid represenation of vector are:
Gaudi::Parsers::IdentifierGrammar< Iterator, double > |
Gaudi::Parsers::IntGrammar< Iterator, unsigned int, Skipper > |
Gaudi::Parsers::IntGrammar< Iterator, unsigned int, Skipper > |
Gaudi::Parsers::RealGrammar< Iterator, double, Skipper > |
Gaudi::Parsers::RealGrammar< Iterator, double, Skipper > |
Gaudi::Parsers::RealGrammar< Iterator, double, Skipper > |
Gaudi::Parsers::VectorGrammar< Iterator, std::vector< double >, Skipper > |
Gaudi::Parsers::VectorGrammar< Iterator, std::vector< double >, Skipper > |
Gaudi::Parsers::VectorGrammar< Iterator, std::vector< std::pair< double, double > >, Skipper > |
Gaudi::Parsers::VectorGrammar< Iterator, std::vector< std::pair< double, double > >, Skipper > |
Gaudi::Parsers::Grammar_< Iterator, T, Skipper, Enable > |
Gaudi::Parsers::Grammar_< Iterator, GaudiUtils::VectorMap< KeyT, ValueT, KeyCompareT, AllocatorT >, Skipper > |
Gaudi::Parsers::Grammar_< Iterator, ROOT::Math::DisplacementVector3D< T1, T2 >, Skipper > |
Gaudi::Parsers::Grammar_< Iterator, ROOT::Math::LorentzVector< T1 >, Skipper > |
Gaudi::Parsers::Grammar_< Iterator, ROOT::Math::PositionVector3D< T1, T2 >, Skipper > |
Gaudi::Parsers::Grammar_< Iterator, Scalar, Skipper > |
Gaudi::Parsers::Grammar_< Iterator, ScalarT, Skipper > |
Gaudi::Parsers::Grammar_< Iterator, std::list< InnerT, AllocatorT >, Skipper > |
Gaudi::Parsers::Grammar_< Iterator, std::map< KeyT, ValueT, KeyCompareT, AllocatorT >, Skipper > |
Gaudi::Parsers::Grammar_< Iterator, std::pair< KeyT, ValueT >, Skipper > |
Gaudi::Parsers::Grammar_< Iterator, std::set< InnerT, CompareT, AllocatorT >, Skipper > |
Gaudi::Parsers::Grammar_< Iterator, std::vector< InnerT, AllocatorT >, Skipper > |
Gaudi::Parsers::Grammar_< Iterator, T, Skipper, typename boost::enable_if< boost::is_floating_point< T > >::type > |
Gaudi::Parsers::Grammar_< Iterator, T, Skipper, typename boost::enable_if< boost::is_integral< T > >::type > |
Gaudi::Parsers::Grammar_< Iterator, typename MapT::key_type, Skipper > |
Gaudi::Parsers::Grammar_< Iterator, typename MapT::mapped_type, Skipper > |
Gaudi::Parsers::Grammar_< Iterator, typename PairT::first_type, Skipper > |
Gaudi::Parsers::Grammar_< Iterator, typename PairT::second_type, Skipper > |
Gaudi::Parsers::Grammar_< Iterator, typename VectorT::value_type, Skipper > |
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
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
GaudiMP.pTools.HistoAgent |
GaudiPython::HistoDecorator | Simple decorator class to allow to reuse the functionality of GaudiHistos<TYPE> class in pythin
GaudiPython.HistoUtils.HistoFile |
Gaudi::HistogramBase | Common base class for all histograms Use is solely functional to minimize dynamic_casts inside HistogramSvc
Gaudi::Generic1D< INTERFACE, IMPLEMENTATION > | Common AIDA implementation stuff for histograms and profiles using ROOT implementations
Gaudi::Histogram1D | AIDA implementation for 1 D histograms using ROOT THD1
Gaudi::Profile1D | AIDA implementation for 1 D profiles using ROOT TProfile
Gaudi::Generic2D< INTERFACE, IMPLEMENTATION > | Common AIDA implementation stuff for histograms and profiles using ROOT implementations
Gaudi::Histogram2D | AIDA implementation for 2 D histograms using ROOT THD2
Gaudi::Profile2D | AIDA implementation for 2 D profiles using ROOT TProfile2D
Gaudi::Generic3D< INTERFACE, IMPLEMENTATION > | Common AIDA implementation stuff for histograms and profiles using ROOT implementations
Gaudi::Histogram3D | AIDA implementation for 2 D histograms using ROOT THD2
Gaudi::Generic1D< AIDA::IHistogram1D, TH1D > |
Gaudi::Generic1D< AIDA::IProfile1D, TProfile > |
Gaudi::Generic2D< AIDA::IProfile2D, TProfile2D > |
Gaudi::Generic2D< IHistogram2D, TH2D > |
Gaudi::Generic3D< AIDA::IHistogram3D, TH3D > |
Gaudi::Utils::HistoStats | The collection of trivial functions to access the statistical information for the histograms
Gaudi::Utils::Histos::HistoStrings | Helper class to produce "good" dictionaries
IAxis |
Gaudi::Axis | An IAxis represents a binned histogram axis
ibs_param_t |
ibsfetchctl_t |
ibsopctl_t |
ibsopdata2_t |
ibsopdata3_t |
ibsopdata_t |
IClassInfo | Data base class allowing to store persistent type information
GaudiAlg::ID | ID class for Histogram and Ntuples
Gaudi::IDataConnection | ABC describing basic data connection
Gaudi::RootDataConnection | Concrete implementation of the IDataConnection interface to access ROOT files
IDataStoreAgent | Generic data agent interface
DataSelectionAgent | DataSelectionAgent base in charge of collecting all the refereces to DataObjects in a transient store that passes some selection criteria
GaudiMP::TESSerializer |
HistogramAgent | HistogramAgent base in charge of collecting all the refereces to DataObjects in a transient store that passes some selection criteria
OutputStreamAgent |
StreamBuffer::IdentifiedLink | Definition of the contained link set
IFileCatalog |
extend_interfaces1< IFileCatalog > |
implements1< IFileCatalog > |
Gaudi::XMLFileCatalog | This class constitutes the core of the XML based FileCatalog API for POOL
extend_interfaces2< IFileCatalog, IFileCatalogMgr > |
IFileCatalogMgr |
extend_interfaces2< IFileCatalog, IFileCatalogMgr > |
IgHookTrace |
IgHookTraceAlloc |
IgnoreError |
IHistogram1D |
Gaudi::Generic1D< AIDA::IHistogram1D, TH1D > |
IHistogram3D |
Gaudi::Generic3D< AIDA::IHistogram3D, TH3D > |
IHistogramFactory |
HistogramSvc | HistogramSvc class definition
IInspectable | Interface definition of an inspectable object
IInterface | Definition of the basic interface
extend_interfaces1< IInterface > |
implements1< IInterface > |
EventSelectorDataStream | Definition of class EventSelectorDataStream
Gaudi::IFileCatalog | File catalog interface
Gaudi::IFileCatalogMgr | File catalog manager
Gaudi::IIODataManager |
Gaudi::ISignalMonitor | Interface for the service that monitors the occurrences of system signals
extend_interfaces1< Gaudi::ISignalMonitor > |
extends1< Service, Gaudi::ISignalMonitor > |
Gaudi::Utils::SignalMonitorSvc | Implementation of Gaudi::ISignalMonitor
IAddressCreator | IAddressCreator interface definition
extend_interfaces2< IConversionSvc, IAddressCreator > |
extend_interfaces3< IConversionSvc, IPersistencySvc, IAddressCreator > |
IAlgContextSvc | An abstract interface for Algorithm Context Service
extend_interfaces2< IAlgContextSvc, IIncidentListener > |
IAppMgrUI | Application Manager User Interface
extend_interfaces4< IAppMgrUI, IEventProcessor, IService, IStateful > |
IChronoSvc | "Chrono"-related part of interface IChronoStatSvc
extend_interfaces3< IService, IChronoSvc, IStatSvc > |
IChronoStatSvc | The IChronoStatSvc is the interface implemented by the ChronoStatService
extend_interfaces2< IChronoStatSvc, IIncidentListener > |
IClassManager | The IClassManager is the interface implemented by the generic Factory in the Application Manager to support class management functions
extend_interfaces1< IClassManager > |
implements1< IClassManager > |
DLLClassManager |
IConverter | The data converters are responsible to translate data from one representation into another
extend_interfaces1< IConverter > |
implements1< IConverter > |
Converter | Converter base class
Gaudi::RootConverter | Description: Definition of the ROOT data converter
Gaudi::RootStatCnv | Description: Base class converter for N-tuples and related classes
Gaudi::RootDirectoryCnv | Description: NTuple directory converter class definition Definition of the converter to manage the directories in an database representing N-Tuples
Gaudi::RootDatabaseCnv | Statistics file converter class definition
Gaudi::RootNTupleCnv | NTuple converter class definition for NTuples writted/read using ROOT
RootHistCnv::RConverter | Root Converter
RootHistCnv::DirectoryCnv |
RootHistCnv::RDirectoryCnv | Create persistent and transient representations of data store directories
RootHistCnv::RFileCnv | NTuple converter class definition
RootHistCnv::RHistogramCnv< T, S, Q > | Generic converter to save/read AIDA_ROOT histograms using ROOT
RootHistCnv::RNTupleCnv | NTuple converter class definition
RootHistCnv::RCWNTupleCnv | Converter of Column-wise NTuple into ROOT format
RootHistCnv::RRWNTupleCnv | Row wise NTuple converter class definition
IConversionSvc |
extend_interfaces2< IConversionSvc, IAddressCreator > |
extend_interfaces3< IConversionSvc, IPersistencySvc, IAddressCreator > |
ICounterSvc | Create / access multi purpose counters
extend_interfaces1< ICounterSvc > |
extends1< Service, ICounterSvc > |
CounterSvc | Simple implementation of the abstract interface ICounterSvc
IDataManagerSvc |
extend_interfaces2< IDataProviderSvc, IDataManagerSvc > |
extend_interfaces3< IDataProviderSvc, IDataManagerSvc, IPartitionControl > |
IDataProviderSvc | Data provider interface definition
extend_interfaces2< IDataProviderSvc, IDataManagerSvc > |
extend_interfaces3< IDataProviderSvc, IDataManagerSvc, IPartitionControl > |
IAIDATupleSvc | Definition of the IAIDATupleSvc interface class
IHistogramSvc | Definition of the IHistogramSvc interface class
extend_interfaces1< IHistogramSvc > |
extends1< DataSvc, IHistogramSvc > |
HistogramSvc | HistogramSvc class definition
INTupleSvc |
extend_interfaces2< INTupleSvc, IDataSourceMgr > |
IDataSourceMgr | IDataSourceMgr interface definition
extend_interfaces2< INTupleSvc, IDataSourceMgr > |
IDetDataSvc |
extend_interfaces2< IDetDataSvc, IIncidentListener > |
IEventProcessor | The IEventProcessor is the interface to process events
extend_interfaces1< IEventProcessor > |
extends1< Service, IEventProcessor > |
MinimalEventLoopMgr | This is the default processing manager of the application manager
EventLoopMgr | Class definition of EventLoopMgr
extend_interfaces4< IAppMgrUI, IEventProcessor, IService, IStateful > |
IEvtSelector | The Event Selector Interface
extend_interfaces1< IEvtSelector > |
extends1< Service, IEvtSelector > |
EventCollectionSelector | Definition of class EventCollectionSelector
EventSelector | Definition of class EventSelector
Gaudi::RootEvtSelector | Concrete event selector implementation to access ROOT files
IExceptionSvc | The abstract interface for exception handling service
extend_interfaces1< IExceptionSvc > |
extends1< Service, IExceptionSvc > |
ExceptionSvc | Simple implementation of IExceptionSvc abstract interface
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
extend_interfaces1< IFileAccess > |
extends1< AlgTool, IFileAccess > |
FileReadTool | Basic implementation of the IFileAccess interface
extends1< Service, IFileAccess > |
VFSSvc | Simple service that allows to read files independently from the storage
IInactiveMessageCounter |
extend_interfaces2< IMessageSvc, IInactiveMessageCounter > |
IIncidentListener | The interface implemented by any class wanting to listen to Incidents
extend_interfaces1< IIncidentListener > |
extends1< Auditor, IIncidentListener > |
Google::AuditorBase | Base for Google Auditors
Google::CPUProfiler | Auditor using the Google CPU Profiler
Google::HeapChecker | Auditor using the Google Heap Checker
Google::HeapProfiler | Auditor based on the Google Heap Profiler
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
extends1< DataSvc, IIncidentListener > |
RecordDataSvc | A RecordDataSvc is the base class for event services
FileRecordDataSvc | A FileRecordDataSvc is the base class for event services
RunRecordDataSvc | A RunRecordDataSvc is the base class for event services
extends1< Service, IIncidentListener > |
DataOnDemandSvc | The DataOnDemandSvc listens to incidents typically triggered by the data service of the configurable name "IncidentName"
Gaudi::Utils::StopSignalHandler | Service that stop the processing if a signal is received
StalledEventMonitor | Service that monitor the time taken by processing of single events using a separate thread
extend_interfaces2< IAlgContextSvc, IIncidentListener > |
extend_interfaces2< IChronoStatSvc, IIncidentListener > |
extend_interfaces2< IDataStoreLeaves, IIncidentListener > |
extend_interfaces2< IDetDataSvc, IIncidentListener > |
extend_interfaces2< IFileMgr, IIncidentListener > |
extend_interfaces2< IHistorySvc, IIncidentListener > |
extend_interfaces2< IIoComponentMgr, IIncidentListener > |
extend_interfaces3< IRndmEngine, ISerialize, IIncidentListener > |
extend_interfaces3< ITHistSvc, IIncidentListener, IIoComponent > |
Gaudi::RootPerfMonSvc | Description:
IntelProfilerAuditor |
IIncidentSvc | The interface implemented by the IncidentSvc service
extend_interfaces1< IIncidentSvc > |
extends1< Service, IIncidentSvc > |
IncidentSvc | Default implementation of the IIncidentSvc interface
IInspector | Inspector base class
IJobOptionsSvc | Main interface for the JobOptions service
extend_interfaces2< IProperty, IJobOptionsSvc > |
IMessageSvc | The IMessage is the interface implemented by the message service
extend_interfaces2< IMessageSvc, IInactiveMessageCounter > |
IMonitorSvc | Definition of the IMonitorSvc interface, which publishes Gaudi variables to outside monitoring processes
INamedInterface | IInterface compliant class extending IInterface with the name() method
IAlgorithm | The IAlgorithm is the interface implemented by the Algorithm base class
extend_interfaces3< IAlgorithm, IProperty, IStateful > |
IAlgTool | The interface implemented by the AlgTool base class
extend_interfaces3< IAlgTool, IProperty, IStateful > |
IDataStoreLeaves | Interface for a tool or service that returns a list of leaves (paths) in a transient store
extend_interfaces2< IDataStoreLeaves, IIncidentListener > |
IDataStreamTool |
extend_interfaces1< IDataStreamTool > |
extends1< AlgTool, IDataStreamTool > |
DataStreamTool |
IDODAlgMapper | Interface of tools used by the DataOnDemandSvc to choose the algorithm to be run to produce the data at a path
extend_interfaces2< IDODAlgMapper, IDODNodeMapper > |
IDODNodeMapper | Interface of tools used by the DataOnDemandSvc to choose the type of node to be created at a path
extend_interfaces2< IDODAlgMapper, IDODNodeMapper > |
IEqSolver | Interface file for multidimensional root-finding (solving nonlinear system with n equations in n unknowns)
extend_interfaces1< IEqSolver > |
extends1< GaudiTool, IEqSolver > |
EqSolver | The simplest concrete implementation of IEqSolver interface
IErrorTool |
ErrorTool |
IEventTimeDecoder | Interface that a Tool that decodes the event time has to implement
IFuncMinimum | Interface file to find minimum of the function and compute covariance matrix (matrix of error)
extend_interfaces1< IFuncMinimum > |
extends1< GaudiTool, IFuncMinimum > |
FuncMinimum | The simplest concrete implementation of IFuncMinimum interface
IGenericTool | General purpose interface class for tools that "do something"
IGslErrorHandler | The abstract interface for arbitrary GSL error handler
extend_interfaces1< IGslErrorHandler > |
extends1< AlgTool, IGslErrorHandler > |
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
IHistoTool | An abstract interface for "histogramming tool"
HistoTool | Simple tool for histogramming (component)
ISequencerTimerTool | Implements the time measurement inside a sequencer
SequencerTimerTool | Implements the time measurement inside a sequencer
ITupleTool |
TupleTool |
IAuditor | The IAuditor is the interface implmented by the AlgAuditor base class
extend_interfaces2< IAuditor, IProperty > |
extend_interfaces2< IService, IAuditor > |
IAuditorSvc | The interface implemented by the IAuditorSvc base class
extend_interfaces1< IAuditorSvc > |
extends1< Service, IAuditorSvc > |
AuditorSvc |
IIoComponent |
extend_interfaces3< ITHistSvc, IIncidentListener, IIoComponent > |
IIoComponentMgr |
extend_interfaces2< IIoComponentMgr, IIncidentListener > |
IService | General service interface definition
extend_interfaces2< IService, IAuditor > |
extend_interfaces3< IService, IChronoSvc, IStatSvc > |
extend_interfaces3< IService, IProperty, IStateful > |
extend_interfaces4< IAppMgrUI, IEventProcessor, IService, IStateful > |
ICounterSummarySvc | Simple service interface to collect counters to persist in a summary file
IFileMgr |
extend_interfaces2< IFileMgr, IIncidentListener > |
IGslSvc | The abstract interface to "deal" with GNU Scientific Library (GLS) The main task is the error handling
extend_interfaces1< IGslSvc > |
extends1< Service, IGslSvc > |
GslSvc | The implementation of IGslSvc interface
IHistorySvc | Definition of the IHistorySvc interface class
extend_interfaces2< IHistorySvc, IIncidentListener > |
IIssueLogger |
extend_interfaces1< IIssueLogger > |
extends1< Service, IIssueLogger > |
IssueLogger |
IMagneticFieldSvc | The interface to the MagneticFieldSvc
IParticlePropertySvc | This class is an interface to the ParticlePropertySvc
extend_interfaces1< IParticlePropertySvc > |
extends1< Service, IParticlePropertySvc > |
Gaudi::ParticlePropertySvc | This service provides access to particle properties
IPartPropSvc |
extend_interfaces1< IPartPropSvc > |
extends1< Service, IPartPropSvc > |
PartPropSvc |
IRndmGenSvc | Random Generator service interface definition Definition of a interface for a service to access random generators according to predefined distributions:
extend_interfaces3< IRndmGenSvc, IRndmEngine, ISerialize > |
IStatusCodeSvc |
extend_interfaces1< IStatusCodeSvc > |
extends1< Service, IStatusCodeSvc > |
StatusCodeSvc |
ITHistSvc |
extend_interfaces3< ITHistSvc, IIncidentListener, IIoComponent > |
IPartitionControl | Create / access partitions
extend_interfaces1< IPartitionControl > |
extends1< Algorithm, IPartitionControl > |
PartitionSwitchAlg | Small algorith, which switches the partition of a configurable multi-service
extends1< AlgTool, IPartitionControl > |
PartitionSwitchTool |
extend_interfaces3< IDataProviderSvc, IDataManagerSvc, IPartitionControl > |
IPersistencySvc | Data persistency service interface
extend_interfaces3< IConversionSvc, IPersistencySvc, IAddressCreator > |
IProperty | The IProperty is the basic interface for all components which have properties that can be set or get
extend_interfaces1< IProperty > |
implements1< IProperty > |
PropertyMgr | Property manager helper class
extend_interfaces2< IAuditor, IProperty > |
extend_interfaces2< IProperty, IJobOptionsSvc > |
extend_interfaces3< IAlgorithm, IProperty, IStateful > |
extend_interfaces3< IAlgTool, IProperty, IStateful > |
extend_interfaces3< IService, IProperty, IStateful > |
IRndmEngine | Definition of a interface for a generic random number generator giving randomly distributed numbers in the range [0...1] number generators
extend_interfaces3< IRndmEngine, ISerialize, IIncidentListener > |
extend_interfaces3< IRndmGenSvc, IRndmEngine, ISerialize > |
IRndmGen | Definition of a interface for a generic random number generators
extend_interfaces1< IRndmGen > |
implements1< IRndmGen > |
RndmGen | Random Generator definition
HepRndm::Generator< TYPE > |
HepRndm::Generator< Rndm::DefinedPdf > |
IRunable | Runable interface definition
extend_interfaces1< IRunable > |
extends1< Service, IRunable > |
AppMgrRunable | Class definition of AppMgrRunable
PythonScriptingSvc | This service handles scripting implemented using Python
ISelectStatement | A select statement can either contain
extend_interfaces1< ISelectStatement > |
implements1< ISelectStatement > |
SelectStatement | Class of a selection statement
NTuple::Selector | NTuple Selector class
ISerialize | Object serialization interface definition
extend_interfaces3< IRndmEngine, ISerialize, IIncidentListener > |
extend_interfaces3< IRndmGenSvc, IRndmEngine, ISerialize > |
IStagerSvc |
IStateful | Interface for classes that implement the Gaudi State Machine
extend_interfaces3< IAlgorithm, IProperty, IStateful > |
extend_interfaces3< IAlgTool, IProperty, IStateful > |
extend_interfaces3< IService, IProperty, IStateful > |
extend_interfaces4< IAppMgrUI, IEventProcessor, IService, IStateful > |
IComponentManager |
extend_interfaces1< IComponentManager > |
implements1< IComponentManager > |
CommonMessaging< implements1< IComponentManager > > |
ComponentManager | Base class for a component manager
extends1< ComponentManager, IAlgManager > |
AlgorithmManager | In charge of the creation of concrete instances of Algorithms
extends2< ComponentManager, ISvcManager, ISvcLocator > |
ServiceManager | In charge of the creation of concrete instances of Services
IAlgManager | The IAlgManager is the interface implemented by the Algorithm Factory in the Application Manager to support management functions
extend_interfaces1< IAlgManager > |
extends1< ComponentManager, IAlgManager > |
ISvcManager | The ISvcManager is the interface implemented by the Service Factory in the Application Manager to support management functions
extend_interfaces2< ISvcManager, ISvcLocator > |
IStatSvc | "Stat"-related part of interface IChronoStatSvc
extend_interfaces3< IService, IChronoSvc, IStatSvc > |
ISvcLocator | The ISvcLocator is the interface implemented by the Service Factory in the Application Manager to locate services in the framework
extend_interfaces1< ISvcLocator > |
implements1< ISvcLocator > |
Gaudi::BootSvcLocator | A dual-stage boostrap mechanism is used to ensure an orderly startup of the ApplicationMgr
extend_interfaces2< ISvcManager, ISvcLocator > |
IToolSvc | The interface implemented by the IToolSvc base class
extend_interfaces1< IToolSvc > |
extends1< Service, IToolSvc > |
ToolSvc | This service manages tools
IUpdateableIF |
IUpdateManagerSvc | Interface class to the Update Manager service
IIODataManager |
extend_interfaces1< IIODataManager > |
extends1< Service, IIODataManager > |
Gaudi::IODataManager |
Incident | Base class for all Incidents (computing events)
ContextIncident< T > |
FileIncident | This class is the FileIncident
ModuleIncident | Base class for Module-related incident
ModuleLoadedIncident | Fired when a module (DLL) is loaded
Gaudi::Parsers::IncludedFiles |
IndefiniteIntegral |
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
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< T > | Helper class for the cast used in the MPL for_each algorithm in the implementation of queryInterface
INTuple | NTuple interface class definition
NTuple::Tuple | Abstract base class which allows the user to interact with the actual N tuple implementation
INTupleItem | NTuple interface class definition
NTuple::_Data< bool > |
NTuple::_Item< bool > |
NTuple::_Data< IOpaqueAddress * > |
NTuple::_Item< IOpaqueAddress * > |
NTuple::_Data< TYP > | Abstract class describing basic data in an Ntuple
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
NTuple::_DataImp< TYP > | Concrete class discribing basic data items in an N tuple
NTuple::_ArrayImp< TYP > | Concrete class discribing a column-array in a N tuple
NTuple::_ItemImp< TYP > | Concrete class discribing a column in a N tuple
NTuple::_MatrixImp< TYP > | Concrete class discribing a matrix column in a N tuple
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
System::IO_COUNTERS | Process I/O Counters NtQueryInformationProcess using ProcessIoCounters
IoComponentMgr::IoComponentEntry |
Io::IoFlags |
IIoComponentMgr::IoMode |
IOpaqueAddress | Opaque address interface definition
GenericAddress | Generic Transient Address
Gaudi::RootAddress | Description:
RootHistCnv::RootObjAddress |
IProfile1D |
Gaudi::Generic1D< AIDA::IProfile1D, TProfile > |
IProfile2D |
Gaudi::Generic2D< AIDA::IProfile2D, TProfile2D > |
IRegistry | The IRegistry represents the entry door to the environment any data object residing in a transient data store is embedded
DataSvcHelpers::RegistryEntry | Definition of an entry in the transient data store
IssueSeverity |
Item< TYP > |
Tuples::ItemStore< VALUE > | Simple class, which represents the local storage of N-tuple items of the given type
IUpdateable | Object update interface definition
IUpdateableIF |
IUpdateableInterface | Component interface counterpart to the above ABC
IValidity | Interface for objects with a validity
IInspector::IValue |
IInspector::_V< T > |
IVersHistoryObj | Interface for Versioned History Objects
AlgorithmHistory | AlgorithmHistory class definition
AlgToolHistory | AlgToolHistory class definition
JobHistory | JobHistory class definition
ServiceHistory | ServiceHistory class definition
GaudiKernel.ProcessJobOptions.JobOptsParser |
System::KERNEL_USER_TIMES | Process/Thread System and User Time NtQueryInformationProcess using ProcessTimes NtQueryInformationThread using ThreadTimes
key_compare |
GaudiUtils::VectorMap< KEY, VALUE, KEYCOMPARE, ALLOCATOR >::_compare_type | The actual structure used to compare the elements Only "key" is important for comparison
key_traits< KEY > | Key traits class
Containers::key_traits< KEY > | Definition of the key traits class
Containers::key_traits< DATATYPE::key_type > |
Containers::traits< CONTAINER, DATATYPE > | Definition of the container traits class
KeyedContainerDict< T > |
KeyedObjectDict< T > |
Containers::KeyedObjectManager< SETUP > | KeyedObjectManager Class to manage keyed objects
DataOnDemandSvc::Leaf |
StoreSnifferAlg::LeafInfo |
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 |
list |
GaudiKernel.GaudiHandles.GaudiHandleArray |
GaudiKernel.GaudiHandles.PrivateToolHandleArray |
GaudiKernel.GaudiHandles.PublicToolHandleArray |
GaudiKernel.GaudiHandles.ServiceHandleArray |
IncidentSvc::Listener |
Gaudi::Utils::LockedChrono | Helper object, useful for measurement of CPU-performance of highly-recursive structures, e.g
install.LogFile |
Gaudi::PluginService::Details::Logger | Simple logging class, just to provide a default implementation
Lomont | The equality comparison of double numbers using as the metric the maximal number of Units in the Last Place (ULP)
Lomont< TYPE > |
GaudiMP.pTools.LumiFSR |
Containers::map |
Gaudi::Utils::MapBase | Helper base-class to allow the generic Python-decoration for all "map-like" classes in Gaudi
GaudiUtils::Map< K, T, M > | Extension of the STL map
GaudiUtils::HashMap< K, T, H, M > | Common class providing an architecture-independent hash map
GaudiUtils::HashMap< const void *, EntryType > |
GaudiUtils::HashMap< Gaudi::StringKey, Leaf > |
GaudiUtils::HashMap< Gaudi::StringKey, ListenerList * > |
GaudiUtils::HashMap< Gaudi::StringKey, Node > |
GaudiUtils::HashMap< long, void * > |
GaudiUtils::HashMap< std::string, Address * > |
GaudiUtils::HashMap< std::string, Bool * > |
GaudiUtils::HashMap< std::string, Char * > |
GaudiUtils::HashMap< std::string, Double * > |
GaudiUtils::HashMap< std::string, FArray * > |
GaudiUtils::HashMap< std::string, Float * > |
GaudiUtils::HashMap< std::string, FMatrix * > |
GaudiUtils::HashMap< std::string, Gaudi::Utils::TypeNameString > |
GaudiUtils::HashMap< std::string, IFileAccess * > |
GaudiUtils::HashMap< std::string, Int * > |
GaudiUtils::HashMap< std::string, int > |
GaudiUtils::HashMap< std::string, LongLong * > |
GaudiUtils::HashMap< std::string, NameMap > |
GaudiUtils::HashMap< std::string, NTuple::Item< VALUE > * > |
GaudiUtils::HashMap< std::string, Short * > |
GaudiUtils::HashMap< std::string, SmartIF< IAlgorithm > > |
GaudiUtils::HashMap< std::string, SmartIF< IService > > |
GaudiUtils::HashMap< std::string, std::string > |
GaudiUtils::HashMap< std::string, UChar * > |
GaudiUtils::HashMap< std::string, UInt * > |
GaudiUtils::HashMap< std::string, ULongLong * > |
GaudiUtils::HashMap< std::string, UShort * > |
GaudiUtils::VectorMap< KEY, VALUE, KEYCOMPARE, ALLOCATOR > | A bit modified version of 'Loki::AssocVector' associative vector from Loki library by Andrei Alexandrescu
GaudiUtils::Map< const void *, EntryType, __gnu_cxx::hash_map< const void *, EntryType, Hash< const void * > > > |
GaudiUtils::Map< Gaudi::StringKey, Leaf, __gnu_cxx::hash_map< Gaudi::StringKey, Leaf, Hash< Gaudi::StringKey > > > |
GaudiUtils::Map< Gaudi::StringKey, ListenerList *, __gnu_cxx::hash_map< Gaudi::StringKey, ListenerList *, Hash< Gaudi::StringKey > > > |
GaudiUtils::Map< Gaudi::StringKey, Node, __gnu_cxx::hash_map< Gaudi::StringKey, Node, Hash< Gaudi::StringKey > > > |
GaudiUtils::Map< InterfaceID, SmartIF< IInterface > > |
GaudiUtils::Map< long, void *, __gnu_cxx::hash_map< long, void *, Hash< long > > > |
GaudiUtils::Map< std::string, Address *, __gnu_cxx::hash_map< std::string, Address *, Hash< std::string > > > |
GaudiUtils::Map< std::string, Bool *, __gnu_cxx::hash_map< std::string, Bool *, Hash< std::string > > > |
GaudiUtils::Map< std::string, Char *, __gnu_cxx::hash_map< std::string, Char *, Hash< std::string > > > |
GaudiUtils::Map< std::string, Double *, __gnu_cxx::hash_map< std::string, Double *, Hash< std::string > > > |
GaudiUtils::Map< std::string, FArray *, __gnu_cxx::hash_map< std::string, FArray *, Hash< std::string > > > |
GaudiUtils::Map< std::string, Float *, __gnu_cxx::hash_map< std::string, Float *, Hash< std::string > > > |
GaudiUtils::Map< std::string, FMatrix *, __gnu_cxx::hash_map< std::string, FMatrix *, Hash< std::string > > > |
GaudiUtils::Map< std::string, Gaudi::Utils::TypeNameString, __gnu_cxx::hash_map< std::string, Gaudi::Utils::TypeNameString, Hash< std::string > > > |
GaudiUtils::Map< std::string, IFileAccess *, __gnu_cxx::hash_map< std::string, IFileAccess *, Hash< std::string > > > |
GaudiUtils::Map< std::string, Int *, __gnu_cxx::hash_map< std::string, Int *, Hash< std::string > > > |
GaudiUtils::Map< std::string, int, __gnu_cxx::hash_map< std::string, int, Hash< std::string > > > |
GaudiUtils::Map< std::string, LongLong *, __gnu_cxx::hash_map< std::string, LongLong *, Hash< std::string > > > |
GaudiUtils::Map< std::string, NameMap, __gnu_cxx::hash_map< std::string, NameMap, Hash< std::string > > > |
GaudiUtils::Map< std::string, NTuple::Item< VALUE > *, __gnu_cxx::hash_map< std::string, NTuple::Item< VALUE > *, Hash< std::string > > > |
GaudiUtils::Map< std::string, Short *, __gnu_cxx::hash_map< std::string, Short *, Hash< std::string > > > |
GaudiUtils::Map< std::string, SmartIF< IAlgorithm >, __gnu_cxx::hash_map< std::string, SmartIF< IAlgorithm >, Hash< std::string > > > |
GaudiUtils::Map< std::string, SmartIF< IService >, __gnu_cxx::hash_map< std::string, SmartIF< IService >, Hash< std::string > > > |
GaudiUtils::Map< std::string, std::string > |
GaudiUtils::Map< std::string, std::string, __gnu_cxx::hash_map< std::string, std::string, Hash< std::string > > > |
GaudiUtils::Map< std::string, UChar *, __gnu_cxx::hash_map< std::string, UChar *, Hash< std::string > > > |
GaudiUtils::Map< std::string, UInt *, __gnu_cxx::hash_map< std::string, UInt *, Hash< std::string > > > |
GaudiUtils::Map< std::string, ULongLong *, __gnu_cxx::hash_map< std::string, ULongLong *, Hash< std::string > > > |
GaudiUtils::Map< std::string, UShort *, __gnu_cxx::hash_map< std::string, UShort *, Hash< std::string > > > |
GaudiUtils::VectorMap< const INamedInterface *, int > |
Matrix< TYP > |
NTuple::Matrix< IOpaqueAddress * > |
MEMORY_MAPPED_FILE |
Message | The Message class
Gaudi::Parsers::Messages |
MessageSvc::MsgAry | Private helper class to keep the count of messages of a type (MSG::LEVEL)
MsgStream | Definition of the MsgStream class used to transmit messages
NamedRange | New concept of "named" range : range with name
DataOnDemandSvc::Node | Helper class of the DataOnDemandSvc
Gaudi::Parsers::Node |
Gaudi::Parsers::NodeOperations |
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
Rndm::Numbers | Random number accessor This small class encapsulates the use of the random number generator
object |
cmt2cmake.Package |
test_cmt2cmake.PackWrap |
cmt2cmake.Project |
test_cmt2cmake.ProjWrap |
EnvConfig.Control.Environment |
EnvConfig.Script |
EnvConfig.TestEnvOps.TempDir |
EnvConfig.Variable.VariableBase |
EnvConfig.Variable.List |
EnvConfig.Variable.Scalar |
EnvConfig.Variable.VariableProcessor |
EnvConfig.Variable.EnvExpander |
EnvConfig.Variable.ListProcessor |
EnvConfig.Variable.DuplicatesRemover |
EnvConfig.Variable.EmptyDirsRemover |
EnvConfig.Variable.UsePythonZip |
EnvConfig.Variable.PathNormalizer |
EnvConfig.Variable.ScalarProcessor |
EnvConfig.xmlModule.XMLFile |
Gaudi._ConfigurablesModule | Small class that allows to access all the configurables as attributes of the instance
Gaudi.Main.gaudimain |
GaudiKernel.Configurable.Configurable |
GaudiKernel.Configurable.ConfigurableAlgorithm |
GaudiKernel.Configurable.ConfigurableAlgTool |
GaudiKernel.Configurable.ConfigurableAuditor |
GaudiKernel.Configurable.ConfigurableGeneric |
GaudiKernel.Configurable.ConfigurableService |
GaudiKernel.Configurable.ConfigurableUser |
Gaudi.Configuration.GaudiPersistency |
GaudiKernel.Configurable.DummyDescriptor | Classes for generic Gaudi component ===========
GaudiKernel.Configurable.PropertyReference | Allow references to options as in old style
GaudiKernel.ConfigurableDb._Singleton |
GaudiKernel.GaudiHandles.GaudiHandle |
GaudiKernel.GaudiHandles.PrivateToolHandle |
GaudiKernel.GaudiHandles.PublicToolHandle |
GaudiKernel.GaudiHandles.ServiceHandle |
GaudiKernel.PropertyProxy.PropertyProxy |
GaudiKernel.PropertyProxy.GaudiHandlePropertyProxyBase |
GaudiKernel.PropertyProxy.GaudiHandleArrayPropertyProxy |
GaudiKernel.PropertyProxy.GaudiHandlePropertyProxy |
GaudiMP.GMPBase.Coord |
GaudiMP.GMPBase.EventCommunicator |
GaudiMP.GMPBase.GMPComponent |
GaudiMP.GMPBase.Reader |
GaudiMP.GMPBase.Subworker |
GaudiMP.GMPBase.Worker |
GaudiMP.GMPBase.Writer |
GaudiMP.GMPBase.MiniWriter |
GaudiMP.GMPBase.TESSerializer |
GaudiMP.IoRegistry.IoRegistry |
GaudiMP.Parallel.SshSession |
GaudiMP.Parallel.Statistics |
GaudiMP.Parallel.Task |
GaudiMP.Parallel.WorkManager |
GaudiMP.pTools.Syncer |
GaudiMP.pTools.SyncMini |
GaudiPython.Bindings.InterfaceCast |
GaudiPython.Bindings.Interface |
GaudiPython.Bindings.iProperty |
GaudiPython.Bindings.iAlgorithm |
GaudiPython.GaudiAlgs.GaudiAlgo | Base class for all algorithm Python-image of C++ clkass GaudiAlgorithm
GaudiPython.GaudiAlgs.HistoAlgo | The base class for easy histogramming
GaudiPython.GaudiAlgs.TupleAlgo | The base class for easy manupulations with N-Tuples
GaudiPython.Bindings.iAlgTool |
GaudiPython.Bindings.iService |
GaudiPython.Bindings.AppMgr |
GaudiPython.Bindings.iDataSvc |
GaudiPython.Bindings.iHistogramSvc |
GaudiPython.Bindings.iNTupleSvc |
GaudiPython.Bindings.iEventSelector |
GaudiPython.Bindings.iJobOptSvc |
GaudiPython.Bindings.iToolSvc |
GaudiPython.Bindings.PropertyEntry |
GaudiPython.GaudiAlgs.objectmethod |
GaudiPython.Persistency.FileDescription |
GaudiPython.Persistency.PersistencyHelper |
GaudiPython.Persistency.RootPersistency |
gaudirun.FakeModule |
locker.LockFile | Lock a file
make_heptools.HepToolsGenerator |
pyparsing._Constants |
pyparsing._NullToken |
pyparsing._ParseResultsWithOffset |
pyparsing.OnlyOnce |
pyparsing.ParserElement |
pyparsing.ParseElementEnhance |
pyparsing.FollowedBy |
pyparsing.Forward |
pyparsing._ForwardNoRecurse |
pyparsing.NotAny |
pyparsing.OneOrMore |
pyparsing.Optional |
pyparsing.SkipTo |
pyparsing.TokenConverter |
pyparsing.Combine |
pyparsing.Dict |
pyparsing.Group |
pyparsing.Suppress |
pyparsing.Upcase |
pyparsing.ZeroOrMore |
pyparsing.ParseExpression |
pyparsing.And |
pyparsing.Each |
pyparsing.MatchFirst |
pyparsing.Or |
pyparsing.Token |
pyparsing._PositionToken |
pyparsing.GoToColumn |
pyparsing.LineEnd |
pyparsing.LineStart |
pyparsing.StringEnd |
pyparsing.StringStart |
pyparsing.WordEnd |
pyparsing.WordStart |
pyparsing.CharsNotIn |
pyparsing.Empty |
pyparsing.And._ErrorStop |
pyparsing.Keyword |
pyparsing.CaselessKeyword |
pyparsing.Literal |
pyparsing.CaselessLiteral |
pyparsing.NoMatch |
pyparsing.QuotedString |
pyparsing.Regex |
pyparsing.White |
pyparsing.Word |
pyparsing.ParseResults |
run_qmtest.Options |
validate_patch.PatchData |
validate_patch.TempDir |
SmartDataObjectPtr::ObjectFinder | Helper class to configure smart pointer functionality
SmartDataObjectPtr::ObjectLoader | Helper class to configure smart pointer functionality
IToolSvc::Observer | Allow call-backs when a tool is a created or retrieved
Gaudi::Parsers::MapGrammar< KeyGrammarT, ValueGrammarT >::Operations |
Gaudi::Parsers::Pnt4DGrammar< Iterator, PointT, Skipper >::Operations |
Gaudi::Parsers::Histo1DGrammar< Iterator, Skipper >::Operations |
Gaudi::Parsers::Pnt3DGrammar< Iterator, PointT, Skipper >::Operations |
ReplayOutputStream::OutStreamAdder | Helper class to fill the internal map of OutputStreams
ReplayOutputStream::OutStreamTrigger | Helper class to call the required OutputStream
GaudiMP.pTools.PackedCaloHypo |
IRndmGen::Param |
Rndm::Binomial | Parameters for the Binomial distributed random number generation
Rndm::Bit | Parameters for the bit value generation: returns values 0 and 1
Rndm::BreitWigner | Parameters for the BreitWigner distributed random number generation
Rndm::BreitWignerCutOff | Parameters for the BreitWigner distributed random number generation with cut off;
Rndm::Chi2 | Parameters for the Chi2 distributed random number generation
Rndm::DefinedPdf | Generate a random number Generator following generally distributed random values, given a user-defined probability distribution function
Rndm::Exponential | Parameters for the Gauss random number generation
Rndm::Flat | Parameters for the flat random number generation within boundaries [minimum, maximum]
Rndm::Gamma | Parameters for the Gamma distributed random number generation
Rndm::Gauss | Parameters for the Gauss random number generation
Rndm::GaussianTail | Parameters for the Gaussian tail number generation
Rndm::Landau | Parameters for the Landau distributed random number generation
Rndm::Poisson | Parameters for the Poisson distributed random number generation with a given mean
Rndm::StudentT | Parameters for the StudentT distributed random number generation
ParticleProperty | A trivial class to hold information about a single particle properties
System::PathResolver |
pentium4_cccr_value_t | Pentium4_cccr_value_t
pentium4_escr_value_t |
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 |
PipeReader |
GaudiUtils::AllocatorPool::PoolChunk |
PoolDbLinkManager | Description: PoolDbLinkManager class implementation definition
PoolDbTokenWrap | Description:
System::POOLED_USAGE_AND_LIMITS | Process Pooled Quota Usage and Limits NtQueryInformationProcess using ProcessPooledUsageAndLimits
GaudiUtils::AllocatorPool::PoolLink |
Gaudi::Parsers::Position |
PositionVector3D< CoordSystem, Tag > |
POSIXFileHandler |
Gaudi::Parsers::PragmaOptions |
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)
System::PROCESS_BASIC_INFORMATION |
System::ProcessDescriptor | Provides access to process information
System::ProcessDescriptor::ProcessHandle |
System::ProcessTime | Simple class to hold the time information of a process
procInfo |
ProcStats |
Property | Property base class allowing Property* collections to be "homogeneous"
GaudiHandleArrayProperty |
GaudiHandleProperty |
PropertyList | List of properties
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
SimpleProperty< TYPE, VERIFIER > | SimpleProperty concrete class which implements the full Property interface
SimpleProperty< bool > |
SimpleProperty< double > |
SimpleProperty< int > |
SimpleProperty< std::string > |
CommandProperty | Command property base class (abstract)
SimpleProperty< std::vector< std::string > > |
SimpleProperty< unsigned int > |
SimplePropertyRef< TYPE, VERIFIER > | SimplePropertyRef templated class
PropertyWithValue< bool > |
PropertyWithVerifier< bool, VERIFIER > |
PropertyWithValue< double > |
PropertyWithVerifier< double, VERIFIER > |
PropertyWithValue< int > |
PropertyWithVerifier< int, VERIFIER > |
PropertyWithValue< std::string > |
PropertyWithVerifier< std::string, VERIFIER > |
PropertyWithValue< std::vector< std::string > > |
PropertyWithVerifier< std::vector< std::string >, VERIFIER > |
PropertyWithValue< unsigned int > |
PropertyWithVerifier< unsigned int, VERIFIER > |
Gaudi::Parsers::Property |
PropertyCallbackFunctor |
PropertyCallbackMemberFunctor< T > |
PropertyCallbackPointerFunctor |
Gaudi::Parsers::PropertyName |
Gaudi::Utils::PropertyTypeTraits< TYPE > | Helper structure to define the types for properties
Gaudi::Utils::PropertyTypeTraits< T[N]> | Specialization for arrays
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]> |
Gaudi::Parsers::PropertyValue |
PropertyVerifier< T > | Templated Verifier base class
BoundedVerifier< TYPE > |
NullVerifier< TYPE > | Default, always true verifier
PropertyVerifier< T[N]> |
BoundedVerifier< T[N]> | Specialization of Bounded verifier for for C-arrays
DataOnDemandSvc::Protection | Helper class of the DataOnDemandSvc
PyAlgorithm |
AnalysisInit.PhysAnalAlg |
PyAlgorithm |
Test.PhysAnalAlg |
GaudiMP::PyROOTPickle |
IUpdateManagerSvc::PythonHelper | Helper class implemented in the python dictionary to allow access from python to template member functions
System::QUOTA_LIMITS | Process Quotas NtQueryInformationProcess using ProcessQuotaLimits NtQueryInformationProcess using ProcessPooledQuotaLimits NtSetInformationProcess using ProcessQuotaLimits
Range< TYP > |
NTuple::Range< TYP > | Class defining a range
NTuple::Range< bool > |
Gaudi::RangeBase_ | Helper class to simplify the dealing with ranges in Python
Gaudi::Range_< CONTAINER > | Useful class for representation of "sequence" of the objects through the range of valid iterators
Gaudi::NamedRange_< TYPE > |
Gaudi::Range_< TYPE > |
GaudiUtils::Allocator< Type >::rebind< U > |
GaudiRoot::RefAccessor |
GaudiTest.ReferenceFileValidator |
Gaudi::PluginService::Details::Registry | In-memory database of the loaded factories
Gaudi::Parsers::MapGrammar< KeyGrammarT, ValueGrammarT >::Operations::result< A, B, C, D > |
Gaudi::Parsers::Pnt4DGrammar< Iterator, PointT, Skipper >::Operations::result< A, B, C, D > |
Gaudi::Parsers::NodeOperations::result< A, B, C, D > |
Gaudi::Parsers::Histo1DGrammar< Iterator, Skipper >::Operations::result< A, B, C, D > |
Gaudi::Parsers::Pnt3DGrammar< Iterator, PointT, Skipper >::Operations::result< A, B, C, D > |
RootHistCnv::RootCompressionSettings | Simple class to decode a ROOT compression settings string, of the form '<Alg>:<level>' into the integer code to pass to ROOT
RootConnectionSet | Class describing the setup parameters of a ROOT data connection
Gaudi::RootConnectionSetup |
RootFileHandler |
Gaudi::RootNTupleDescriptor | Description:
Gaudi::RootObjectRefs | Persistent reference object containing all leafs and links corresponding to a Gaudi DataObject
Gaudi::RootRef | Persistent reference object
RuntimeError |
EnvConfig.EnvError |
GaudiKernel.Configurable.Error |
GaudiKernel.ProcessJobOptions.ParserError |
GaudiPython.Persistency.PersistencyError |
GaudiPython.Persistency.UnknownPersistency |
ZipPythonDir.ZipdirError | Class for generic exception coming from the zipdir() function
S_module |
Gaudi::Parsers::KeyValueGrammar< Iterator, Skipper >::second |
Gaudi::Parsers::PairGrammar< KeyGrammarT, ValueGrammarT >::second |
PersistencySvc::ServiceEntry |
ServiceManager::ServiceItem |
ServiceLocatorHelper | Helper to share the implementation of service() among the various kernel base classes $Id:
SmartDataObjectPtr | 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
SmartDataStorePtr< TYPE, SmartDataObjectPtr::ObjectLoader > |
SmartDataLocator< TYPE > | 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
SmartIF< T > | Small smart pointer class with automatic reference counting for IInterface
SmartIF< Gaudi::ISignalMonitor > |
SmartIF< IAddressCreator > |
SmartIF< IAlgContextSvc > |
SmartIF< IAlgManager > |
SmartIF< IAlgorithm > |
SmartIF< IAppMgrUI > |
SmartIF< IAuditorSvc > |
SmartIF< IChronoStatSvc > |
SmartIF< IConversionSvc > |
SmartIF< IDataManagerSvc > |
SmartIF< IDataProviderSvc > |
SmartIF< IEventProcessor > |
SmartIF< IEvtSelector > |
SmartIF< IExceptionSvc > |
SmartIF< IFileCatalog > |
SmartIF< IHistogramSvc > |
SmartIF< IIncidentListener > |
SmartIF< IIncidentSvc > |
SmartIF< IInterface > |
SmartIF< IJobOptionsSvc > |
SmartIF< IMessageSvc > |
SmartIF< IMonitorSvc > |
SmartIF< INTupleSvc > |
SmartIF< IPartitionControl > |
SmartIF< IProperty > |
SmartIF< IRndmGenSvc > |
SmartIF< IRunable > |
SmartIF< IService > |
SmartIF< IStateful > |
SmartIF< ISvcLocator > |
SmartIF< ISvcManager > |
SmartIF< IToolSvc > |
SmartRef< TYPE > | Kernel objects: SmartRef
SmartRef< ContainedObject > |
SmartRef< DataObject > |
SmartRef< KeyType > |
SmartRefArray< TYPE > |
SmartRefBase | User example objects: SmartRefBase
SmartRefList< TYPE > |
SmartRefMap< TYPE > |
Genfun::GaudiMathImplementation::SplineBase |
IntelProfilerAuditor::stack_entity |
Stat | Small wrapper class for easy manipulation with generic counters and IStatSvc&ICounterSvc interface
StatusCodeSvc::StatCodeDat |
StatEntity | The basic counter used for Monitoring purposes
StatusCode | This class is used for returning status codes from appropriate routines
ana.Step |
StreamBuffer | The stream buffer is a small object collecting object data
StreamHandler |
GaudiKernel.ProcessJobOptions.ConsoleHandler |
StreamLogger |
Gaudi::StringKey | The helper class to represent the efficient "key" for access
Structure |
GaudiPluginService.cpluginsvc.Factory |
GaudiPluginService.cpluginsvc.Property |
GaudiPluginService.cpluginsvc.Registry |
ana.Summary |
SvcCatalog |
SvcFactory< T > |
Gaudi::SysProcStat |
Gaudi::Utils::Histos::Table | Simple class for the customizeble printout of the histogram tables
IInspector::Tag |
IInspector::_TT< T > |
Gaudi::Parsers::MapGrammar< KeyGrammarT, ValueGrammarT >::tag_key |
Gaudi::Parsers::MapGrammar< KeyGrammarT, ValueGrammarT >::tag_mapped |
MultiStoreSvc::tagROOT |
Task |
gaudi-policy.gen_conf |
gaudi-policy.merge_confdb |
TClassStreamer |
GaudiRoot::IOHandler< T > |
GaudiTest.TempDir |
GaudiTest.TempFile |
GaudiTest.TemporaryEnvironment | Utility Classes
TestCase |
EnvConfig.TestEnvOps.Test |
EnvConfig.TestXMLOps.Test |
THistSvc::THistID |
ThreadGaudi | Singleton mapping the pthread ID to the Gaudi thread ID
Gaudi::Time | Based on seal::Time
TimerForSequencer | Auxilliary class
Gaudi::TimeSpan | Based on seal::TimeSpan
Tokenizer::Token | Definition of the sub-class Token
pool::Token | Shadow class to mimik POOL tokens
Tokenizer | STL Include files
Gaudi::RootDataConnection::Tool | Helper class to facilitate an abstraction layer for reading POOL style files with this package
Gaudi::PoolTool |
Gaudi::RootTool | Description:
ToolFactory< T > |
ToolHandleInfo | General info and helper functions for toolhandles and arrays
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
traits< CONTAINER, DATATYPE > | Container traits class
Tuples::Tuple | A simple wrapper class over standard Gaudi NTuple::Tuple facility
GaudiPython::TupleAlgDecorator | Simple class to perform the "decoration" of Tuples in Python/ROOT
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
TupleItem< ITEM > |
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
GaudiPython::TupleToolDecorator | Simple class to perform the "decoration" of Tuples in Python/ROOT
type |
GaudiKernel.ConfigurableMeta.ConfigurableMeta | This metaclass installs PropertyProxy descriptors for Gaudi properties
Gaudi::Utils::TypeNameString | Helper class to parse a string of format "type/name"
UCharDbArray | Shadow class to mimik POOL blobs
std::unary_function< _Arg, _Result > [external] |
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
std::unary_function< ARGUMENT, RESULT > [external] |
Tuples::_TupAdapter< OBJECT, ARGUMENT, RESULT > | Trivial adapter to avoid the GCC problem (pointer to the function is never evaluated as "const TYPE&" )
std::unary_function< const IInterface *, IInterface * > [external] |
GaudiPython::Interface< IInterface > |
std::unary_function< const path &, bool > [external] |
DirSearchPath::eqPath | Name
std::unary_function< const T *, std::size_t > [external] |
GaudiUtils::Hash< T * > | Partial specialization for pointers
GaudiUtils::Hash< const T * > | Remove extra qualifiers:
std::unary_function< const T(&)[N], std::size_t > [external] |
GaudiUtils::Hash< const T(&)[N]> | Generic specialization for arrays
std::unary_function< Property, bool > [external] |
Gaudi::Parsers::Property::Equal |
std::unary_function< T(&)[N], std::size_t > [external] |
GaudiUtils::Hash< T(&)[N]> | Generic specialization for arrays
std::unary_function< T, std::size_t > [external] |
GaudiUtils::GenericHash< T > | Generic hash implementation (for easy migration to the new Hash class)
GaudiUtils::Hash< T > | Simple hash function
GaudiUtils::Hash< const T & > | Remove extra qualifiers:
GaudiUtils::Hash< const T > | Remove extra qualifiers:
GaudiUtils::Hash< T & > | Remove extra qualifiers:
std::unary_function< TYPE, TYPE > [external] |
GaudiPython::_identity< TYPE > | It is here due to 'missing'(?) std::identity
std::unary_function< WorkerEntry, bool > [external] |
ConversionSvc::CnvTest |
Gaudi::Parsers::Units |
Gaudi::Parsers::NodeOperations::value |
Containers::vector |
Containers::vector< void * > |
System::VM_COUNTERS | Process Virtual Memory Counters NtQueryInformationProcess using ProcessVmCounters
WatchdogThread | Simple class for asynchronous check of time-out
ConversionSvc::WorkerEntry |
BASE |
CommonMessaging< BASE > | Templated class to add the standard messaging functionalities
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
ExecTestBase |
GaudiTest.GaudiExeTest |
HTMLParser |
validate_patch.SavannahParser | Parse the
I1 |
extend_interfaces1< I1 > | Base class to be used to extend an interface
extends1< BASE, I1 > | Base class used to extend a class implementing other interfaces
implements1< I1 > | Base class used to implement the interfaces
extend_interfaces2< I1, I2 > | Base class to be used to extend an interface
extends2< BASE, I1, I2 > | Base class used to extend a class implementing other interfaces
extends2< AlgTool, IDataStoreLeaves, IIncidentListener > |
DataSvcFileEntriesTool | Tool to scan a transient store branch that collects all the objects that belong to the same source (file)
extends2< AlgTool, IDODAlgMapper, IDODNodeMapper > |
DODBasicMapper | Default implementation of a DataOnDemand mapper
extends2< ComponentManager, ISvcManager, ISvcLocator > |
extends2< DataSvc, IDetDataSvc, IIncidentListener > |
DetDataSvc |
extends2< DataSvc, INTupleSvc, IDataSourceMgr > |
NTupleSvc | NTuple service
TagCollectionSvc | Gaudi tag collection service definition
extends2< Service, IAlgContextSvc, IIncidentListener > |
AlgContextSvc |
extends2< Service, IChronoStatSvc, IIncidentListener > |
ChronoStatSvc | The Chrono & Stat Sservice: service implements the IChronoStatSvc interface and provides the basic chronometry and some statistical counts needed by all applications
extends2< Service, IConversionSvc, IAddressCreator > |
ConversionSvc | Base class for all conversion services
Gaudi::RootCnvSvc | Description:
RootHistCnv::PersSvc | Persistency service - to store histograms in ROOT format
extends2< Service, IDataProviderSvc, IDataManagerSvc > |
DataSvc | Data service base class
EvtDataSvc | A EvtDataSvc is the base class for event services
extends1< DataSvc, IHistogramSvc > |
extends1< DataSvc, IIncidentListener > |
extends2< DataSvc, IDetDataSvc, IIncidentListener > |
extends2< DataSvc, INTupleSvc, IDataSourceMgr > |
extends2< Service, IFileCatalog, IFileCatalogMgr > |
Gaudi::MultiFileCatalog | This class constitutes the core of the XML based FileCatalog API for using POOL within Gaudi
extends2< Service, IFileMgr, IIncidentListener > |
FileMgr |
extends2< Service, IHistorySvc, IIncidentListener > |
HistorySvc | HistorySvc class definition
extends2< Service, IIoComponentMgr, IIncidentListener > |
IoComponentMgr |
extends2< Service, IMessageSvc, IInactiveMessageCounter > |
MessageSvc |
extends2< Service, IProperty, IJobOptionsSvc > |
JobOptionsSvc |
implements2< I1, I2 > | Base class used to implement the interfaces
implements2< IAuditor, IProperty > |
Auditor | Base class from which all concrete auditor classes should be derived
AlgContextAuditor | Description: Register/Unregister the AlgContext of each algorithm before entering the algorithm and after leaving it
AlgErrorAuditor | Monitors the cpu time usage of each algorithm
CommonAuditor | Base class with common functionalities shared by few auditor implementations
ChronoAuditor | Monitors the cpu time usage of each algorithm
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
NameAuditor | Prints the name of each algorithm before entering the algorithm and after leaving it
extends1< Auditor, IIncidentListener > |
IntelProfilerAuditor |
PerfMonAuditor | Performance Monitoring Auditor that uses Perfmon2 library to monitor algorithms
extend_interfaces3< I1, I2, I3 > | Base class to be used to extend an interface
extends3< BASE, I1, I2, I3 > | Base class used to extend a class implementing other interfaces
extends3< Service, IConversionSvc, IPersistencySvc, IAddressCreator > |
PersistencySvc | PersistencySvc class implementation definition
DetPersistencySvc |
EvtPersistencySvc | EvtPersistencySvc class implementation definition
HistogramPersistencySvc | HistogramPersistencySvc class implementation definition
extends3< Service, IDataProviderSvc, IDataManagerSvc, IPartitionControl > |
MultiStoreSvc | Data service base class
extends3< Service, IRndmEngine, ISerialize, IIncidentListener > |
RndmEngine | Random Generator engine definition
HepRndm::BaseEngine |
HepRndm::Engine< TYPE > |
extends3< Service, IRndmGenSvc, IRndmEngine, ISerialize > |
RndmGenSvc | Random Generator service definition
extends3< Service, ITHistSvc, IIncidentListener, IIoComponent > |
THistSvc |
implements3< I1, I2, I3 > | Base class used to implement the interfaces
implements3< IAlgorithm, IProperty, IStateful > |
Algorithm | Base class from which all concrete algorithm classes should be derived
CollectionCloneAlg | Small algorithm, which allows to merge N-tuples in a generic way
EventCounter |
EvtCollectionStream | A small to stream Data I/O
extends1< Algorithm, IPartitionControl > |
GaudiCommon< Algorithm > |
GaudiAlgorithm | The useful base class for data processing algorithms
EventNodeKiller | Algorithm to kill nodes in the event data store
GaudiHistos< GaudiAlgorithm > |
GaudiHistoAlg | Simple class to extend the functionality of class GaudiAlgorithm
GaudiTuples< GaudiHistoAlg > |
GaudiTupleAlg | Simple class to extend the functionality of class GaudiHistoAlg
GaudiSequencer | Sequencer for executing several algorithms, stopping when one is faulty
Prescaler |
RecordOutputStream | Simple class that adds an entry to the Transient Event Store to record that the processing flow triggered its execution
ReplayOutputStream |
GaudiPython::PyAlgorithm | Python Algorithm base class
GaudiMP.GMPBase.CollectHistograms |
OutputStream | A small to stream Data I/O
InputCopyStream | Extension of OutputStream to copy the content of the main input file
RecordStream | Extension of OutputStream to write run records after last event
RunRecordStream | Extension of OutputStream to write run records after last event
SequentialOutputStream | Extension of OutputStream to write run records after last event
TagCollectionStream | Specialized output stream class for event tag collections, where the basic Event entry point should be placed as well into the collection itself
Sequencer | ClassName: Sequencer
StoreExplorerAlg | Small algorith, which traverses the data store and prints generic information about all leaves, which can be loaded/accessed
StoreSnifferAlg | Small algorithm, which traverses the data store and prints a summary of the leafs accessed during the run
implements3< IAlgTool, IProperty, IStateful > |
AlgTool | Base class from which all the concrete tool classes should be derived
extends1< AlgTool, IDataStreamTool > |
extends1< AlgTool, IFileAccess > |
extends1< AlgTool, IGslErrorHandler > |
extends1< AlgTool, IPartitionControl > |
extends2< AlgTool, IDataStoreLeaves, IIncidentListener > |
extends2< AlgTool, IDODAlgMapper, IDODNodeMapper > |
GaudiCommon< AlgTool > |
GaudiTool | The useful base class for tools
ErrorTool |
extends1< GaudiTool, IEqSolver > |
extends1< GaudiTool, IFuncMinimum > |
GaudiHistos< GaudiTool > |
GaudiHistoTool | Simple class to extend the functionality of class GaudiTool
GaudiTuples< GaudiHistoTool > |
GaudiTupleTool | Simple class to extend the functionality of class GaudiHistoTool
TupleTool |
HistoTool | Simple tool for histogramming (component)
SequencerTimerTool | Implements the time measurement inside a sequencer
implements3< IService, IProperty, IStateful > |
CommonMessaging< implements3< IService, IProperty, IStateful > > |
Service | Base class for all services
extends1< Service, Gaudi::ISignalMonitor > |
extends1< Service, IAuditorSvc > |
extends1< Service, ICounterSvc > |
extends1< Service, IEventProcessor > |
extends1< Service, IEvtSelector > |
extends1< Service, IExceptionSvc > |
extends1< Service, IFileAccess > |
extends1< Service, IGslSvc > |
extends1< Service, IIncidentListener > |
extends1< Service, IIncidentSvc > |
extends1< Service, IIODataManager > |
extends1< Service, IIssueLogger > |
extends1< Service, IParticlePropertySvc > |
extends1< Service, IPartPropSvc > |
extends1< Service, IRunable > |
extends1< Service, IStatusCodeSvc > |
extends1< Service, IToolSvc > |
extends2< Service, IAlgContextSvc, IIncidentListener > |
extends2< Service, IChronoStatSvc, IIncidentListener > |
extends2< Service, IConversionSvc, IAddressCreator > |
extends2< Service, IDataProviderSvc, IDataManagerSvc > |
extends2< Service, IFileCatalog, IFileCatalogMgr > |
extends2< Service, IFileMgr, IIncidentListener > |
extends2< Service, IHistorySvc, IIncidentListener > |
extends2< Service, IIoComponentMgr, IIncidentListener > |
extends2< Service, IMessageSvc, IInactiveMessageCounter > |
extends2< Service, IProperty, IJobOptionsSvc > |
extends3< Service, IConversionSvc, IPersistencySvc, IAddressCreator > |
extends3< Service, IDataProviderSvc, IDataManagerSvc, IPartitionControl > |
extends3< Service, IRndmEngine, ISerialize, IIncidentListener > |
extends3< Service, IRndmGenSvc, IRndmEngine, ISerialize > |
extends3< Service, ITHistSvc, IIncidentListener, IIoComponent > |
Gaudi::RootPerfMonSvc | Description:
extend_interfaces4< I1, I2, I3, I4 > | Base class to be used to extend an interface
implements4< I1, I2, I3, I4 > | Base class used to implement the interfaces
implements4< IAppMgrUI, IEventProcessor, IService, IStateful > |
CommonMessaging< implements4< IAppMgrUI, IEventProcessor, IService, IStateful > > |
ApplicationMgr | The Application Manager class
I2 |
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
I3 |
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
I4 |
extend_interfaces4< I1, I2, I3, I4 > | Base class to be used to extend an interface
IAnnotation |
AIDA::Annotation | Implementation of the AIDA IAnnotation interface class
IHistogram2D |
Gaudi::Generic2D< IHistogram2D, TH2D > |
INTERFACE |
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
PBASE |
GaudiCommon< PBASE > | Implements the common functionality between GaudiTools and GaudiAlgorithms
GaudiHistos< PBASE > | Templated base class providing common histogramming methods for GaudiAlgorithm and GaudiTool like classes
GaudiTuples< PBASE > | Templated base class providing common 'ntupling' methods
ResultStream |
GaudiTest.HTMLResultStream |
GaudiTest.XMLResultStream |