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

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

/// @file   AliHLTOUT.h
/// @author Matthias Richter
/// @date   
/// @brief  The control class for HLTOUT data.
///

#include <vector>
#include "AliHLTLogging.h"
#include "AliHLTModuleAgent.h"

class AliHLTOUTHandler;
class AliHLTOUTHandlerDesc; // AliHLTModuleAgent.h
class AliESDEvent;
class AliHLTReconstructor;
class AliRawReader;
class TTree;

#define AliHLTOUTInvalidIndex (~(AliHLTUInt32_t)0)

using std::vector;

typedef vector<AliHLTUInt32_t> AliHLTOUTIndexList;

/**
 * @class AliHLTOUT
 * The control class for HLTOUT data.
 * The output of the HLT, either from the HLTOUT nodes or simulated output,
 * is transferred and stored in the HOMER format. The AliHLTOUT class 
 * implements scanning of the HOMER data for all HLTOUT DDL links and
 * abstracts access to the complete HLTOUT data.
 * 
 */
class AliHLTOUT {
 public:
  /** standard constructor */
  AliHLTOUT();
  /** standard destructor */
  virtual ~AliHLTOUT();

  typedef const AliHLTUInt8_t* AliConstExternalBuffer;

  /**
   * Create an AliHLTOUTRawReader instance.
   * Helper function to transparently access classes from the
   * libHLTrec library.
   */
  static AliHLTOUT* New(AliRawReader* pRawReader);

  /**
   * Create an AliHLTOUTDigitReader instance
   * Helper function to transparently access classes from the
   * libHLTrec library.
   */
  static AliHLTOUT* New(TTree* pDigitTree, int event=-1);

  /**
   * Create an AliHLTOUTDigitReader instance
   * Helper function to transparently access classes from the
   * libHLTrec library.
   */
  static AliHLTOUT* New(const char* filename, int event=-1);

  /**
   * Get the global instance.
   * The global instance is set temporarily by the AliHLTOUTGlobalInstanceGuard
   * mainly for the sake of data input to an analysis chain. The
   * AliHLTOUTPublisherComponent objects can access the global instance.
   */
  static AliHLTOUT* GetGlobalInstance() {return fgGlobalInstance;}

  /**
   * Delete an instance of the HLTOUT.
   * Helper function to transparently access classes from the
   * libHLTrec library. Before deleting, the availability of the
   * library is checked.
   */
  static void Delete(AliHLTOUT* pInstance);

  /**
   * Locking guard for the AliHLTOUT object.
   * If the object is locked, the selection of data blocks can not be changed.
   */
  class AliHLTOUTLockGuard {
  public:
    /** constructor */
    AliHLTOUTLockGuard(AliHLTOUT* pInstance) : fpInstance(pInstance)
    {if (fpInstance) fpInstance->SetStatusFlag(kLocked);}
    /** destructor */
    ~AliHLTOUTLockGuard()
    {if (fpInstance) fpInstance->ClearStatusFlag(kLocked);}

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

    /** the AliHLTOUT instance the guard is locking */
    AliHLTOUT* fpInstance; //!transient
  };

  /**
   * Guard for handling of global AliHLTOUT instance.
   * The global HLTOUT instance can be set for certain steps of the
   * processing. The initial objective is to support input to the
   * AliHLTOUTPublisherComponent running in a kChain handler.
   *
   * The Guard restores the original instance when closed.
   */
  class AliHLTOUTGlobalInstanceGuard {
  public:
    /** constructor */
    AliHLTOUTGlobalInstanceGuard(AliHLTOUT* pInstance) : fpLastInstance(AliHLTOUT::fgGlobalInstance)
    {AliHLTOUT::fgGlobalInstance=pInstance;}
    /** destructor */
    ~AliHLTOUTGlobalInstanceGuard()
    {AliHLTOUT::fgGlobalInstance=fpLastInstance;}

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

    /** the AliHLTOUT instance the guard is locking */
    AliHLTOUT* fpLastInstance; //!transient
  };

  /**
   * The HLT OUT Event Header.
   * Defined between HLT and DAQ.
   */
  struct AliHLTOUTEventHeader {
    /**Total length of the data in bytes, including HLT event header, excluding CDH. */
    AliHLTUInt32_t fLength; //! see above
    /** version of the header */
    AliHLTUInt32_t fVersion; //! see above
    /** High 32 bit word of event id */
    AliHLTUInt32_t fEventIDHigh; //! see above
    /** Low 32 bit word of event id */
    AliHLTUInt32_t fEventIDLow; //! see above
  };

  enum {
    /// versions 1 of the HLT header
    kVersion1 = 1,
    /// versions 2 of the HLT header
    kVersion2 = 2
  };

  enum {
    /// size of HLT decision in data format version 1: 29x4
    kSizeDecisionVersion1 = 116,
    /// size of HLT decision in data format version 2: 30x4
    kSizeDecisionVersion2 = 120
  };

  // definitions from ALICE internal notes ALICE-INT-2002-010 and
  // ALICE-INT-2006-XXX
  enum {
    /** the 32bit word in the CDH containing the status flags */
    kCDHStatusWord=4, //! see above
    /** start of the flags in word fgkCDHStatusWord */
    kCDHStatusFlagsOffset=12, //! see above
    /** bit indicating HLT decision in the HLTOUT*/
    kCDHFlagsHLTDecision=6, //! see above
    /** bit indicating HLT payload in the HLTOUT*/
    kCDHFlagsHLTPayload=7 //! see above
  };

  class AliHLTOUTHandlerListEntry;
  /**
   * Block descriptor.
   */
  class AliHLTOUTBlockDescriptor {
  public:
    AliHLTOUTBlockDescriptor(AliHLTComponentDataType dt, AliHLTUInt32_t spec, AliHLTUInt32_t index, AliHLTOUT* pCollection)
      : fDataType(dt), fSpecification(spec), fIndex(index), fSelected(false), fProcessed(false), fpCollection(pCollection) {};
    AliHLTOUTBlockDescriptor(const AliHLTOUTBlockDescriptor& src)
      : fDataType(src.fDataType), fSpecification(src.fSpecification), fIndex(src.fIndex), fSelected(false), fProcessed(false), fpCollection(src.fpCollection) {}
    AliHLTOUTBlockDescriptor& operator=(const AliHLTOUTBlockDescriptor& src) {
      if (this==&src) return *this;
      fDataType=src.fDataType; fSpecification=src.fSpecification; fIndex=src.fIndex; fSelected=false; fProcessed=false; fpCollection=src.fpCollection; return *this;
    }
    ~AliHLTOUTBlockDescriptor() {}

    operator AliHLTComponentDataType() const {return fDataType;}
    operator AliHLTUInt32_t() const {return fSpecification;}
    int operator==(AliHLTComponentDataType dt) const {return dt==fDataType;}
    int operator==(AliHLTUInt32_t spec) const {return spec==fSpecification;}
    int operator==(AliHLTOUT* collection) const {return collection==fpCollection;}

