source: trunk/VUT/GtpVisibilityPreprocessor/src/Environment.h @ 372

Revision 372, 11.2 KB checked in by bittner, 19 years ago (diff)

preparation for vss preprocessor. converted all .cpp and .h to dos new line format

Line 
1// ===================================================================
2// $Id: environ.h,v 1.1 2004/02/16 14:46:00 bittner Exp $
3//
4// environ.h
5//     Header file for environment operations, i.e.. reading
6//     environment file, reading command line parameters etc.
7//
8// Class: CEnvironment
9//
10/// Initial coding by
11/// @author             Tomas Kopal
12
13#ifndef __ENVIRONMENT_H__
14#define __ENVIRONMENT_H__
15
16// forward declarations
17
18#include "common.h"
19
20class Vector3;
21
22
23
24/// Enumeration type used to distinguish the type of the environment variable
25enum EOptType {
26  /// the integer variable
27  optInt,
28  /// the Real variable
29  optFloat,
30  /// the bool variable
31  optBool,
32  /// the vector variable
33  optVector,
34  /// the string variable
35  optString
36};
37
38class COption
39{
40public:
41  COption() {
42    name = NULL;
43    value = NULL;
44    abbrev = NULL;
45    defaultValue = NULL;
46    description = NULL;
47    pointer = NULL;
48  }
49
50  virtual ~COption() {
51    if (name)
52      delete name;
53    if (value)
54      delete value;
55    if (abbrev)
56      delete abbrev;
57    if (defaultValue)
58      delete defaultValue;
59    if (description)
60      delete description;
61   
62  }
63
64  EOptType type;
65  char *name;
66  char *value;
67  char *abbrev;
68  char *defaultValue;
69
70  char *description;
71  void *pointer;
72  friend ostream &operator <<(ostream &s, const COption &o) {
73    s<<o.name<<"\t";
74    if (o.abbrev)
75      s<<o.abbrev;
76    else
77      s<<"no abbrev";
78    s<<"\t";
79    if (o.value)
80      s<<o.value;
81    else
82      s<<"not set";
83    s<<"\t";
84    if (o.defaultValue)
85      s<<"["<<o.defaultValue<<"]";
86    else
87      s<<"[not set]";
88    s<<"\t";
89    if (o.description)
90      s<<endl<<o.description;
91    return s;
92  }
93 
94};
95
96/** CEnvironment class.
97  This class is used for reading command line, reading environment file and
98  managing options. Each recognizable option must be registered in the
99  constructor of this class.
100 */
101class Environment {
102  /**@name Variables */
103  //@{
104private:
105  /// Maximal number of options
106  int maxOptions;
107  /// Number of columns in the parameter table.
108  int numParams;
109  /// Number of rows in the parameter table.
110  int paramRows;
111  /// String with prefixes with non-optional parameters.
112  char *optionalParams;
113  /// Current row in the parameter table.
114  int curRow;
115
116  /** Parameter table itself.
117    The organization of this table is two dimensional array of character
118    strings. First column are parameters, all the other columns are options
119    prefixed by char passed to function GetCmdlineParams and paired with
120    corresponding parameters.
121   */
122  char ***params;
123
124  /// Number of registered options.
125  int numOptions;
126  /** Options table itself.
127    This table is two dimensional array of character strings with four
128    columns. First column contains name of the option, second it's value,
129    third eventual abbreviation, and finally the fourth contains the default
130    value specified when registering the option.
131    */
132  COption *options;
133  //  char ***options;
134  /** Options types.
135    This is auxiliary table to the table "options". It contains the type of
136    each option as specified when registering.
137    */
138  //  EOptType *optTypes;
139  //@}
140
141  /**@name Methods */
142  //@{
143  /** Auxiliary method for parsing environment file.
144    Function gets one string from buffer, skipping leading whitespaces, and
145    appends it at the end of the string parameter. Returns pointer to the next
146    string in the buffer with trailing whitespaces skipped. If no string in
147    the buffer can't be found, returns NULL.
148    @param buffer Input line for parsing.
149    @param string Buffer to append gathered string to.
150    @return Pointer to next string or NULL if not succesful.
151    */
152  char* ParseString(char *buffer, char *string) const;
153  /** Method for checking variable type.
154    This method is used to check if the value of the variable can be taken
155    as the specified type.
156    @param value Tested value of the variable.
157    @param type The type of the variable.
158    @return true if the variable is of the specified type, false elsewhere.
159    */
160  bool CheckType(const char *value, const EOptType type) const;
161  //@}
162
163  int
164  FindOption(const char *name,
165             const bool isFatal=false) const;
166
167  bool
168  ParseBool(const char *name) const;
169  void
170  ParseVector(const char *name, Vector3 &v) const;
171
172
173
174public: 
175  /**@name Methods */
176  //@{
177  /// Constructor of the CEnvironment class.
178  Environment();
179  /// Destructor of the CEnvironment class.
180  virtual ~Environment();
181 
182  /// This method is used as a help on available command line options.
183  virtual void PrintUsage(ostream &s) const;
184
185  virtual void SetStaticOptions();
186
187
188  /** Method for registering new option.
189      Using this method is possible to register new option with it's name, type,
190      abbreviation and default value.
191      @param name Name of the option.
192      @param type The type of the variable.
193      @param abbrev If not NULL, alias usable as a command line option.
194      @param defValue Implicit value used if not specified explicitly.
195  */
196  void RegisterOption(const char *name, const EOptType type,
197                      const char *abbrev, const char *defValue = NULL);
198 
199  /** Check if the specified switch is present in the command line.
200    Primary use of this function is to check for presence of some special
201    switch, e.g. -h for help. It can be used anytime.
202    @param argc Number of command line arguments.
203    @param argv Array of command line arguments.
204    @param swtch Switch we are checking for.
205    @return true if found, false elsewhere.
206   */
207  bool CheckForSwitch(const int argc,
208                      const char *argv[],
209                      const char swtch) const;
210  /** First pass of parsing command line.
211    This function parses command line and gets from there all non-optional
212    parameters (i.e. not prefixed by the dash) and builds a table of
213    parameters. According to param optParams, it also writes some optional
214    parameters to this table and pair them with corresponding non-optional
215    parameters.
216    @param argc Number of command line arguments.
217    @param argv Array of command line arguments.
218    @param optParams String consisting of prefixes to non-optional parameters.
219                     All prefixes must be only one character wide !
220   */
221  void ReadCmdlineParams(const int argc,
222                         const char *argv[],
223                         const char *optParams);
224  /** Reading of the environment file.
225    This function reads the environment file.
226    @param filename The name of the environment file to read.
227    @return true if OK, false in case of error.
228    */
229  bool ReadEnvFile(const char *filename);
230  /** Second pass of the command line parsing.
231    Performs parsing of the command line ignoring all parameters and options
232    read in the first pass. Builds table of options.
233    @param argc Number of command line arguments.
234    @param argv Array of command line arguments.
235    @param index Index of non-optional parameter, of which options should
236                 be read in.
237   */
238  void ParseCmdline(const int argc, const char *argv[], const int index);
239
240  /** Clears the environment data structures.
241    This function is intended to clear all data structures corresponding to
242    particular non-optional parameter to allow options for the next
243    non-optional parameter to be read. After this clearing, function
244    ReadEnvFile() can be called again to obtain next load of options.
245    */
246  //  void ClearEnvironment();
247 
248  /** Parameters number query function.
249    This function returns number of non-optional parameters specified on
250    the command line.
251    */
252  int GetParamNum() const { return paramRows; }
253  /** Returns the indexed parameter or corresponding optional parameter.
254   This function is used for queries on individual non-optional parameters.
255   The table must be constructed to allow this function to operate (i.e. the
256   first pass of command line parsing must be done).
257   @param name If space (' '), returns the non-optional parameter, else returns
258               the corresponding optional parameter.
259   @param index Index of the non-optional parameter to which all other options
260                corresponds.
261   @param value Return value of the queried parameter.
262   @return true if OK, false in case of error or if the parameter wasn't
263           specified.
264   */
265  bool GetParam(const char name, const int index, char *value) const;
266
267  /**@name Options query functions.
268   These functions are used for queries on individual options. The table must
269   be constructed to allow these functions to operate (i.e. the environment
270   file must be read and the second pass of command line parsing be done).
271   @param name Name of the option to retrieve.
272   @param value Return value of the queried option.
273   @param isFatal Boolean value specifying, if the function should exit or
274                  return false in case of error.
275   @return true if OK, false in case of error.
276   */
277  //@{
278  /// returns true, if the specified option has been specified
279  bool OptionPresent(const char *name) const;
280  /// returns named option as a integral value.
281  bool GetIntValue(const char *name,
282                   int &value,
283                   const bool isFatal = false) const;
284 
285  /// returns named option as a floating point value.
286  bool GetDoubleValue(const char *name,
287                      double &value,
288                      const bool isFatal = false) const;
289
290  /// returns named option as a floating point value.
291  bool GetRealValue(const char *name,
292                    Real &value,
293                    const bool isFatal = false) const;
294
295  bool GetFloatValue(const char *name,
296                     float &value,
297                     const bool isFatal = false) const;
298
299  /// returns named option as a boolean value.
300  bool GetBoolValue(const char *name,
301                    bool &value,
302                    const bool isFatal = false) const;
303
304  bool GetBool(const char *name, const bool isFatal = false) const;
305 
306  /// returns named option as a 3D vector.
307  bool GetVectorValue(const char *name,
308                      Vector3 &v,
309                      const bool isFatal = false) const;
310
311  /// returns named option as a character string.
312  bool GetStringValue(const char *name,
313                                                                                        char *value,
314                                                                                        const bool isFatal = false) const;
315 
316  //@}
317  /**@name Options set functions.
318   These functions are used for setting individual options.
319   @param name Name of the option to set.
320   @param value Value to set the option to.
321   */
322  //@{
323  /// sets named option as a integral value.
324  void SetInt(const char *name, const int value);
325  /// sets named option as a floating point value.
326  void SetFloat(const char *name, const Real value);
327  /// sets named option as a boolean value.
328  void SetBool(const char *name, const bool value);
329  /// sets named option as a 3D vector.
330  void SetVector(const char *name,
331                 const Vector3 &v);
332  /// sets named option as a character string.
333  void SetString(const char *name, const char *value);
334  //@}
335  //@}
336
337  void Parse(const int argc, const char *argv[], bool useExePath);
338
339  void
340  CodeString(char *buff, int max);
341
342  void
343  DecodeString(char *buff, int max);
344
345  void
346  SaveCodedFile(char *filenameText,
347                char *filenameCoded);
348
349};
350
351// global environment value
352extern Environment *environment;
353
354#endif // __ENVIRON_H__
355
Note: See TracBrowser for help on using the repository browser.