6 //* This file is property of and copyright by the ALICE HLT Project *
7 //* ALICE Experiment at CERN, All rights reserved. *
8 //* See cxx source for full Copyright notice *
11 /// @author Matthias Richter
13 /// @brief The control class for HLTOUT data.
17 #include "AliHLTLogging.h"
18 #include "AliHLTModuleAgent.h"
20 class AliHLTOUTHandler;
21 class AliHLTOUTHandlerDesc; // AliHLTModuleAgent.h
23 class AliHLTReconstructor;
27 #define AliHLTOUTInvalidIndex (~(AliHLTUInt32_t)0)
29 typedef vector<AliHLTUInt32_t> AliHLTOUTIndexList;
33 * The control class for HLTOUT data.
34 * The output of the HLT, either from the HLTOUT nodes or simulated output,
35 * is transferred and stored in the HOMER format. The AliHLTOUT class
36 * implements scanning of the HOMER data for all HLTOUT DDL links and
37 * abstracts access to the complete HLTOUT data.
42 /** standard constructor */
44 /** standard destructor */
48 * Create an AliHLTOUTRawReader instance.
49 * Helper function to transparently access classes from the
52 static AliHLTOUT* New(AliRawReader* pRawReader);
55 * Create an AliHLTOUTDigitReader instance
56 * Helper function to transparently access classes from the
59 static AliHLTOUT* New(TTree* pDigitTree, int event=-1);
62 * Create an AliHLTOUTDigitReader instance
63 * Helper function to transparently access classes from the
66 static AliHLTOUT* New(const char* filename, int event=-1);
69 * Get the global instance.
70 * The global instance is set temporarily by the AliHLTOUTGlobalInstanceGuard
71 * mainly for the sake of data input to an analysis chain. The
72 * AliHLTOUTPublisherComponent objects can access the global instance.
74 static AliHLTOUT* GetGlobalInstance() {return fgGlobalInstance;}
77 * Delete an instance of the HLTOUT.
78 * Helper function to transparently access classes from the
79 * libHLTrec library. Before deleting, the availability of the
82 static void Delete(AliHLTOUT* pInstance);
85 * Locking guard for the AliHLTOUT object.
86 * If the object is locked, the selection of data blocks can not be changed.
88 class AliHLTOUTLockGuard {
91 AliHLTOUTLockGuard(AliHLTOUT* pInstance) : fpInstance(pInstance)
92 {if (fpInstance) fpInstance->SetStatusFlag(kLocked);}
95 {if (fpInstance) fpInstance->ClearStatusFlag(kLocked);}
98 /** standard constructor prohibited */
100 /** copy constructor prohibited */
101 AliHLTOUTLockGuard(const AliHLTOUTLockGuard&);
102 /** assignment operator prohibited */
103 AliHLTOUTLockGuard& operator=(const AliHLTOUTLockGuard&);
105 /** the AliHLTOUT instance the guard is locking */
106 AliHLTOUT* fpInstance; //!transient
110 * Guard for handling of global AliHLTOUT instance.
111 * The global HLTOUT instance can be set for certain steps of the
112 * processing. The initial objective is to support input to the
113 * AliHLTOUTPublisherComponent running in a kChain handler.
115 * The Guard restores the original instance when closed.
117 class AliHLTOUTGlobalInstanceGuard {
120 AliHLTOUTGlobalInstanceGuard(AliHLTOUT* pInstance) : fpLastInstance(AliHLTOUT::fgGlobalInstance)
121 {AliHLTOUT::fgGlobalInstance=pInstance;}
123 ~AliHLTOUTGlobalInstanceGuard()
124 {AliHLTOUT::fgGlobalInstance=fpLastInstance;}
127 /** standard constructor prohibited */
128 AliHLTOUTGlobalInstanceGuard();
129 /** copy constructor prohibited */
130 AliHLTOUTGlobalInstanceGuard(const AliHLTOUTGlobalInstanceGuard&);
131 /** assignment operator prohibited */
132 AliHLTOUTGlobalInstanceGuard& operator=(const AliHLTOUTGlobalInstanceGuard&);
134 /** the AliHLTOUT instance the guard is locking */
135 AliHLTOUT* fpLastInstance; //!transient
139 * The HLT OUT Event Header.
140 * Defined between HLT and DAQ.
142 struct AliHLTOUTEventHeader {
143 /**Total length of the data in bytes, including HLT event header, excluding CDH. */
144 AliHLTUInt32_t fLength; //! see above
145 /** version of the header */
146 AliHLTUInt32_t fVersion; //! see above
147 /** High 32 bit word of event id */
148 AliHLTUInt32_t fEventIDHigh; //! see above
149 /** Low 32 bit word of event id */
150 AliHLTUInt32_t fEventIDLow; //! see above
154 /// versions 1 of the HLT header
156 /// versions 2 of the HLT header
161 /// size of HLT decision in data format version 1: 29x4
162 kSizeDecisionVersion1 = 116,
163 /// size of HLT decision in data format version 2: 30x4
164 kSizeDecisionVersion2 = 120
167 // definitions from ALICE internal notes ALICE-INT-2002-010 and
168 // ALICE-INT-2006-XXX
170 /** the 32bit word in the CDH containing the status flags */
171 kCDHStatusWord=4, //! see above
172 /** start of the flags in word fgkCDHStatusWord */
173 kCDHStatusFlagsOffset=12, //! see above
174 /** bit indicating HLT decision in the HLTOUT*/
175 kCDHFlagsHLTDecision=6, //! see above
176 /** bit indicating HLT payload in the HLTOUT*/
177 kCDHFlagsHLTPayload=7 //! see above
180 class AliHLTOUTHandlerListEntry;
184 class AliHLTOUTBlockDescriptor {
186 AliHLTOUTBlockDescriptor(AliHLTComponentDataType dt, AliHLTUInt32_t spec, AliHLTUInt32_t index, AliHLTOUT* pCollection)
187 : fDataType(dt), fSpecification(spec), fIndex(index), fSelected(false), fProcessed(false), fpCollection(pCollection) {};
188 AliHLTOUTBlockDescriptor(const AliHLTOUTBlockDescriptor& src)
189 : fDataType(src.fDataType), fSpecification(src.fSpecification), fIndex(src.fIndex), fSelected(false), fProcessed(false), fpCollection(src.fpCollection) {}
190 AliHLTOUTBlockDescriptor& operator=(const AliHLTOUTBlockDescriptor& src)
191 { fDataType=src.fDataType; fSpecification=src.fSpecification; fIndex=src.fIndex; fSelected=false; fProcessed=false; fpCollection=src.fpCollection; return *this; }
192 ~AliHLTOUTBlockDescriptor() {}
194 operator AliHLTComponentDataType() const {return fDataType;}
195 operator AliHLTUInt32_t() const {return fSpecification;}
196 int operator==(AliHLTComponentDataType dt) const {return dt==fDataType;}
197 int operator==(AliHLTUInt32_t spec) const {return spec==fSpecification;}
198 int operator==(AliHLTOUT* collection) const {return collection==fpCollection;}
200 AliHLTUInt32_t GetIndex() const {return fIndex;}
201 AliHLTOUT* GetCollection() const {return fpCollection;}
203 bool IsSelected() const {return fSelected;}
204 void Select(bool selected=true) {fSelected=selected;}
205 bool IsProcessed() const {return fProcessed;}
206 void MarkProcessed() {fProcessed=true;}
209 * Get the data buffer
210 * @param [out] pBuffer buffer of the selected data block
211 * @param [out] size size of the selected data block
213 int GetDataBuffer(const AliHLTUInt8_t* &pBuffer, AliHLTUInt32_t& size) {
214 if (fpCollection) return fpCollection->GetDataBuffer(GetIndex(), pBuffer, size);
219 * Get the handler descriptor
221 const AliHLTOUTHandlerListEntry& GetHandlerDesc();
224 void Print(const char* option="") const;
227 /** data type of the block */
228 AliHLTComponentDataType fDataType; //!transient
229 /** data specification of the block */
230 AliHLTUInt32_t fSpecification; //!transient
231 /** index in the data stream */
232 AliHLTUInt32_t fIndex; //!transient
233 /** selection flag */
234 bool fSelected; //!transient
235 /** processed flag */
236 bool fProcessed; //!transient
237 /** the collection */
238 AliHLTOUT* fpCollection; //!transient
241 class AliHLTOUTHandlerListEntry {
243 AliHLTOUTHandlerListEntry(AliHLTOUTHandler* pHandler,
244 AliHLTModuleAgent::AliHLTOUTHandlerDesc& handlerDesc,
245 AliHLTModuleAgent* pAgent,
246 AliHLTUInt32_t index);
248 /** copy constructor for vector handling */
249 AliHLTOUTHandlerListEntry(const AliHLTOUTHandlerListEntry& src);
251 /** assignment operator for vector handling */
252 AliHLTOUTHandlerListEntry& operator=(const AliHLTOUTHandlerListEntry& src);
254 ~AliHLTOUTHandlerListEntry();
256 static const AliHLTOUTHandlerListEntry fgkVoidHandlerListEntry; //! initializer
258 operator AliHLTOUTHandler*() const {return fpHandler;}
260 // please note that fpHandlerDesc is really a pointer and is created
261 // in the constructor. Thats why it is dereferenced here. The pointer
262 // type is on purpose, even though it is a bit confusing with the
263 // argument by reference in the AliHLTOUTHandlerListEntry constructor.
264 operator const AliHLTModuleAgent::AliHLTOUTHandlerDesc&() const
265 {return fpHandlerDesc?*fpHandlerDesc:AliHLTModuleAgent::fgkVoidHandlerDesc;}
266 operator AliHLTModuleAgent*() const {return fpAgent;}
269 * Two list entries are considered to be equal if the handlers
272 bool operator==(const AliHLTOUTHandlerListEntry& entry) const;
274 bool operator==(const AliHLTModuleAgent::AliHLTOUTHandlerType handlerType) const;
277 * Compare the handler descriptor of this list entry with another
279 * @return true if both handler and agent match
281 bool operator==(const AliHLTModuleAgent::AliHLTOUTHandlerDesc desc) const;
283 AliHLTUInt32_t operator[](int i) const;
286 * Add a block index to this descriptor.
287 * One descriptor can serve multiple blocks if the agent returns the
288 * same handler for all of the blocks. Instead of creating a new entry
289 * the block index ist just added
291 void AddIndex(AliHLTUInt32_t index);
294 * Add all indices of the descriptor.
296 void AddIndex(AliHLTOUTHandlerListEntry &desc);
299 * Check if an index is served by this descriptor.
300 * @return true if the index is in the table
302 bool HasIndex(AliHLTUInt32_t index) const;
305 * Invalidate all block indices
307 void InvalidateBlocks() {fBlocks.clear();}
310 * Check whether the entry has valid blocks.
312 bool IsEmpty() {return fBlocks.size()==0;}
315 void Print(const char* option="") const;
318 /** standard constructor prohibited */
319 AliHLTOUTHandlerListEntry();
321 /** pointer to the handler */
322 AliHLTOUTHandler* fpHandler; //! transient
324 /** pointer to handler description */
325 AliHLTModuleAgent::AliHLTOUTHandlerDesc* fpHandlerDesc; //! transient
327 /** pointer to module agent */
328 AliHLTModuleAgent* fpAgent; //! transient
330 /** list of block indices */
331 AliHLTOUTIndexList fBlocks; //!transient
334 typedef vector<AliHLTOUTHandlerListEntry> AliHLTOUTHandlerListEntryVector;
335 typedef vector<AliHLTOUTBlockDescriptor> AliHLTOUTBlockDescriptorVector;
336 typedef vector<AliHLTOUT*> AliHLTOUTPVector;
339 * Selection guard for the AliHLTOUT object.
340 * If the object is locked, the selection of data blocks can not be changed.
342 class AliHLTOUTSelectionGuard {
345 AliHLTOUTSelectionGuard(AliHLTOUT* pInstance) : fpInstance(pInstance)
346 {if (fpInstance) fpInstance->SelectDataBlock();}
348 AliHLTOUTSelectionGuard(AliHLTOUT* pInstance, const AliHLTOUTHandlerListEntry* pHandlerDesc) : fpInstance(pInstance)
349 {if (fpInstance) fpInstance->SelectDataBlocks(pHandlerDesc);}
351 ~AliHLTOUTSelectionGuard()
352 {if (fpInstance) fpInstance->DisableBlockSelection();}
355 /** standard constructor prohibited */
356 AliHLTOUTSelectionGuard();
357 /** copy constructor prohibited */
358 AliHLTOUTSelectionGuard(const AliHLTOUTSelectionGuard&);
359 /** assignment operator prohibited */
360 AliHLTOUTSelectionGuard& operator=(const AliHLTOUTSelectionGuard&);
362 /** the AliHLTOUT instance the guard is locking */
363 AliHLTOUT* fpInstance; //!transient
367 * Init for processing.
368 * The HLTOUT is scanned for all available data blocks and the
369 * AliHLTOUTHandler objects for the data blocks are created according
370 * to the module agents (see AliHLTModuleAgent).
375 * Reset and clear all data block descriptors.
376 * @note Since sub-collections are only referred via the block
377 * descriptors, all information on sub-collections is also lost.
378 * Child classes should implement ResetInput in order to cleanup
384 * Get the current event id
386 AliHLTUInt64_t EventId() {return fCurrentEventId;}
389 * Get number of data blocks in the HLTOUT data
391 int GetNofDataBlocks();
394 * Select the first data block of a certain data type and specification.
395 * The selection criteria can be of kAliHLTAnyDataType and/or
396 * kAliHLTVoidDataSpec in order to be ignored and just match any data block.
398 * The search criteria can be combined with a handler type (e.g. kRawReader)
399 * @param [in] dt data type to match <br>
400 * @param [in] spec data specification to match <br>
401 * @param [in] handlerType type of the handler
402 * @param [in] skipProcessed skip all block marked processed
403 * @return block index: >= 0 if success, -ENOENT if no block found <br>
404 * neg. error code if failed <br>
405 * -EPERM if access denied (object locked)
407 int SelectFirstDataBlock(AliHLTComponentDataType dt=kAliHLTAnyDataType,
408 AliHLTUInt32_t spec=kAliHLTVoidDataSpec,
409 AliHLTModuleAgent::AliHLTOUTHandlerType handlerType=AliHLTModuleAgent::kUnknownOutput,
410 bool skipProcessed=true);
413 * Select the next data block of data type and specification of the previous
414 * call to @ref SelectFirstDataBlock.
415 * @return block index: >= 0 if success, -ENOENT if no block found <br>
416 * neg. error code if failed <br>
417 * -EPERM if access denied (object locked)
419 int SelectNextDataBlock();
422 * Get properties of the selected data block.
423 * @param [out] dt data type of the selected block
424 * @param [out] spec data specification of the selected block
426 int GetDataBlockDescription(AliHLTComponentDataType& dt, AliHLTUInt32_t& spec);
429 * Get handler description of the current data block.
431 const AliHLTOUTHandlerListEntry& GetDataBlockHandlerDesc();
434 * Get handler type of the selected data block.
435 * @return handler type for the selected data block
437 AliHLTModuleAgent::AliHLTOUTHandlerType GetDataBlockHandlerType();
440 * Get the index of the current data block.
441 * @return index, AliHLTOUTInvalidIndex if no block selected
443 AliHLTUInt32_t GetDataBlockIndex();
446 * Get buffer of the selected data block.
447 * @param [out] pBuffer buffer of the selected data block
448 * @param [out] size size of the selected data block
450 int GetDataBuffer(const AliHLTUInt8_t* &pBuffer, AliHLTUInt32_t& size);
453 * Release buffer after use.
454 * @param [in] pBuffer buffer of the selected data block
456 int ReleaseDataBuffer(const AliHLTUInt8_t* pBuffer);
459 * Get a TObject from the data buffer
460 * @return TObject pointer if data block is a streamed object
462 TObject* GetDataObject();
465 * Release data object
467 int ReleaseDataObject(TObject* pObject);
470 * Add the current data block to the selection.
471 * Note: enables also the block selection
473 int SelectDataBlock();
476 * Add the all data blocks of a certain handler to the selection.
477 * Note: enables also the block selection
479 int SelectDataBlocks(const AliHLTOUTHandlerListEntry* pHandlerDesc);
482 * Enable the selection of data blocks.
484 int EnableBlockSelection();
487 * Disable the selection of data blocks.
489 int DisableBlockSelection();
492 * Reset the data block selection.
493 * Resets the selection list, none of the blocks is selected.
495 int ResetBlockSelection();
498 * Mark the current block as processed.
500 int MarkDataBlockProcessed();
503 * Mark all data blocks of a certain handler processed.
505 int MarkDataBlocksProcessed(const AliHLTOUTHandlerListEntry* pHandlerDesc);
508 * Add a sub collection to the HLTOUT.
510 int AddSubCollection(AliHLTOUT* pCollection);
513 * Release a previously added sub collection.
515 int ReleaseSubCollection(AliHLTOUT* pCollection);
518 * Get module agent for the selected data block.
520 AliHLTModuleAgent* GetAgent();
523 * Get handler for the selected data block.
525 AliHLTOUTHandler* GetHandler();
528 * Convert data buffer to ESD.
529 * The buffer is supposed to describe a streamed AliESDEvent object.
530 * If no target object is specified, the ESD is written to a file AliHLTdetESDs.root,
531 * where 'det' is derived from the data type origin. Each time the function is invoked
532 * a new event is created. Dummy events are added if the previous events did not contain
534 * The function needs AliRoot and might not be implemented by all AliHLTOUT
536 * a data block of this specification.
537 * @param [in] pBuffer the data buffer
538 * @param [in] size data buffer size
539 * @param [in] dt data type of the block
540 * @param [out] tgtesd optional target
542 virtual int WriteESD(const AliHLTUInt8_t* pBuffer, AliHLTUInt32_t size, AliHLTComponentDataType dt, AliESDEvent* tgtesd=NULL) const;
544 enum AliHLTOUTByteOrder {
545 /** no data block selected */
546 kInvalidByteOrder=-1,
552 enum AliHLTOUTDataType {
562 * Check byte order of selected block
564 AliHLTOUTByteOrder CheckByteOrder();
567 * Check alignment of selected block
569 int CheckAlignment(AliHLTOUT::AliHLTOUTDataType type);
572 * Helper function to byte swap a 64 bit value.
574 static AliHLTUInt64_t ByteSwap64(AliHLTUInt64_t src);
577 * Helper function to byte swap a 32 bit value.
579 static AliHLTUInt32_t ByteSwap32(AliHLTUInt32_t src);
582 * Insert a handler item.
583 * The current list entries are checked if the handler is already in
584 * the list. It is added if not in the list, otherwise the block index
585 * is added to the existing entry.
586 * @param list the handler list
587 * @param entry handler list entry
588 * @return 0 if added, EEXIST (non negative!) if merged with existing entry <br>
589 * neg. error code if failed
591 static int InsertHandler(AliHLTOUTHandlerListEntryVector& list, const AliHLTOUTHandlerListEntry &entry);
594 * Insert all handlers of the specified type to the list.
596 int FillHandlerList(AliHLTOUTHandlerListEntryVector& list, AliHLTModuleAgent::AliHLTOUTHandlerType handlerType);
599 * Remove empty items which have a duplicate in the list.
601 static int RemoveEmptyDuplicateHandlers(AliHLTOUTHandlerListEntryVector& list);
604 * Find an entry of a certain description in the list.
605 * @return index of the entry if found, -ENOENT if not found
607 static int FindHandler(AliHLTOUTHandlerListEntryVector& list, const AliHLTModuleAgent::AliHLTOUTHandlerDesc desc);
610 * Invalidate all blocks of the handlers in the list
612 static int InvalidateBlocks(AliHLTOUTHandlerListEntryVector& list);
616 * Add a block descriptor.
617 * This is done by the child classes generating the index. The AliHLTOUT
618 * object must be locked for index generation.
619 * @param desc the block descriptor
620 * @return 0 if success, -EPERM if access denied
622 int AddBlockDescriptor(const AliHLTOUTBlockDescriptor desc);
625 * Set the event id, only for child classes
627 void SetEventId(AliHLTUInt64_t id);
630 * Print output or suppress.
632 bool BeVerbose() {return fbVerbose;}
637 void SwitchVerbosity(bool verbose) {fbVerbose=verbose;}
640 void Print(const char* option="") const;
643 /** copy constructor prohibited */
644 AliHLTOUT(const AliHLTOUT&);
645 /** assignment operator prohibited */
646 AliHLTOUT& operator=(const AliHLTOUT&);
649 * Internal status flags
652 /** the HLTOUT object is locked with the current data block selection */
654 /** childs can add block descriptors */
656 /** user of the data block has checked the byte order */
657 kByteOrderChecked = 0x4,
658 /** warning on byte order missmatch has been printed */
659 kByteOrderWarning = 0x8,
660 /** user of the data block has checked the alignment */
661 kAlignmentChecked = 0x10,
662 /** warning on alignment missmatch has been printed */
663 kAlignmentWarning = 0x20,
664 /** enable block selection list */
665 kBlockSelection = 0x40,
666 /** skip processed data blocks */
667 kSkipProcessed = 0x80,
668 /** marked as sub collection */
669 kIsSubCollection = 0x100
673 * Generate the index of the HLTOUT data.
674 * Must be implemented by the child classes.
676 virtual int GenerateIndex()=0;
679 * Find AliHLTOUTHandler objects for the data blocks.
680 * The available AliHLTModuleAgents are probed whether they provide
681 * handlers for data processing.
686 * Cleanup and reset the data input.
688 virtual int ResetInput();
691 * Get the data buffer
692 * @param [in] index index of the block
693 * @param [out] pBuffer buffer of the selected data block
694 * @param [out] size size of the selected data block
696 virtual int GetDataBuffer(AliHLTUInt32_t index, const AliHLTUInt8_t* &pBuffer,
697 AliHLTUInt32_t& size)=0;
700 * Check byte order of data block
702 virtual AliHLTOUTByteOrder CheckBlockByteOrder(AliHLTUInt32_t index)=0;
705 * Check alignment of data block
707 virtual int CheckBlockAlignment(AliHLTUInt32_t index, AliHLTOUT::AliHLTOUTDataType type)=0;
710 * Select the data block of data type and specification of the previous
711 * call to @ref SelectFirstDataBlock. Core function of @ref SelectFirstDataBlock
712 * and @ref SelectNextDataBlock, starts to find a block at the current list
715 * The data block is searched from the conditions of fSearchDataType,
716 * fSearchSpecification, fSearchHandlerType and the selection list.
718 * @return identifier >=0 if success, neg. error code if failed <br>
719 * -ENOENT if no block found <br>
720 * -EPERM if access denied (object locked)
722 int FindAndSelectDataBlock();
726 * @param flag flag to set
727 * @return current status flags
729 unsigned int SetStatusFlag(unsigned int flag) {return fFlags|=flag;}
733 * @param flag flag to clear
734 * @return current status flags
736 unsigned int ClearStatusFlag(unsigned int flag) {return fFlags&=~flag;}
740 * @param flag flag to check
741 * @return 1 if flag is set
743 int CheckStatusFlag(unsigned int flag) const {return (fFlags&flag)==flag;}
746 * Find handler description for a certain block index.
748 const AliHLTOUTHandlerListEntry& FindHandlerDesc(AliHLTUInt32_t blockIndex);
751 * Set the RawReader as parameter.
752 * The function is for internal use only in conjunction with the
755 virtual void SetParam(AliRawReader* pRawReader);
758 * Set the RunLoader as parameter
759 * The function is for internal use only in conjunction with the
762 virtual void SetParam(TTree* pDigitTree, int event=-1);
765 * Set name of the digit file as parameter
766 * The function is for internal use only in conjunction with the
769 virtual void SetParam(const char* filename, int event=-1);
771 /** data type for the current block search, set from @ref SelectFirstDataBlock */
772 AliHLTComponentDataType fSearchDataType; //!transient
774 /** data specification for the current block search */
775 AliHLTUInt32_t fSearchSpecification; //!transient
777 /** handler type for the current block search */
778 AliHLTModuleAgent::AliHLTOUTHandlerType fSearchHandlerType; // !transient
780 /** instance flags: locked, collecting, ... */
781 unsigned int fFlags; //!transient
783 /** list of block descriptors */
784 AliHLTOUTBlockDescriptorVector fBlockDescList; //!transient
786 /** current position in the list */
787 unsigned int fCurrent; //!transient
789 /** data buffer under processing */
790 const AliHLTUInt8_t* fpBuffer; //!transient
792 /** list of AliHLTOUTHandlers */
793 AliHLTOUTHandlerListEntryVector fDataHandlers; // !transient
795 /** verbose or silent output */
796 bool fbVerbose; //!transient
798 /** gobal instance set for certain steps of the analysis */
799 static AliHLTOUT* fgGlobalInstance; //! transient
801 /** logging methods */
802 AliHLTLogging fLog; //! transient
804 /** current buffer converted to a TObject */
805 TObject* fpDataObject; //!
806 const AliHLTUInt8_t* fpObjectBuffer; //!
807 AliHLTUInt32_t fObjectBufferSize; //!
809 /** current event id */
810 AliHLTUInt64_t fCurrentEventId; //!
812 ClassDef(AliHLTOUT, 6)