14a58a17dba4f6b61e0a2b6491b1e5763ce52b9b
[u/mrichter/AliRoot.git] / HLT / BASE / util / AliHLTFileWriter.h
1 // @(#) $Id$
2
3 #ifndef ALIHLTFILEWRITER_H
4 #define ALIHLTFILEWRITER_H
5 /* This file is property of and copyright by the ALICE HLT Project        * 
6  * ALICE Experiment at CERN, All rights reserved.                         *
7  * See cxx source for full Copyright notice                               */
8
9 /** @file   AliHLTFileWriter.h
10     @author Matthias Richter
11     @date   
12     @brief  An HLT file dump (data sink) component.
13 */
14
15 #include "AliHLTDataSink.h"
16 #include <TString.h>
17 //#include <TList.h>
18
19 /**
20  * @class AliHLTFileWriter
21  * An HLT data sink component which writes data to file(s).
22  *
23  * Component ID: \b FileWriter <br>
24  * Library: \b libAliHLTUtil.
25  *
26  * Mandatory arguments: <br>
27  * <!-- NOTE: ignore the \li. <i> and </i>: it's just doxygen formating -->
28  *
29  * Optional arguments: <br>
30  * <!-- NOTE: ignore the \li. <i> and </i>: it's just doxygen formating -->
31  * \li -datafile     <i> filename   </i> <br>
32  *      file name base
33  * \li -directory    <i> directory  </i> <br>
34  *      target directory
35  * \li -subdir[=pattern] <br>
36  *      create sub dir for each event, the format patern can contain printf
37  *      specifiers to print the evntn no into the dir name, default is
38  *      'event%03d' (-subdir w/o additional pattern)
39  * \li -idfmt[=pattern] <br>
40  *      format specifier for the event id in the file name,                <br>
41  *      default: on, default pattern: '_0x%08x'
42  * \li -specfmt[=pattern] <br>
43  *      format specifier for the data specification in the file name       <br>
44  *      default: off, default pattern: '_0x%08x'
45  * \li -blocknofmt[=pattern] <br>
46  *      format specifier for the block no in the file name                 <br>
47  *      default: on, default pattern: '_0x%02x'
48  * \li -enumerate <br>
49  *      don't use the event number but an event counter beginning from 0
50  * \li -concatenate-blocks <br>
51  *      concatenate all blocks of one event into one file, this skips
52  *      the block no, and the block data type in the file name
53  * \li -concatenate-events <br>
54  *      concatenate all events into one file, this skips the event no,
55  *      the block no, and the block data type in the file name. Currently,
56  *      this implies the -concatenate-blocks option.
57  *
58  * By default, file name is built from the basename, the event number, the
59  * block number and the data type in the format:
60  * <pre>
61  * basename_eventno_dt
62  * </pre>
63  * If the basename was not given, \em 'event' ist used instead. A file
64  * extension after the last dot is separated from the basename and appended
65  * to the final name.
66  *
67  * The naming rule can be changed by the -xxfmt options, which can contain
68  * printf format specifiers in order to print the corresponding variable. E.g.
69  * <pre>
70  * -specfmt             append specification
71  * -subdir=test_%d      store in sub folders
72  * -blcknofmt=_0x%x     format block no in hex
73  * -idfmt=_%04d         print id in 4-digits decimal number
74  * </pre>
75  *
76  * The class can be used as a base class for file writers. Additional
77  * argument scan can be implemented in @ref ScanArgument which is called
78  * for each unknown argument.
79  * @ingroup alihlt_component
80  */
81 class AliHLTFileWriter : public AliHLTDataSink  {
82  public:
83   /** standard constructor */
84   AliHLTFileWriter();
85   /** destructor */
86   virtual ~AliHLTFileWriter();
87
88   virtual const char* GetComponentID();
89   virtual void GetInputDataTypes( vector<AliHLTComponentDataType>& list);
90   virtual AliHLTComponent* Spawn();
91
92  protected:
93   /**
94    * Init method.
95    */
96   int DoInit( int argc, const char** argv );
97
98   /**
99    * Deinit method.
100    */
101   int DoDeinit();
102
103   /**
104    * Init the writer.
105    * The DoInit function is not available for child classes. InitWriter is the
106    * corresponding function for classes derived from AliHLTFileWriter.
107    */
108   virtual int InitWriter();
109
110   /**
111    * Close the writer.
112    * The DoDeinit function is not available for child classes. CloseWriter is the
113    * corresponding function for classes derived from AliHLTFileWriter.
114    */
115   virtual int CloseWriter();
116
117   /**
118    * Data processing method for the component.
119    * The function can be overloaded by other file writer components.
120    * @param evtData       event data structure
121    * @param blocks        input data block descriptors
122    * @param trigData      trigger data structure
123    */
124   virtual int DumpEvent( const AliHLTComponentEventData& evtData,
125                          const AliHLTComponentBlockData* blocks, 
126                          AliHLTComponentTriggerData& trigData );
127
128   using AliHLTDataSink::DumpEvent;
129
130   /**
131    * Scan one argument and adjacent parameters.
132    * Can be overloaded by child classes in order to add additional arguments
133    * beyond the standard arguments of the file publisher. The method is called
134    * whenever a non-standard argument is recognized. Make sure to return 
135    * <tt> -EPROTO </tt> if the argument is not recognized be the child.
136    * @param argc           size of the argument array
137    * @param argv           agument array for component initialization
138    * @return number of processed members of the argv <br>
139    *         -EINVAL unknown argument <br>
140    *         -EPROTO parameter for argument missing <br>
141    */
142   virtual int ScanArgument(int argc, const char** argv);
143
144   /**
145    * Build file name from eventID data type and the specified directory and basename.
146    * @param eventID [in]   the ID of the event
147    * @param blockID [in]   the ID of the current block
148    *                       no block string appended if -1
149    * @param dataType [in]  the data type of the data block
150    *                       no type string appanded if @ref kAliHLTVoidDataType
151    * @param specification  data specification of the block
152    * @param filename [out] string to receive the file name
153    */
154   int BuildFileName(const AliHLTEventID_t eventID, const int blockID,
155                     const AliHLTComponentDataType& dataType,
156                     const AliHLTUInt32_t specification,
157                     TString& filename);
158
159   /**
160    * Set a mode flag.
161    * @return current mode flags
162    */
163   int SetMode(Short_t mode);
164     
165   /**
166    * Clear a mode flag.
167    * @return current mode flags
168    */
169   int ClearMode(Short_t mode);
170
171   /**
172    * Check a mode flag.
173    * @return 1 if flag is set, 0 if not
174    */
175   int CheckMode(Short_t mode) const;
176
177   /**
178    * Working modes of the writer
179    * @internal
180    */
181   enum TWriterMode {
182     /**
183      * flag to indicate whether to write each incoming block to separate files
184      * or all blocks of one event to one file. set = concatenate (one file).
185      */
186     kConcatenateBlocks = 0x1,
187
188     /**
189      * flag to indicate whether to concatenate incoming blocks of the same type
190      * for all events to one file. If also @ref kConcatenateBlocks is set,
191      * or all blocks of all events are written to the same file.
192      */
193     kConcatenateEvents = 0x2,
194
195     /** event enumeration flag */
196     kEnumerate = 0x4
197
198   };
199
200  private:
201   /** copy constructor prohibited */
202   AliHLTFileWriter(const AliHLTFileWriter&);
203   /** assignment operator prohibited */
204   AliHLTFileWriter& operator=(const AliHLTFileWriter&);
205
206   /** the basename of the output file */
207   TString    fBaseName;                                            // see above
208   /** the extension of the output file */
209   TString    fExtension;                                           // see above
210   /** target directory */
211   TString    fDirectory;                                           // see above
212   /** base name of the event sub directories */
213   TString    fSubDirFormat;                                        // see above
214   /** event id format string (when added to file name) */
215   TString    fIdFormat;                                            // see above
216   /** specification format string (when added to file name) */
217   TString    fSpecFormat;                                          // see above
218   /** format string for block no (when added to file name) */
219   TString    fBlcknoFormat;                                        // see above
220  protected:
221   /** enumeration format string */
222   TString    fCurrentFileName;                                     // see above
223  private:
224
225   /** mode specifier, see @ref TWriterMode */
226   Short_t    fMode;                                                // see above
227
228   ClassDef(AliHLTFileWriter, 2)
229 };
230 #endif