    AliHLTUInt32_t GetIndex() const {return fIndex;}
    AliHLTOUT* GetCollection() const {return fpCollection;}

    bool IsSelected() const {return fSelected;}
    void Select(bool selected=true) {fSelected=selected;}
    bool IsProcessed() const {return fProcessed;}
    void MarkProcessed() {fProcessed=true;}

    /**
     * Get the data buffer
     * @param [out] pBuffer buffer of the selected data block
     * @param [out] size    size of the selected data block
     */
    int GetDataBuffer(const AliHLTUInt8_t* &pBuffer, AliHLTUInt32_t& size) {
      if (fpCollection) return fpCollection->GetDataBuffer(GetIndex(), pBuffer, size);
      return -ENODEV;
    }

    /**
     * Get the handler descriptor
     */
    const AliHLTOUTHandlerListEntry& GetHandlerDesc();

    /// print info
    void Print(const char* option="") const;

  private:      
    /** data type of the block */
    AliHLTComponentDataType fDataType; //!transient
    /** data specification of the block */
    AliHLTUInt32_t          fSpecification; //!transient
    /** index in the data stream */
    AliHLTUInt32_t          fIndex; //!transient
    /** selection flag */
    bool                    fSelected; //!transient
    /** processed flag */
    bool                    fProcessed; //!transient
    /** the collection */
    AliHLTOUT*              fpCollection; //!transient
  };

  class AliHLTOUTHandlerListEntry {
  public:
    AliHLTOUTHandlerListEntry(AliHLTOUTHandler* pHandler, 
			      AliHLTModuleAgent::AliHLTOUTHandlerDesc& handlerDesc,
			      AliHLTModuleAgent* pAgent,
			      AliHLTUInt32_t index);

    /** copy constructor for vector handling */
    AliHLTOUTHandlerListEntry(const AliHLTOUTHandlerListEntry& src);

    /** assignment operator for vector handling */
    AliHLTOUTHandlerListEntry& operator=(const AliHLTOUTHandlerListEntry& src);

    ~AliHLTOUTHandlerListEntry();

    static const AliHLTOUTHandlerListEntry& VoidHandlerListEntry() {return fgkVoidHandlerListEntry;}

    operator AliHLTOUTHandler*() const {return fpHandler;}

    // please note that fpHandlerDesc is really a pointer and is created
    // in the constructor. Thats why it is dereferenced here. The pointer
    // type is on purpose, even though it is a bit confusing with the 
    // argument by reference in the AliHLTOUTHandlerListEntry constructor.
    operator const AliHLTModuleAgent::AliHLTOUTHandlerDesc&() const 
    {return fpHandlerDesc?*fpHandlerDesc:AliHLTModuleAgent::fgkVoidHandlerDesc;}
    operator AliHLTModuleAgent*() const {return fpAgent;}

    /**
     * Two list entries are considered to be equal if the handlers
     * are equal.
     */
    bool operator==(const AliHLTOUTHandlerListEntry& entry) const;

    bool operator==(const AliHLTModuleAgent::AliHLTOUTHandlerType handlerType) const;

    /**
     * Compare the handler descriptor of this list entry with another
     * descriptor.
     * @return true if both handler and agent match
     */
    bool operator==(const AliHLTModuleAgent::AliHLTOUTHandlerDesc desc) const; 

    AliHLTUInt32_t operator[](int i) const;

    /**
     * Add a block index to this descriptor.
     * One descriptor can serve multiple blocks if the agent returns the
     * same handler for all of the blocks. Instead of creating a new entry
     * the block index ist just added
     */
    void AddIndex(AliHLTUInt32_t index);

    /**
     * Add all indices of the descriptor.
     */
    void AddIndex(const AliHLTOUTHandlerListEntry &desc);

    /**
     * Check if an index is served by this descriptor.
     * @return true if the index is in the table
     */
    bool HasIndex(AliHLTUInt32_t index) const;

    /**
     * Invalidate all block indices
     */
    void InvalidateBlocks() {fBlocks.clear();}

    /**
     * Check whether the entry has valid blocks.
     */
    bool IsEmpty() {return fBlocks.size()==0;}

    /// print info
    void Print(const char* option="") const;

  private:
    /** standard constructor prohibited */
    AliHLTOUTHandlerListEntry();

    static const AliHLTOUTHandlerListEntry fgkVoidHandlerListEntry; //! initializer

    /** pointer to the handler */
    AliHLTOUTHandler* fpHandler; //! transient

    /** pointer to handler description */
    AliHLTModuleAgent::AliHLTOUTHandlerDesc* fpHandlerDesc; //! transient

    /** pointer to module agent */
    AliHLTModuleAgent* fpAgent; //! transient

    /** list of block indices */
    AliHLTOUTIndexList fBlocks; //!transient
  };

  typedef vector<AliHLTOUTHandlerListEntry> AliHLTOUTHandlerListEntryVector;
  typedef vector<AliHLTOUTBlockDescriptor>  AliHLTOUTBlockDescriptorVector;
  typedef vector<AliHLTOUT*>                AliHLTOUTPVector;

  /**
   * Selection guard for the AliHLTOUT object.
   * If the object is locked, the selection of data blocks can not be changed.
   */
  class AliHLTOUTSelectionGuard {
  public:
    /** constructor */
    AliHLTOUTSelectionGuard(AliHLTOUT* pInstance) : fpInstance(pInstance)
    {if (fpInstance) fpInstance->SelectDataBlock();}
    /** constructor */
    AliHLTOUTSelectionGuard(AliHLTOUT* pInstance, const AliHLTOUTHandlerListEntry* pHandlerDesc) : fpInstance(pInstance)
    {if (fpInstance) fpInstance->SelectDataBlocks(pHandlerDesc);}
    /** destructor */
    ~AliHLTOUTSelectionGuard()
    {if (fpInstance) fpInstance->DisableBlockSelection();}

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

    /** the AliHLTOUT instance the guard is locking */
    AliHLTOUT* fpInstance; //!transient
  };

  /**
   * Init for processing.
   * The HLTOUT is scanned for all available data blocks and the
   * AliHLTOUTHandler objects for the data blocks are created according
   * to the module agents (see AliHLTModuleAgent).
   */
  int Init();

  /**
   * Reset and clear all data block descriptors.
   * @note Since sub-collections are only referred via the block
   * descriptors, all information on sub-collections is also lost.
   * Child classes should implement ResetInput in order to cleanup
   * the input devices.
   */
  int Reset();

  /**
   * Get the current event id
   */
  AliHLTUInt64_t EventId() const {return fCurrentEventId;}

  /**
   * Get number of data blocks in the HLTOUT data
   */
  int GetNofDataBlocks();

