ROOT logo
//-*- Mode: C++ -*-
// $Id$

#ifndef ALIHLTCOMPONENT_H
#define ALIHLTCOMPONENT_H
//* This file is property of and copyright by the ALICE HLT Project        * 
//* ALICE Experiment at CERN, All rights reserved.                         *
//* See cxx source for full Copyright notice                               *

//  @file   AliHLTComponent.h
//  @author Matthias Richter, Timm Steinbeck
//  @date   
//  @brief  Base class declaration for HLT components. 
//  @note   The class is both used in Online (PubSub) and Offline (AliRoot)
//          context


/**
 * @defgroup alihlt_component Component handling of the HLT module
 * This section describes the the component base classes and handling for
 * the HLT module.
 *
 * @section alihlt_component_intro General remarks
 * HLT analysis is organized in so called components. Each component can
 * subscribe to the data produced by other components and can from the
 * analysis publish new data for the subsequent components. Only the
 * input data blocks and entries from CDB are available for the analysis. 
 *
 * @section alihlt_component_implementation Component implementation
 * AliHLTComponent provides the interface for all components, see there
 * for details. Three types are provided:
 * - AliHLTProcessor
 * - AliHLTDataSource
 * - AliHLTDataSink
 *
 * The two last represent data sinks and sources for the HLT integration
 * into AliRoot. When running only, only the processors are relevant,
 * sources and sinks are provided by the HLT PubSub framework. Please check
 * AliHLTComponent for detailed description.
 *
 * @section alihlt_component_registration Component registration
 * Components need to be registered with the AliHLTComponentHandler in
 * order to be used with the system. Registration is purely done from the
 * module library. Two methods are possible:
 * - the module library implements an AliHLTModuleAgent and overloads the
 *   AliHLTModuleAgent::RegisterComponents() function
 * - in the implementation file, one object is defined. The global object is
 *   automatically instantiated when the library is loaded for the first
 *   time and the object is used for registration.
 *
 * In both cases, the library must be loaded via the method
 * <pre>
 *  AliHLTComponentHandler::LoadComponentLibraries()
 * </pre>
 * For the global object approach it is important that the library is
 * not loaded elsewhere before (e.g. a gSystem->Load operation in your
 * rootlogon.C).
 *
 *
 */

#include <vector>
#include <string>
#include "AliHLTLogging.h"
#include "AliHLTDataTypes.h"
#include "AliHLTCommonCDBEntries.h"

/* Matthias Dec 2006
 * The names have been changed for Aliroot's coding conventions sake
 * The old names are defined for backward compatibility with the 
 * stand alone SampleLib package
 */
typedef AliHLTComponentLogSeverity AliHLTComponent_LogSeverity;
typedef AliHLTComponentEventData AliHLTComponent_EventData;
typedef AliHLTComponentShmData AliHLTComponent_ShmData;
typedef AliHLTComponentDataType AliHLTComponent_DataType;
typedef AliHLTComponentBlockData AliHLTComponent_BlockData;
typedef AliHLTComponentTriggerData AliHLTComponent_TriggerData;
typedef AliHLTComponentEventDoneData AliHLTComponent_EventDoneData;

class AliHLTComponentHandler;
class TObjArray;
class TMap;
class TStopwatch;
class TUUID;
class AliHLTComponent;
class AliHLTMemoryFile;
class AliHLTCTPData;
class AliHLTReadoutList;
class AliHLTCDHWrapper;

using std::vector;

/** list of component data type structures */
typedef vector<AliHLTComponentDataType>   AliHLTComponentDataTypeList;
/** list of component block data structures */
typedef vector<AliHLTComponentBlockData>  AliHLTComponentBlockDataList;
/** list of component statistics struct */
typedef vector<AliHLTComponentStatistics> AliHLTComponentStatisticsList;
/** list of component pointers */
typedef vector<AliHLTComponent*>          AliHLTComponentPList;
/** list of memory file pointers */
typedef vector<AliHLTMemoryFile*>         AliHLTMemoryFilePList;

/**
 * @class AliHLTComponent
 * Base class of HLT data processing components.
 * The class provides a common interface for HLT data processing components.
 * The interface can be accessed from the online HLT framework or the AliRoot
 * offline analysis framework.
 * @section alihltcomponent-properties Component identification and properties
 * Each component must provide a unique ID, input and output data type indications,
 * and a spawn function.
 * @subsection alihltcomponent-req-methods Required property methods
 * - @ref GetComponentID
 * - @ref GetInputDataTypes (see @ref alihltcomponent-type for default
 *   implementations.)
 * - @ref GetOutputDataType (see @ref alihltcomponent-type for default
 *   implementations.)
 * - @ref GetOutputDataSize (see @ref alihltcomponent-type for default
 *   implementations.)
 * - @ref Spawn
 *
 * @subsection alihltcomponent-opt-mehods Optional handlers
 * - @ref DoInit
 * - @ref DoDeinit
 * - @ref GetOutputDataTypes
 *   If the component has multiple output data types @ref GetOutputDataType
 *   should return @ref kAliHLTMultipleDataType. The framework will invoke
 *   @ref GetOutputDataTypes, a list can be filled.
 * - @ref Reconfigure
 *   This function is invoked by the framework on a special event which
 *   triggers the reconfiguration of the component.
 *
 * @subsection alihltcomponent-processing-mehods Data processing
 * 
 * 
 * @subsection alihltcomponent-type Component type
 * Components can be of type
 * - @ref kSource     components which only produce data 
 * - @ref kProcessor  components which consume and produce data
 * - @ref kSink       components which only consume data
 *
 * where data production and consumption refer to the analysis data stream. In
 * order to indicate the type, a child component can overload the
 * @ref GetComponentType function.
 * @subsubsection alihltcomponent-type-std Standard implementations
 * Components in general do not need to implement this function, standard
 * implementations of the 3 types are available:
 * - AliHLTDataSource for components of type @ref kSource <br>
 *   All types of data sources can inherit from AliHLTDataSource and must
 *   implement the @ref AliHLTDataSource::GetEvent method. The class
 *   also implements a standard method for @ref GetInputDataTypes.
 *   
 * - AliHLTProcessor for components of type @ref kProcessor <br>
 *   All types of data processors can inherit from AliHLTProcessor and must
 *   implement the @ref AliHLTProcessor::DoEvent method.
 *
 * - AliHLTDataSink for components of type @ref kSink <br>
 *   All types of data processors can inherit from AliHLTDataSink and must
 *   implement the @ref AliHLTDataSink::DumpEvent method. The class
 *   also implements a standard method for @ref GetOutputDataType and @ref
 *   GetOutputDataSize.
 *
 * @subsection alihltcomponent-environment Running environment
 *
 * In order to adapt to different environments (on-line/off-line), the component
 * gets an environment structure with function pointers. The base class provides
 * member functions for those environment dependend functions. The member 
 * functions are used by the component implementation and are re-mapped to the
 * corresponding functions.
 *
 * @section alihltcomponent-interfaces Component interfaces
 * Each of the 3 standard component base classes AliHLTProcessor, AliHLTDataSource
 * and AliHLTDataSink provides it's own processing method (see
 * @ref alihltcomponent-type-std), which splits into a high and a low-level
 * method. For the @ref alihltcomponent-low-level-interface, all parameters are
 * shipped as function arguments, the component is supposed to write data to the
 * output buffer and handle all block descriptors. 
 * The @ref alihltcomponent-high-level-interface is the standard processing
 * method and will be used whenever the low-level method is not overloaded.
 *
 * In both cases it is necessary to calculate/estimate the size of the output
 * buffer before the processing. Output buffers can never be allocated inside
 * the component because of the push-architecture of the HLT.
 * For that reason the @ref GetOutputDataSize function should return a rough
 * estimatian of the data to be produced by the component. The component is
 * responsible for checking the memory size and must return -ENOSPC if the
 * available buffer is too small, and update the estimator respectively. The
 * framework will allocate a buffer of appropriate size and call the processing
 * again.
 *
 * @subsection alihltcomponent-error-codes Return values/Error codes
 * For return codes, the following scheme applies:
 * - The data processing methods have to indicate error conditions by a negative
 * error/return code. Preferably the system error codes are used like
 * e.g. -EINVAL. This requires to include the header
 * <pre>
 * \#include \<cerrno\>
 * </pre>
 * This schema aplies to all interface functions of the component base class.
 * For data processing it is as follows:
 * - If no suitable input block could be found (e.g. no clusters for the TPC cluster
 * finder) set size to 0, block list is empty, return 0
 * - If no ususable or significant signal could be found in the input blocks
 * return an empty output block, set size accordingly, and return 0. An empty output
 * block here could be either a real empty one of size 0 (in which case size also
 * would have to be set to zero) or a block filled with just the minimum necessary
 * accounting/meta-structures. E.g. in the TPC
 *
 * @subsection alihltcomponent-high-level-interface High-level interface
 * The high-level component interface provides functionality to exchange ROOT
 * structures between components. In contrast to the 
 * @ref alihltcomponent-low-level-interface, a couple of functions can be used
 * to access data blocks of the input stream
 * and send data blocks or ROOT TObject's to the output stream. The functionality
 * is hidden from the user and is implemented by using ROOT's TMessage class.
 *
 * @subsubsection alihltcomponent-high-level-int-methods Interface methods
 * The interface provides a couple of methods in order to get objects from the
 * input, data blocks (non TObject) from the input, and to push back objects and
 * data blocks to the output. For convenience there are several functions of 
 * identical name (and similar behavior) with different parameters defined.
 * Please refer to the function documentation.
 * - @ref GetNumberOfInputBlocks <br>
 *        return the number of data blocks in the input stream
 * - @ref GetFirstInputObject <br>
 *        get the first object of a specific data type
 * - @ref GetNextInputObject <br>
 *        get the next object of same data type as last GetFirstInputObject/Block call
 * - @ref GetFirstInputBlock <br>
 *        get the first block of a specific data type
 * - @ref GetNextInputBlock <br>
 *        get the next block of same data type as last GetFirstInputBlock/Block call
 * - @ref PushBack <br>
 *        insert an object or data buffer into the output
 * - @ref CreateEventDoneData <br>
 *        add event information to the output
 * 
 * In addition, the processing methods are simplified a bit by cutting out most of
 * the parameters.
 * @see 
 * - @ref AliHLTProcessor::DoEvent
 * - @ref AliHLTDataSource::GetEvent
 * - @ref AliHLTDataSink::DumpEvent
 *
 * \em IMPORTANT: objects and block descriptors provided by the high-level interface
 *  <b>MUST NOT BE DELETED</b> by the caller.
 *
 * @subsubsection alihltcomponent-high-level-int-guidelines High-level interface guidelines
 * - Structures must inherit from the ROOT object base class TObject in order be 
 * transported by the transportation framework.
 * - all pointer members must be transient (marked <tt>//!</tt> behind the member
 * definition), i.e. will not be stored/transported, or properly marked
 * (<tt>//-></tt>) in order to call the streamer of the object the member is pointing
 * to. The latter is not recomended. Structures to be transported between components
 * should be streamlined.
 * - no use of stl vectors/strings, use appropriate ROOT classes instead 
 * 
 * @subsection alihltcomponent-low-level-interface Low-level interface
 * The low-level component interface consists of the specific data processing
 * methods for @ref AliHLTProcessor, @ref AliHLTDataSource, and @ref AliHLTDataSink.
 * - @ref AliHLTProcessor::DoEvent
 * - @ref AliHLTDataSource::GetEvent
 * - @ref AliHLTDataSink::DumpEvent
 * 
 * The base class passes all relevant parameters for data access directly on to the
 * component. Input blocks can be accessed by means of the array <tt> blocks </tt>.
 * Output data are written directly to shared memory provided by the pointer
 * <tt> outputPtr </tt> and output block descriptors are inserted directly to the
 * list <tt> outputBlocks </tt>.
 *
 * \b NOTE: The high-level input data access methods can be used also from the low
 * level interface. Also the PushBack functions can be used BUT ONLY if no data is
 * written to the output buffer and no data block descriptors are inserted into the
 * output block list.
 *
 * @section alihltcomponent-initialization Component initialization and configuration
 * The component interface provides two optional methods for component initialization
 * and configuration. The @ref DoInit function is called once before the processing.
 * During the event processing, a special event can trigger a reconfiguration and the
 * @ref Reconfigure method is called. There are three possible options of initialization
 * and configuration:
 * - default values: set directly in the source code
 * - OCDB objects: all necessary information must be loaded from OCDB objects. The
 *   Offline Conditions Data Base stores objects specifically valid for individual runs
 *   or run ranges.
 * - Component arguments: can be specified for every component in the chain
 *   configuration. The arguments can be used to override specific parameters of the
 *   component.
 *
 * As a general rule, the three options should be processed in that sequence, i.e
 * default parameters might be overridden by OCDB configuration, and the latter one
 * by component arguments.
 *
 * @subsection alihltcomponent-initialization-arguments Component arguments
 * In normal operation, components are supposed to run without any additional argument,
 * however such arguments can be useful for testing and debugging. The idea follows
 * the format of command line arguments. A keyword is indicated by a dash and an
 * optional argument might follow, e.g.:
 * <pre>
 * -argument1 0.5 -argument2
 * </pre>
 * In this case argument1 requires an additional parameter whereas argument2 does not.
 * The arguments will be provided as an array of separated arguments.
 *
 * Component arguments can be classified into initialization arguments and configuration
 * arguments. The latter are applicable for both the @ref DoInit and @ref Reconfigure
 * method whereas initialization arguments are not applicable after DoInit.
 *
 * @subsection alihltcomponent-initialization-ocdb OCDB objects
 * OCDB objects are ROOT <tt>TObjects</tt> and can be of any type. This is in particular
 * useful for complex parameter sets. However in most cases, a simple approach of human
 * readable command line arguments is appropriate. Such a string can be simply stored
 * in a TObjString (take note that the TString does not derive from TObject). The
 * same arguments as for the command line can be used. Take note that in the TObjString
 * all arguments are separated by blanks, instead of being in an array of separate
 * strings.
 *
 * The base class provides two functions regarding OCDB objects: 
 * - LoadAndExtractOCDBObject() loads the OCDB entry for the specified path and extracts
 *                              the TObject from it. An optional key allows to access
 *                              a TObject within a TMap
 * - ConfigureFromCDBTObjString() can load a number of OCDB objects and calls the
 *                              argument parsing ConfigureFromArgumentString
 *
 *
 * @subsection alihltcomponent-initialization-sequence Initialization sequence
 * Using the approach of <tt>TObjString</tt>-type configuration objects allows to treat
 * configuration from both @ref DoInit and @ref Reconfigure in the same way.
 *
 * The base class provides the function ConfigureFromArgumentString() which loops over
 * all arguments and calls the child's method ScanConfigurationArgument(). Here the
 * actual treatment of the argument and its parameters needs to be implemented.
 * ConfigureFromArgumentString() can treat both arrays of arguments and arguments in
 * one single string separated by blanks. The two options can be mixed.
 *
 * A second base class function ConfigureFromCDBTObjString() allows to configure
 * directly from a number of OCDB objects. This requires the entries to be of
 * type TObjString and the child implementation of ScanConfigurationArgument().
 * The object can also be of type TMap with TObjStrings as key-value pairs. The
 * key identifier can be chosen by the component implementation. Normally it will
 * be the run type ("p","A-A", "p-A", ...) or e.g. the trigger code secified by
 * ECS.
 *
 * @section alihltcomponent-handling Component handling 
 * The handling of HLT analysis components is carried out by the AliHLTComponentHandler.
 * Component are registered automatically at load-time of the component shared library
 * under the following suppositions:
 * - the component library has to be loaded from the AliHLTComponentHandler using the
 *   @ref AliHLTComponentHandler::LoadLibrary method.
 * - the library defines an AliHLTModuleAgent which registers all components.
 *   See AliHLTModuleAgent::RegisterComponents                               <br>
 *     or                                                                    <br>
 * - the component implementation defines one global object (which is generated
 *   when the library is loaded)                                             <br>
 *
 * @subsection alihltcomponent-design-rules General design considerations
 * The analysis code should be implemented in one or more destict class(es). A 
 * \em component should be implemented which interface the destict analysis code to the
 * component interface. This component generates the analysis object dynamically. <br>
 *
 * Assume you have an implemetation <tt> AliHLTDetMyAnalysis </tt>, another class <tt>
 * AliHLTDetMyAnalysisComponent </tt> contains:
 * <pre>
 * private:
 *   AliHLTDetMyAnalysis* fMyAnalysis;  //!
 * </pre>
 * The object should then be instantiated in the DoInit handler of 
 * <tt>AliHLTDetMyAnalysisComponent </tt>, and cleaned in the DoDeinit handler.
 *
 * Further rules:
 * - avoid big static arrays in the component, allocate the memory at runtime
 * - allocate all kind of complex data members (like classes, ROOT TObjects of
 *   any kind) dynamically in DoInit and clean up in DoDeinit
 *
 * @section alihlt_component_arguments Default arguments
 * The component base class provides some default arguments:
 * <!-- NOTE: ignore the \li. <i> and </i>: it's just doxygen formatting -->
 * \li -loglevel=level     <br>
 * \li -object-compression=level     <br>
 *      compression level for ROOT objects, default is defined by
 *      @ref ALIHLTCOMPONENT_DEFAULT_OBJECT_COMPRESSION
 * \li -pushback-period=period     <br>
 *      scale down for PushBack of objects, shipped only for one event
 *      every <i>period</i> seconds
 * \li -event-module=number     <br>
 *      This option reduces the event processing rate by processing only n'th event
 *      based on the modulo number <i>number</i>. The scale down should be about
 *      1/<i>number</i>, where <i>number</i> is a positive integer.
 *
 * @ingroup alihlt_component
 * @section alihltcomponent-members Class members
 */
