components return -ENOSPC if output buffer too small, second trial by the AliRoot...
[u/mrichter/AliRoot.git] / HLT / BASE / AliHLTConfiguration.h
1 //-*- Mode: C++ -*-
2 // @(#) $Id$
3
4 #ifndef ALIHLTCONFIGURATION_H
5 #define ALIHLTCONFIGURATION_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   AliHLTConfiguration.h
11     @author Matthias Richter
12     @date   
13     @brief  Base class and handling of HLT configurations.
14     @note   The class is used in Offline (AliRoot) context
15 */
16
17 // see below for class documentation
18 // or
19 // refer to README to build package
20 // or
21 // visit http://web.ift.uib.no/~kjeks/doc/alice-hlt   
22
23 #include <cerrno>
24 #include <vector>
25 #include <TObject.h>
26 #include <TList.h>
27 #include "AliHLTDataTypes.h"
28 #include "AliHLTLogging.h"
29 #include "AliHLTDataBuffer.h"
30
31 class AliHLTConfigurationHandler;
32
33 /**
34  * @class AliHLTConfiguration
35  * @brief Description of HLT processing chains.
36  *
37  * This class describes a certain configuration af an HLT processing step
38  * by the following parameters:
39  * - a unique id string/name
40  * - the id of the component
41  * - the ids of the configurations it requires input from
42  * - the arguments, which are passed to the component when it is initialized
43  *
44  * The setup of a configuration requires simply the creation of a global object
45  * of @ref AliHLTConfiguration. The Configuration is automatically registered
46  * in the list of available configurations maintained by the @ref
47  * AliHLTConfigurationHandler. The list is used by to resolve the dependencies
48  * on other configurations. Hierarchies can be built up in an easy way.
49  *
50  * A configuration is interpreted by the @ref AliHLTConfigurationHandler and
51  * transformed into a Task List.
52  *
53  * @note This class is only used for the @ref alihlt_system.
54  *
55  * @ingroup alihlt_system
56  */
57 class AliHLTConfiguration : public TObject, public AliHLTLogging {
58  public:
59   /**
60    * standard constructor. The configuration is automatically registered in the
61    * global configuration manager
62    */
63   AliHLTConfiguration();
64   /**
65    * constructor. The configuration is automatically registered in the
66    * global configuration manager
67    * @param id         unique id of the configuration
68    * @param component  component id
69    * @param sources    blank separated list of source configuration ids
70    * @param arguments  argument string passed to the component at initialization
71    */
72   AliHLTConfiguration(const char* id, const char* component,
73                       const char* sources, const char* arguments);
74   /** copy constructor */
75   AliHLTConfiguration(const AliHLTConfiguration& src);
76   /** assignment op */
77   AliHLTConfiguration& operator=(const AliHLTConfiguration& src);
78   /** destructor */
79   virtual ~AliHLTConfiguration();
80
81   /*****************************************************************************
82    * global initialization
83    */
84
85   /**
86    * Global initialization of the configuration handler.
87    */
88   static int GlobalInit(AliHLTConfigurationHandler* pHandler);
89
90   /**
91    * Global de-init and cleanup of the global configuration handler
92    */
93   static int GlobalDeinit(AliHLTConfigurationHandler* pHandler);
94
95   /*****************************************************************************
96    * properties of the configuration
97    */
98
99   /**
100    * Get configuration id, a unique name
101    * This is an overridden TObject function in order to return the configuration
102    * name instead of the class name. Enables use of TList standard functions.
103    * @return configuration id
104    */
105   const char *GetName() const;
106
107   /**
108    * Get id of the component.
109    * The id is a unique string.
110    * @return id of the component
111    */
112   const char* GetComponentID() const {return fComponent;}
113
114   /**
115    * Print status info.
116    * Short summary on id, component, sources and unresolved sources.
117    */
118   void PrintStatus();
119
120   /**
121    * Get a certain source.
122    * @param  id of the source configuration
123    * @result pointer to the corresponding configuration descriptor
124    */
125   AliHLTConfiguration* GetSource(const char* id);
126
127   /**
128    * Try to find a dependency recursively in the list of sources.
129    * @param id       the source to search for
130    * @param pTgtList (optional) target list to receive the dependency tree
131    * @return
132    *   0 if not found
133    *   n found in the n-th level
134    *   dependency list in the target list  
135    */
136   int FollowDependency(const char* id, TList* pTgtList=NULL);
137
138   /**
139    * Get the number of resolved sources.
140    * @return number of resolved sources
141    */
142   int GetNofSources() {return fListSources.size();}
143
144   /**
145    * Check resolving status.
146    * @param bAuto resolve if ==1 
147    * @return 1 if all sources resolved
148    */
149   int SourcesResolved(int bAuto=0);
150
151   /**
152    * Start iteration and get the first source.
153    * @result pointer to the first configuration descriptor
154    */
155   AliHLTConfiguration* GetFirstSource();
156
157   /**
158    * Continue iteration and get the next source.
159    * @result pointer to the next configuration descriptor in the list
160    */
161   AliHLTConfiguration* GetNextSource();
162
163   /**
164    * Invalidate a dependency and mark the configuration to be re-evaluted. 
165    * @param pConf pointer to configuration descriptor
166    */
167   int InvalidateSource(AliHLTConfiguration* pConf);
168
169   /**
170    * Mark the configuration to be re-evaluted.
171    */
172   int InvalidateSources() {fNofSources=-1; return 0;}
173
174   /**
175    * Get the arguments array.
176    * @param pArgv   pointer to receive argument array pointer
177    * @return argc if succeeded, neg. error code if failed
178    */
179   int GetArguments(const char*** pArgv);
180
181  protected:
182   
183
184  private:
185   /* extract the source configurations from the sources string
186    */
187   int ExtractSources();
188
189   /* extract arguments from the argument string
190    */
191   int ExtractArguments();
192
193   /**
194    * Helper function to build a vector from an argument string
195    * @param arg       pointer to argument string
196    * @param argList   target to receive the argument list
197    */
198   int InterpreteString(const char* arg, vector<char*>& argList);
199
200   /** id of this configuration */
201   TString fID;                                                     // see above
202   /** component id of this configuration */
203   TString fComponent;                                              // see above
204
205   /** the <i>sources</i> string as passed to the constructor */
206   TString fStringSources;                                          // see above
207   /** number of resolved sources, -1 indicates re-evaluation */
208   int fNofSources;                                                 // see above
209   /** list of sources */
210   vector<AliHLTConfiguration*> fListSources;                       // see above
211   /** iterator for the above list */
212   vector<AliHLTConfiguration*>::iterator fListSrcElement;          // see above
213
214   /**
215    * The argument string as passed to the constructor.
216    * Specifies the arguments for the Analysys component. The string will
217    * be parsed and the separated arguments stored in the @ref fArgv array
218    * and @ref fArgc member.
219    */
220   TString fArguments;                                              // see above
221   /** number of arguments */
222   int fArgc;                                                       // see above
223   /** argument array */
224   char** fArgv;                                                    // see above
225
226   /** the instance of the global configuration handler */
227   static AliHLTConfigurationHandler* fgConfigurationHandler;       //! transient
228
229   ClassDef(AliHLTConfiguration, 0);
230 };
231
232 #endif