  /**
   * Select the first data block of a certain data type and specification.
   * The selection criteria can be of kAliHLTAnyDataType and/or
   * kAliHLTVoidDataSpec in order to be ignored and just match any data block.
   *
   * The search criteria can be combined with a handler type (e.g. kRawReader)
   * @param [in] dt     data type to match                                <br>
   * @param [in] spec   data specification to match                       <br>
   * @param [in] handlerType  type of the handler
   * @param [in] skipProcessed skip all block marked processed
   * @return block index: >= 0 if success, -ENOENT if no block found      <br>
   *         neg. error code if failed                                    <br>
   *                        -EPERM if access denied (object locked)
   */
  int SelectFirstDataBlock(AliHLTComponentDataType dt=kAliHLTAnyDataType,
			   AliHLTUInt32_t spec=kAliHLTVoidDataSpec,
			   AliHLTModuleAgent::AliHLTOUTHandlerType handlerType=AliHLTModuleAgent::kUnknownOutput,
			   bool skipProcessed=true);

  /**
   * Select the next data block of data type and specification of the previous
   * call to @ref SelectFirstDataBlock.
   * @return block index: >= 0 if success, -ENOENT if no block found      <br>
   *         neg. error code if failed                                    <br>
   *                        -EPERM if access denied (object locked)
   */
  int SelectNextDataBlock();

  /**
   * Get properties of the selected data block.
   * @param [out] dt    data type of the selected block
   * @param [out] spec  data specification of the selected block
   */
  int GetDataBlockDescription(AliHLTComponentDataType& dt, AliHLTUInt32_t& spec);

  /**
   * Get handler description of the current data block.
   */
  const AliHLTOUTHandlerListEntry& GetDataBlockHandlerDesc();

  /**
   * Get handler type of the selected data block.
   * @return handler type for the selected data block
   */
  AliHLTModuleAgent::AliHLTOUTHandlerType GetDataBlockHandlerType();

  /**
   * Get the index of the current data block.
   * @return index, AliHLTOUTInvalidIndex if no block selected
   */
  AliHLTUInt32_t GetDataBlockIndex();

  /**
   * Get buffer of the selected data block.
   * Buffer has to be released using ReleaseDataBuffer
   * @param [out] desc  block data descriptor
   */
  int GetDataBuffer(AliHLTComponentBlockData& desc);

  /**
   * Get buffer of the selected data block.
   * Buffer has to be released using ReleaseDataBuffer
   * @param [out] pBuffer buffer of the selected data block
   * @param [out] size    size of the selected data block
   */
  int GetDataBuffer(const AliHLTUInt8_t* &pBuffer, AliHLTUInt32_t& size);

  /**
   * Release buffer after use.
   * @param [in] pBuffer  buffer of the selected data block
   */
  int ReleaseDataBuffer(const AliHLTUInt8_t* pBuffer);

  /**
   * Get a TObject from the data buffer
   * @return TObject pointer if data block is a streamed object
   */
  TObject* GetDataObject();

  /**
   * Release data object
   */
  int ReleaseDataObject(TObject* pObject);

  /**
   * Add the current data block to the selection.
   * Note: enables also the block selection
   */
  int SelectDataBlock();

  /**
   * Add the all data blocks of a certain handler to the selection.
   * Note: enables also the block selection
   */
  int SelectDataBlocks(const AliHLTOUTHandlerListEntry* pHandlerDesc);

  /**
   * Enable the selection of data blocks.
   */
  int EnableBlockSelection();

  /**
   * Disable the selection of data blocks.
   */
  int DisableBlockSelection();

  /**
   * Reset the data block selection.
   * Resets the selection list, none of the blocks is selected.
   */
  int ResetBlockSelection();

  /**
   * Mark the current block as processed.
   */
  int MarkDataBlockProcessed();

  /**
   * Mark all data blocks of a certain handler processed.
   */
  int MarkDataBlocksProcessed(const AliHLTOUTHandlerListEntry* pHandlerDesc);

  /**
   * Add a sub collection to the HLTOUT.
   */
  int AddSubCollection(AliHLTOUT* pCollection);

  /**
   * Release a previously added sub collection.
   */
  int ReleaseSubCollection(AliHLTOUT* pCollection);

  /**
   * Get module agent for the selected data block.
   */
  AliHLTModuleAgent* GetAgent();

  /**
   * Get handler for the selected data block.
   */
  AliHLTOUTHandler* GetHandler();

  /**
   * Convert data buffer to ESD.
   * The buffer is supposed to describe a streamed AliESDEvent object.
   * If no target object is specified, the ESD is written to a file AliHLTdetESDs.root,
   * where 'det' is derived from the data type origin. Each time the function is invoked
   * a new event is created. Dummy events are added if the previous events did not contain
   *
   * The function needs AliRoot and might not be implemented by all AliHLTOUT
   * implementations.
   * a data block of this specification.
   * @param [in]  pBuffer  the data buffer
   * @param [in]  size     data buffer size
   * @param [in]  dt       data type of the block
   * @param [out] tgtesd   optional target
   */
  virtual int WriteESD(const AliHLTUInt8_t* pBuffer, AliHLTUInt32_t size, AliHLTComponentDataType dt, AliESDEvent* tgtesd=NULL) const;

  enum AliHLTOUTByteOrder {
    /** no data block selected */
    kInvalidByteOrder=-1,
    kUnknownByteOrder=0,
    kLittleEndian,
    kBigEndian
  };

  enum AliHLTOUTDataType {
    kUint64 = 0,
    kUint32 = 1,
    kUint16 = 2,
    kUint8  = 3,
    kDouble = 4,
    kFloat  = 5
  };

  /**
   * Check byte order of selected block
   */
  AliHLTOUTByteOrder CheckByteOrder();

  /**
   * Check alignment of selected block
   */
  int CheckAlignment(AliHLTOUT::AliHLTOUTDataType type);

  /**
   * Helper function to byte swap a 64 bit value.
   */
  static AliHLTUInt64_t ByteSwap64(AliHLTUInt64_t src);

  /**
   * Helper function to byte swap a 32 bit value.
   */
  static AliHLTUInt32_t ByteSwap32(AliHLTUInt32_t src);

  /**
   * Insert a handler item.
   * The current list entries are checked if the handler is already in
   * the list. It is added if not in the list, otherwise the block index
   * is added to the existing entry.
   * @param list     the handler list
   * @param entry    handler list entry
   * @return 0 if added, EEXIST (non negative!) if merged with existing entry <br>
   *         neg. error code if failed
   */
  static int InsertHandler(AliHLTOUTHandlerListEntryVector& list, const AliHLTOUTHandlerListEntry &entry);
  
  /**
   * Insert all handlers of the specified type to the list.
   */
  int FillHandlerList(AliHLTOUTHandlerListEntryVector& list, AliHLTModuleAgent::AliHLTOUTHandlerType handlerType);

  /**
   * Remove empty items which have a duplicate in the list.
   */
  static int RemoveEmptyDuplicateHandlers(AliHLTOUTHandlerListEntryVector& list);

  /**
   * Find an entry of a certain description in the list.
   * @return index of the entry if found, -ENOENT if not found
   */
  static int FindHandler(AliHLTOUTHandlerListEntryVector& list, const AliHLTModuleAgent::AliHLTOUTHandlerDesc desc);