class AliHLTComponent : public AliHLTLogging {
 public:
  /** standard constructor */
  AliHLTComponent();
  /** standard destructor */
  virtual ~AliHLTComponent();

  /** component type definitions */
  enum TComponentType { kUnknown=0, kSource=1, kProcessor=2, kSink=3 };

  /**
   * Init function to prepare data processing.
   * Initialization of common data structures for a sequence of events.
   * The call is redirected to the internal method DoInit which can be
   * overridden by the child class.
   * During Init also the environment structure is passed to the component.
   * @param comenv         environment pointer with environment dependent function
   *                       calls
   * @param environParam   additional parameter for function calls, the pointer
   *                       is passed as it is
   * @param argc           size of the argument array
   * @param argv           augment array for component initialization
   */
  virtual int Init( const AliHLTAnalysisEnvironment* comenv, void* environParam, int argc, const char** argv );

  /**
   * Clean-up function to terminate data processing.
   * Clean-up of common data structures after data processing.
   * The call is redirected to the internal method @ref DoDeinit which can be
   * overridden by the child class.
   */
  virtual int Deinit();

  /**
   * Processing of one event.
   * The method is the entrance of the event processing. The parameters are
   * cached for uses with the high-level interface and the DoProcessing
   * implementation is called.
   *
   * @param evtData
   * @param blocks
   * @param trigData
   * @param outputPtr
   * @param size
   * @param outputBlockCnt  out: size of the output block array, set by the component
   * @param outputBlocks    out: the output block array is allocated internally
   * @param edd
   * @return neg. error code if failed
   */
  int ProcessEvent( const AliHLTComponentEventData& evtData, const AliHLTComponentBlockData* blocks, 
			    AliHLTComponentTriggerData& trigData, AliHLTUInt8_t* outputPtr, 
			    AliHLTUInt32_t& size, AliHLTUInt32_t& outputBlockCnt, 
			    AliHLTComponentBlockData*& outputBlocks,
			    AliHLTComponentEventDoneData*& edd );

  /**
   * Internal processing of one event.
   * The method is pure virtual and implemented by the child classes 
   * - @ref AliHLTProcessor
   * - @ref AliHLTDataSource
   * - @ref AliHLTDataSink
   *
   * @param evtData
   * @param blocks
   * @param trigData
   * @param outputPtr
   * @param size
   * @param outputBlocks    out: the output block array is allocated internally
   * @param edd
   * @return neg. error code if failed
   */
  virtual int DoProcessing( const AliHLTComponentEventData& evtData, const AliHLTComponentBlockData* blocks, 
			    AliHLTComponentTriggerData& trigData, AliHLTUInt8_t* outputPtr, 
			    AliHLTUInt32_t& size,
			    AliHLTComponentBlockDataList& outputBlocks,
			    AliHLTComponentEventDoneData*& edd ) = 0;

  /**
   * Init the CDB.
   * The function must not be called when running in AliRoot unless it it
   * really wanted. The CDB path will be set to the specified path, which might
   * override the path initialized at the beginning of the AliRoot reconstruction.
   *
   * The method is used from the external interface in order to set the correct
   * path when running on-line. The function also initializes the function
   * callback for setting the run no during operation.
   *
   * A separation of library and component handling is maybe appropriate in the
   * future. Using the global component handler here is maybe not the cleanest
   * solution.
   * @param cdbPath      path of the CDB
   * @param pHandler     the component handler used for llibrary handling.
   */
  int InitCDB(const char* cdbPath, AliHLTComponentHandler* pHandler);

  /**
   * Set the run no for the CDB.
   * The function must not be called when running in AliRoot unless it it
   * really wanted. The CDB path will be set to the specified path, which might
   * override the run no initialized at the beginning of the AliRoot reconstruction.
   * InitCDB() has to be called before in order to really change the CDB settings.
   *
   * The method is used from the external interface in order to set the correct
   * path when running on-line.
   */
  int SetCDBRunNo(int runNo);

  /**
   * Set the run description.
   * The run description is set before the call of Init() -> DoInit().
   * @note: This functionality has been added in Juli 2008. The transmission of
   * run properties by a special SOR (SOD event in DAQ terminalogy but this was
   * changed after the HLT interface was designed) event is not sufficient because
   * the data might be needed already in the DoInit handler of the component.
   * @param desc    run descriptor, currently only the run no member is used
   * @param runType originally, run type was supposed to be a number and part
   *                of the run descriptor. But it was defined as string later
   */
  int SetRunDescription(const AliHLTRunDesc* desc, const char* runType);

  /**
   * Set the component description.
   * The description string can contain tokens separated by blanks, a token
   * consists of a key and an optional value separated by '='.
   * Possible keys:
   * \li -chainid=id        string id within the chain of the instance
   *
   * @param desc    component description
   */
  int SetComponentDescription(const char* desc);

  /**
   * Set the running environment for the component.
   * Originally, the environment was set in the Init function. However, the setup of
   * the CDB is required before. In order to have proper logging functionality, the
   * environment is required.
   * @param comenv         environment pointer with environment dependent function
   *                       calls
   * @param environParam   additional parameter for function calls, the pointer
   *                       is passed as it is
   */
  int SetComponentEnvironment(const AliHLTAnalysisEnvironment* comenv, void* environParam);

  // Information member functions for registration.

  /**
   * Get the type of the component.
   * The function is pure virtual and must be implemented by the child class.
   * @return component type id
   */
  virtual TComponentType GetComponentType() = 0; // Source, sink, or processor

  /**
   * Get the id of the component.
   * Each component is identified by a unique id.
   * The function is pure virtual and must be implemented by the child class.
   * @return component id (string)
   */
  virtual const char* GetComponentID() = 0;

  /**
   * Get the input data types of the component.
   * The function is pure virtual and must be implemented by the child class.
   * @return list of data types in the vector reference
   */
  virtual void GetInputDataTypes( AliHLTComponentDataTypeList& ) = 0;

  /**
   * Get the output data type of the component.
   * The function is pure virtual and must be implemented by the child class.
   * @return output data type
   */
  virtual AliHLTComponentDataType GetOutputDataType() = 0;

  /**
   * Get the output data types of the component.
   * The function can be implemented to indicate multiple output data types
   * in the target array.
   * @ref GetOutputDataType must return @ref kAliHLTMultipleDataType in order
   * to invoke this method.
   * @param tgtList          list to receive the data types
   * @return no of output data types, data types in the target list
   */
  virtual int GetOutputDataTypes(AliHLTComponentDataTypeList& tgtList);

  /**
   * Get a ratio by how much the data volume is shrunken or enhanced.
   * The function is pure virtual and must be implemented by the child class.
   * @param constBase        <i>return</i>: additive part, independent of the
   *                                   input data volume  
   * @param inputMultiplier  <i>return</i>: multiplication ratio
   * @return values in the reference variables
   */
  virtual void GetOutputDataSize( unsigned long& constBase, double& inputMultiplier ) = 0;

  /**
   * Get a list of OCDB object description.
   * The list of objects is provided in a TMap
   * - key: complete OCDB path, e.g. GRP/GRP/Data
   * - value: short description why the object is needed
   * Key and value objects created inside this class go into ownership of
   * target TMap.
   * @param targetMap   TMap instance receiving the list
   * @return void
   */
  virtual void GetOCDBObjectDescription( TMap* const targetArray);

  /**
   * Spawn function.
   * Each component must implement a spawn function to create a new instance of 
   * the class. Basically the function must return <i>new <b>my_class_name</b></i>.
   * @return new class instance
   */
  virtual AliHLTComponent* Spawn() = 0;

  /**
   * check the availability of the OCDB entry descriptions in the TMap
   *  key : complete OCDB path of the entry
   *  value : auxiliary object - short description
   * if the external map was not provided the function invokes
   * interface function GetOCDBObjectDescription() to retrieve the list.
   * @param externList  map of entries to be tested
   * @result 0 if all found, -ENOENT if objects not found
   */
  int CheckOCDBEntries(const TMap* const externList=NULL);

  /**
   * Find matching data types between this component and a consumer component.
   * Currently, a component can produce only one type of data. This restriction is most
   * likely to be abolished in the future.
   * @param pConsumer a component and consumer of the data produced by this component
   * @param tgtList   reference to a vector list to receive the matching data types.
   * @return >= 0 success, neg. error code if failed
   */ 
  int FindMatchingDataTypes(AliHLTComponent* pConsumer, AliHLTComponentDataTypeList* tgtList);
 
  /**
   * Set the global component handler.
   * The static method is needed for the automatic registration of components. 
   */
  static int SetGlobalComponentHandler(AliHLTComponentHandler* pCH, int bOverwrite=0);

  /**
   * Clear the global component handler.
   * The static method is needed for the automatic registration of components. 
   */
  static int UnsetGlobalComponentHandler();

  /**
   * Helper function to convert the data type to a string.
   * @param type        data type structure
   * @param mode        0 print string origin:type          <br>
   *                    1 print chars                       <br>
   *                    2 print numbers                     <br>
   *                    3 print 'type' 'origin' 
   */
  static string DataType2Text( const AliHLTComponentDataType& type, int mode=0);

  /**
   * Calculate a CRC checksum of a data buffer.
   * Polynomial for the calculation is 0xD8.
   */
  static AliHLTUInt32_t CalculateChecksum(const AliHLTUInt8_t* buffer, int size);

  /**
   * Helper function to print content of data type.
   */
  static void PrintDataTypeContent(AliHLTComponentDataType& dt, const char* format=NULL);

  /**
   * helper function to initialize AliHLTComponentEventData structure
   */
  static void FillEventData(AliHLTComponentEventData& evtData);

  /**
   * Print info on an AliHLTComponentDataType structure
   * This is just a helper function to examine an @ref AliHLTComponentDataType
   * structur.
   */
  static void PrintComponentDataTypeInfo(const AliHLTComponentDataType& dt);

  /**
   * Fill AliHLTComponentBlockData structure with default values.
   * @param blockData   reference to data structure
   */
  static void FillBlockData( AliHLTComponentBlockData& blockData );

  /**
   * Fill AliHLTComponentShmData structure with default values.
   * @param shmData   reference to data structure
   */
  static void FillShmData( AliHLTComponentShmData& shmData );

  /**
   * Fill AliHLTComponentDataType structure with default values.
   * @param dataType   reference to data structure
   */
  static void FillDataType( AliHLTComponentDataType& dataType );
  
  /**
   * Copy data type structure
   * Copies the value an AliHLTComponentDataType structure to another one
   * @param [out] tgtdt   target structure
   * @param [in] srcdt   source structure
   */
  static void CopyDataType(AliHLTComponentDataType& tgtdt, const AliHLTComponentDataType& srcdt);

  /**
   * Set the ID and Origin of an AliHLTComponentDataType structure.
   * The function sets the fStructureSize member and copies the strings
   * to the ID and Origin. Only characters from the valid part of the string
   * are copied, the rest is filled with 0's. <br>
   * Please note that the fID and fOrigin members are not strings, just arrays of
   * chars of size @ref kAliHLTComponentDataTypefIDsize and
   * @ref kAliHLTComponentDataTypefOriginSize respectively and not necessarily with
   * a terminating zero. <br>
   * It is possible to pass NULL pointers as id or origin argument, in that case they
   * are just ignored.
   * @param tgtdt   target data type structure
   * @param id      ID string
   * @param origin  Origin string
   */
  static void SetDataType(AliHLTComponentDataType& tgtdt, const char* id, const char* origin);

  /**
   * Set the ID and Origin of an AliHLTComponentDataType structure.
   * Given the fact that the data type ID is 64bit wide and origin 32, this helper
   * function sets the data type from those two parameters.
   * @param dt      target data type structure
   * @param id      64bit id
   * @param orig    32bit origin
   */
  static void SetDataType(AliHLTComponentDataType& dt, AliHLTUInt64_t id, AliHLTUInt32_t orig); 

  /**
   * Extract a component table entry from the payload buffer.
   * The entry consists of the AliHLTComponentTableEntry structure, the array of
   * parents and a description string of the format 'chain-id{component-id:component-args}'.
   * The function fills all the variables after a consistency check.
   */
  static int ExtractComponentTableEntry(const AliHLTUInt8_t* pBuffer, AliHLTUInt32_t size,
					string& chainId, string& compId, string& compParam,
					vector<AliHLTUInt32_t>& parents) {
    int dummy=0;
    return ExtractComponentTableEntry(pBuffer, size, chainId, compId, compParam, parents, dummy);
  }

  static int ExtractComponentTableEntry(const AliHLTUInt8_t* pBuffer, AliHLTUInt32_t size,
					string& chainId, string& compId, string& compParam,
					vector<AliHLTUInt32_t>& parents, int& level);

  /**
   * Extracts the different data parts from the trigger data structure.
   * @param [in] trigData  The trigger data as passed to the DoProcessing method.
   * @param [out] attributes  The data block attributes given by the HLT framework.
   * @param [out] status  The HLT status bits given by the HLT framework.
   * @param [out] cdh  The common data header received from DDL links.
   * @param [out] readoutlist  The readout list to fill with readout list bits
   *                           passed on by the HLT framework.
   * @param [in] printErrors  If true then error messages are generated as necessary
   *                          and suppressed otherwise.
   * @note If any of the output parameters are set to NULL then the field is not set.
   *   For example, the following line will only fill the CDH pointer.
   *   \code
   *     AliHLTCDHWrapper cdh;
   *     ExtractTriggerData(trigData, NULL, NULL, &cdh, NULL);
   *   \endcode
   * @return zero on success or one of the following error codes on failure.
   *   if a non-zero error code is returned then none of the output parameters are
   *   modified.
   *    \li -ENOENT  The <i>trigData</i> structure size is wrong.
   *    \li -EBADF   The <i>trigData</i> data size is wrong.
   *    \li -EBADMSG The common data header (CDH) in the trigger data has the wrong
   *                 number of words indicated.
   *    \li -EPROTO  The readout list structure in the trigger data has the wrong
   *                 number of words indicated.
   */
  static int ExtractTriggerData(
      const AliHLTComponentTriggerData& trigData,
      const AliHLTUInt8_t (**attributes)[gkAliHLTBlockDAttributeCount],
      AliHLTUInt64_t* status,
      AliHLTCDHWrapper* const cdh,
      AliHLTReadoutList* readoutlist,
      bool printErrors = false
    );

  /**
   * Extracts the readout list from a trigger data structure.
   * @param [in] trigData  The trigger data as passed to the DoProcessing method.
   * @param [out] list  The output readout list to fill.
   * @param [in] printErrors  If true then error messages are generated as necessary
   *                          and suppressed otherwise.
   * @return zero on success or one of the error codes returned by ExtractTriggerData.
   */
  static int GetReadoutList(
      const AliHLTComponentTriggerData& trigData, AliHLTReadoutList& list,
      bool printErrors = false
    )
  {
    return ExtractTriggerData(trigData, NULL, NULL, NULL, &list, printErrors);
  }

  /**
   * Extracts the event type from the given Common Data Header.
   * @param [in] cdh  The Common Data Header to extract the event type from.
   * @return the event type code from the CDH.
   */
  static AliHLTUInt32_t ExtractEventTypeFromCDH(const AliHLTCDHWrapper* const cdh);
  
  /**
   * Stopwatch type for benchmarking.
   */
  enum AliHLTStopwatchType {
    /** total time for event processing */
    kSWBase,
    /** detector algorithm w/o interface callbacks */
    kSWDA,
    /** data sources */
    kSWInput,
    /** data sinks */
    kSWOutput,
    /** number of types */
    kSWTypeCount
  };

