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