  /**
   * Invalidate all blocks of the handlers in the list
   */
  static int InvalidateBlocks(AliHLTOUTHandlerListEntryVector& list);

 protected:
  /**
   * Add a block descriptor.
   * This is done by the child classes generating the index. The AliHLTOUT
   * object must be locked for index generation.
   * @param desc    the block descriptor
   * @return 0 if success, -EPERM if access denied
   */
  int AddBlockDescriptor(const AliHLTOUTBlockDescriptor desc);

  /**
   * Set the event id, only for child classes
   */
  void SetEventId(AliHLTUInt64_t id);

  /**
   * Print output or suppress.
   */
  bool BeVerbose() const {return fbVerbose;}

  /**
   * Switch output.
   */
  void SwitchVerbosity(bool verbose) {fbVerbose=verbose;}

  /// print info
  void Print(const char* option="") const;

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

  /**
   * Internal status flags
   */
  enum {
    /** the HLTOUT object is locked with the current data block selection */
    kLocked = 0x1,
    /** childs can add block descriptors */
    kCollecting = 0x2,
    /** user of the data block has checked the byte order */
    kByteOrderChecked = 0x4,
    /** warning on byte order missmatch has been printed */
    kByteOrderWarning = 0x8,
    /** user of the data block has checked the alignment */
    kAlignmentChecked = 0x10,
    /** warning on alignment missmatch has been printed */
    kAlignmentWarning = 0x20,
    /** enable block selection list */
    kBlockSelection = 0x40,
    /** skip processed data blocks */
    kSkipProcessed = 0x80,
    /** marked as sub collection */
    kIsSubCollection = 0x100
  };

  /**
   * Generate the index of the HLTOUT data.
   * Must be implemented by the child classes.
   */
  virtual int GenerateIndex()=0;

  /**
   * Find AliHLTOUTHandler objects for the data blocks.
   * The available AliHLTModuleAgents are probed whether they provide
   * handlers for data processing.
   */
  int InitHandlers();

  /**
   * Cleanup and reset the data input.
   */
  virtual int ResetInput();

  /**
   * Get the data buffer
   * @param [in]  index   index of the block
   * @param [out] pBuffer buffer of the selected data block
   * @param [out] size    size of the selected data block
   */
  virtual int GetDataBuffer(AliHLTUInt32_t index, const AliHLTUInt8_t* &pBuffer, 
			    AliHLTUInt32_t& size)=0;

  /**
   * Check byte order of data block
   */
  virtual AliHLTOUTByteOrder CheckBlockByteOrder(AliHLTUInt32_t index)=0;

  /**
   * Check alignment of data block
   */
  virtual int CheckBlockAlignment(AliHLTUInt32_t index, AliHLTOUT::AliHLTOUTDataType type)=0;

  /**
   * Select the data block of data type and specification of the previous
   * call to @ref SelectFirstDataBlock. Core function of @ref SelectFirstDataBlock
   * and @ref SelectNextDataBlock, starts to find a block at the current list
   * position.
   * 
   * The data block is searched from the conditions of fSearchDataType,
   * fSearchSpecification, fSearchHandlerType and the selection list.
   *
   * @return identifier >=0 if success, neg. error code if failed         <br>
   *                        -ENOENT if no block found                     <br>
   *                        -EPERM if access denied (object locked)
   */
  int FindAndSelectDataBlock();

  /**
   * Set status flag.
   * @param flag     flag to set
   * @return current status flags
   */
  unsigned int SetStatusFlag(unsigned int flag) {return fFlags|=flag;}

  /**
   * Clear status flag.
   * @param flag     flag to clear
   * @return current status flags
   */
  unsigned int ClearStatusFlag(unsigned int flag) {return fFlags&=~flag;}

  /**
   * Check status flag.
   * @param flag     flag to check
   * @return 1 if flag is set
   */
  int CheckStatusFlag(unsigned int flag) const {return (fFlags&flag)==flag;}

  /**
   * Find handler description for a certain block index.
   */
  const AliHLTOUTHandlerListEntry& FindHandlerDesc(AliHLTUInt32_t blockIndex);

  /**
   * Set the RawReader as parameter.
   * The function is for internal use only in conjunction with the
   * New() functions.
   */
  virtual void SetParam(AliRawReader* pRawReader);

  /**
   * Set the RunLoader as parameter
   * The function is for internal use only in conjunction with the
   * New() functions.
   */
  virtual void SetParam(TTree* pDigitTree, int event=-1);

  /**
   * Set name of the digit file as parameter
   * The function is for internal use only in conjunction with the
   * New() functions.
   */
  virtual void SetParam(const char* filename, int event=-1);

  /** data type for the current block search, set from @ref SelectFirstDataBlock */
  AliHLTComponentDataType fSearchDataType; //!transient

  /** data specification for the current block search */
  AliHLTUInt32_t fSearchSpecification; //!transient

  /** handler type for the current block search */
  AliHLTModuleAgent::AliHLTOUTHandlerType fSearchHandlerType; // !transient

  /** instance flags: locked, collecting, ... */
  unsigned int fFlags; //!transient

  /** list of block descriptors */
  AliHLTOUTBlockDescriptorVector fBlockDescList; //!transient

  /** current position in the list */
  unsigned int fCurrent; //!transient

  /** data buffer under processing */
  AliConstExternalBuffer fpBuffer; //!transient

  /** list of AliHLTOUTHandlers */
  AliHLTOUTHandlerListEntryVector fDataHandlers; // !transient

  /** verbose or silent output */
  bool fbVerbose; //!transient

  /** gobal instance set for certain steps of the analysis */
  static AliHLTOUT* fgGlobalInstance; //! transient

  /** logging methods */
  AliHLTLogging fLog; //! transient

  /** current buffer converted to a TObject */
  TObject* fpDataObject; //!
  AliConstExternalBuffer fpObjectBuffer; //!
  AliHLTUInt32_t fObjectBufferSize; //!

  /** current event id */
  AliHLTUInt64_t fCurrentEventId; //!