  /**
   * Helper class for starting and stopping a stopwatch.
   * The guard can be used by instantiating an object in a function. The
   * specified stopwatch is started and the previous stopwatch put on
   * hold. When the function is terminated, the object is deleted automatically
   * deleted, stopping the stopwatch and starting the one on hold.<br>
   * \em IMPORTANT: never create dynamic objects from this guard as this violates
   * the idea of a guard.
   */
  class AliHLTStopwatchGuard {
  public:
    /** standard constructor (not for use) */
    AliHLTStopwatchGuard();
    /** constructor */
    AliHLTStopwatchGuard(TStopwatch* pStart);
    /** copy constructor (not for use) */
    AliHLTStopwatchGuard(const AliHLTStopwatchGuard&);
    /** assignment operator (not for use) */
    AliHLTStopwatchGuard& operator=(const AliHLTStopwatchGuard&);
    /** destructor */
    ~AliHLTStopwatchGuard();

  private:
    /**
     * Hold the previous guard for the existence of this guard.
     * Checks whether this guard controls a new stopwatch. In that case, the
     * previous guard and its stopwatch are put on hold.
     * @param pSucc        instance of the stopwatch of the new guard
     * @return    1 if pSucc is a different stopwatch which should
     *            be started<br>
     *            0 if it controls the same stopwatch
     */
    int Hold(const TStopwatch* pSucc);

    /**
     * Resume the previous guard.
     * Checks whether the peceeding guard controls a different stopwatch. In that
     * case, the its stopwatch is resumed.
     * @param pSucc        instance of the stopwatch of the new guard
     * @return    1 if pSucc is a different stopwatch which should
     *            be stopped<br>
     *            0 if it controls the same stopwatch
     */
    int Resume(const TStopwatch* pSucc);

    /** the stopwatch controlled by this guard */
    TStopwatch* fpStopwatch;                                                //!transient

    /** previous stopwatch guard, put on hold during existence of the guard */
    AliHLTStopwatchGuard* fpPrec;                                           //!transient

    /** active stopwatch guard */
    static AliHLTStopwatchGuard* fgpCurrent;                                //!transient
  };

  /**
   * Set a stopwatch for a given purpose.
   * @param pSW         stopwatch object
   * @param type        type of the stopwatch
   */
  int SetStopwatch(TObject* pSW, AliHLTStopwatchType type=kSWBase);

  /**
   * Init a set of stopwatches.
   * @param pStopwatches object array of stopwatches
   */
  int SetStopwatches(TObjArray* pStopwatches);

  /**
   * Customized logging function.
   * The chain id, component id and pointer is added at the beginning of each message.
   */
  int LoggingVarargs(AliHLTComponentLogSeverity severity, 
		     const char* originClass, const char* originFunc,
		     const char* file, int line, ... ) const;

  /**
   * Get size of last serialized object.
   * During PushBack, TObjects are serialized in a separate buffer. The
   * size of the last object can be retrieved by this function.
   *
   * This might be especially useful for PushBack failures caused by too
   * small output buffer.
   */
  int GetLastObjectSize() const {return fLastObjectSize;}

  /**
   * This method generates a V4 Globally Unique Identifier (GUID) using the
   * ROOT TRandom3 pseudo-random number generator with the process' UID, GID
   * PID and host address as seeds. For good measure MD5 sum hashing is also
   * applied.
   * @return the newly generated GUID structure.
   */
  static TUUID GenerateGUID();

  /// get the compression level for TObjects
  int GetCompressionLevel() const {return fCompressionLevel;}

 protected:

  /**
   * Default method for the internal initialization.
   * The method is called by @ref Init
   */
  virtual int DoInit( int argc, const char** argv );

  /**
   * Default method for the internal clean-up.
   * The method is called by @ref Deinit
   */
  virtual int DoDeinit();

  /**
   * Reconfigure the component.
   * The method is called when an event of type @ref kAliHLTDataTypeComConf
   * {COM_CONF:PRIV} is received by the component. If the event is sent as
   * part of a normal event, the component configuration is called first.
   *
   * The CDB path parameter specifies the path in the CDB, i.e. without
   * leading absolute path of the CDB location. The framework might also
   * provide the id of the component in the analysis chain.
   *
   * The actual sequence of configuration depends on the component. As a
   * general rule, the component should load the specific OCDB object if
   * provided as parameter, and load the default objects if the parameter
   * is NULL. However, other schemes are possible. See @ref 
   *
   * \b Note: The CDB will be initialized by the framework, either already set
   * from AliRoot or from the wrapper interface during initialization.
   *
   * @param cdbEntry     path of the cdbEntry
   * @param chainId      the id/name of the component in the current analysis
   *                     chain. This is not necessarily the same as what is
   *                     returned by the GetComponentID() method.
   * @note both parameters can be NULL, check before usage
   */
  virtual int Reconfigure(const char* cdbEntry, const char* chainId);

  /**
   * Read the Preprocessor values.
   * The function is invoked when the component is notified about available/
   * updated data points from the detector Preprocessors. The 'modules'
   * argument contains all detectors for which the Preprocessors have
   * updated data points. The component has to implement the CDB access to
   * get the desired data points.
   * @param modules     detectors for which the Preprocessors have updated
   *                    data points: TPC, TRD, ITS, PHOS, MUON, or ALL if
   *                    no argument was received.
   * @return neg. error code if failed
   */
  virtual int ReadPreprocessorValues(const char* modules);

  /**
   * Child implementation to scan a number of configuration arguments.
   * The method is invoked by the framework in conjunction with the
   * common framework functions ConfigureFromArgumentString and
   * ConfigureFromCDBTObjString.
   * Function needs to scan the argument and optional additional
   * parameters and returns the number of elements in the array which
   * have been treated.
   * @param argc
   * @param argv
   * @return number of arguments which have been scanned or neg error
   *         code if failed                                              <br>
   *         \li -EINVAL      unknown argument
   *         \li -EPROTO      protocol error, e.g. missing parameter
   */
  virtual int ScanConfigurationArgument(int argc, const char** argv);

  /**
   * Custom handler for the SOR event.
   * Is invoked from the base class if an SOR event is in the block list.
   * The handler is called before the processing function. The processing
   * function is skipped if there are no other data blocks available.
   *
   * The SOR event is generated by the PubSub framework in response to
   * the DAQ start of data (SOD - has been renamed after HLT interface
   * was designed). The SOD event consists of 3 blocks:
   * - ::kAliHLTDataTypeEvent block: spec ::gkAliEventTypeStartOfRun
   * - SOD block of type ::kAliHLTDataTypeSOR, payload: AliHLTRunDesc struct
   * - run type block ::kAliHLTDataTypeRunType, payload: run type string 
   *
   * Run properties can be retrieved by getters like GetRunNo().
   * @return neg. error code if failed
   */
  virtual int StartOfRun();

  /**
   * Custom handler for the EOR event.
   * Is invoked from the base class if an EOR event is in the block list.
   * The handler is called before the processing function. The processing
   * function is skipped if there are no other data blocks available.
   *
   * See StartOfRun() for more comments of the sequence of steering events.
   *
   * @return neg. error code if failed
   */
  virtual int EndOfRun();

  /**
   * Check whether a component requires all steering blocks.
   * Childs can overload in order to indicate that they want to
   * receive also the steering data blocks. There is also the
   * possibility to add the required data types to the input
   * data type list in GetInputDataTypes().
   */
  virtual bool RequireSteeringBlocks() const {return false;}

  /**
   * General memory allocation method.
   * All memory which is going to be used 'outside' of the interface must
   * be provided by the framework (online or offline).
   * The method is redirected to a function provided by the current
   * framework. Function pointers are transferred via the @ref
   * AliHLTAnalysisEnvironment structure.
   */
  void* AllocMemory( unsigned long size );

  /**
   * Helper function to create a monolithic BlockData description block out
   * of a list BlockData descriptors.
   * For convenience, inside the interface vector lists are used, to make the
   * interface pure C style, monilithic blocks must be exchanged. 
   * The method is redirected to a function provided by the current
   * framework. Function pointers are transferred via the @ref
   * AliHLTAnalysisEnvironment structure.
   */
  int MakeOutputDataBlockList( const AliHLTComponentBlockDataList& blocks, AliHLTUInt32_t* blockCount,
			       AliHLTComponentBlockData** outputBlocks );

  /**
   * Fill the EventDoneData structure.
   * The method is redirected to a function provided by the current
   * framework. Function pointers are transferred via the @ref
   * AliHLTAnalysisEnvironment structure.
   */
  int GetEventDoneData( unsigned long size, AliHLTComponentEventDoneData** edd ) const;

  /**
   * Allocate an EventDoneData structure for the current event .
   * The method allocates the memory internally and does not interact with the current Framework.
   * The allocated data structure is empty initially and can be filled by calls to the 
   * @ref PushEventDoneData method. The memory will be automatically released after the event has been processed.
   * 
   */
  int ReserveEventDoneData( unsigned long size );

  /**
   * Push a 32 bit word of data into event done data for the current event which
   * has previously been allocated by the @ref ReserveEventDoneData method.
   */
  int PushEventDoneData( AliHLTUInt32_t eddDataWord );

  /**
   * Release event done data previously reserved by @ref ReserveEventDoneData
   */
   void ReleaseEventDoneData();

  /**
   * Get the pointer to the event done data available/built so far for the current event via
   * @ref ReserveEventDoneData and @ref PushEventDoneData
   */
  AliHLTComponentEventDoneData* GetCurrentEventDoneData() const
    {
    return fEventDoneData;
    }

  /**
   * Helper function to convert the data type to a string.
   */
  void DataType2Text(const AliHLTComponentDataType& type, char output[kAliHLTComponentDataTypefIDsize+kAliHLTComponentDataTypefOriginSize+2]) const;

  /**
   * Loop through a list of component arguments.
   * The list can be either an array of separated strings or one single
   * string containing blank separated arguments, or both mixed.
   * ScanConfigurationArgument() is called to allow the component to treat
   * the individual arguments.
   * @return neg. error code if failed
   */
  int ConfigureFromArgumentString(int argc, const char** argv);

  /**
   * Read configuration objects from OCDB and configure from
   * the content of TObjString entries.
   * @param entries   blank separated list of OCDB paths
   * @param key       if the entry is a TMap, search for the corresponding object
   * @return neg. error code if failed
   */
  int ConfigureFromCDBTObjString(const char* entries, const char* key=NULL);

  /**
   * Load specified entry from the OCDB and extract the object.
   * The entry is explicitely unloaded from the cache before it is loaded.
   * If parameter key is specified the OCDB object is treated as TMap
   * and the TObject associated with 'key' is loaded.
   * @param path      path of the entry under to root of the OCDB
   * @param version   version of the entry
   * @param subVersion  subversion of the entry
   * @param key       key of the object within TMap
   */
  TObject* LoadAndExtractOCDBObject(const char* path, const char* key=NULL) const;

  /**
   * Get event number.
   * @return value of the internal event counter
   */
  int GetEventCount() const;

  /**
   * Get the number of input blocks.
   * @return number of input blocks
   */
  int GetNumberOfInputBlocks() const;

  /**
   * Get id of the current event
   * @return event id
   */
  AliHLTEventID_t GetEventId() const;

  /**
   * Get the first object of a specific data type from the input data.
   * The High-level methods provide functionality to transfer ROOT data
   * structures which inherit from TObject.
   *
   * The method looks for the first ROOT object of type dt in the input stream.
   * If also the class name is provided, the object is checked for the right
   * class type. The input data block needs a certain structure, namely the 
   * buffer size as first word. If the cross check fails, the retrieval is
   * silently abandoned, unless the \em bForce parameter is set.<br>
   * \b Note: THE OBJECT MUST NOT BE DELETED by the caller.
   *
   * If called without parameters, the function tries to create objects from
   * all available input blocks, also the ones of data type kAliHLTVoidDataType
   * which are not matched by kAliHLTAnyDataType.
   *
   * @param dt          data type of the object
   * @param classname   class name of the object
   * @param bForce      force the retrieval of an object, error messages
   *                    are suppressed if \em bForce is not set
   * @return pointer to @ref TObject, NULL if no objects of specified type
   *         available
   */
  const TObject* GetFirstInputObject(const AliHLTComponentDataType& dt=kAliHLTAllDataTypes,
				     const char* classname=NULL,
				     int bForce=0);

  /**
   * Get the first object of a specific data type from the input data.
   * The High-level methods provide functionality to transfer ROOT data
   * structures which inherit from TObject.
   * The method looks for the first ROOT object of type specified by the ID and 
   * Origin strings in the input stream.
   * If also the class name is provided, the object is checked for the right
   * class type. The input data block needs a certain structure, namely the 
   * buffer size as first word. If the cross check fails, the retrieval is
   * silently abandoned, unless the \em bForce parameter is set.<br>
   * \em Note: THE OBJECT MUST NOT BE DELETED by the caller.
   * @param dtID        data type ID of the object
   * @param dtOrigin    data type origin of the object
   * @param classname   class name of the object
   * @param bForce      force the retrieval of an object, error messages
   *                    are suppressed if \em bForce is not set
   * @return pointer to @ref TObject, NULL if no objects of specified type
   *         available
   */
  const TObject* GetFirstInputObject(const char* dtID, 
				     const char* dtOrigin,
				     const char* classname=NULL,
				     int bForce=0);

  /**
   * Get the next object of a specific data type from the input data.
   * The High-level methods provide functionality to transfer ROOT data
   * structures which inherit from TObject.
   * The method looks for the next ROOT object of type and class specified
   * to the previous @ref GetFirstInputObject call.<br>
   * \em Note: THE OBJECT MUST NOT BE DELETED by the caller.
   * @param bForce      force the retrieval of an object, error messages
   *                    are suppressed if \em bForce is not set
   * @return pointer to @ref TObject, NULL if no more objects available
   */
  const TObject* GetNextInputObject(int bForce=0);

  /**
   * Get data type of an input block.
   * Get data type of the object previously fetched via
   * GetFirstInputObject/NextInputObject or the last one if no object
   * specified.
   * @param pObject     pointer to TObject
   * @return data specification, kAliHLTVoidDataSpec if failed
   */
  AliHLTComponentDataType GetDataType(const TObject* pObject=NULL);

  /**
   * Get data specification of an input block.
   * Get data specification of the object previously fetched via
   * GetFirstInputObject/NextInputObject or the last one if no object
   * specified.
   * @param pObject     pointer to TObject
   * @return data specification, kAliHLTVoidDataSpec if failed
   */
  AliHLTUInt32_t GetSpecification(const TObject* pObject=NULL);

  /**
   * Get the first block of a specific data type from the input data.
   * The method looks for the first block of type dt in the input stream.
   * It is intended to be used within the high-level interface.<br>
   * \em Note: THE BLOCK DESCRIPTOR MUST NOT BE DELETED by the caller.
   *
   * If called without parameters, the function works on all input blocks,
   * also the ones of data type kAliHLTVoidDataType which are not matched by
   * kAliHLTAnyDataType.
   *
   * @param dt          data type of the block
   * @return pointer to @ref AliHLTComponentBlockData
   */
  const AliHLTComponentBlockData* GetFirstInputBlock(const AliHLTComponentDataType& dt=kAliHLTAllDataTypes);

  /**
   * Get the first block of a specific data type from the input data.
   * The method looks for the first block of type specified by the ID and 
   * Origin strings in the input stream.  It is intended
   * to be used within the high-level interface.<br>
   * \em Note: THE BLOCK DESCRIPTOR MUST NOT BE DELETED by the caller.
   * @param dtID        data type ID of the block
   * @param dtOrigin    data type origin of the block
   * @return pointer to @ref AliHLTComponentBlockData
   */
  const AliHLTComponentBlockData* GetFirstInputBlock(const char* dtID, 
						      const char* dtOrigin);

  /**
   * Get input block by index.<br>
   * \em Note: THE BLOCK DESCRIPTOR MUST NOT BE DELETED by the caller.
   * @return pointer to AliHLTComponentBlockData, NULL if index out of range
   */
  const AliHLTComponentBlockData* GetInputBlock(int index) const;

  /**
   * Get the next block of a specific data type from the input data.
   * The method looks for the next block  of type and class specified
   * to the previous @ref GetFirstInputBlock call.
   * To be used within the high-level interface.<br>
   * \em Note: THE BLOCK DESCRIPTOR MUST NOT BE DELETED by the caller.
   */
  const AliHLTComponentBlockData* GetNextInputBlock();

  /**
   * Get data specification of an input block.
   * Get data specification of the input block previously fetched via
   * GetFirstInputObject/NextInputObject or the last one if no block
   * specified.
   * @param pBlock     pointer to input block
   * @return data specification, kAliHLTVoidDataSpec if failed
   */
  AliHLTUInt32_t GetSpecification(const AliHLTComponentBlockData* pBlock);

