HLTcalo module

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

diff --git a/HLT/BASE/AliHLTOfflineInterface.h b/HLT/BASE/AliHLTOfflineInterface.h
index cac9ba89ff0c17a612491afc4595150660c1d6c2..21e9aed8369f1ca0847e2475b8a31dbe9ef6bfa9 100644 (file)
--- a/HLT/BASE/AliHLTOfflineInterface.h
+++ b/HLT/BASE/AliHLTOfflineInterface.h
@@ -3,21 +3,22 @@
 
 #ifndef ALIHLTOFFLINEINTERFACE_H
 #define ALIHLTOFFLINEINTERFACE_H
-/* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
- * See cxx source for full Copyright notice                               */
+//* This file is property of and copyright by the                          * 
+//* ALICE Experiment at CERN, All rights reserved.                         *
+//* See cxx source for full Copyright notice                               *
 
-/** @file   AliHLTOfflineInterface.h
-    @author Matthias Richter
-    @date   
-    @brief  the HLT interface to AliRoot
-*/
+/// @file   AliHLTOfflineInterface.h
+/// @author Matthias Richter
+/// @date   
+/// @brief  the HLT interface to AliRoot
+///
 
 #include <TObject.h>
 #include <TList.h>
 
 class AliRunLoader;
 class AliRawReader;
-class AliESD;
+class AliESDEvent;
 class TTree;
 
 /******************************************************************************/
@@ -27,9 +28,9 @@ class TTree;
  * The class implements the basic interface to the AliRoot objects during
  * reconstructions.
  * It serves as a base class for offline source and sink interface components
- * and provides access methods for the AliRunLoader, AliRawReader and AliESD
+ * and provides access methods for the AliRunLoader, AliRawReader and AliESDEvent
  * objects. The AliRunLoader and the AliRawReader are fixed during one run,
- * while the AliESD object will be changed from event to event.<br>
+ * while the AliESDEvent object will be changed from event to event.<br>
  * \em Note: The digits and clusters trees are not available through this
  * interface class as they are completetly detector (AliLoader) dependend.
  *
@@ -46,32 +47,28 @@ class AliHLTOfflineInterface : public TObject {
    *  @param pRawReader   pointer to AliRoot raw reader
    */
   AliHLTOfflineInterface(AliRunLoader* pRunLoader, AliRawReader* pRawReader);
-  /** not a valid copy constructor, defined according to effective C++ style */
-  AliHLTOfflineInterface(const AliHLTOfflineInterface&);
-  /** not a valid assignment op, but defined according to effective C++ style */
-  AliHLTOfflineInterface& operator=(const AliHLTOfflineInterface&);
   /** destructor */
   virtual ~AliHLTOfflineInterface();
 
   /**
    * Get the AliRoot run loader.
    */
-  const AliRunLoader* GetRunLoader() const;
+  AliRunLoader* GetRunLoader() const;
 
   /**
    * Get the AliRoot raw reader
    */
-  const AliRawReader* GetRawReader() const;
+  AliRawReader* GetRawReader() const;
 
   /**
    * Set AliRoot ESD for the current event.
    */
-  int SetESD(Int_t eventNo, AliESD* pESD);
+  int SetESD(Int_t eventNo, AliESDEvent* pESD);
 
   /**
    * Get the AliRoot ESD
    */
-  AliESD* GetESD() const;
+  AliESDEvent* GetESD() const;
 
   /**
    * Set AliRoot external params.
@@ -100,22 +97,26 @@ class AliHLTOfflineInterface : public TObject {
    * Fill ESD for one event.
    * Fill the ESD with the previously reconstructed data. It must be implmented
    * by the child class.
+   * @param eventNo       event No. \em Note: this is an internal enumeration of the
+   *                      processed events.
    * @param runLoader     the AliRoot runloader
-   * @param esd           an AliESD instance
+   * @param esd           an AliESDEvent instance
    * @return neg. error code if failed 
    */
-  virtual int FillESD(AliRunLoader* runLoader, AliESD* esd)=0;
+  virtual int FillESD(int eventNo, AliRunLoader* runLoader, AliESDEvent* esd)=0;
 
   /**
    * Fill ESD for one event.
    * The FillESD method of all active AliHLTOfflineDataSink's is called in
    * order to fill the ESD with the previously reconstructed data. This method
    * works on the global list.
+   * @param eventNo       event No. \em Note: this is an internal enumeration of the
+   *                      processed events.
    * @param runLoader     the AliRoot runloader
-   * @param esd           an AliESD instance
+   * @param esd           an AliESDEvent instance
    * @return neg. error code if failed 
    */
-  static int FillComponentESDs(AliRunLoader* runLoader, AliESD* esd);
+  static int FillComponentESDs(int eventNo, AliRunLoader* runLoader, AliESDEvent* esd);
 
   /**
    * Reset AliRoot internal params of all active components.
@@ -139,20 +140,36 @@ protected:
   static int Unregister(AliHLTOfflineInterface* me);
 
  private:
-  /** the list of active interfaces */
-  static TList fgList;                                            // see above
+  /** copy constructor prohibited */
+  AliHLTOfflineInterface(const AliHLTOfflineInterface&);
+  /** assignment operator prohibited */
+  AliHLTOfflineInterface& operator=(const AliHLTOfflineInterface&);
 
-  /** the current object link (list position) */
-  static TObjLink* fgCurrentLnk;                                  // see above
+  /** global AliRoot run loader instance (for all components) */
+  static AliRunLoader* fgpRunLoader;                              //! transient
+  /** global AliRoot raw reader instance (for all components) */
+  static AliRawReader* fgpRawReader;                              //! transient
 
-  /** AliRoot run loader instance */
+  /** private AliRoot run loader instance */
   AliRunLoader* fpRunLoader;                                      //! transient
-  /** AliRoot raw reader instance */
+  /** private AliRoot raw reader instance */
   AliRawReader* fpRawReader;                                      //! transient
   /** AliRoot HLT ESD instance */
-  AliESD* fpESD;                                                  //! transient
+  AliESDEvent* fpESD;                                                  //! transient
+
+  /** the list of active interfaces */
+  static AliHLTOfflineInterface* fgAnchor;                        //! transient
+
+  /** next element in the list */
+  AliHLTOfflineInterface* fpNext;                                 //! transient
+
+  /** the current element */
+  static AliHLTOfflineInterface* fgCurrent;                       //! transient
+
+  /** number of interfaces */
+  static int fgCount;                                             //! see above
 
-  ClassDef(AliHLTOfflineInterface, 1);
+  ClassDef(AliHLTOfflineInterface, 0);
 };
 
 #endif