  ClassDef(AliHLTOUT, 6)
};
#endif
 AliHLTOUT.h:1
 AliHLTOUT.h:2
 AliHLTOUT.h:3
 AliHLTOUT.h:4
 AliHLTOUT.h:5
 AliHLTOUT.h:6
 AliHLTOUT.h:7
 AliHLTOUT.h:8
 AliHLTOUT.h:9
 AliHLTOUT.h:10
 AliHLTOUT.h:11
 AliHLTOUT.h:12
 AliHLTOUT.h:13
 AliHLTOUT.h:14
 AliHLTOUT.h:15
 AliHLTOUT.h:16
 AliHLTOUT.h:17
 AliHLTOUT.h:18
 AliHLTOUT.h:19
 AliHLTOUT.h:20
 AliHLTOUT.h:21
 AliHLTOUT.h:22
 AliHLTOUT.h:23
 AliHLTOUT.h:24
 AliHLTOUT.h:25
 AliHLTOUT.h:26
 AliHLTOUT.h:27
 AliHLTOUT.h:28
 AliHLTOUT.h:29
 AliHLTOUT.h:30
 AliHLTOUT.h:31
 AliHLTOUT.h:32
 AliHLTOUT.h:33
 AliHLTOUT.h:34
 AliHLTOUT.h:35
 AliHLTOUT.h:36
 AliHLTOUT.h:37
 AliHLTOUT.h:38
 AliHLTOUT.h:39
 AliHLTOUT.h:40
 AliHLTOUT.h:41
 AliHLTOUT.h:42
 AliHLTOUT.h:43
 AliHLTOUT.h:44
 AliHLTOUT.h:45
 AliHLTOUT.h:46
 AliHLTOUT.h:47
 AliHLTOUT.h:48
 AliHLTOUT.h:49
 AliHLTOUT.h:50
 AliHLTOUT.h:51
 AliHLTOUT.h:52
 AliHLTOUT.h:53
 AliHLTOUT.h:54
 AliHLTOUT.h:55
 AliHLTOUT.h:56
 AliHLTOUT.h:57
 AliHLTOUT.h:58
 AliHLTOUT.h:59
 AliHLTOUT.h:60
 AliHLTOUT.h:61
 AliHLTOUT.h:62
 AliHLTOUT.h:63
 AliHLTOUT.h:64
 AliHLTOUT.h:65
 AliHLTOUT.h:66
 AliHLTOUT.h:67
 AliHLTOUT.h:68
 AliHLTOUT.h:69
 AliHLTOUT.h:70
 AliHLTOUT.h:71
 AliHLTOUT.h:72
 AliHLTOUT.h:73
 AliHLTOUT.h:74
 AliHLTOUT.h:75
 AliHLTOUT.h:76
 AliHLTOUT.h:77
 AliHLTOUT.h:78
 AliHLTOUT.h:79
 AliHLTOUT.h:80
 AliHLTOUT.h:81
 AliHLTOUT.h:82
 AliHLTOUT.h:83
 AliHLTOUT.h:84
 AliHLTOUT.h:85
 AliHLTOUT.h:86
 AliHLTOUT.h:87
 AliHLTOUT.h:88
 AliHLTOUT.h:89
 AliHLTOUT.h:90
 AliHLTOUT.h:91
 AliHLTOUT.h:92
 AliHLTOUT.h:93
 AliHLTOUT.h:94
 AliHLTOUT.h:95
 AliHLTOUT.h:96
 AliHLTOUT.h:97
 AliHLTOUT.h:98
 AliHLTOUT.h:99
 AliHLTOUT.h:100
 AliHLTOUT.h:101
 AliHLTOUT.h:102
 AliHLTOUT.h:103
 AliHLTOUT.h:104
 AliHLTOUT.h:105
 AliHLTOUT.h:106
 AliHLTOUT.h:107
 AliHLTOUT.h:108
 AliHLTOUT.h:109
 AliHLTOUT.h:110
 AliHLTOUT.h:111
 AliHLTOUT.h:112
 AliHLTOUT.h:113
 AliHLTOUT.h:114
 AliHLTOUT.h:115
 AliHLTOUT.h:116
 AliHLTOUT.h:117
 AliHLTOUT.h:118
 AliHLTOUT.h:119
 AliHLTOUT.h:120
 AliHLTOUT.h:121
 AliHLTOUT.h:122
 AliHLTOUT.h:123
 AliHLTOUT.h:124
 AliHLTOUT.h:125
 AliHLTOUT.h:126
 AliHLTOUT.h:127
 AliHLTOUT.h:128
 AliHLTOUT.h:129
 AliHLTOUT.h:130
 AliHLTOUT.h:131
 AliHLTOUT.h:132
 AliHLTOUT.h:133
 AliHLTOUT.h:134
 AliHLTOUT.h:135
 AliHLTOUT.h:136
 AliHLTOUT.h:137
 AliHLTOUT.h:138
 AliHLTOUT.h:139
 AliHLTOUT.h:140
 AliHLTOUT.h:141
 AliHLTOUT.h:142
 AliHLTOUT.h:143
 AliHLTOUT.h:144
 AliHLTOUT.h:145
 AliHLTOUT.h:146
 AliHLTOUT.h:147
 AliHLTOUT.h:148
 AliHLTOUT.h:149
 AliHLTOUT.h:150
 AliHLTOUT.h:151
 AliHLTOUT.h:152
 AliHLTOUT.h:153
 AliHLTOUT.h:154
 AliHLTOUT.h:155
 AliHLTOUT.h:156
 AliHLTOUT.h:157
 AliHLTOUT.h:158
 AliHLTOUT.h:159
 AliHLTOUT.h:160
 AliHLTOUT.h:161
 AliHLTOUT.h:162
 AliHLTOUT.h:163
 AliHLTOUT.h:164
 AliHLTOUT.h:165
 AliHLTOUT.h:166
 AliHLTOUT.h:167
 AliHLTOUT.h:168
 AliHLTOUT.h:169
 AliHLTOUT.h:170
 AliHLTOUT.h:171
 AliHLTOUT.h:172
 AliHLTOUT.h:173
 AliHLTOUT.h:174
 AliHLTOUT.h:175
 AliHLTOUT.h:176
 AliHLTOUT.h:177
 AliHLTOUT.h:178
 AliHLTOUT.h:179
 AliHLTOUT.h:180
 AliHLTOUT.h:181
 AliHLTOUT.h:182
 AliHLTOUT.h:183
 AliHLTOUT.h:184
 AliHLTOUT.h:185
 AliHLTOUT.h:186
 AliHLTOUT.h:187
 AliHLTOUT.h:188
 AliHLTOUT.h:189
 AliHLTOUT.h:190
 AliHLTOUT.h:191
 AliHLTOUT.h:192
 AliHLTOUT.h:193
 AliHLTOUT.h:194
 AliHLTOUT.h:195
 AliHLTOUT.h:196
 AliHLTOUT.h:197
 AliHLTOUT.h:198
 AliHLTOUT.h:199
 AliHLTOUT.h:200
 AliHLTOUT.h:201
 AliHLTOUT.h:202
 AliHLTOUT.h:203
 AliHLTOUT.h:204
 AliHLTOUT.h:205
 AliHLTOUT.h:206
 AliHLTOUT.h:207
 AliHLTOUT.h:208
 AliHLTOUT.h:209
 AliHLTOUT.h:210
 AliHLTOUT.h:211
 AliHLTOUT.h:212
 AliHLTOUT.h:213
 AliHLTOUT.h:214
 AliHLTOUT.h:215
 AliHLTOUT.h:216
 AliHLTOUT.h:217
 AliHLTOUT.h:218
 AliHLTOUT.h:219
 AliHLTOUT.h:220
 AliHLTOUT.h:221
 AliHLTOUT.h:222
 AliHLTOUT.h:223
 AliHLTOUT.h:224
 AliHLTOUT.h:225
 AliHLTOUT.h:226
 AliHLTOUT.h:227
 AliHLTOUT.h:228
 AliHLTOUT.h:229
 AliHLTOUT.h:230
 AliHLTOUT.h:231
 AliHLTOUT.h:232
 AliHLTOUT.h:233
 AliHLTOUT.h:234
 AliHLTOUT.h:235
 AliHLTOUT.h:236
 AliHLTOUT.h:237
 AliHLTOUT.h:238
 AliHLTOUT.h:239
 AliHLTOUT.h:240
 AliHLTOUT.h:241
 AliHLTOUT.h:242
 AliHLTOUT.h:243
 AliHLTOUT.h:244
 AliHLTOUT.h:245
 AliHLTOUT.h:246
 AliHLTOUT.h:247
 AliHLTOUT.h:248
 AliHLTOUT.h:249
 AliHLTOUT.h:250
 AliHLTOUT.h:251
 AliHLTOUT.h:252
 AliHLTOUT.h:253
 AliHLTOUT.h:254
 AliHLTOUT.h:255
 AliHLTOUT.h:256
 AliHLTOUT.h:257
 AliHLTOUT.h:258
 AliHLTOUT.h:259
 AliHLTOUT.h:260
 AliHLTOUT.h:261
 AliHLTOUT.h:262
 AliHLTOUT.h:263
 AliHLTOUT.h:264
 AliHLTOUT.h:265
 AliHLTOUT.h:266
 AliHLTOUT.h:267
 AliHLTOUT.h:268
 AliHLTOUT.h:269
 AliHLTOUT.h:270
 AliHLTOUT.h:271
 AliHLTOUT.h:272
 AliHLTOUT.h:273
 AliHLTOUT.h:274
 AliHLTOUT.h:275
 AliHLTOUT.h:276
 AliHLTOUT.h:277
 AliHLTOUT.h:278
 AliHLTOUT.h:279
 AliHLTOUT.h:280
 AliHLTOUT.h:281
 AliHLTOUT.h:282
 AliHLTOUT.h:283
 AliHLTOUT.h:284
 AliHLTOUT.h:285
 AliHLTOUT.h:286
 AliHLTOUT.h:287
 AliHLTOUT.h:288
 AliHLTOUT.h:289
 AliHLTOUT.h:290
 AliHLTOUT.h:291
 AliHLTOUT.h:292
 AliHLTOUT.h:293
 AliHLTOUT.h:294
 AliHLTOUT.h:295
 AliHLTOUT.h:296
 AliHLTOUT.h:297
 AliHLTOUT.h:298
 AliHLTOUT.h:299
 AliHLTOUT.h:300
 AliHLTOUT.h:301
 AliHLTOUT.h:302
 AliHLTOUT.h:303
 AliHLTOUT.h:304
 AliHLTOUT.h:305
 AliHLTOUT.h:306
 AliHLTOUT.h:307
 AliHLTOUT.h:308
 AliHLTOUT.h:309
 AliHLTOUT.h:310
 AliHLTOUT.h:311
 AliHLTOUT.h:312
 AliHLTOUT.h:313
 AliHLTOUT.h:314
 AliHLTOUT.h:315
 AliHLTOUT.h:316
 AliHLTOUT.h:317
 AliHLTOUT.h:318
 AliHLTOUT.h:319
 AliHLTOUT.h:320
 AliHLTOUT.h:321
 AliHLTOUT.h:322
 AliHLTOUT.h:323
 AliHLTOUT.h:324
 AliHLTOUT.h:325
 AliHLTOUT.h:326
 AliHLTOUT.h:327
 AliHLTOUT.h:328
 AliHLTOUT.h:329
 AliHLTOUT.h:330
 AliHLTOUT.h:331
 AliHLTOUT.h:332
 AliHLTOUT.h:333
 AliHLTOUT.h:334
 AliHLTOUT.h:335
 AliHLTOUT.h:336
 AliHLTOUT.h:337
 AliHLTOUT.h:338
 AliHLTOUT.h:339
 AliHLTOUT.h:340
 AliHLTOUT.h:341
 AliHLTOUT.h:342
 AliHLTOUT.h:343
 AliHLTOUT.h:344
 AliHLTOUT.h:345
 AliHLTOUT.h:346
 AliHLTOUT.h:347
 AliHLTOUT.h:348
 AliHLTOUT.h:349
 AliHLTOUT.h:350
 AliHLTOUT.h:351
 AliHLTOUT.h:352
 AliHLTOUT.h:353
 AliHLTOUT.h:354
 AliHLTOUT.h:355
 AliHLTOUT.h:356
 AliHLTOUT.h:357
 AliHLTOUT.h:358
 AliHLTOUT.h:359
 AliHLTOUT.h:360
 AliHLTOUT.h:361
 AliHLTOUT.h:362
 AliHLTOUT.h:363
 AliHLTOUT.h:364
 AliHLTOUT.h:365
 AliHLTOUT.h:366
 AliHLTOUT.h:367
 AliHLTOUT.h:368
 AliHLTOUT.h:369
 AliHLTOUT.h:370
 AliHLTOUT.h:371
 AliHLTOUT.h:372
 AliHLTOUT.h:373
 AliHLTOUT.h:374
 AliHLTOUT.h:375
 AliHLTOUT.h:376
 AliHLTOUT.h:377
 AliHLTOUT.h:378
 AliHLTOUT.h:379
 AliHLTOUT.h:380
 AliHLTOUT.h:381
 AliHLTOUT.h:382
 AliHLTOUT.h:383
 AliHLTOUT.h:384
 AliHLTOUT.h:385
 AliHLTOUT.h:386
 AliHLTOUT.h:387
 AliHLTOUT.h:388
 AliHLTOUT.h:389
 AliHLTOUT.h:390
 AliHLTOUT.h:391
 AliHLTOUT.h:392
 AliHLTOUT.h:393
 AliHLTOUT.h:394
 AliHLTOUT.h:395
 AliHLTOUT.h:396
 AliHLTOUT.h:397
 AliHLTOUT.h:398
 AliHLTOUT.h:399
 AliHLTOUT.h:400
 AliHLTOUT.h:401
 AliHLTOUT.h:402
 AliHLTOUT.h:403
 AliHLTOUT.h:404
 AliHLTOUT.h:405
 AliHLTOUT.h:406
 AliHLTOUT.h:407
 AliHLTOUT.h:408
 AliHLTOUT.h:409
 AliHLTOUT.h:410
 AliHLTOUT.h:411
 AliHLTOUT.h:412
 AliHLTOUT.h:413
 AliHLTOUT.h:414
 AliHLTOUT.h:415
 AliHLTOUT.h:416
 AliHLTOUT.h:417
 AliHLTOUT.h:418
 AliHLTOUT.h:419
 AliHLTOUT.h:420
 AliHLTOUT.h:421
 AliHLTOUT.h:422
 AliHLTOUT.h:423
 AliHLTOUT.h:424
 AliHLTOUT.h:425
 AliHLTOUT.h:426
 AliHLTOUT.h:427
 AliHLTOUT.h:428
 AliHLTOUT.h:429
 AliHLTOUT.h:430
 AliHLTOUT.h:431
 AliHLTOUT.h:432
 AliHLTOUT.h:433
 AliHLTOUT.h:434
 AliHLTOUT.h:435
 AliHLTOUT.h:436
 AliHLTOUT.h:437
 AliHLTOUT.h:438
 AliHLTOUT.h:439
 AliHLTOUT.h:440
 AliHLTOUT.h:441
 AliHLTOUT.h:442
 AliHLTOUT.h:443
 AliHLTOUT.h:444
 AliHLTOUT.h:445
 AliHLTOUT.h:446
 AliHLTOUT.h:447
 AliHLTOUT.h:448
 AliHLTOUT.h:449
 AliHLTOUT.h:450
 AliHLTOUT.h:451
 AliHLTOUT.h:452
 AliHLTOUT.h:453
 AliHLTOUT.h:454
 AliHLTOUT.h:455
 AliHLTOUT.h:456
 AliHLTOUT.h:457
 AliHLTOUT.h:458
 AliHLTOUT.h:459
 AliHLTOUT.h:460
 AliHLTOUT.h:461
 AliHLTOUT.h:462
 AliHLTOUT.h:463
 AliHLTOUT.h:464
 AliHLTOUT.h:465
 AliHLTOUT.h:466
 AliHLTOUT.h:467
 AliHLTOUT.h:468
 AliHLTOUT.h:469
 AliHLTOUT.h:470
 AliHLTOUT.h:471
 AliHLTOUT.h:472
 AliHLTOUT.h:473
 AliHLTOUT.h:474
 AliHLTOUT.h:475
 AliHLTOUT.h:476
 AliHLTOUT.h:477
 AliHLTOUT.h:478
 AliHLTOUT.h:479
 AliHLTOUT.h:480
 AliHLTOUT.h:481
 AliHLTOUT.h:482
 AliHLTOUT.h:483
 AliHLTOUT.h:484
 AliHLTOUT.h:485
 AliHLTOUT.h:486
 AliHLTOUT.h:487
 AliHLTOUT.h:488
 AliHLTOUT.h:489
 AliHLTOUT.h:490
 AliHLTOUT.h:491
 AliHLTOUT.h:492
 AliHLTOUT.h:493
 AliHLTOUT.h:494
 AliHLTOUT.h:495
 AliHLTOUT.h:496
 AliHLTOUT.h:497
 AliHLTOUT.h:498
 AliHLTOUT.h:499
 AliHLTOUT.h:500
 AliHLTOUT.h:501
 AliHLTOUT.h:502
 AliHLTOUT.h:503
 AliHLTOUT.h:504
 AliHLTOUT.h:505
 AliHLTOUT.h:506
 AliHLTOUT.h:507
 AliHLTOUT.h:508
 AliHLTOUT.h:509
 AliHLTOUT.h:510
 AliHLTOUT.h:511
 AliHLTOUT.h:512
 AliHLTOUT.h:513
 AliHLTOUT.h:514
 AliHLTOUT.h:515
 AliHLTOUT.h:516
 AliHLTOUT.h:517
 AliHLTOUT.h:518
 AliHLTOUT.h:519
 AliHLTOUT.h:520
 AliHLTOUT.h:521
 AliHLTOUT.h:522
 AliHLTOUT.h:523
 AliHLTOUT.h:524
 AliHLTOUT.h:525
 AliHLTOUT.h:526
 AliHLTOUT.h:527
 AliHLTOUT.h:528
 AliHLTOUT.h:529
 AliHLTOUT.h:530
 AliHLTOUT.h:531
 AliHLTOUT.h:532
 AliHLTOUT.h:533
 AliHLTOUT.h:534
 AliHLTOUT.h:535
 AliHLTOUT.h:536
 AliHLTOUT.h:537
 AliHLTOUT.h:538
 AliHLTOUT.h:539
 AliHLTOUT.h:540
 AliHLTOUT.h:541
 AliHLTOUT.h:542
 AliHLTOUT.h:543
 AliHLTOUT.h:544
 AliHLTOUT.h:545
 AliHLTOUT.h:546
 AliHLTOUT.h:547
 AliHLTOUT.h:548
 AliHLTOUT.h:549
 AliHLTOUT.h:550
 AliHLTOUT.h:551
 AliHLTOUT.h:552
 AliHLTOUT.h:553
 AliHLTOUT.h:554
 AliHLTOUT.h:555
 AliHLTOUT.h:556
 AliHLTOUT.h:557
 AliHLTOUT.h:558
 AliHLTOUT.h:559
 AliHLTOUT.h:560
 AliHLTOUT.h:561
 AliHLTOUT.h:562
 AliHLTOUT.h:563
 AliHLTOUT.h:564
 AliHLTOUT.h:565
 AliHLTOUT.h:566
 AliHLTOUT.h:567
 AliHLTOUT.h:568
 AliHLTOUT.h:569
 AliHLTOUT.h:570
 AliHLTOUT.h:571
 AliHLTOUT.h:572
 AliHLTOUT.h:573
 AliHLTOUT.h:574
 AliHLTOUT.h:575
 AliHLTOUT.h:576
 AliHLTOUT.h:577
 AliHLTOUT.h:578
 AliHLTOUT.h:579
 AliHLTOUT.h:580
 AliHLTOUT.h:581
 AliHLTOUT.h:582
 AliHLTOUT.h:583
 AliHLTOUT.h:584
 AliHLTOUT.h:585
 AliHLTOUT.h:586
 AliHLTOUT.h:587
 AliHLTOUT.h:588
 AliHLTOUT.h:589
 AliHLTOUT.h:590
 AliHLTOUT.h:591
 AliHLTOUT.h:592
 AliHLTOUT.h:593
 AliHLTOUT.h:594
 AliHLTOUT.h:595
 AliHLTOUT.h:596
 AliHLTOUT.h:597
 AliHLTOUT.h:598
 AliHLTOUT.h:599
 AliHLTOUT.h:600
 AliHLTOUT.h:601
 AliHLTOUT.h:602
 AliHLTOUT.h:603
 AliHLTOUT.h:604
 AliHLTOUT.h:605
 AliHLTOUT.h:606
 AliHLTOUT.h:607
 AliHLTOUT.h:608
 AliHLTOUT.h:609
 AliHLTOUT.h:610
 AliHLTOUT.h:611
 AliHLTOUT.h:612
 AliHLTOUT.h:613
 AliHLTOUT.h:614
 AliHLTOUT.h:615
 AliHLTOUT.h:616
 AliHLTOUT.h:617
 AliHLTOUT.h:618
 AliHLTOUT.h:619
 AliHLTOUT.h:620
 AliHLTOUT.h:621
 AliHLTOUT.h:622
 AliHLTOUT.h:623
 AliHLTOUT.h:624
 AliHLTOUT.h:625
 AliHLTOUT.h:626
 AliHLTOUT.h:627
 AliHLTOUT.h:628
 AliHLTOUT.h:629
 AliHLTOUT.h:630
 AliHLTOUT.h:631
 AliHLTOUT.h:632
 AliHLTOUT.h:633
 AliHLTOUT.h:634
 AliHLTOUT.h:635
 AliHLTOUT.h:636
 AliHLTOUT.h:637
 AliHLTOUT.h:638
 AliHLTOUT.h:639
 AliHLTOUT.h:640
 AliHLTOUT.h:641
 AliHLTOUT.h:642
 AliHLTOUT.h:643
 AliHLTOUT.h:644
 AliHLTOUT.h:645
 AliHLTOUT.h:646
 AliHLTOUT.h:647
 AliHLTOUT.h:648
 AliHLTOUT.h:649
 AliHLTOUT.h:650
 AliHLTOUT.h:651
 AliHLTOUT.h:652
 AliHLTOUT.h:653
 AliHLTOUT.h:654
 AliHLTOUT.h:655
 AliHLTOUT.h:656
 AliHLTOUT.h:657
 AliHLTOUT.h:658
 AliHLTOUT.h:659
 AliHLTOUT.h:660
 AliHLTOUT.h:661
 AliHLTOUT.h:662
 AliHLTOUT.h:663
 AliHLTOUT.h:664
 AliHLTOUT.h:665
 AliHLTOUT.h:666
 AliHLTOUT.h:667
 AliHLTOUT.h:668
 AliHLTOUT.h:669
 AliHLTOUT.h:670
 AliHLTOUT.h:671
 AliHLTOUT.h:672
 AliHLTOUT.h:673
 AliHLTOUT.h:674
 AliHLTOUT.h:675
 AliHLTOUT.h:676
 AliHLTOUT.h:677
 AliHLTOUT.h:678
 AliHLTOUT.h:679
 AliHLTOUT.h:680
 AliHLTOUT.h:681
 AliHLTOUT.h:682
 AliHLTOUT.h:683
 AliHLTOUT.h:684
 AliHLTOUT.h:685
 AliHLTOUT.h:686
 AliHLTOUT.h:687
 AliHLTOUT.h:688
 AliHLTOUT.h:689
 AliHLTOUT.h:690
 AliHLTOUT.h:691
 AliHLTOUT.h:692
 AliHLTOUT.h:693
 AliHLTOUT.h:694
 AliHLTOUT.h:695
 AliHLTOUT.h:696
 AliHLTOUT.h:697
 AliHLTOUT.h:698
 AliHLTOUT.h:699
 AliHLTOUT.h:700
 AliHLTOUT.h:701
 AliHLTOUT.h:702
 AliHLTOUT.h:703
 AliHLTOUT.h:704
 AliHLTOUT.h:705
 AliHLTOUT.h:706
 AliHLTOUT.h:707
 AliHLTOUT.h:708
 AliHLTOUT.h:709
 AliHLTOUT.h:710
 AliHLTOUT.h:711
 AliHLTOUT.h:712
 AliHLTOUT.h:713
 AliHLTOUT.h:714
 AliHLTOUT.h:715
 AliHLTOUT.h:716
 AliHLTOUT.h:717
 AliHLTOUT.h:718
 AliHLTOUT.h:719
 AliHLTOUT.h:720
 AliHLTOUT.h:721
 AliHLTOUT.h:722
 AliHLTOUT.h:723
 AliHLTOUT.h:724
 AliHLTOUT.h:725
 AliHLTOUT.h:726
 AliHLTOUT.h:727
 AliHLTOUT.h:728
 AliHLTOUT.h:729
 AliHLTOUT.h:730
 AliHLTOUT.h:731
 AliHLTOUT.h:732
 AliHLTOUT.h:733
 AliHLTOUT.h:734
 AliHLTOUT.h:735
 AliHLTOUT.h:736
 AliHLTOUT.h:737
 AliHLTOUT.h:738
 AliHLTOUT.h:739
 AliHLTOUT.h:740
 AliHLTOUT.h:741
 AliHLTOUT.h:742
 AliHLTOUT.h:743
 AliHLTOUT.h:744
 AliHLTOUT.h:745
 AliHLTOUT.h:746
 AliHLTOUT.h:747
 AliHLTOUT.h:748
 AliHLTOUT.h:749
 AliHLTOUT.h:750
 AliHLTOUT.h:751
 AliHLTOUT.h:752
 AliHLTOUT.h:753
 AliHLTOUT.h:754
 AliHLTOUT.h:755
 AliHLTOUT.h:756
 AliHLTOUT.h:757
 AliHLTOUT.h:758
 AliHLTOUT.h:759
 AliHLTOUT.h:760
 AliHLTOUT.h:761
 AliHLTOUT.h:762
 AliHLTOUT.h:763
 AliHLTOUT.h:764
 AliHLTOUT.h:765
 AliHLTOUT.h:766
 AliHLTOUT.h:767
 AliHLTOUT.h:768
 AliHLTOUT.h:769
 AliHLTOUT.h:770
 AliHLTOUT.h:771
 AliHLTOUT.h:772
 AliHLTOUT.h:773
 AliHLTOUT.h:774
 AliHLTOUT.h:775
 AliHLTOUT.h:776
 AliHLTOUT.h:777
 AliHLTOUT.h:778
 AliHLTOUT.h:779
 AliHLTOUT.h:780
 AliHLTOUT.h:781
 AliHLTOUT.h:782
 AliHLTOUT.h:783
 AliHLTOUT.h:784
 AliHLTOUT.h:785
 AliHLTOUT.h:786
 AliHLTOUT.h:787
 AliHLTOUT.h:788
 AliHLTOUT.h:789
 AliHLTOUT.h:790
 AliHLTOUT.h:791
 AliHLTOUT.h:792
 AliHLTOUT.h:793
 AliHLTOUT.h:794
 AliHLTOUT.h:795
 AliHLTOUT.h:796
 AliHLTOUT.h:797
 AliHLTOUT.h:798
 AliHLTOUT.h:799
 AliHLTOUT.h:800
 AliHLTOUT.h:801
 AliHLTOUT.h:802
 AliHLTOUT.h:803
 AliHLTOUT.h:804
 AliHLTOUT.h:805
 AliHLTOUT.h:806
 AliHLTOUT.h:807
 AliHLTOUT.h:808
 AliHLTOUT.h:809
 AliHLTOUT.h:810
 AliHLTOUT.h:811
 AliHLTOUT.h:812
 AliHLTOUT.h:813
 AliHLTOUT.h:814
 AliHLTOUT.h:815
 AliHLTOUT.h:816
 AliHLTOUT.h:817
 AliHLTOUT.h:818
 AliHLTOUT.h:819
 AliHLTOUT.h:820
 AliHLTOUT.h:821
 AliHLTOUT.h:822
 AliHLTOUT.h:823
 AliHLTOUT.h:824
 AliHLTOUT.h:825
 AliHLTOUT.h:826
 AliHLTOUT.h:827
 AliHLTOUT.h:828
 AliHLTOUT.h:829
 AliHLTOUT.h:830