  /**
   * Forward an input object to the output.
   * Forward the input block of an object previously fetched via
   * GetFirstInputObject/NextInputObject or the last one if no object
   * specified.
   * The block descriptor of the input block is forwarded to the
   * output block list.
   * @param pObject     pointer to TObject
   * @return neg. error code if failed
   */
  int Forward(const TObject* pObject);

  /**
   * Forward an input block to the output.
   * Forward the input block fetched via GetFirstInputObject/
   * NextInputBlock or the last one if no block specified.
   * The block descriptor of the input block is forwarded to the
   * output block list.
   * @param pBlock     pointer to input block
   * @return neg. error code if failed
   */
  int Forward(const AliHLTComponentBlockData* pBlock=NULL);

  /**
   * Insert an object into the output.
   * If header is specified, it will be inserted before the root object,
   * default is no header.
   * The publishing can be downscaled by means of the -pushback-period
   * parameter. This is especially useful for histograms which do not
   * need to be sent for every event.
   * @param pObject     pointer to root object
   * @param dt          data type of the object
   * @param spec        data specification
   * @param pHeader     pointer to header
   * @param headerSize  size of Header
   * @return neg. error code if failed 
   */
  int PushBack(const TObject* pObject, const AliHLTComponentDataType& dt, 
	       AliHLTUInt32_t spec=kAliHLTVoidDataSpec, 
	       void* pHeader=NULL, int headerSize=0);

  /**
   * Insert an object into the output.
   * If header is specified, it will be inserted before the root object,
   * default is no header.
   * The publishing can be downscaled by means of the -pushback-period
   * parameter. This is especially useful for histograms which do not
   * need to be sent for every event.
   * @param pObject     pointer to root object
   * @param dtID        data type ID of the object
   * @param dtOrigin    data type origin of the object
   * @param spec        data specification
   * @param pHeader     pointer to header
   * @param headerSize  size of Header
   * @return neg. error code if failed 
   */
  int PushBack(const TObject* pObject, const char* dtID, const char* dtOrigin,
	       AliHLTUInt32_t spec=kAliHLTVoidDataSpec,
	       void* pHeader=NULL, int headerSize=0);
 
  /**
   * Insert an object into the output.
   * @param pBuffer     pointer to buffer
   * @param iSize       size of the buffer
   * @param dt          data type of the object
   * @param spec        data specification
   * @param pHeader     pointer to header
   * @param headerSize size of Header
   * @return neg. error code if failed 
   */
  int PushBack(const void* pBuffer, int iSize, const AliHLTComponentDataType& dt,
	       AliHLTUInt32_t spec=kAliHLTVoidDataSpec,
	       const void* pHeader=NULL, int headerSize=0);

  /**
   * Insert an object into the output.
   * @param pBuffer     pointer to buffer
   * @param iSize       size of the buffer
   * @param dtID        data type ID of the object
   * @param dtOrigin    data type origin of the object
   * @param spec        data specification
   * @param pHeader     pointer to header
   * @param headerSize size of Header
   * @return neg. error code if failed 
   */
  int PushBack(const void* pBuffer, int iSize, const char* dtID, const char* dtOrigin,
	       AliHLTUInt32_t spec=kAliHLTVoidDataSpec,
	       const void* pHeader=NULL, int headerSize=0);

  /**
   * Estimate size of a TObject
   * @param pObject
   * @return buffer size in byte
   */
  int EstimateObjectSize(const TObject* pObject) const;

  /**
   * Create a memory file in the output stream.
   * This method creates a TFile object which stores all data in
   * memory instead of disk. The TFile object is published as binary data.
   * The instance can be used like a normal TFile object. The TFile::Close
   * or @ref CloseMemoryFile method has to be called in order to flush the
   * output stream.
   *
   * \b Note: The returned object is deleted by the framework.
   * @param capacity    total size reserved for the memory file
   * @param dtID        data type ID of the file
   * @param dtOrigin    data type origin of the file
   * @param spec        data specification
   * @return file handle, NULL if failed 
   */
  AliHLTMemoryFile* CreateMemoryFile(int capacity, const char* dtID, const char* dtOrigin,
				     AliHLTUInt32_t spec=kAliHLTVoidDataSpec);

  /**
   * Create a memory file in the output stream.
   * This method creates a TFile object which stores all data in
   * memory instead of disk. The TFile object is published as binary data.
   * The instance can be used like a normal TFile object. The TFile::Close
   * or @ref CloseMemoryFile method has to be called in order to flush the
   * output stream.
   *
   * \b Note: The returned object is deleted by the framework.
   * @param capacity    total size reserved for the memory file
   * @param dt          data type of the file
   * @param spec        data specification
   * @return file handle, NULL if failed 
   */
  AliHLTMemoryFile* CreateMemoryFile(int capacity, 
				     const AliHLTComponentDataType& dt=kAliHLTAnyDataType,
				     AliHLTUInt32_t spec=kAliHLTVoidDataSpec);

  /**
   * Create a memory file in the output stream.
   * This method creates a TFile object which stores all data in
   * memory instead of disk. The TFile object is published as binary data.
   * The instance can be used like a normal TFile object. The TFile::Close
   * or @ref CloseMemoryFile method has to be called in order to flush the
   * output stream.
   *
   * \b Note: The returned object is deleted by the framework.
   * @param dtID        data type ID of the file
   * @param dtOrigin    data type origin of the file
   * @param spec        data specification
   * @param capacity    fraction of the available output buffer size
   * @return file handle, NULL if failed 
   */
  AliHLTMemoryFile* CreateMemoryFile(const char* dtID, const char* dtOrigin,
				     AliHLTUInt32_t spec=kAliHLTVoidDataSpec,
				     float capacity=1.0);

  /**
   * Create a memory file in the output stream.
   * This method creates a TFile object which stores all data in
   * memory instead of disk. The TFile object is published as binary data.
   * The instance can be used like a normal TFile object. The TFile::Close
   * or @ref CloseMemoryFile method has to be called in order to flush the
   * output stream.
   *
   * \b Note: The returned object is deleted by the framework.
   * @param dt          data type of the file
   * @param spec        data specification
   * @param capacity    fraction of the available output buffer size
   * @return file handle, NULL if failed 
   */
  AliHLTMemoryFile* CreateMemoryFile(const AliHLTComponentDataType& dt=kAliHLTAnyDataType,
				     AliHLTUInt32_t spec=kAliHLTVoidDataSpec,
				     float capacity=1.0);

  /**
   * Write an object to memory file in the output stream.
   * @param pFile       file handle
   * @param pObject     pointer to root object
   * @param key         key in ROOT file
   * @param option      options, see TObject::Write
   * @return neg. error code if failed
   *         - -ENOSPC    no space left
   */
  int Write(AliHLTMemoryFile* pFile, const TObject* pObject, const char* key=NULL, int option=TObject::kOverwrite);

  /**
   * Close object memory file.
   * @param pFile       file handle
   * @return neg. error code if failed
   *         - -ENOSPC    buffer size too small
   */
  int CloseMemoryFile(AliHLTMemoryFile* pFile);

  /**
   * Insert event-done data information into the output.
   * @param edd          event-done data information
   */
  int CreateEventDoneData(AliHLTComponentEventDoneData edd);

  /**
   * Get current run number
   */
  AliHLTUInt32_t GetRunNo() const;

  /**
   * Get the current run type.
   */
  AliHLTUInt32_t GetRunType() const;

  /**
   * Get the chain id of the component.
   */
  const char* GetChainId() const {return fChainId.c_str();}

  /**
   * Get a timestamp of the current event
   * Exact format needs to be documented.
   */
  AliHLTUInt32_t    GetTimeStamp() const;

  /**
   * Get the period number.
   * Upper 28 bits (36 to 63) of the 64-bit event id 
   */
  AliHLTUInt32_t    GetPeriodNumber() const;

  /**
   * Get the period number.
   * 24 bits, 12 to 35 of the 64-bit event id 
   */
  AliHLTUInt32_t    GetOrbitNumber() const;

  /**
   * Get the bunch crossing number.
   * 12 bits, 0 to 12 of the 64-bit event id 
   */
  AliHLTUInt16_t    GetBunchCrossNumber() const;

  /**
   * Setup the CTP accounting functionality of the base class.
   * The method can be invoked from DoInit() for componenets which want to
   * use the CTP functionality of the base class.
   *
   * The AliHLTCTPData is initialized with the trigger classes from the ECS
   * parameters. The base class automatically increments the counters according
   * to the trigger pattern in the CDH before the event processing. 
   */
  int SetupCTPData();

  /**
   * Get the instance of the CTP data.
   */
  const AliHLTCTPData* CTPData() const {return fpCTPData;}

  /**
   * Check whether a combination of trigger classes is fired.
   * The expression can contain trigger class ids and logic operators
   * like &&, ||, !, and ^, and may be grouped by parentheses.
   * @note the function requires the setup of the CTP handling for the component by
   * invoking SetupCTPData() from DoInit()
   * @param expression     a logic expression of trigger class ids
   * @param trigData       the trigger data data
   */
  bool EvaluateCTPTriggerClass(const char* expression, AliHLTComponentTriggerData& trigData) const;

  /**
   * Check state of a trigger class.
   * If the class name is not part of the current trigger setup (i.e. ECS parameter
   * does not contain a trigger definition for this class name) the function
   * returns -1
   * @note the function requires the setup of the CTP handling for the component by
   * invoking SetupCTPData() from DoInit()
   * @return -1 class name not initialized, 
   *          0 trigger not active
   *          1 trigger active
   */
  int CheckCTPTrigger(const char* name) const;

  /**
   * Get the overall solenoid field.
   */
  Double_t GetBz();
  /**
   * Get the solenoid field at point r.
   */
  Double_t GetBz(const Double_t *r);
  /**
   * Get the solenoid field components at point r.
   */
  void GetBxByBz(const Double_t r[3], Double_t b[3]);

  /**
   * Check whether the current event is a valid data event.
   * @param pTgt    optional pointer to get the event type
   * @return true if the current event is a real data event
   */
  bool IsDataEvent(AliHLTUInt32_t* pTgt=NULL) const;

  /**
   * Copy a struct from block data.
   * The function checks for block size and struct size. The least common
   * size will be copied to the target struct, remaining fields are initialized
   * to zero.<br>
   * The target struct must have a 32bit struct size indicator as first member.
   * @param pStruct     target struct
   * @param iStructSize size of the struct
   * @param iBlockNo    index of input block
   * @param structname  name of the struct (log messages)
   * @param eventname   name of the event (log messages)
   * @return size copied, neg. error if failed
   */
  int CopyStruct(void* pStruct, unsigned int iStructSize, unsigned int iBlockNo,
		 const char* structname="", const char* eventname="");

 private:
  /** copy constructor prohibited */
  AliHLTComponent(const AliHLTComponent&);
  /** assignment operator prohibited */
  AliHLTComponent& operator=(const AliHLTComponent&);

  /**
   * Increment the internal event counter.
   * To be used by the friend classes AliHLTProcessor, AliHLTDataSource
   * and AliHLTDataSink.
   * @return new value of the internal event counter
   * @internal
   */
  int IncrementEventCounter();

  /**
   * Find the first input block of specified data type beginning at index.
   * Input blocks containing a TObject have the size of the object as an
   * unsigned 32 bit number in the first 4 bytes. This has to match the block
   * size minus 4.
   *
   * kAliHLTAllDataTypes is a special data type which includes both 
   * kAliHLTVoidDataType and kAliHLTAnyDataType.
   *
   * @param dt          data type
   * @param startIdx    index to start the search
   * @param bObject     check if this is an object
   * @return index of the block, -ENOENT if no block found
   *
   * @internal
   */
  int FindInputBlock(const AliHLTComponentDataType& dt, int startIdx=-1, int bObject=0) const;

  /**
   * Get index in the array of input bocks.
   * Calculate index and check integrety of a block data structure pointer.
   * @param pBlock      pointer to block data
   * @return index of the block, -ENOENT if no block found
   *
   * @internal
   */
  int FindInputBlock(const AliHLTComponentBlockData* pBlock) const;

  /**
   * Create an object from a specified input block.
   * @param idx         index of the input block
   * @param bForce      force the retrieval of an object, error messages
   *                    are suppressed if \em bForce is not set
   * @return pointer to TObject, caller must delete the object after use
   *
   * @internal
   */
  TObject* CreateInputObject(int idx, int bForce=0);

  /**
   * Get input object
   * Get object from the input block list. The methods first checks whether the
   * object was already created. If not, it is created by @ref CreateInputObject
   * and inserted into the list of objects.
   * @param idx         index in the input block list
   * @param classname   name of the class, object is checked for correct class
   *                    name if set
   * @param bForce      force the retrieval of an object, error messages
   *                    are suppressed if \em bForce is not set
   * @return pointer to TObject
   *
   * @internal
   */
  TObject* GetInputObject(int idx, const char* classname=NULL, int bForce=0);

  /**
   * Clean the list of input objects.
   * Cleanup is done at the end of each event processing.
   */
  int CleanupInputObjects();

  /**
   * Insert a buffer into the output block stream.
   * This is the only method to insert blocks into the output stream, called
   * from all types of the Pushback method. The actual data might have been
   * written to the output buffer already. In that case NULL can be provided
   * as buffer, only the block descriptor will be build. If a header is specified, 
   * it will be inserted before the buffer, default is no header.
   * @param pBuffer     pointer to buffer
   * @param iBufferSize size of the buffer in byte
   * @param dt          data type
   * @param spec        data specification
   * @param pHeader     pointer to header
   * @param iHeaderSize size of Header
   * @return neg. error code if failed
   */
  int InsertOutputBlock(const void* pBuffer, int iBufferSize,
			const AliHLTComponentDataType& dt,
			AliHLTUInt32_t spec,
			const void* pHeader=NULL, int iHeaderSize=0);

  /**
   * Add a component statistics block to the output.
   * @return size of the added data
   */
  int AddComponentStatistics(AliHLTComponentBlockDataList& blocks, 
			     AliHLTUInt8_t* buffer,
			     AliHLTUInt32_t bufferSize,
			     AliHLTUInt32_t offset,
			     AliHLTComponentStatisticsList& stats) const;

  /**
   * Add a component table entry (descriptor) to the output
   * This is done at SOR/EOR. The component table is a list of chain ids
   * and 32bit ids calculated by a crc algorithm from the chian id. This
   * allows to tag data blocks with the id number rather than the string.
   *
   * The kAliHLTDataTypeComponentTable data block currently has the string
   * as payload and the crc id as specification.
   * @return size of the added data
   */
  int  AddComponentTableEntry(AliHLTComponentBlockDataList& blocks, 
			      AliHLTUInt8_t* buffer,
			      AliHLTUInt32_t bufferSize,
			      AliHLTUInt32_t offset,
			      const vector<AliHLTUInt32_t>& parents,
			      int processingLevel) const;

  /**
   * Scan the ECS parameter string.
   * The framework provides both the parameters of CONFIGURE and ENGAGE
   * in one string in a special data block kAliHLTDataTypeECSParam
   * {ECSPARAM:PRIV}. The general format is
   * <command>;<parameterkey>=<parametervalue>;<parameterkey>=<parametervalue>;...
   */
  int ScanECSParam(const char* ecsParam);

  /**
   * The trigger classes are determined from the trigger and propagated by
   * ECS as part of the ENGAGE command parameter which is sent through the
   * framework during the SOR event. This function treats the value of the
   * parameter key CTP_TRIGGER_CLASS.
   */
  int InitCTPTriggerClasses(const char* ctpString);

  enum {
    kRequireSteeringBlocks = 0x1,
    kDisableComponentStat = 0x2
  };

  /** The global component handler instance */
  static AliHLTComponentHandler* fgpComponentHandler;              //! transient

  /** The environment where the component is running in */
  AliHLTAnalysisEnvironment fEnvironment;                         // see above

  /** Set by ProcessEvent before the processing starts */
  AliHLTEventID_t fCurrentEvent;                                   // see above

  /** internal event no */
  int fEventCount;                                                 // see above

  /** the number of failed events */
  int fFailedEvents;                                               // see above

  /** event data struct of the current event under processing */
  AliHLTComponentEventData fCurrentEventData;                      // see above

  /** array of input data blocks of the current event */
  const AliHLTComponentBlockData* fpInputBlocks;                   //! transient

  /** index of the current input block */
  int fCurrentInputBlock;                                          // see above

  /** data type of the last block search */
  AliHLTComponentDataType fSearchDataType;                         // see above

  /** name of the class for the object to search for */
  string fClassName;                                               // see above

  /** array of generated input objects */
  TObjArray* fpInputObjects;                                       //! transient
 
  /** the output buffer */
  AliHLTUInt8_t* fpOutputBuffer;                                   //! transient

  /** size of the output buffer */
  AliHLTUInt32_t fOutputBufferSize;                                // see above

