added -overwrite option to ROOTFileWriter -> use TObject::kOverwrite flag; minor...
[u/mrichter/AliRoot.git] / HLT / BASE / util / AliHLTDataGenerator.h
1 // -*- Mode: C++ -*-
2 // $Id$
3
4 #ifndef ALIHLTDATAGENERATOR_H
5 #define ALIHLTDATAGENERATOR_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   AliHLTDataGenerator.h
11     @author Matthias Richter
12     @date   
13     @brief  An HLT file publishing (data source) component.
14     @note   The class is used in Offline (AliRoot) context
15 */
16
17 #include "AliHLTDataSource.h"
18
19 /**
20  * @class AliHLTDataGenerator
21  * An HLT data source component to produce random data.
22  *
23  * Component ID: \b DataGenerator <br>
24  * Library: \b libAliHLTUtil.
25  *
26  * Mandatory arguments: <br>
27  * <!-- NOTE: ignore the \li. <i> and </i>: it's just doxygen formatting -->
28  * \li -datatype     <i> datatype   dataorigin </i> <br>
29  *      data type ID and origin, e.g. <tt>-datatype 'CLUSTERS' 'TPC ' </tt>
30  * \li -dataspec     <i> specification </i> <br>
31  *      data specification treated as decimal number or hex number if
32  *      prepended by '0x'
33  * \li -minsize      <i> size </i> <br>
34  *      the minimum size of the data to be produced
35  * \li -maxsize      <i> size </i> <br>
36  *      the maximum size of the data to be produced, default = minsize
37  *
38  * Optional arguments:<br>
39  * \li -divisor <i> m </i> <br>
40  *      a divisor to shrink the size after \em modulo events
41  * \li -offset <i> m </i> <br>
42  *      an offset to subtract from the size after \em modulo events
43  * \li -modulo <i> n </i> <br>
44  *      size manipulated by the disisor or subtractor after \em n events
45  *
46  * The component produces data blocks of random content and random size in the
47  * range of [\em minsize , \em maxsize ]. The size arguments can contain 'k' or
48  * 'M' to indicate kByte or MByte.
49  *
50  * @ingroup alihlt_util_components
51  */
52 class AliHLTDataGenerator : public AliHLTDataSource  {
53  public:
54   /** standard constructor */
55   AliHLTDataGenerator();
56   /** destructor */
57   virtual ~AliHLTDataGenerator();
58
59   const char* GetComponentID();
60   AliHLTComponentDataType GetOutputDataType();
61   int GetOutputDataTypes(vector<AliHLTComponentDataType>& tgtList);
62   void GetOutputDataSize( unsigned long& constBase, double& inputMultiplier );
63   AliHLTComponent* Spawn();
64
65  protected:
66   /**
67    * Init method.
68    */
69   int DoInit( int argc, const char** argv );
70
71   /**
72    * Deinit method.
73    */
74   int DoDeinit();
75
76   /**
77    * Data processing method for the component.
78    * @param evtData       event data structure
79    * @param trigData      trigger data structure
80    * @param outputPtr     pointer to target buffer
81    * @param size          <i>input</i>: size of target buffer
82    *                      <i>output</i>:size of produced data
83    * @param outputBlocks  list to receive output block descriptors
84    * @return
85    */
86   int GetEvent( const AliHLTComponentEventData& evtData,
87                         AliHLTComponentTriggerData& trigData,
88                         AliHLTUInt8_t* outputPtr, 
89                         AliHLTUInt32_t& size,
90                         vector<AliHLTComponentBlockData>& outputBlocks );
91
92   using AliHLTDataSource::GetEvent;
93
94   /**
95    * Scan one argument and adjacent parameters.
96    * Can be overloaded by child classes in order to add additional arguments
97    * beyond the standard arguments of the file publisher. The method is called
98    * whenever a non-standard argument is recognized.
99    * @param argc           size of the argument array
100    * @param argv           agument array for component initialization
101    * @return number of processed members of the argv <br>
102    *         -EINVAL unknown argument <br>
103    *         -EPROTO parameter for argument missing <br>
104    */
105   virtual int ScanArgument(int argc, const char** argv);
106
107  protected:
108   /**
109    * Scan a size argument.
110    * The argument is expected to be an integer, which can be suffixed by 'k'
111    * or 'M' in order to indicate the base, kByte or MByte.
112    * @param size      target to store the size
113    * @param arg       the argument to scan
114    */
115   int ScanSizeArgument(AliHLTUInt32_t &size, const char* arg);
116
117  private:
118   /** prohibit copy constructor */
119   AliHLTDataGenerator(const AliHLTDataGenerator&);
120   /** prohibit assignment operator */
121   AliHLTDataGenerator& operator=(const AliHLTDataGenerator&);
122
123   /** data type */
124   AliHLTComponentDataType fDataType;                                //! transient
125
126   /** specification */
127   AliHLTUInt32_t fSpecification;                                    //! transient
128
129   /** the original size size */
130   AliHLTUInt32_t fSize;                                             //! transient
131
132   /** the manipulated size */
133   AliHLTUInt32_t fCurrSize;                                         //! transient
134
135   /** range */
136   AliHLTUInt32_t fRange;                                            //! transient
137
138   /** divisor */
139   AliHLTUInt32_t fDivisor;                                          //! transient
140
141   /** subtractor */
142   AliHLTUInt32_t fSubtractor;                                       //! transient
143
144   /** modulo for size manipulation */
145   AliHLTUInt32_t fModulo;                                           //! transient
146
147   ClassDef(AliHLTDataGenerator, 0)
148 };
149 #endif