Major update required to handle old and new AliHLTEventDDL structures within HLT...

[u/mrichter/AliRoot.git] / HLT / BASE / AliHLTProcessor.h

diff --git a/HLT/BASE/AliHLTProcessor.h b/HLT/BASE/AliHLTProcessor.h
index a44ba3c877a086ca64dd7011c2258c33658c856b..3b6b23c9e7c3254c081668f642abe1f08ddb9ebc 100644 (file)
--- a/HLT/BASE/AliHLTProcessor.h
+++ b/HLT/BASE/AliHLTProcessor.h
@@ -1,45 +1,119 @@
+//-*- Mode: C++ -*-
 // @(#) $Id$
 
 #ifndef ALIHLTPROCESSOR_H
 #define ALIHLTPROCESSOR_H
-/* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
+/* 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                               */
 
-/* AliHLTProcessor
-   base class for HLT processing components
- */
+/** @file   AliHLTProcessor.h
+    @author Matthias Richter, Timm Steinbeck
+    @date   
+    @brief  Base class declaration for HLT analysis components. */
+
+// see below for class documentation
+// or
+// refer to README to build package
+// or
+// visit http://web.ift.uib.no/~kjeks/doc/alice-hlt   
 
 #include "AliHLTComponent.h"
 
+/**
+ * @class AliHLTProcessor
+ * Base class of HLT data analysis components.
+ * The class provides a common interface for the implementation of HLT data
+ * analysis components. The child class must implement the functions:
+ * - @ref DoInit (optional)
+ * - @ref DoDeinit (optional)
+ * - @ref DoEvent
+ * - @ref GetComponentID
+ * - @ref GetInputDataTypes
+ * - @ref GetOutputDataType
+ * - @ref GetOutputDataSize
+ * - @ref Spawn
+ *
+ * @ingroup alihlt_component
+ */
 class AliHLTProcessor : public AliHLTComponent {
  public:
+  /** standard constructor */
   AliHLTProcessor();
+  /** standard destructor */
   virtual ~AliHLTProcessor();
 
-  int Init( AliHLTComponentEnvironment* environ, void* environ_param, int argc, const char** argv );
-  int Deinit();
-  int ProcessEvent( AliHLTComponent_EventData evtData, AliHLTComponent_BlockData* blocks, 
-                   AliHLTComponent_TriggerData trigData, AliHLTUInt8_t* outputPtr, 
-                   AliHLTUInt32_t* size, AliHLTUInt32_t* outputBlockCnt, 
-                   AliHLTComponent_BlockData** outputBlocks,
-                   AliHLTComponent_EventDoneData** edd );
+  /**
+   * Event processing function.
+   * The method is called by the framework to process one event. After 
+   * preparation of data structures. The call is redirected to DoEvent.
+   * @return neg. error code if failed 
+   */
+  int DoProcessing( const AliHLTComponentEventData& evtData,
+                   const AliHLTComponentBlockData* blocks, 
+                   AliHLTComponentTriggerData& trigData,
+                   AliHLTUInt8_t* outputPtr, 
+                   AliHLTUInt32_t& size,
+                   AliHLTComponentBlockDataList& outputBlocks,
+                   AliHLTComponentEventDoneData*& edd );
 
   // Information member functions for registration.
+
+  /**
+   * Return @ref AliHLTComponent::kProcessor type as component type.
+   * @return component type id
+   */
   TComponentType GetComponentType() { return AliHLTComponent::kProcessor;}
 
- private:
-  virtual int DoInit( int argc, const char** argv ){
-    return 0;
-  }
+ protected:
+  /**
+   * The low-level data processing method for the component.
+   * This is the custom processing method and can be overloaded by 
+   * the component.
+   * @param evtData       event data structure
+   * @param blocks        input data block descriptors
+   * @param trigData     trigger data structure
+   * @param outputPtr    pointer to target buffer
+   * @param size         <i>input</i>: size of target buffer
+   *                     <i>output</i>:size of produced data
+   * @param outputBlocks  list to receive output block descriptors
+   * @return neg. error code if failed                                <br>
+   *         -ENOSPC      output buffer too small
+   */
+  virtual int DoEvent( const AliHLTComponentEventData& evtData,
+                      const AliHLTComponentBlockData* blocks, 
+                      AliHLTComponentTriggerData& trigData,
+                      AliHLTUInt8_t* outputPtr, 
+                      AliHLTUInt32_t& size,
+                      AliHLTComponentBlockDataList& outputBlocks );
+
+  /**
+   * The high-level data processing method.
+   * This is the default processing method; the method is called
+   * if no low level @ref DoEvent method is overloaded by the component.
+   * @param evtData       event data structure
+   * @param trigData     trigger data structure
+   * @return neg. error code if failed
+   */
+  virtual int DoEvent( const AliHLTComponentEventData& evtData, AliHLTComponentTriggerData& trigData);
+
+  // collection of debug counters
+  struct AliHLTProcessorCounters {
+    AliHLTProcessorCounters() : fReadoutFilter(0), fMonitoringFilter(0), fMonitoringEvent(0), fMismatch(0) {}
+    int fReadoutFilter;    // counter for the EDD readout filter
+    int fMonitoringFilter; // counter for the EDD monitoring filter
+    int fMonitoringEvent;  // counter for the EDD monitoring event
+    int fMismatch;         // counter for EDD format mismatch
+  };
 
-  virtual int DoDeinit(){
-    return 0;
-  }
-  virtual int DoEvent( AliHLTComponent_EventData evtData, AliHLTComponent_BlockData* blocks, 
-                      AliHLTComponent_TriggerData trigData, AliHLTUInt8_t* outputPtr, 
-                      AliHLTUInt32_t* size, vector<AliHLTComponent_BlockData>& outputBlocks ) = 0;
+private:
+  /// copy contructor prohibited
+  AliHLTProcessor(const AliHLTProcessor&);
+  /// assignment operator prohibited
+  AliHLTProcessor& operator=(const AliHLTProcessor&);
 
+  AliHLTProcessorCounters* fpDebugCounters; // optional debugging counters
 
-  ClassDef(AliHLTProcessor, 0)
+  ClassDef(AliHLTProcessor, 2)
 };
 #endif