  /** size of data written to output buffer */
  AliHLTUInt32_t fOutputBufferFilled;                              // see above

  /** list of ouput block data descriptors */
  AliHLTComponentBlockDataList fOutputBlocks;                      // see above

  /** stopwatch array */
  TObjArray* fpStopwatches;                                        //! transient

  /** array of memory files AliHLTMemoryFile */
  AliHLTMemoryFilePList fMemFiles;                                 //! transient

  /** descriptor of the current run */
  AliHLTRunDesc* fpRunDesc;                                        //! transient

  /** external fct to set CDB run no, indicates external CDB initialization */
  void (*fCDBSetRunNoFunc)();                                      //! transient

  /** id of the component in the analysis chain */
  string fChainId;                                                 //! transient

  /** crc value of the chainid, used as a 32bit id */
  AliHLTUInt32_t fChainIdCrc;                                      //! transient

  /** optional benchmarking for the component statistics */
  TStopwatch* fpBenchmark;                                         //! transient

  /** component flags, cleared in Deinit */
  AliHLTUInt32_t fFlags;                                           //! transient

  /** current event type */
  AliHLTUInt32_t fEventType;                                       //! transient

  /** component arguments */
  string fComponentArgs;                                           //! transient


  /** event done data */
  AliHLTComponentEventDoneData* fEventDoneData;                    //! transient

  /** Reserved size of the memory stored at fEventDoneData */
  unsigned long fEventDoneDataSize;                                //! transient

  /** Comression level for ROOT objects */
  int fCompressionLevel;                                           //! transient

  /** size of last PushBack-serialized object */
  int fLastObjectSize;                                             //! transient

 /**  array of trigger class descriptors */
  AliHLTCTPData* fpCTPData;                                        //! transient

  /// update period for PushBack calls
  int fPushbackPeriod;                                             //! transient
  /// time of last executed PushBack
  int fLastPushBackTime;                                           //! transient
  
  /// Event modulo for down scaling the processing rate.
  int fEventModulo;                                                //! transient

