Adding base class of HLTOUT handler for TObjects to be merged into hltEsd.
[u/mrichter/AliRoot.git] / HLT / BASE / AliHLTOUTHandlerEsdBranch.h
1 //-*- Mode: C++ -*-
2 // $Id$
3
4 #ifndef ALIHLTOUTHANDLERESDBRANCH_H
5 #define ALIHLTOUTHANDLERESDBRANCH_H
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                               *
9
10 /// @file   AliHLTOUTHandlerEsdBranch.h
11 /// @author Matthias Richter
12 /// @date   01.07.2010
13 /// @brief  HLTOUT handler of type kEsd to merge objects into the hltEsd.
14
15 #include "AliHLTOUTHandler.h"
16 #include "TString.h"
17
18 class TArrayC;
19 class AliESDEvent;
20
21 /**
22  * @class AliHLTOUTHandlerEsdBranch
23  * An HLTOUT handler of type kEsd to add objects to hltEsd branches.
24  *
25  * The handler extracts objects from HLTOUT data blocks or converts
26  * data to objects to be added to hltEsd branches. The default implementation
27  * covers the first case right away, the class can be used directly for single
28  * objects streamed to the HLTOUT.
29  *
30  * <h2>Object conversion</h2>
31  * The method ExtractAndAddObjects() has to loop over all input blocks and
32  * provide an appropriate conversion. If the data block simply contains a
33  * streamed object it just needs to be extracted and added to the ESD using
34  * the function Add(). Thhis case is covered by the default implementation.
35  * Child classes can overload ExtractAndAddObjects() if there is further
36  * conversion/formatting required.
37  *
38  * <h2>Usage example:</h2>
39  * An agent implementation must announce to ability to process a certain
40  * data block by implementing AliHLTModuleAgent::GetHandlerDescription()
41  * and AliHLTModuleAgent::GetOutputHandler(). See AliHLTModuleAgent for
42  * more details.
43  * <pre>
44  *  int AliHLTMyAgent::GetHandlerDescription(AliHLTComponentDataType dt,
45  *                                           AliHLTUInt32_t spec,
46  *                                           AliHLTOUTHandlerDesc& desc) const
47  *  {
48  *    // add TObject data blocks of type {ROOTTOBJ:SMPL} to ESD
49  *    if (dt==(kAliHLTDataTypeTObject|kAliHLTDataOriginSample)) {
50  *        desc=AliHLTOUTHandlerDesc(kEsd, dt, GetModuleId());
51  *        return 1;
52  *    }
53  *  
54  *    return 0;
55  *  }
56  *
57  *  AliHLTOUTHandler* AliHLTMyAgent::GetOutputHandler(AliHLTComponentDataType dt,
58  *                                                    AliHLTUInt32_t spec)
59  *  {
60  *   // merge my objects into the hltEsd
61  *   if (dt==(kAliHLTDataTypeTObject|kAliHLTDataOriginSample)) {
62  *     static AliHLTOUTHandlerEsdBranch handler;
63  *     return &handler;
64  *   }
65  *
66  *   return NULL;
67  *  }
68  * </pre>
69  *
70  * <h2>Data output</h2>
71  * The handler produces a partial ESD containing the data objects. The framework
72  * merges all the different partial ESDs in the AliHLTEsdManager, respectively the
73  * specific implementation AliHLTEsdManagerImplementation.
74  *
75  * HLTOUT processing sequence:
76  * - first handlers of type kChain
77  * - handlers of type kEsd
78  * - handlers of type kProprietary
79  *
80  * @ingroup alihlt_aliroot_reconstruction
81  */
82 class AliHLTOUTHandlerEsdBranch : public AliHLTOUTHandler {
83  public:
84   /** constructor */
85   AliHLTOUTHandlerEsdBranch(const char* branchname=NULL);
86   /** standard destructor */
87   virtual ~AliHLTOUTHandlerEsdBranch();
88
89   /**
90    * Process a data block.
91    * @return 
92    */
93   int ProcessData(AliHLTOUT* pData);
94
95   int GetProcessedData(const AliHLTUInt8_t* &pData);
96   int ReleaseProcessedData(const AliHLTUInt8_t* pData, int size);
97
98  protected:
99   /**
100    * Extract and add objects
101    * Loop over input blocks and extract/format the objects. Child class
102    * can implement specific conversion. The default implementation just
103    * extracts and adds objects.
104    */
105   virtual int ExtractAndAddObjects(AliHLTOUT* pData);
106
107   /**
108    * Add object to internal ESD.
109    * If there is an object with 'branchname' the object is copied, otherwise
110    * added.
111    */
112   virtual int Add(TObject* object, const char* branchname);
113
114  private:
115   /** copy constructor prohibited */
116   AliHLTOUTHandlerEsdBranch(const AliHLTOUTHandlerEsdBranch&);
117   /** assignment operator prohibited */
118   AliHLTOUTHandlerEsdBranch& operator=(const AliHLTOUTHandlerEsdBranch&);
119
120   TString fBranch; //! transient
121   AliESDEvent* fESD; //! transient
122   TArrayC* fpData;  //! transient
123   int fSize; //! transient
124
125   ClassDef(AliHLTOUTHandlerEsdBranch, 1)
126 };
127 #endif