Planet
navi homePPSaboutscreenshotsdownloaddevelopmentforum

source: orxonox.OLD/orxonox/trunk/src/util/loading/load_param.h @ 4993

Last change on this file since 4993 was 4972, checked in by bensch, 20 years ago

orxonox/trunk: many loadParams
File size: 18.1 KB
Line 
1/*
2   orxonox - the future of 3D-vertical-scrollers
3
4   Copyright (C) 2004 orx
5
6   This program is free software; you can redistribute it and/or modify
7   it under the terms of the GNU General Public License as published by
8   the Free Software Foundation; either version 2, or (at your option)
9   any later version.
10
11   ### File Specific:
12   main-programmer: Benjamin Grauer
13   co-programmer: ...
14*/
15
16/*!
17    \file load_param.h
18  *  A Class and macro-functions, that makes our lives easy to load-in parameters
19*/
20
21#ifndef _LOAD_PARAM_H
22#define _LOAD_PARAM_H
23
24#include "base_object.h"
25#include "vector.h"
26#include "factory.h"
27#include "debug.h"
28#include "substring.h"
29#include "tinyxml.h"
30
31// Forward Declaration //
32template<class T> class tList;
33
34//! macro that makes it even more easy to load a Parameter
35/**
36 * @param className the name of the class to load
37 * @param parameterName the name of the parameter to load as written in the XML-file
38 * @param function the function to call
39 */
40#define LOAD_PARAM(className, parameterName, paramFunction) \
41        LoadParam<className>(root, #parameterName, this, &className::paramFunction)
42
43/**
44 * this Starts a Cycle in the Loading Process
45 * be aware, that in the cycle the first parameter of load_param should because
46 * called element, and that you must say true at the Fith parameter, or it will fail
47 * also you will have to close the Cycle again with LOAD_PARAM_END_CYCLE
48 */
49#define LOAD_PARAM_START_CYCLE   const TiXmlElement* element; \
50                                 element = root->FirstChildElement(); \
51                                 while( element != NULL) \
52                                  {
53/**
54 * closes a LoadParam Loop
55 * @see LOAD_PARAM_START_CYCLE
56 */
57#define LOAD_PARAM_END_CYCLE        element = element->NextSiblingElement(); \
58                                  }
59
60
61
62/**
63   useable FunctionParameters are:
64   l_INT:       int
65   l_LONG:      long
66   l_SHORT:     short
67   l_FLOAT:     float
68   l_STRING:    const char*
69   l_XML_ELEM:  TiXmlElement*
70*/
71
72#define l_BOOL_TYPE        bool                 //!< The type of an BOOL
73#define l_BOOL_FUNC        isBool               //!< The function to call to parse BOOL
74#define l_BOOL_NAME        "bool"               //!< The name of an BOOL
75#define l_BOOL_DEFAULT     false                //!< a default Value for an BOOL
76
77
78#define l_INT_TYPE         int                  //!< The type of an INT
79#define l_INT_FUNC         isInt                //!< The function to call to parse INT
80#define l_INT_NAME         "int"                //!< The name of an INT
81#define l_INT_DEFAULT      0                    //!< a default Value for an INT
82
83#define l_UINT_TYPE        unsigned int         //!< The type of an UINT
84#define l_UINT_FUNC        isInt                //!< The function to call to parse UINT
85#define l_UINT_NAME        "unsigned int"       //!< The name of an UINT
86#define l_UINT_DEFAULT     0                    //!< a default Value for an UINT
87
88#define l_LONG_TYPE        long                 //!< The type of a LONG
89#define l_LONG_FUNC        isInt                //!< The function to parse a LONG
90#define l_LONG_NAME        "long"               //!< The name of a LONG
91#define l_LONG_DEFAULT     0                    //!< a default Value for a LONG
92
93// #define l_SHORT_TYPE       short                //!< The type of a SHORT
94// #define l_SHORT_FUNC       atoi                 //!< The function to parse a SHORT
95// #define l_SHORT_NAME       "short"              //!< The name of a SHORT
96// #define l_SHORT_DEFAULT    0                    //!< a default Value for a SHORT
97
98#define l_FLOAT_TYPE       float                //!< The type of a FLOAT
99#define l_FLOAT_FUNC       isFloat              //!< The function to parse a FLOAT
100#define l_FLOAT_NAME       "float"              //!< The name of a FLOAT
101#define l_FLOAT_DEFAULT    0.0                  //!< a default Value for a FLOAT
102
103//#define l_VECTOR_TYPE      const Vector&        //!< The type of a VECTOR
104//#define l_VECTOR_FUNC      isVector             //!< The function to parse a VECTOR
105//#define l_VECTOR_NAME      "Vector[x/y/z]"      //!< The name of a VECTOR
106//#define l_VECTOR_DEFAULT   Vector(0,0,0)        //!< Default value for a VECTOR
107
108#define l_STRING_TYPE      const char*          //!< The type of a STRING
109#define l_STRING_FUNC      isString             //!< The function to parse a STRING
110#define l_STRING_NAME      "string"             //!< The name of a STRING
111#define l_STRING_DEFAULT   ""                   //!< a default Value for an STRING
112
113#define l_XML_ELEM_TYPE    const TiXmlElement*  //!< The type of an XML_ELEM
114#define l_XML_ELEM_FUNC                         //!< The function to parse an XML_ELEM
115#define l_XML_ELEM_NAME    "XML"                //!< The name of an XML_ELEM
116#define l_XML_ELEM_DEFAULT NULL                 //!< The dafault Value for an XML_ELEM
117
118
119/*****************************************
120**** MACROS DEFINITIONS OF LOADABLES *****
121*****************************************/
122// 1. TYPE
123/**
124 *  a Macro to easily implement many different Constructors for the LoadParam-Class with 1 argument
125 * @param type1 The type of the first functionParameter
126*/
127#define LoadParam1(type1) \
128 LoadParam(const TiXmlElement* root, const char* paramName, T* pt2Object, void(T::*function)(type1##_TYPE), \
129           bool multi = false, type1##_TYPE default1 = type1##_DEFAULT) \
130  : BaseLoadParam(root, pt2Object, paramName, 1, multi, NULL, type1##_NAME, default1) \
131    { \
132      if (loadString != NULL && root != NULL) \
133        (*pt2Object.*function)(type1##_FUNC(loadString, default1)); \
134      else \
135        PRINTF(4)("Not loaded parameter %s of %s\n", paramName, pt2Object->getClassName()); \
136    }
137
138
139// 2. TYPES
140/**
141 *  a Macro to easily implement many different Constructors for the LoadParam-Class with 2 arguments
142 * @param type1 The type of the first functionParameter
143 * @param type2 The type of the second functionParameter
144*/
145#define LoadParam2(type1, type2) \
146 LoadParam(const TiXmlElement* root, const char* paramName, T* pt2Object, void(T::*function)(type1##_TYPE, type2##_TYPE), \
147           bool multi = false,  type1##_TYPE default1 = type1##_DEFAULT,  type2##_TYPE default2 = type2##_DEFAULT) \
148  : BaseLoadParam(root, pt2Object, paramName, 2, multi, NULL, type1##_NAME, default1, type2##_NAME, default2) \
149    { \
150      if (loadString != NULL && root != NULL) \
151        { \
152          SubString subLoads(loadString); \
153          if (subLoads.getCount() == 2) \
154            (*pt2Object.*function)(type1##_FUNC(subLoads.getString(0), default1), type2##_FUNC(subLoads.getString(1), default2)); \
155          else \
156            PRINTF(2)("Not loaded Parameter %s of %s, because wrong count of arguments.\n -> Should have %d but have %d\n", \
157                      paramName, pt2Object->getClassName(), 2, subLoads.getCount()); \
158        } \
159      else \
160        PRINTF(4)("Not loaded parameter %s of %s\n", paramName, pt2Object->getClassName()); \
161    }
162
163
164// 3. TYPES
165/**
166 *  a Macro to easily implement many different Constructors for the LoadParam-Class with 3 arguments
167 * @param type1 The type of the first functionParameter
168 * @param type2 The type of the second functionParameter
169 * @param type3 The type of the third functionParameter
170*/
171#define LoadParam3(type1, type2, type3) \
172 LoadParam(const TiXmlElement* root, const char* paramName, T* pt2Object, void(T::*function)(type1##_TYPE, type2##_TYPE, type3##_TYPE), \
173           bool multi = false, type1##_TYPE default1 = type1##_DEFAULT, type2##_TYPE default2 = type2##_DEFAULT, type3##_TYPE default3 = type3##_DEFAULT)\
174  : BaseLoadParam(root, pt2Object, paramName, 3, multi, NULL, type1##_NAME, default1, type2##_NAME, default2, type3##_NAME, default3) \
175    { \
176      if (loadString != NULL && root != NULL) \
177        { \
178          SubString subLoads(loadString); \
179          if (subLoads.getCount() == 3) \
180            (*pt2Object.*function)(type1##_FUNC(subLoads.getString(0), default1), type2##_FUNC(subLoads.getString(1), default2), type3##_FUNC(subLoads.getString(2), default3)); \
181          else \
182            PRINTF(2)("Not loaded Parameter %s of %s, because wrong count of arguments.\n -> Should have %d but have %d\n", \
183                      paramName, pt2Object->getClassName(), 3, subLoads.getCount()); \
184        } \
185      else \
186        PRINTF(4)("Not loaded parameter %s of %s\n", paramName, pt2Object->getClassName()); \
187    }
188
189
190// 4. TYPES
191/**
192 *  a Macro to easily implement many different Constructors for the LoadParam-Class with 4 arguments
193 * @param type1 The type of the first functionParameter
194 * @param type2 The type of the second functionParameter
195 * @param type3 The type of the third functionParameter
196 * @param type4 The type of the forth functionParameter
197*/
198#define LoadParam4(type1, type2, type3, type4) \
199 LoadParam(const TiXmlElement* root, const char* paramName, T* pt2Object, void(T::*function)(type1##_TYPE, type2##_TYPE, type3##_TYPE, type4##_TYPE), \
200           bool multi = false, type1##_TYPE default1 = type1##_DEFAULT, type2##_TYPE default2 = type2##_DEFAULT, type3##_TYPE default3 = type3##_DEFAULT, \
201           type4##_TYPE default4 = type4##_DEFAULT) \
202  : BaseLoadParam(root, pt2Object, paramName, 4, multi, NULL, type1##_NAME, default1, type2##_NAME, default2, type3##_NAME, default3, \
203                  type4##_NAME, default4) \
204    { \
205      if (loadString != NULL && root != NULL) \
206        { \
207          SubString subLoads(loadString); \
208          if (subLoads.getCount() == 4) \
209            (*pt2Object.*function)(type1##_FUNC(subLoads.getString(0), default1), type2##_FUNC(subLoads.getString(1), default2), type3##_FUNC(subLoads.getString(2), default3), type4##_FUNC(subLoads.getString(3), default4)); \
210          else \
211            PRINTF(2)("Not loaded Parameter %s of %s, because wrong count of arguments.\n -> Should have %d but have %d\n", \
212                      paramName, pt2Object->getClassName(), 4, subLoads.getCount()); \
213        } \
214      else \
215        PRINTF(4)("Not loaded parameter %s of %s\n", paramName, pt2Object->getClassName()); \
216    }
217
218
219// 5. TYPES
220/**
221 *  a Macro to easily implement many different Constructors for the LoadParam-Class with 5 arguments
222 * @param type1 The type of the first functionParameter
223 * @param type2 The type of the second functionParameter
224 * @param type3 The type of the third functionParameter
225 * @param type4 The type of the forth functionParameter
226 * @param type5 The type of the fifth functionParameter
227*/
228#define LoadParam5(type1, type2, type3, type4, type5) \
229 LoadParam(const TiXmlElement* root, const char* paramName, T* pt2Object, \
230           void(T::*function)(type1##_TYPE, type2##_TYPE, type3##_TYPE, type4##_TYPE, type5##_TYPE), \
231           bool multi = false, type1##_TYPE default1 = type1##_DEFAULT, type2##_TYPE default2 = type2##_DEFAULT, type3##_TYPE default3 = type3##_DEFAULT, \
232           type4##_TYPE default4 = type4##_DEFAULT, type5##_TYPE default5 = type5##_DEFAULT ) \
233  : BaseLoadParam(root, pt2Object, paramName, 5, multi, NULL, type1##_NAME, default1, type2##_NAME, default2, type3##_NAME, default3, \
234                  type4##_NAME, default4, type5##_NAME, default5) \
235    { \
236      if (loadString != NULL && root != NULL) \
237        { \
238          SubString subLoads(loadString); \
239          if (subLoads.getCount() == 5) \
240            (*pt2Object.*function)(type1##_FUNC(subLoads.getString(0), default1), type2##_FUNC(subLoads.getString(1), default2), type3##_FUNC(subLoads.getString(2), default3), type4##_FUNC(subLoads.getString(3), default4), type5##_FUNC(subLoads.getString(4), default5)); \
241          else \
242            PRINTF(2)("Not loaded Parameter %s of %s, because wrong count of arguments.\n -> Should have %d but have %d\n", \
243                      paramName, pt2Object->getClassName(), 5, subLoads.getCount()); \
244        } \
245      else \
246        PRINTF(4)("Not loaded parameter %s of %s\n", paramName, pt2Object->getClassName()); \
247    }
248
249// Pointer TYPE
250/**
251 *  a Macro to easily implement many different Constructors for the LoadParam-Class with one Pointer argument
252 * @param type1 The type of the Pointer
253 */
254#define LoadParamPT(type1) \
255 LoadParam(const TiXmlElement* root, const char* paramName, T* pt2Object, void(T::*function)(type1##_TYPE), type1##_TYPE pointerToParam, bool multi = false) \
256  : BaseLoadParam(root, pt2Object, paramName, 1, multi, pointerToParam, type1##_NAME) \
257{ \
258      if (pointerToParam != NULL && root != NULL) \
259        (*pt2Object.*function)((type1##_TYPE) pointerToParam); \
260      else \
261        PRINTF(4)("Not loaded parameter %s of %s\n", paramName, pt2Object->getClassName()); \
262}
263
264
265/***********************
266*** HELPER FUNCTIONS ***
267***********************/
268bool          isBool(const char* BOOL, bool defaultValue);
269int           isInt(const char* INT, int defaultValue);
270float         isFloat(const char* FLOAT, float defaultValue);
271//const Vector& isVector(const char* VECTOR, const Vector& defaultValue);
272const char*   isString(const char* STRING, const char* defaultValue);
273
274//TiXmlEmlemnt* isXmlElem(const)
275
276
277/************************
278*** DESCRIPTION STUFF ***
279************************/
280//! A class that handles the description of loadable parameters
281class LoadParamDescription
282{
283  friend class BaseLoadParam;
284  friend class LoadClassDescription;
285 public:
286  LoadParamDescription(const char* paramName);
287  ~LoadParamDescription();
288
289  void setDescription(const char* descriptionText);
290  /** @returns the descriptionString */
291  const char* getDescription() { return this->description; };
292
293  void print() const;
294 private:
295  char*         paramName;             //!< The name of the parameter.
296  int           paramCount;            //!< The count of parameters.
297  char**        types;                 //!< What kind of parameters does this function take ??
298  char*         description;           //!< A longer description about this function.
299  char**        defaultValues;         //!< The 'Default Values'.
300};
301
302//! A class for descriptions of a loadable module
303class LoadClassDescription
304{
305  friend class BaseLoadParam;
306 public:
307  LoadClassDescription(const char* className);
308  ~LoadClassDescription();
309
310  static LoadClassDescription* addClass(const char* className);
311  LoadParamDescription* addParam(const char* paramName);
312
313
314  static void printAll(const char* fileName = NULL);
315
316 private:
317  static bool                          parametersDescription;  //!< if parameter-description should be enabled.
318  static tList<LoadClassDescription>*  classList;              //!< a list, that holds all the loadable classes. (after one instance has been loaded)
319  char*                                className;              //!< name of the class
320  tList<LoadParamDescription>*         paramList;              //!< List of parameters this class knows.
321};
322
323
324/**************************
325**** REAL DECLARATIONS ****
326**************************/
327//! abstract Base class for a Loadable parameter
328class BaseLoadParam : public BaseObject
329{
330 public:
331  BaseLoadParam* describe(const char* descriptionText);
332
333 protected:
334  BaseLoadParam(const TiXmlElement* root, BaseObject* object, const char* paramName, int paramCount, bool multi, const void* pointerToParam, ...);
335
336 protected:
337  LoadClassDescription*    classDesc;            //!< The LoadClassDescription of this LoadParameter
338  LoadParamDescription*    paramDesc;            //!< The LoadParameterDescription of this LoadParameter
339  const char*              loadString;           //!< The string loaded by this LoadParam
340  const void*              pointerToParam;       //!< A Pointer to a Parameter.
341};
342
343
344//! derived template class, so all the Classes can load something.
345template<class T> class LoadParam : public BaseLoadParam
346{
347 public:
348  LoadParam(const TiXmlElement* root, const char* paramName, T* pt2Object, void(T::*function)(), bool multi = false)
349    : BaseLoadParam(root, pt2Object, paramName, 0, multi, NULL, "")
350    {
351      if (loadString != NULL && root != NULL)
352        (*pt2Object.*function)();
353      else
354        PRINTF(4)("Not loaded parameter %s of %s\n", paramName, pt2Object->getClassName());
355    }
356
357
358  //! makes functions with one string loadable
359  LoadParam1(l_STRING);
360  //! makes functions with two strings loadable
361  LoadParam2(l_STRING, l_STRING);
362  //! makes functions with three strings loadable
363  LoadParam3(l_STRING, l_STRING, l_STRING);
364  //! makes functions with four strings loadable
365  LoadParam4(l_STRING, l_STRING, l_STRING, l_STRING);
366
367  //! makes functions with one bool loadeable
368  LoadParam1(l_BOOL);
369
370  //! makes functions with one int loadable
371  LoadParam1(l_INT);
372  //! makes functions with two ints loadable
373  LoadParam2(l_INT, l_INT);
374  //! makes functions with three ints loadable
375  LoadParam3(l_INT, l_INT, l_INT);
376  //! makes functions with four ints loadable
377  LoadParam4(l_INT, l_INT, l_INT, l_INT);
378
379
380  //! makes functions with one unsigned int loadable
381  LoadParam1(l_UINT);
382  //! makes functions with two unsigned ints loadable
383  LoadParam2(l_UINT, l_UINT);
384  //! makes functions with three unsigned ints loadable
385  LoadParam3(l_UINT, l_UINT, l_UINT);
386  //! makes functions with four unsigned ints loadable
387  LoadParam4(l_UINT, l_UINT, l_UINT, l_UINT);
388
389  //! makes functions with one float loadable
390  LoadParam1(l_FLOAT);
391  //! makes functions with two floats loadable
392  LoadParam2(l_FLOAT, l_FLOAT);
393  //! makes functions with three floats loadable
394  LoadParam3(l_FLOAT, l_FLOAT, l_FLOAT);
395  //! makes functions with four floats loadable
396  LoadParam4(l_FLOAT, l_FLOAT, l_FLOAT, l_FLOAT);
397  //! makes functions with four floats loadable
398  LoadParam5(l_FLOAT, l_FLOAT, l_FLOAT, l_FLOAT, l_FLOAT);
399
400  //! mixed values:
401  LoadParam2(l_STRING, l_FLOAT);
402
403  //! makes functions with one Vector loadable
404  //LoadParam1(l_VECTOR);
405
406  // loads a Ti-XML-element
407  LoadParam(const TiXmlElement* root, const char* paramName, T* pt2Object, void(T::*function)(const TiXmlElement*), bool multi = false)
408  : BaseLoadParam(root, pt2Object, paramName, 1, multi, NULL, "XML")
409  {
410    if (root != NULL)
411    {
412      const TiXmlElement* elem = root->FirstChildElement(paramName);
413      if (likely(elem != NULL))
414        (*pt2Object.*function)(elem);
415      else
416        PRINTF(2)("%s of %s is empty", paramName, pt2Object->getClassName());
417    }
418    else
419      PRINTF(4)("Not loaded parameter %s of %s\n", paramName, pt2Object->getClassName());
420  }
421
422  //LoadParamPT(l_XML_ELEM);
423};
424
425// helper function
426
427const char* grabParameter(const TiXmlElement* root, const char* parameterName);
428
429#endif /* _LOAD_PARAM_H */
Note: See TracBrowser for help on using the repository browser.