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