  ClassDef(AliHLTComponent, 0)
};
#endif
 AliHLTComponent.h:1
 AliHLTComponent.h:2
 AliHLTComponent.h:3
 AliHLTComponent.h:4
 AliHLTComponent.h:5
 AliHLTComponent.h:6
 AliHLTComponent.h:7
 AliHLTComponent.h:8
 AliHLTComponent.h:9
 AliHLTComponent.h:10
 AliHLTComponent.h:11
 AliHLTComponent.h:12
 AliHLTComponent.h:13
 AliHLTComponent.h:14
 AliHLTComponent.h:15
 AliHLTComponent.h:16
 AliHLTComponent.h:17
 AliHLTComponent.h:18
 AliHLTComponent.h:19
 AliHLTComponent.h:20
 AliHLTComponent.h:21
 AliHLTComponent.h:22
 AliHLTComponent.h:23
 AliHLTComponent.h:24
 AliHLTComponent.h:25
 AliHLTComponent.h:26
 AliHLTComponent.h:27
 AliHLTComponent.h:28
 AliHLTComponent.h:29
 AliHLTComponent.h:30
 AliHLTComponent.h:31
 AliHLTComponent.h:32
 AliHLTComponent.h:33
 AliHLTComponent.h:34
 AliHLTComponent.h:35
 AliHLTComponent.h:36
 AliHLTComponent.h:37
 AliHLTComponent.h:38
 AliHLTComponent.h:39
 AliHLTComponent.h:40
 AliHLTComponent.h:41
 AliHLTComponent.h:42
 AliHLTComponent.h:43
 AliHLTComponent.h:44
 AliHLTComponent.h:45
 AliHLTComponent.h:46
 AliHLTComponent.h:47
 AliHLTComponent.h:48
 AliHLTComponent.h:49
 AliHLTComponent.h:50
 AliHLTComponent.h:51
 AliHLTComponent.h:52
 AliHLTComponent.h:53
 AliHLTComponent.h:54
 AliHLTComponent.h:55
 AliHLTComponent.h:56
 AliHLTComponent.h:57
 AliHLTComponent.h:58
 AliHLTComponent.h:59
 AliHLTComponent.h:60
 AliHLTComponent.h:61
 AliHLTComponent.h:62
 AliHLTComponent.h:63
 AliHLTComponent.h:64
 AliHLTComponent.h:65
 AliHLTComponent.h:66
 AliHLTComponent.h:67
 AliHLTComponent.h:68
 AliHLTComponent.h:69
 AliHLTComponent.h:70
 AliHLTComponent.h:71
 AliHLTComponent.h:72
 AliHLTComponent.h:73
 AliHLTComponent.h:74
 AliHLTComponent.h:75
 AliHLTComponent.h:76
 AliHLTComponent.h:77
 AliHLTComponent.h:78
 AliHLTComponent.h:79
 AliHLTComponent.h:80
 AliHLTComponent.h:81
 AliHLTComponent.h:82
 AliHLTComponent.h:83
 AliHLTComponent.h:84
 AliHLTComponent.h:85
 AliHLTComponent.h:86
 AliHLTComponent.h:87
 AliHLTComponent.h:88
 AliHLTComponent.h:89
 AliHLTComponent.h:90
 AliHLTComponent.h:91
 AliHLTComponent.h:92
 AliHLTComponent.h:93
 AliHLTComponent.h:94
 AliHLTComponent.h:95
 AliHLTComponent.h:96
 AliHLTComponent.h:97
 AliHLTComponent.h:98
 AliHLTComponent.h:99
 AliHLTComponent.h:100
 AliHLTComponent.h:101
 AliHLTComponent.h:102
 AliHLTComponent.h:103
 AliHLTComponent.h:104
 AliHLTComponent.h:105
 AliHLTComponent.h:106
 AliHLTComponent.h:107
 AliHLTComponent.h:108
 AliHLTComponent.h:109
 AliHLTComponent.h:110
 AliHLTComponent.h:111
 AliHLTComponent.h:112
 AliHLTComponent.h:113
 AliHLTComponent.h:114
 AliHLTComponent.h:115
 AliHLTComponent.h:116
 AliHLTComponent.h:117
 AliHLTComponent.h:118
 AliHLTComponent.h:119
 AliHLTComponent.h:120
 AliHLTComponent.h:121
 AliHLTComponent.h:122
 AliHLTComponent.h:123
 AliHLTComponent.h:124
 AliHLTComponent.h:125
 AliHLTComponent.h:126
 AliHLTComponent.h:127
 AliHLTComponent.h:128
 AliHLTComponent.h:129
 AliHLTComponent.h:130
 AliHLTComponent.h:131
 AliHLTComponent.h:132
 AliHLTComponent.h:133
 AliHLTComponent.h:134
 AliHLTComponent.h:135
 AliHLTComponent.h:136
 AliHLTComponent.h:137
 AliHLTComponent.h:138
 AliHLTComponent.h:139
 AliHLTComponent.h:140
 AliHLTComponent.h:141
 AliHLTComponent.h:142
 AliHLTComponent.h:143
 AliHLTComponent.h:144
 AliHLTComponent.h:145
 AliHLTComponent.h:146
 AliHLTComponent.h:147
 AliHLTComponent.h:148
 AliHLTComponent.h:149
 AliHLTComponent.h:150
 AliHLTComponent.h:151
 AliHLTComponent.h:152
 AliHLTComponent.h:153
 AliHLTComponent.h:154
 AliHLTComponent.h:155
 AliHLTComponent.h:156
 AliHLTComponent.h:157
 AliHLTComponent.h:158
 AliHLTComponent.h:159
 AliHLTComponent.h:160
 AliHLTComponent.h:161
 AliHLTComponent.h:162
 AliHLTComponent.h:163
 AliHLTComponent.h:164
 AliHLTComponent.h:165
 AliHLTComponent.h:166
 AliHLTComponent.h:167
 AliHLTComponent.h:168
 AliHLTComponent.h:169
 AliHLTComponent.h:170
 AliHLTComponent.h:171
 AliHLTComponent.h:172
 AliHLTComponent.h:173
 AliHLTComponent.h:174
 AliHLTComponent.h:175
 AliHLTComponent.h:176
 AliHLTComponent.h:177
 AliHLTComponent.h:178
 AliHLTComponent.h:179
 AliHLTComponent.h:180
 AliHLTComponent.h:181
 AliHLTComponent.h:182
 AliHLTComponent.h:183
 AliHLTComponent.h:184
 AliHLTComponent.h:185
 AliHLTComponent.h:186
 AliHLTComponent.h:187
 AliHLTComponent.h:188
 AliHLTComponent.h:189
 AliHLTComponent.h:190
 AliHLTComponent.h:191
 AliHLTComponent.h:192
 AliHLTComponent.h:193
 AliHLTComponent.h:194
 AliHLTComponent.h:195
 AliHLTComponent.h:196
 AliHLTComponent.h:197
 AliHLTComponent.h:198
 AliHLTComponent.h:199
 AliHLTComponent.h:200
 AliHLTComponent.h:201
 AliHLTComponent.h:202
 AliHLTComponent.h:203
 AliHLTComponent.h:204
 AliHLTComponent.h:205
 AliHLTComponent.h:206
 AliHLTComponent.h:207
 AliHLTComponent.h:208
 AliHLTComponent.h:209
 AliHLTComponent.h:210
 AliHLTComponent.h:211
 AliHLTComponent.h:212
 AliHLTComponent.h:213
 AliHLTComponent.h:214
 AliHLTComponent.h:215
 AliHLTComponent.h:216
 AliHLTComponent.h:217
 AliHLTComponent.h:218
 AliHLTComponent.h:219
 AliHLTComponent.h:220
 AliHLTComponent.h:221
 AliHLTComponent.h:222
 AliHLTComponent.h:223
 AliHLTComponent.h:224
 AliHLTComponent.h:225
 AliHLTComponent.h:226
 AliHLTComponent.h:227
 AliHLTComponent.h:228
 AliHLTComponent.h:229
 AliHLTComponent.h:230
 AliHLTComponent.h:231
 AliHLTComponent.h:232
 AliHLTComponent.h:233
 AliHLTComponent.h:234
 AliHLTComponent.h:235
 AliHLTComponent.h:236
 AliHLTComponent.h:237
 AliHLTComponent.h:238
 AliHLTComponent.h:239
 AliHLTComponent.h:240
 AliHLTComponent.h:241
 AliHLTComponent.h:242
 AliHLTComponent.h:243
 AliHLTComponent.h:244
 AliHLTComponent.h:245
 AliHLTComponent.h:246
 AliHLTComponent.h:247
 AliHLTComponent.h:248
 AliHLTComponent.h:249
 AliHLTComponent.h:250
 AliHLTComponent.h:251
 AliHLTComponent.h:252
 AliHLTComponent.h:253
 AliHLTComponent.h:254
 AliHLTComponent.h:255
 AliHLTComponent.h:256
 AliHLTComponent.h:257
 AliHLTComponent.h:258
 AliHLTComponent.h:259
 AliHLTComponent.h:260
 AliHLTComponent.h:261
 AliHLTComponent.h:262
 AliHLTComponent.h:263
 AliHLTComponent.h:264
 AliHLTComponent.h:265
 AliHLTComponent.h:266
 AliHLTComponent.h:267
 AliHLTComponent.h:268
 AliHLTComponent.h:269
 AliHLTComponent.h:270
 AliHLTComponent.h:271
 AliHLTComponent.h:272
 AliHLTComponent.h:273
 AliHLTComponent.h:274
 AliHLTComponent.h:275
 AliHLTComponent.h:276
 AliHLTComponent.h:277
 AliHLTComponent.h:278
 AliHLTComponent.h:279
 AliHLTComponent.h:280
 AliHLTComponent.h:281
 AliHLTComponent.h:282
 AliHLTComponent.h:283
 AliHLTComponent.h:284
 AliHLTComponent.h:285
 AliHLTComponent.h:286
 AliHLTComponent.h:287
 AliHLTComponent.h:288
 AliHLTComponent.h:289
 AliHLTComponent.h:290
 AliHLTComponent.h:291
 AliHLTComponent.h:292
 AliHLTComponent.h:293
 AliHLTComponent.h:294
 AliHLTComponent.h:295
 AliHLTComponent.h:296
 AliHLTComponent.h:297
 AliHLTComponent.h:298
 AliHLTComponent.h:299
 AliHLTComponent.h:300
 AliHLTComponent.h:301
 AliHLTComponent.h:302
 AliHLTComponent.h:303
 AliHLTComponent.h:304
 AliHLTComponent.h:305
 AliHLTComponent.h:306
 AliHLTComponent.h:307
 AliHLTComponent.h:308
 AliHLTComponent.h:309
 AliHLTComponent.h:310
 AliHLTComponent.h:311
 AliHLTComponent.h:312
 AliHLTComponent.h:313
 AliHLTComponent.h:314
 AliHLTComponent.h:315
 AliHLTComponent.h:316
 AliHLTComponent.h:317
 AliHLTComponent.h:318
 AliHLTComponent.h:319
 AliHLTComponent.h:320
 AliHLTComponent.h:321
 AliHLTComponent.h:322
 AliHLTComponent.h:323
 AliHLTComponent.h:324
 AliHLTComponent.h:325
 AliHLTComponent.h:326
 AliHLTComponent.h:327
 AliHLTComponent.h:328
 AliHLTComponent.h:329
 AliHLTComponent.h:330
 AliHLTComponent.h:331
 AliHLTComponent.h:332
 AliHLTComponent.h:333
 AliHLTComponent.h:334
 AliHLTComponent.h:335
 AliHLTComponent.h:336
 AliHLTComponent.h:337
 AliHLTComponent.h:338
 AliHLTComponent.h:339
 AliHLTComponent.h:340
 AliHLTComponent.h:341
 AliHLTComponent.h:342
 AliHLTComponent.h:343
 AliHLTComponent.h:344
 AliHLTComponent.h:345
 AliHLTComponent.h:346
 AliHLTComponent.h:347
 AliHLTComponent.h:348
 AliHLTComponent.h:349
 AliHLTComponent.h:350
 AliHLTComponent.h:351
 AliHLTComponent.h:352
 AliHLTComponent.h:353
 AliHLTComponent.h:354
 AliHLTComponent.h:355
 AliHLTComponent.h:356
 AliHLTComponent.h:357
 AliHLTComponent.h:358
 AliHLTComponent.h:359
 AliHLTComponent.h:360
 AliHLTComponent.h:361
 AliHLTComponent.h:362
 AliHLTComponent.h:363
 AliHLTComponent.h:364
 AliHLTComponent.h:365
 AliHLTComponent.h:366
 AliHLTComponent.h:367
 AliHLTComponent.h:368
 AliHLTComponent.h:369
 AliHLTComponent.h:370
 AliHLTComponent.h:371
 AliHLTComponent.h:372
 AliHLTComponent.h:373
 AliHLTComponent.h:374
 AliHLTComponent.h:375
 AliHLTComponent.h:376
 AliHLTComponent.h:377
 AliHLTComponent.h:378
 AliHLTComponent.h:379
 AliHLTComponent.h:380
 AliHLTComponent.h:381
 AliHLTComponent.h:382
 AliHLTComponent.h:383
 AliHLTComponent.h:384
 AliHLTComponent.h:385
 AliHLTComponent.h:386
 AliHLTComponent.h:387
 AliHLTComponent.h:388
 AliHLTComponent.h:389
 AliHLTComponent.h:390
 AliHLTComponent.h:391
 AliHLTComponent.h:392
 AliHLTComponent.h:393
 AliHLTComponent.h:394
 AliHLTComponent.h:395
 AliHLTComponent.h:396
 AliHLTComponent.h:397
 AliHLTComponent.h:398
 AliHLTComponent.h:399
 AliHLTComponent.h:400
 AliHLTComponent.h:401
 AliHLTComponent.h:402
 AliHLTComponent.h:403
 AliHLTComponent.h:404
 AliHLTComponent.h:405
 AliHLTComponent.h:406
 AliHLTComponent.h:407
 AliHLTComponent.h:408
 AliHLTComponent.h:409
 AliHLTComponent.h:410
 AliHLTComponent.h:411
 AliHLTComponent.h:412
 AliHLTComponent.h:413
 AliHLTComponent.h:414
 AliHLTComponent.h:415
 AliHLTComponent.h:416
 AliHLTComponent.h:417
 AliHLTComponent.h:418
 AliHLTComponent.h:419
 AliHLTComponent.h:420
 AliHLTComponent.h:421
 AliHLTComponent.h:422
 AliHLTComponent.h:423
 AliHLTComponent.h:424
 AliHLTComponent.h:425
 AliHLTComponent.h:426
 AliHLTComponent.h:427
 AliHLTComponent.h:428
 AliHLTComponent.h:429
 AliHLTComponent.h:430
 AliHLTComponent.h:431
 AliHLTComponent.h:432
 AliHLTComponent.h:433
 AliHLTComponent.h:434
 AliHLTComponent.h:435
 AliHLTComponent.h:436
 AliHLTComponent.h:437
 AliHLTComponent.h:438
 AliHLTComponent.h:439
 AliHLTComponent.h:440
 AliHLTComponent.h:441
 AliHLTComponent.h:442
 AliHLTComponent.h:443
 AliHLTComponent.h:444
 AliHLTComponent.h:445
 AliHLTComponent.h:446
 AliHLTComponent.h:447
 AliHLTComponent.h:448
 AliHLTComponent.h:449
 AliHLTComponent.h:450
 AliHLTComponent.h:451
 AliHLTComponent.h:452
 AliHLTComponent.h:453
 AliHLTComponent.h:454
 AliHLTComponent.h:455
 AliHLTComponent.h:456
 AliHLTComponent.h:457
 AliHLTComponent.h:458
 AliHLTComponent.h:459
 AliHLTComponent.h:460
 AliHLTComponent.h:461
 AliHLTComponent.h:462
 AliHLTComponent.h:463
 AliHLTComponent.h:464
 AliHLTComponent.h:465
 AliHLTComponent.h:466
 AliHLTComponent.h:467
 AliHLTComponent.h:468
 AliHLTComponent.h:469
 AliHLTComponent.h:470
 AliHLTComponent.h:471
 AliHLTComponent.h:472
 AliHLTComponent.h:473
 AliHLTComponent.h:474
 AliHLTComponent.h:475
 AliHLTComponent.h:476
 AliHLTComponent.h:477
 AliHLTComponent.h:478
 AliHLTComponent.h:479
 AliHLTComponent.h:480
 AliHLTComponent.h:481
 AliHLTComponent.h:482
 AliHLTComponent.h:483
 AliHLTComponent.h:484
 AliHLTComponent.h:485
 AliHLTComponent.h:486
 AliHLTComponent.h:487
 AliHLTComponent.h:488
 AliHLTComponent.h:489
 AliHLTComponent.h:490
 AliHLTComponent.h:491
 AliHLTComponent.h:492
 AliHLTComponent.h:493
 AliHLTComponent.h:494
 AliHLTComponent.h:495
 AliHLTComponent.h:496
 AliHLTComponent.h:497
 AliHLTComponent.h:498
 AliHLTComponent.h:499
 AliHLTComponent.h:500
 AliHLTComponent.h:501
 AliHLTComponent.h:502
 AliHLTComponent.h:503
 AliHLTComponent.h:504
 AliHLTComponent.h:505
 AliHLTComponent.h:506
 AliHLTComponent.h:507
 AliHLTComponent.h:508
 AliHLTComponent.h:509
 AliHLTComponent.h:510
 AliHLTComponent.h:511
 AliHLTComponent.h:512
 AliHLTComponent.h:513
 AliHLTComponent.h:514
 AliHLTComponent.h:515
 AliHLTComponent.h:516
 AliHLTComponent.h:517
 AliHLTComponent.h:518
 AliHLTComponent.h:519
 AliHLTComponent.h:520
 AliHLTComponent.h:521
 AliHLTComponent.h:522
 AliHLTComponent.h:523
 AliHLTComponent.h:524
 AliHLTComponent.h:525
 AliHLTComponent.h:526
 AliHLTComponent.h:527
 AliHLTComponent.h:528
 AliHLTComponent.h:529
 AliHLTComponent.h:530
 AliHLTComponent.h:531
 AliHLTComponent.h:532
 AliHLTComponent.h:533
 AliHLTComponent.h:534
 AliHLTComponent.h:535
 AliHLTComponent.h:536
 AliHLTComponent.h:537
 AliHLTComponent.h:538
 AliHLTComponent.h:539
 AliHLTComponent.h:540
 AliHLTComponent.h:541
 AliHLTComponent.h:542
 AliHLTComponent.h:543
 AliHLTComponent.h:544
 AliHLTComponent.h:545
 AliHLTComponent.h:546
 AliHLTComponent.h:547
 AliHLTComponent.h:548
 AliHLTComponent.h:549
 AliHLTComponent.h:550
 AliHLTComponent.h:551
 AliHLTComponent.h:552
 AliHLTComponent.h:553
 AliHLTComponent.h:554
 AliHLTComponent.h:555
 AliHLTComponent.h:556
 AliHLTComponent.h:557
 AliHLTComponent.h:558
 AliHLTComponent.h:559
 AliHLTComponent.h:560
 AliHLTComponent.h:561
 AliHLTComponent.h:562
 AliHLTComponent.h:563
 AliHLTComponent.h:564
 AliHLTComponent.h:565
 AliHLTComponent.h:566
 AliHLTComponent.h:567
 AliHLTComponent.h:568
 AliHLTComponent.h:569
 AliHLTComponent.h:570
 AliHLTComponent.h:571
 AliHLTComponent.h:572
 AliHLTComponent.h:573
 AliHLTComponent.h:574
 AliHLTComponent.h:575
 AliHLTComponent.h:576
 AliHLTComponent.h:577
 AliHLTComponent.h:578
 AliHLTComponent.h:579
 AliHLTComponent.h:580
 AliHLTComponent.h:581
 AliHLTComponent.h:582
 AliHLTComponent.h:583
 AliHLTComponent.h:584
 AliHLTComponent.h:585
 AliHLTComponent.h:586
 AliHLTComponent.h:587
 AliHLTComponent.h:588
 AliHLTComponent.h:589
 AliHLTComponent.h:590
 AliHLTComponent.h:591
 AliHLTComponent.h:592
 AliHLTComponent.h:593
 AliHLTComponent.h:594
 AliHLTComponent.h:595
 AliHLTComponent.h:596
 AliHLTComponent.h:597
 AliHLTComponent.h:598
 AliHLTComponent.h:599
 AliHLTComponent.h:600
 AliHLTComponent.h:601
 AliHLTComponent.h:602
 AliHLTComponent.h:603
 AliHLTComponent.h:604
 AliHLTComponent.h:605
 AliHLTComponent.h:606
 AliHLTComponent.h:607
 AliHLTComponent.h:608
 AliHLTComponent.h:609
 AliHLTComponent.h:610
 AliHLTComponent.h:611
 AliHLTComponent.h:612
 AliHLTComponent.h:613
 AliHLTComponent.h:614
 AliHLTComponent.h:615
 AliHLTComponent.h:616
 AliHLTComponent.h:617
 AliHLTComponent.h:618
 AliHLTComponent.h:619
 AliHLTComponent.h:620
 AliHLTComponent.h:621
 AliHLTComponent.h:622
 AliHLTComponent.h:623
 AliHLTComponent.h:624
 AliHLTComponent.h:625
 AliHLTComponent.h:626
 AliHLTComponent.h:627
 AliHLTComponent.h:628
 AliHLTComponent.h:629
 AliHLTComponent.h:630
 AliHLTComponent.h:631
 AliHLTComponent.h:632
 AliHLTComponent.h:633
 AliHLTComponent.h:634
 AliHLTComponent.h:635
 AliHLTComponent.h:636
 AliHLTComponent.h:637
 AliHLTComponent.h:638
 AliHLTComponent.h:639
 AliHLTComponent.h:640
 AliHLTComponent.h:641
 AliHLTComponent.h:642
 AliHLTComponent.h:643
 AliHLTComponent.h:644
 AliHLTComponent.h:645
 AliHLTComponent.h:646
 AliHLTComponent.h:647
 AliHLTComponent.h:648
 AliHLTComponent.h:649
 AliHLTComponent.h:650
 AliHLTComponent.h:651
 AliHLTComponent.h:652
 AliHLTComponent.h:653
 AliHLTComponent.h:654
 AliHLTComponent.h:655
 AliHLTComponent.h:656
 AliHLTComponent.h:657
 AliHLTComponent.h:658
 AliHLTComponent.h:659
 AliHLTComponent.h:660
 AliHLTComponent.h:661
 AliHLTComponent.h:662
 AliHLTComponent.h:663
 AliHLTComponent.h:664
 AliHLTComponent.h:665
 AliHLTComponent.h:666
 AliHLTComponent.h:667
 AliHLTComponent.h:668
 AliHLTComponent.h:669
 AliHLTComponent.h:670
 AliHLTComponent.h:671
 AliHLTComponent.h:672
 AliHLTComponent.h:673
 AliHLTComponent.h:674
 AliHLTComponent.h:675
 AliHLTComponent.h:676
 AliHLTComponent.h:677
 AliHLTComponent.h:678
 AliHLTComponent.h:679
 AliHLTComponent.h:680
 AliHLTComponent.h:681
 AliHLTComponent.h:682
 AliHLTComponent.h:683
 AliHLTComponent.h:684
 AliHLTComponent.h:685
 AliHLTComponent.h:686
 AliHLTComponent.h:687
 AliHLTComponent.h:688
 AliHLTComponent.h:689
 AliHLTComponent.h:690
 AliHLTComponent.h:691
 AliHLTComponent.h:692
 AliHLTComponent.h:693
 AliHLTComponent.h:694
 AliHLTComponent.h:695
 AliHLTComponent.h:696
 AliHLTComponent.h:697
 AliHLTComponent.h:698
 AliHLTComponent.h:699
 AliHLTComponent.h:700
 AliHLTComponent.h:701
 AliHLTComponent.h:702
 AliHLTComponent.h:703
 AliHLTComponent.h:704
 AliHLTComponent.h:705
 AliHLTComponent.h:706
 AliHLTComponent.h:707
 AliHLTComponent.h:708
 AliHLTComponent.h:709
 AliHLTComponent.h:710
 AliHLTComponent.h:711
 AliHLTComponent.h:712
 AliHLTComponent.h:713
 AliHLTComponent.h:714
 AliHLTComponent.h:715
 AliHLTComponent.h:716
 AliHLTComponent.h:717
 AliHLTComponent.h:718
 AliHLTComponent.h:719
 AliHLTComponent.h:720
 AliHLTComponent.h:721
 AliHLTComponent.h:722
 AliHLTComponent.h:723
 AliHLTComponent.h:724
 AliHLTComponent.h:725
 AliHLTComponent.h:726
 AliHLTComponent.h:727
 AliHLTComponent.h:728
 AliHLTComponent.h:729
 AliHLTComponent.h:730
 AliHLTComponent.h:731
 AliHLTComponent.h:732
 AliHLTComponent.h:733
 AliHLTComponent.h:734
 AliHLTComponent.h:735
 AliHLTComponent.h:736
 AliHLTComponent.h:737
 AliHLTComponent.h:738
 AliHLTComponent.h:739
 AliHLTComponent.h:740
 AliHLTComponent.h:741
 AliHLTComponent.h:742
 AliHLTComponent.h:743
 AliHLTComponent.h:744
 AliHLTComponent.h:745
 AliHLTComponent.h:746
 AliHLTComponent.h:747
 AliHLTComponent.h:748
 AliHLTComponent.h:749
 AliHLTComponent.h:750
 AliHLTComponent.h:751
 AliHLTComponent.h:752
 AliHLTComponent.h:753
 AliHLTComponent.h:754
 AliHLTComponent.h:755
 AliHLTComponent.h:756
 AliHLTComponent.h:757
 AliHLTComponent.h:758
 AliHLTComponent.h:759
 AliHLTComponent.h:760
 AliHLTComponent.h:761
 AliHLTComponent.h:762
 AliHLTComponent.h:763
 AliHLTComponent.h:764
 AliHLTComponent.h:765
 AliHLTComponent.h:766
 AliHLTComponent.h:767
 AliHLTComponent.h:768
 AliHLTComponent.h:769
 AliHLTComponent.h:770
 AliHLTComponent.h:771
 AliHLTComponent.h:772
 AliHLTComponent.h:773
 AliHLTComponent.h:774
 AliHLTComponent.h:775
 AliHLTComponent.h:776
 AliHLTComponent.h:777
 AliHLTComponent.h:778
 AliHLTComponent.h:779
 AliHLTComponent.h:780
 AliHLTComponent.h:781
 AliHLTComponent.h:782
 AliHLTComponent.h:783
 AliHLTComponent.h:784
 AliHLTComponent.h:785
 AliHLTComponent.h:786
 AliHLTComponent.h:787
 AliHLTComponent.h:788
 AliHLTComponent.h:789
 AliHLTComponent.h:790
 AliHLTComponent.h:791
 AliHLTComponent.h:792
 AliHLTComponent.h:793
 AliHLTComponent.h:794
 AliHLTComponent.h:795
 AliHLTComponent.h:796
 AliHLTComponent.h:797
 AliHLTComponent.h:798
 AliHLTComponent.h:799
 AliHLTComponent.h:800
 AliHLTComponent.h:801
 AliHLTComponent.h:802
 AliHLTComponent.h:803
 AliHLTComponent.h:804
 AliHLTComponent.h:805
 AliHLTComponent.h:806
 AliHLTComponent.h:807
 AliHLTComponent.h:808
 AliHLTComponent.h:809
 AliHLTComponent.h:810
 AliHLTComponent.h:811
 AliHLTComponent.h:812
 AliHLTComponent.h:813
 AliHLTComponent.h:814
 AliHLTComponent.h:815
 AliHLTComponent.h:816
 AliHLTComponent.h:817
 AliHLTComponent.h:818
 AliHLTComponent.h:819
 AliHLTComponent.h:820
 AliHLTComponent.h:821
 AliHLTComponent.h:822
 AliHLTComponent.h:823
 AliHLTComponent.h:824
 AliHLTComponent.h:825
 AliHLTComponent.h:826
 AliHLTComponent.h:827
 AliHLTComponent.h:828
 AliHLTComponent.h:829
 AliHLTComponent.h:830
 AliHLTComponent.h:831
 AliHLTComponent.h:832
 AliHLTComponent.h:833
 AliHLTComponent.h:834
 AliHLTComponent.h:835
 AliHLTComponent.h:836
 AliHLTComponent.h:837
 AliHLTComponent.h:838
 AliHLTComponent.h:839
 AliHLTComponent.h:840
 AliHLTComponent.h:841
 AliHLTComponent.h:842
 AliHLTComponent.h:843
 AliHLTComponent.h:844
 AliHLTComponent.h:845
 AliHLTComponent.h:846
 AliHLTComponent.h:847
 AliHLTComponent.h:848
 AliHLTComponent.h:849
 AliHLTComponent.h:850
 AliHLTComponent.h:851
 AliHLTComponent.h:852
 AliHLTComponent.h:853
 AliHLTComponent.h:854
 AliHLTComponent.h:855
 AliHLTComponent.h:856
 AliHLTComponent.h:857
 AliHLTComponent.h:858
 AliHLTComponent.h:859
 AliHLTComponent.h:860
 AliHLTComponent.h:861
 AliHLTComponent.h:862
 AliHLTComponent.h:863
 AliHLTComponent.h:864
 AliHLTComponent.h:865
 AliHLTComponent.h:866
 AliHLTComponent.h:867
 AliHLTComponent.h:868
 AliHLTComponent.h:869
 AliHLTComponent.h:870
 AliHLTComponent.h:871
 AliHLTComponent.h:872
 AliHLTComponent.h:873
 AliHLTComponent.h:874
 AliHLTComponent.h:875
 AliHLTComponent.h:876
 AliHLTComponent.h:877
 AliHLTComponent.h:878
 AliHLTComponent.h:879
 AliHLTComponent.h:880
 AliHLTComponent.h:881
 AliHLTComponent.h:882
 AliHLTComponent.h:883
 AliHLTComponent.h:884
 AliHLTComponent.h:885
 AliHLTComponent.h:886
 AliHLTComponent.h:887
 AliHLTComponent.h:888
 AliHLTComponent.h:889
 AliHLTComponent.h:890
 AliHLTComponent.h:891
 AliHLTComponent.h:892
 AliHLTComponent.h:893
 AliHLTComponent.h:894
 AliHLTComponent.h:895
 AliHLTComponent.h:896
 AliHLTComponent.h:897
 AliHLTComponent.h:898
 AliHLTComponent.h:899
 AliHLTComponent.h:900
 AliHLTComponent.h:901
 AliHLTComponent.h:902
 AliHLTComponent.h:903
 AliHLTComponent.h:904
 AliHLTComponent.h:905
 AliHLTComponent.h:906
 AliHLTComponent.h:907
 AliHLTComponent.h:908
 AliHLTComponent.h:909
 AliHLTComponent.h:910
 AliHLTComponent.h:911
 AliHLTComponent.h:912
 AliHLTComponent.h:913
 AliHLTComponent.h:914
 AliHLTComponent.h:915
 AliHLTComponent.h:916
 AliHLTComponent.h:917
 AliHLTComponent.h:918
 AliHLTComponent.h:919
 AliHLTComponent.h:920
 AliHLTComponent.h:921
 AliHLTComponent.h:922
 AliHLTComponent.h:923
 AliHLTComponent.h:924
 AliHLTComponent.h:925
 AliHLTComponent.h:926
 AliHLTComponent.h:927
 AliHLTComponent.h:928
 AliHLTComponent.h:929
 AliHLTComponent.h:930
 AliHLTComponent.h:931
 AliHLTComponent.h:932
 AliHLTComponent.h:933
 AliHLTComponent.h:934
 AliHLTComponent.h:935
 AliHLTComponent.h:936
 AliHLTComponent.h:937
 AliHLTComponent.h:938
 AliHLTComponent.h:939
 AliHLTComponent.h:940
 AliHLTComponent.h:941
 AliHLTComponent.h:942
 AliHLTComponent.h:943
 AliHLTComponent.h:944
 AliHLTComponent.h:945
 AliHLTComponent.h:946
 AliHLTComponent.h:947
 AliHLTComponent.h:948
 AliHLTComponent.h:949
 AliHLTComponent.h:950
 AliHLTComponent.h:951
 AliHLTComponent.h:952
 AliHLTComponent.h:953
 AliHLTComponent.h:954
 AliHLTComponent.h:955
 AliHLTComponent.h:956
 AliHLTComponent.h:957
 AliHLTComponent.h:958
 AliHLTComponent.h:959
 AliHLTComponent.h:960
 AliHLTComponent.h:961
 AliHLTComponent.h:962
 AliHLTComponent.h:963
 AliHLTComponent.h:964
 AliHLTComponent.h:965
 AliHLTComponent.h:966
 AliHLTComponent.h:967
 AliHLTComponent.h:968
 AliHLTComponent.h:969
 AliHLTComponent.h:970
 AliHLTComponent.h:971
 AliHLTComponent.h:972
 AliHLTComponent.h:973
 AliHLTComponent.h:974
 AliHLTComponent.h:975
 AliHLTComponent.h:976
 AliHLTComponent.h:977
 AliHLTComponent.h:978
 AliHLTComponent.h:979
 AliHLTComponent.h:980
 AliHLTComponent.h:981
 AliHLTComponent.h:982
 AliHLTComponent.h:983
 AliHLTComponent.h:984
 AliHLTComponent.h:985
 AliHLTComponent.h:986
 AliHLTComponent.h:987
 AliHLTComponent.h:988
 AliHLTComponent.h:989
 AliHLTComponent.h:990
 AliHLTComponent.h:991
 AliHLTComponent.h:992
 AliHLTComponent.h:993
 AliHLTComponent.h:994
 AliHLTComponent.h:995
 AliHLTComponent.h:996
 AliHLTComponent.h:997
 AliHLTComponent.h:998
 AliHLTComponent.h:999
 AliHLTComponent.h:1000
 AliHLTComponent.h:1001
 AliHLTComponent.h:1002
 AliHLTComponent.h:1003
 AliHLTComponent.h:1004
 AliHLTComponent.h:1005
 AliHLTComponent.h:1006
 AliHLTComponent.h:1007
 AliHLTComponent.h:1008
 AliHLTComponent.h:1009
 AliHLTComponent.h:1010
 AliHLTComponent.h:1011
 AliHLTComponent.h:1012
 AliHLTComponent.h:1013
 AliHLTComponent.h:1014
 AliHLTComponent.h:1015
 AliHLTComponent.h:1016
 AliHLTComponent.h:1017
 AliHLTComponent.h:1018
 AliHLTComponent.h:1019
 AliHLTComponent.h:1020
 AliHLTComponent.h:1021
 AliHLTComponent.h:1022
 AliHLTComponent.h:1023
 AliHLTComponent.h:1024
 AliHLTComponent.h:1025
 AliHLTComponent.h:1026
 AliHLTComponent.h:1027
 AliHLTComponent.h:1028
 AliHLTComponent.h:1029
 AliHLTComponent.h:1030
 AliHLTComponent.h:1031
 AliHLTComponent.h:1032
 AliHLTComponent.h:1033
 AliHLTComponent.h:1034
 AliHLTComponent.h:1035
 AliHLTComponent.h:1036
 AliHLTComponent.h:1037
 AliHLTComponent.h:1038
 AliHLTComponent.h:1039
 AliHLTComponent.h:1040
 AliHLTComponent.h:1041
 AliHLTComponent.h:1042
 AliHLTComponent.h:1043
 AliHLTComponent.h:1044
 AliHLTComponent.h:1045
 AliHLTComponent.h:1046
 AliHLTComponent.h:1047
 AliHLTComponent.h:1048
 AliHLTComponent.h:1049
 AliHLTComponent.h:1050
 AliHLTComponent.h:1051
 AliHLTComponent.h:1052
 AliHLTComponent.h:1053
 AliHLTComponent.h:1054
 AliHLTComponent.h:1055
 AliHLTComponent.h:1056
 AliHLTComponent.h:1057
 AliHLTComponent.h:1058
 AliHLTComponent.h:1059
 AliHLTComponent.h:1060
 AliHLTComponent.h:1061
 AliHLTComponent.h:1062
 AliHLTComponent.h:1063
 AliHLTComponent.h:1064
 AliHLTComponent.h:1065
 AliHLTComponent.h:1066
 AliHLTComponent.h:1067
 AliHLTComponent.h:1068
 AliHLTComponent.h:1069
 AliHLTComponent.h:1070
 AliHLTComponent.h:1071
 AliHLTComponent.h:1072
 AliHLTComponent.h:1073
 AliHLTComponent.h:1074
 AliHLTComponent.h:1075
 AliHLTComponent.h:1076
 AliHLTComponent.h:1077
 AliHLTComponent.h:1078
 AliHLTComponent.h:1079
 AliHLTComponent.h:1080
 AliHLTComponent.h:1081
 AliHLTComponent.h:1082
 AliHLTComponent.h:1083
 AliHLTComponent.h:1084
 AliHLTComponent.h:1085
 AliHLTComponent.h:1086
 AliHLTComponent.h:1087
 AliHLTComponent.h:1088
 AliHLTComponent.h:1089
 AliHLTComponent.h:1090
 AliHLTComponent.h:1091
 AliHLTComponent.h:1092
 AliHLTComponent.h:1093
 AliHLTComponent.h:1094
 AliHLTComponent.h:1095
 AliHLTComponent.h:1096
 AliHLTComponent.h:1097
 AliHLTComponent.h:1098
 AliHLTComponent.h:1099
 AliHLTComponent.h:1100
 AliHLTComponent.h:1101
 AliHLTComponent.h:1102
 AliHLTComponent.h:1103
 AliHLTComponent.h:1104
 AliHLTComponent.h:1105
 AliHLTComponent.h:1106
 AliHLTComponent.h:1107
 AliHLTComponent.h:1108
 AliHLTComponent.h:1109
 AliHLTComponent.h:1110
 AliHLTComponent.h:1111
 AliHLTComponent.h:1112
 AliHLTComponent.h:1113
 AliHLTComponent.h:1114
 AliHLTComponent.h:1115
 AliHLTComponent.h:1116
 AliHLTComponent.h:1117
 AliHLTComponent.h:1118
 AliHLTComponent.h:1119
 AliHLTComponent.h:1120
 AliHLTComponent.h:1121
 AliHLTComponent.h:1122
 AliHLTComponent.h:1123
 AliHLTComponent.h:1124
 AliHLTComponent.h:1125
 AliHLTComponent.h:1126
 AliHLTComponent.h:1127
 AliHLTComponent.h:1128
 AliHLTComponent.h:1129
 AliHLTComponent.h:1130
 AliHLTComponent.h:1131
 AliHLTComponent.h:1132
 AliHLTComponent.h:1133
 AliHLTComponent.h:1134
 AliHLTComponent.h:1135
 AliHLTComponent.h:1136
 AliHLTComponent.h:1137
 AliHLTComponent.h:1138
 AliHLTComponent.h:1139
 AliHLTComponent.h:1140
 AliHLTComponent.h:1141
 AliHLTComponent.h:1142
 AliHLTComponent.h:1143
 AliHLTComponent.h:1144
 AliHLTComponent.h:1145
 AliHLTComponent.h:1146
 AliHLTComponent.h:1147
 AliHLTComponent.h:1148
 AliHLTComponent.h:1149
 AliHLTComponent.h:1150
 AliHLTComponent.h:1151
 AliHLTComponent.h:1152
 AliHLTComponent.h:1153
 AliHLTComponent.h:1154
 AliHLTComponent.h:1155
 AliHLTComponent.h:1156
 AliHLTComponent.h:1157
 AliHLTComponent.h:1158
 AliHLTComponent.h:1159
 AliHLTComponent.h:1160
 AliHLTComponent.h:1161
 AliHLTComponent.h:1162
 AliHLTComponent.h:1163
 AliHLTComponent.h:1164
 AliHLTComponent.h:1165
 AliHLTComponent.h:1166
 AliHLTComponent.h:1167
 AliHLTComponent.h:1168
 AliHLTComponent.h:1169
 AliHLTComponent.h:1170
 AliHLTComponent.h:1171
 AliHLTComponent.h:1172
 AliHLTComponent.h:1173
 AliHLTComponent.h:1174
 AliHLTComponent.h:1175
 AliHLTComponent.h:1176
 AliHLTComponent.h:1177
 AliHLTComponent.h:1178
 AliHLTComponent.h:1179
 AliHLTComponent.h:1180
 AliHLTComponent.h:1181
 AliHLTComponent.h:1182
 AliHLTComponent.h:1183
 AliHLTComponent.h:1184
 AliHLTComponent.h:1185
 AliHLTComponent.h:1186
 AliHLTComponent.h:1187
 AliHLTComponent.h:1188
 AliHLTComponent.h:1189
 AliHLTComponent.h:1190
 AliHLTComponent.h:1191
 AliHLTComponent.h:1192
 AliHLTComponent.h:1193
 AliHLTComponent.h:1194
 AliHLTComponent.h:1195
 AliHLTComponent.h:1196
 AliHLTComponent.h:1197
 AliHLTComponent.h:1198
 AliHLTComponent.h:1199
 AliHLTComponent.h:1200
 AliHLTComponent.h:1201
 AliHLTComponent.h:1202
 AliHLTComponent.h:1203
 AliHLTComponent.h:1204
 AliHLTComponent.h:1205
 AliHLTComponent.h:1206
 AliHLTComponent.h:1207
 AliHLTComponent.h:1208
 AliHLTComponent.h:1209
 AliHLTComponent.h:1210
 AliHLTComponent.h:1211
 AliHLTComponent.h:1212
 AliHLTComponent.h:1213
 AliHLTComponent.h:1214
 AliHLTComponent.h:1215
 AliHLTComponent.h:1216
 AliHLTComponent.h:1217
 AliHLTComponent.h:1218
 AliHLTComponent.h:1219
 AliHLTComponent.h:1220
 AliHLTComponent.h:1221
 AliHLTComponent.h:1222
 AliHLTComponent.h:1223
 AliHLTComponent.h:1224
 AliHLTComponent.h:1225
 AliHLTComponent.h:1226
 AliHLTComponent.h:1227
 AliHLTComponent.h:1228
 AliHLTComponent.h:1229
 AliHLTComponent.h:1230
 AliHLTComponent.h:1231
 AliHLTComponent.h:1232
 AliHLTComponent.h:1233
 AliHLTComponent.h:1234
 AliHLTComponent.h:1235
 AliHLTComponent.h:1236
 AliHLTComponent.h:1237
 AliHLTComponent.h:1238
 AliHLTComponent.h:1239
 AliHLTComponent.h:1240
 AliHLTComponent.h:1241
 AliHLTComponent.h:1242
 AliHLTComponent.h:1243
 AliHLTComponent.h:1244
 AliHLTComponent.h:1245
 AliHLTComponent.h:1246
 AliHLTComponent.h:1247
 AliHLTComponent.h:1248
 AliHLTComponent.h:1249
 AliHLTComponent.h:1250
 AliHLTComponent.h:1251
 AliHLTComponent.h:1252
 AliHLTComponent.h:1253
 AliHLTComponent.h:1254
 AliHLTComponent.h:1255
 AliHLTComponent.h:1256
 AliHLTComponent.h:1257
 AliHLTComponent.h:1258
 AliHLTComponent.h:1259
 AliHLTComponent.h:1260
 AliHLTComponent.h:1261
 AliHLTComponent.h:1262
 AliHLTComponent.h:1263
 AliHLTComponent.h:1264
 AliHLTComponent.h:1265
 AliHLTComponent.h:1266
 AliHLTComponent.h:1267
 AliHLTComponent.h:1268
 AliHLTComponent.h:1269
 AliHLTComponent.h:1270
 AliHLTComponent.h:1271
 AliHLTComponent.h:1272
 AliHLTComponent.h:1273
 AliHLTComponent.h:1274
 AliHLTComponent.h:1275
 AliHLTComponent.h:1276
 AliHLTComponent.h:1277
 AliHLTComponent.h:1278
 AliHLTComponent.h:1279
 AliHLTComponent.h:1280
 AliHLTComponent.h:1281
 AliHLTComponent.h:1282
 AliHLTComponent.h:1283
 AliHLTComponent.h:1284
 AliHLTComponent.h:1285
 AliHLTComponent.h:1286
 AliHLTComponent.h:1287
 AliHLTComponent.h:1288
 AliHLTComponent.h:1289
 AliHLTComponent.h:1290
 AliHLTComponent.h:1291
 AliHLTComponent.h:1292
 AliHLTComponent.h:1293
 AliHLTComponent.h:1294
 AliHLTComponent.h:1295
 AliHLTComponent.h:1296
 AliHLTComponent.h:1297
 AliHLTComponent.h:1298
 AliHLTComponent.h:1299
 AliHLTComponent.h:1300
 AliHLTComponent.h:1301
 AliHLTComponent.h:1302
 AliHLTComponent.h:1303
 AliHLTComponent.h:1304
 AliHLTComponent.h:1305
 AliHLTComponent.h:1306
 AliHLTComponent.h:1307
 AliHLTComponent.h:1308
 AliHLTComponent.h:1309
 AliHLTComponent.h:1310
 AliHLTComponent.h:1311
 AliHLTComponent.h:1312
 AliHLTComponent.h:1313
 AliHLTComponent.h:1314
 AliHLTComponent.h:1315
 AliHLTComponent.h:1316
 AliHLTComponent.h:1317
 AliHLTComponent.h:1318
 AliHLTComponent.h:1319
 AliHLTComponent.h:1320
 AliHLTComponent.h:1321
 AliHLTComponent.h:1322
 AliHLTComponent.h:1323
 AliHLTComponent.h:1324
 AliHLTComponent.h:1325
 AliHLTComponent.h:1326
 AliHLTComponent.h:1327
 AliHLTComponent.h:1328
 AliHLTComponent.h:1329
 AliHLTComponent.h:1330
 AliHLTComponent.h:1331
 AliHLTComponent.h:1332
 AliHLTComponent.h:1333
 AliHLTComponent.h:1334
 AliHLTComponent.h:1335
 AliHLTComponent.h:1336
 AliHLTComponent.h:1337
 AliHLTComponent.h:1338
 AliHLTComponent.h:1339
 AliHLTComponent.h:1340
 AliHLTComponent.h:1341
 AliHLTComponent.h:1342
 AliHLTComponent.h:1343
 AliHLTComponent.h:1344
 AliHLTComponent.h:1345
 AliHLTComponent.h:1346
 AliHLTComponent.h:1347
 AliHLTComponent.h:1348
 AliHLTComponent.h:1349
 AliHLTComponent.h:1350
 AliHLTComponent.h:1351
 AliHLTComponent.h:1352
 AliHLTComponent.h:1353
 AliHLTComponent.h:1354
 AliHLTComponent.h:1355
 AliHLTComponent.h:1356
 AliHLTComponent.h:1357
 AliHLTComponent.h:1358
 AliHLTComponent.h:1359
 AliHLTComponent.h:1360
 AliHLTComponent.h:1361
 AliHLTComponent.h:1362
 AliHLTComponent.h:1363
 AliHLTComponent.h:1364
 AliHLTComponent.h:1365
 AliHLTComponent.h:1366
 AliHLTComponent.h:1367
 AliHLTComponent.h:1368
 AliHLTComponent.h:1369
 AliHLTComponent.h:1370
 AliHLTComponent.h:1371
 AliHLTComponent.h:1372
 AliHLTComponent.h:1373
 AliHLTComponent.h:1374
 AliHLTComponent.h:1375
 AliHLTComponent.h:1376
 AliHLTComponent.h:1377
 AliHLTComponent.h:1378
 AliHLTComponent.h:1379
 AliHLTComponent.h:1380
 AliHLTComponent.h:1381
 AliHLTComponent.h:1382
 AliHLTComponent.h:1383
 AliHLTComponent.h:1384
 AliHLTComponent.h:1385
 AliHLTComponent.h:1386
 AliHLTComponent.h:1387
 AliHLTComponent.h:1388
 AliHLTComponent.h:1389
 AliHLTComponent.h:1390
 AliHLTComponent.h:1391
 AliHLTComponent.h:1392
 AliHLTComponent.h:1393
 AliHLTComponent.h:1394
 AliHLTComponent.h:1395
 AliHLTComponent.h:1396
 AliHLTComponent.h:1397
 AliHLTComponent.h:1398
 AliHLTComponent.h:1399
 AliHLTComponent.h:1400
 AliHLTComponent.h:1401
 AliHLTComponent.h:1402
 AliHLTComponent.h:1403
 AliHLTComponent.h:1404
 AliHLTComponent.h:1405
 AliHLTComponent.h:1406
 AliHLTComponent.h:1407
 AliHLTComponent.h:1408
 AliHLTComponent.h:1409
 AliHLTComponent.h:1410
 AliHLTComponent.h:1411
 AliHLTComponent.h:1412
 AliHLTComponent.h:1413
 AliHLTComponent.h:1414
 AliHLTComponent.h:1415
 AliHLTComponent.h:1416
 AliHLTComponent.h:1417
 AliHLTComponent.h:1418
 AliHLTComponent.h:1419
 AliHLTComponent.h:1420
 AliHLTComponent.h:1421
 AliHLTComponent.h:1422
 AliHLTComponent.h:1423
 AliHLTComponent.h:1424
 AliHLTComponent.h:1425
 AliHLTComponent.h:1426
 AliHLTComponent.h:1427
 AliHLTComponent.h:1428
 AliHLTComponent.h:1429
 AliHLTComponent.h:1430
 AliHLTComponent.h:1431
 AliHLTComponent.h:1432
 AliHLTComponent.h:1433
 AliHLTComponent.h:1434
 AliHLTComponent.h:1435
 AliHLTComponent.h:1436
 AliHLTComponent.h:1437
 AliHLTComponent.h:1438
 AliHLTComponent.h:1439
 AliHLTComponent.h:1440
 AliHLTComponent.h:1441
 AliHLTComponent.h:1442
 AliHLTComponent.h:1443
 AliHLTComponent.h:1444
 AliHLTComponent.h:1445
 AliHLTComponent.h:1446
 AliHLTComponent.h:1447
 AliHLTComponent.h:1448
 AliHLTComponent.h:1449
 AliHLTComponent.h:1450
 AliHLTComponent.h:1451
 AliHLTComponent.h:1452
 AliHLTComponent.h:1453
 AliHLTComponent.h:1454
 AliHLTComponent.h:1455
 AliHLTComponent.h:1456
 AliHLTComponent.h:1457
 AliHLTComponent.h:1458
 AliHLTComponent.h:1459
 AliHLTComponent.h:1460
 AliHLTComponent.h:1461
 AliHLTComponent.h:1462
 AliHLTComponent.h:1463
 AliHLTComponent.h:1464
 AliHLTComponent.h:1465
 AliHLTComponent.h:1466
 AliHLTComponent.h:1467
 AliHLTComponent.h:1468
 AliHLTComponent.h:1469
 AliHLTComponent.h:1470
 AliHLTComponent.h:1471
 AliHLTComponent.h:1472
 AliHLTComponent.h:1473
 AliHLTComponent.h:1474
 AliHLTComponent.h:1475
 AliHLTComponent.h:1476
 AliHLTComponent.h:1477
 AliHLTComponent.h:1478
 AliHLTComponent.h:1479
 AliHLTComponent.h:1480
 AliHLTComponent.h:1481
 AliHLTComponent.h:1482
 AliHLTComponent.h:1483
 AliHLTComponent.h:1484
 AliHLTComponent.h:1485
 AliHLTComponent.h:1486
 AliHLTComponent.h:1487
 AliHLTComponent.h:1488
 AliHLTComponent.h:1489
 AliHLTComponent.h:1490
 AliHLTComponent.h:1491
 AliHLTComponent.h:1492
 AliHLTComponent.h:1493
 AliHLTComponent.h:1494
 AliHLTComponent.h:1495
 AliHLTComponent.h:1496
 AliHLTComponent.h:1497
 AliHLTComponent.h:1498
 AliHLTComponent.h:1499
 AliHLTComponent.h:1500
 AliHLTComponent.h:1501
 AliHLTComponent.h:1502
 AliHLTComponent.h:1503
 AliHLTComponent.h:1504
 AliHLTComponent.h:1505
 AliHLTComponent.h:1506
 AliHLTComponent.h:1507
 AliHLTComponent.h:1508
 AliHLTComponent.h:1509
 AliHLTComponent.h:1510
 AliHLTComponent.h:1511
 AliHLTComponent.h:1512
 AliHLTComponent.h:1513
 AliHLTComponent.h:1514
 AliHLTComponent.h:1515
 AliHLTComponent.h:1516
 AliHLTComponent.h:1517
 AliHLTComponent.h:1518
 AliHLTComponent.h:1519
 AliHLTComponent.h:1520
 AliHLTComponent.h:1521
 AliHLTComponent.h:1522
 AliHLTComponent.h:1523
 AliHLTComponent.h:1524
 AliHLTComponent.h:1525
 AliHLTComponent.h:1526
 AliHLTComponent.h:1527
 AliHLTComponent.h:1528
 AliHLTComponent.h:1529
 AliHLTComponent.h:1530
 AliHLTComponent.h:1531
 AliHLTComponent.h:1532
 AliHLTComponent.h:1533
 AliHLTComponent.h:1534
 AliHLTComponent.h:1535
 AliHLTComponent.h:1536
 AliHLTComponent.h:1537
 AliHLTComponent.h:1538
 AliHLTComponent.h:1539
 AliHLTComponent.h:1540
 AliHLTComponent.h:1541
 AliHLTComponent.h:1542
 AliHLTComponent.h:1543
 AliHLTComponent.h:1544
 AliHLTComponent.h:1545
 AliHLTComponent.h:1546
 AliHLTComponent.h:1547
 AliHLTComponent.h:1548
 AliHLTComponent.h:1549
 AliHLTComponent.h:1550
 AliHLTComponent.h:1551
 AliHLTComponent.h:1552
 AliHLTComponent.h:1553
 AliHLTComponent.h:1554
 AliHLTComponent.h:1555
 AliHLTComponent.h:1556
 AliHLTComponent.h:1557
 AliHLTComponent.h:1558
 AliHLTComponent.h:1559
 AliHLTComponent.h:1560
 AliHLTComponent.h:1561
 AliHLTComponent.h:1562
 AliHLTComponent.h:1563
 AliHLTComponent.h:1564
 AliHLTComponent.h:1565
 AliHLTComponent.h:1566
 AliHLTComponent.h:1567
 AliHLTComponent.h:1568
 AliHLTComponent.h:1569
 AliHLTComponent.h:1570
 AliHLTComponent.h:1571
 AliHLTComponent.h:1572
 AliHLTComponent.h:1573
 AliHLTComponent.h:1574
 AliHLTComponent.h:1575
 AliHLTComponent.h:1576
 AliHLTComponent.h:1577
 AliHLTComponent.h:1578
 AliHLTComponent.h:1579
 AliHLTComponent.h:1580
 AliHLTComponent.h:1581
 AliHLTComponent.h:1582
 AliHLTComponent.h:1583
 AliHLTComponent.h:1584
 AliHLTComponent.h:1585
 AliHLTComponent.h:1586
 AliHLTComponent.h:1587
 AliHLTComponent.h:1588
 AliHLTComponent.h:1589
 AliHLTComponent.h:1590
 AliHLTComponent.h:1591
 AliHLTComponent.h:1592
 AliHLTComponent.h:1593
 AliHLTComponent.h:1594
 AliHLTComponent.h:1595
 AliHLTComponent.h:1596
 AliHLTComponent.h:1597
 AliHLTComponent.h:1598
 AliHLTComponent.h:1599
 AliHLTComponent.h:1600
 AliHLTComponent.h:1601
 AliHLTComponent.h:1602
 AliHLTComponent.h:1603
 AliHLTComponent.h:1604
 AliHLTComponent.h:1605
 AliHLTComponent.h:1606
 AliHLTComponent.h:1607
 AliHLTComponent.h:1608
 AliHLTComponent.h:1609
 AliHLTComponent.h:1610
 AliHLTComponent.h:1611
 AliHLTComponent.h:1612
 AliHLTComponent.h:1613
 AliHLTComponent.h:1614
 AliHLTComponent.h:1615
 AliHLTComponent.h:1616
 AliHLTComponent.h:1617
 AliHLTComponent.h:1618
 AliHLTComponent.h:1619
 AliHLTComponent.h:1620
 AliHLTComponent.h:1621
 AliHLTComponent.h:1622
 AliHLTComponent.h:1623
 AliHLTComponent.h:1624
 AliHLTComponent.h:1625
 AliHLTComponent.h:1626
 AliHLTComponent.h:1627
 AliHLTComponent.h:1628
 AliHLTComponent.h:1629
 AliHLTComponent.h:1630
 AliHLTComponent.h:1631
 AliHLTComponent.h:1632
 AliHLTComponent.h:1633
 AliHLTComponent.h:1634
 AliHLTComponent.h:1635
 AliHLTComponent.h:1636
 AliHLTComponent.h:1637
 AliHLTComponent.h:1638
 AliHLTComponent.h:1639
 AliHLTComponent.h:1640
 AliHLTComponent.h:1641
 AliHLTComponent.h:1642
 AliHLTComponent.h:1643
 AliHLTComponent.h:1644
 AliHLTComponent.h:1645
 AliHLTComponent.h:1646
 AliHLTComponent.h:1647
 AliHLTComponent.h:1648
 AliHLTComponent.h:1649
 AliHLTComponent.h:1650
 AliHLTComponent.h:1651
 AliHLTComponent.h:1652
 AliHLTComponent.h:1653
 AliHLTComponent.h:1654
 AliHLTComponent.h:1655
 AliHLTComponent.h:1656
 AliHLTComponent.h:1657
 AliHLTComponent.h:1658
 AliHLTComponent.h:1659
 AliHLTComponent.h:1660
 AliHLTComponent.h:1661
 AliHLTComponent.h:1662
 AliHLTComponent.h:1663
 AliHLTComponent.h:1664
 AliHLTComponent.h:1665
 AliHLTComponent.h:1666
 AliHLTComponent.h:1667
 AliHLTComponent.h:1668
 AliHLTComponent.h:1669
 AliHLTComponent.h:1670
 AliHLTComponent.h:1671
 AliHLTComponent.h:1672
 AliHLTComponent.h:1673
 AliHLTComponent.h:1674
 AliHLTComponent.h:1675
 AliHLTComponent.h:1676
 AliHLTComponent.h:1677
 AliHLTComponent.h:1678
 AliHLTComponent.h:1679
 AliHLTComponent.h:1680
 AliHLTComponent.h:1681
 AliHLTComponent.h:1682
 AliHLTComponent.h:1683
 AliHLTComponent.h:1684
 AliHLTComponent.h:1685
 AliHLTComponent.h:1686
 AliHLTComponent.h:1687
 AliHLTComponent.h:1688
 AliHLTComponent.h:1689
 AliHLTComponent.h:1690
 AliHLTComponent.h:1691
 AliHLTComponent.h:1692
 AliHLTComponent.h:1693
 AliHLTComponent.h:1694
 AliHLTComponent.h:1695
 AliHLTComponent.h:1696
 AliHLTComponent.h:1697
 AliHLTComponent.h:1698
 AliHLTComponent.h:1699
 AliHLTComponent.h:1700
 AliHLTComponent.h:1701
 AliHLTComponent.h:1702
 AliHLTComponent.h:1703
 AliHLTComponent.h:1704
 AliHLTComponent.h:1705
 AliHLTComponent.h:1706
 AliHLTComponent.h:1707
 AliHLTComponent.h:1708
 AliHLTComponent.h:1709
 AliHLTComponent.h:1710
 AliHLTComponent.h:1711
 AliHLTComponent.h:1712
 AliHLTComponent.h:1713
 AliHLTComponent.h:1714
 AliHLTComponent.h:1715
 AliHLTComponent.h:1716
 AliHLTComponent.h:1717
 AliHLTComponent.h:1718
 AliHLTComponent.h:1719
 AliHLTComponent.h:1720
 AliHLTComponent.h:1721
 AliHLTComponent.h:1722
 AliHLTComponent.h:1723
 AliHLTComponent.h:1724
 AliHLTComponent.h:1725
 AliHLTComponent.h:1726
 AliHLTComponent.h:1727
 AliHLTComponent.h:1728
 AliHLTComponent.h:1729
 AliHLTComponent.h:1730
 AliHLTComponent.h:1731
 AliHLTComponent.h:1732
 AliHLTComponent.h:1733
 AliHLTComponent.h:1734
 AliHLTComponent.h:1735
 AliHLTComponent.h:1736
 AliHLTComponent.h:1737
 AliHLTComponent.h:1738
 AliHLTComponent.h:1739
 AliHLTComponent.h:1740
 AliHLTComponent.h:1741
 AliHLTComponent.h:1742
 AliHLTComponent.h:1743
 AliHLTComponent.h:1744
 AliHLTComponent.h:1745
 AliHLTComponent.h:1746
 AliHLTComponent.h:1747
 AliHLTComponent.h:1748
 AliHLTComponent.h:1749
 AliHLTComponent.h:1750
 AliHLTComponent.h:1751
 AliHLTComponent.h:1752
 AliHLTComponent.h:1753
 AliHLTComponent.h:1754
 AliHLTComponent.h:1755
 AliHLTComponent.h:1756
 AliHLTComponent.h:1757
 AliHLTComponent.h:1758
 AliHLTComponent.h:1759
 AliHLTComponent.h:1760
 AliHLTComponent.h:1761
 AliHLTComponent.h:1762
 AliHLTComponent.h:1763
 AliHLTComponent.h:1764
 AliHLTComponent.h:1765
 AliHLTComponent.h:1766
 AliHLTComponent.h:1767
 AliHLTComponent.h:1768
 AliHLTComponent.h:1769
 AliHLTComponent.h:1770
 AliHLTComponent.h:1771
 AliHLTComponent.h:1772
 AliHLTComponent.h:1773
 AliHLTComponent.h:1774
 AliHLTComponent.h:1775
 AliHLTComponent.h:1776
 AliHLTComponent.h:1777
 AliHLTComponent.h:1778
 AliHLTComponent.h:1779
 AliHLTComponent.h:1780
 AliHLTComponent.h:1781
 AliHLTComponent.h:1782
 AliHLTComponent.h:1783
 AliHLTComponent.h:1784
 AliHLTComponent.h:1785
 AliHLTComponent.h:1786
 AliHLTComponent.h:1787
 AliHLTComponent.h:1788
 AliHLTComponent.h:1789
 AliHLTComponent.h:1790
 AliHLTComponent.h:1791
 AliHLTComponent.h:1792
 AliHLTComponent.h:1793
 AliHLTComponent.h:1794
 AliHLTComponent.h:1795
 AliHLTComponent.h:1796
 AliHLTComponent.h:1797
 AliHLTComponent.h:1798
 AliHLTComponent.h:1799
 AliHLTComponent.h:1800
 AliHLTComponent.h:1801
 AliHLTComponent.h:1802
 AliHLTComponent.h:1803
 AliHLTComponent.h:1804
 AliHLTComponent.h:1805
 AliHLTComponent.h:1806
 AliHLTComponent.h:1807
 AliHLTComponent.h:1808
 AliHLTComponent.h:1809
 AliHLTComponent.h:1810
 AliHLTComponent.h:1811
 AliHLTComponent.h:1812
 AliHLTComponent.h:1813
 AliHLTComponent.h:1814
 AliHLTComponent.h:1815
 AliHLTComponent.h:1816
 AliHLTComponent.h:1817
 AliHLTComponent.h:1818
 AliHLTComponent.h:1819
 AliHLTComponent.h:1820
 AliHLTComponent.h:1821
 AliHLTComponent.h:1822
 AliHLTComponent.h:1823
 AliHLTComponent.h:1824
 AliHLTComponent.h:1825
 AliHLTComponent.h:1826
 AliHLTComponent.h:1827
 AliHLTComponent.h:1828
 AliHLTComponent.h:1829
 AliHLTComponent.h:1830
 AliHLTComponent.h:1831
 AliHLTComponent.h:1832
 AliHLTComponent.h:1833
 AliHLTComponent.h:1834