Planet
navi homePPSaboutscreenshotsdownloaddevelopmentforum

source: orxonox.OLD/trunk/src/lib/util/loading/load_param.cc @ 9346

Last change on this file since 9346 was 8408, checked in by bensch, 18 years ago

trunk: merged the script_engine branche back here
merged with command
svn merge https://svn.orxonox.net/orxonox/branches/script_engine . -r8284:HEAD
no conflicts

File size: 7.7 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#define DEBUG_SPECIAL_MODULE DEBUG_MODULE_LOADING
17
18#include "util/loading/load_param.h"
19#include "load_param_description.h"
20
21#include <stdarg.h>
22
23/**
24 * Constructs a new LoadParameter
25 * @param root the XML-element to load this Parameter from
26 * @param paramName the Parameter to load
27 * @param object the BaseObject, to load this parameter on to (will be cast to executor's Parameter)
28 * @param executor the Executor, that executes the loading procedure.
29 */
30CLoadParam::CLoadParam(const TiXmlElement* root, const std::string& paramName, BaseObject* object, Executor* executor, bool inLoadCycle)
31  :  object(object), paramName(paramName)
32{
33  this->inLoadCycle = inLoadCycle;
34
35  // determin the LoadString.
36  if (likely(!inLoadCycle))
37    this->loadElem = grabParameterElement(root, paramName);
38  else if (paramName == root->Value())
39    this->loadElem = (TiXmlElement*)root->FirstChild();
40  else
41    this->loadElem = NULL;
42
43  // set the Executor.
44  this->executor = executor;
45
46  //if (this->executor)
47  //  this->executor->setName(paramName);
48}
49
50/**
51 * This is a VERY SPECIAL deconsrtuctor.
52 * It is made, so that it loads the Parameters on destruction.
53 * meaning, if an Executor a valid Object exist, and all
54 * Execution-Conditions are met, they are executed here.
55 */
56CLoadParam::~CLoadParam()
57{
58  if (likely(this->executor != NULL))
59  {
60    std::string loadString = "";
61    if (this->loadElem != NULL &&  this->loadElem->ToText())
62      loadString = this->loadElem->Value();
63    if (likely(this->object != NULL) &&
64        ( !loadString.empty() ||
65          ((this->executor->getType() & Executor_NoLoadString) == Executor_NoLoadString)))
66    {
67      PRINTF(4)("Loading value '%s' with Parameters '%s' onto: %s::%s\n", this->paramName.c_str(), loadString.c_str(), this->object->getClassName(), this->object->getName());
68      (*this->executor)(this->object, SubString(loadString, ",", SubString::WhiteSpaces, false, '\\'));
69    }
70    delete this->executor;
71  }
72}
73
74/**
75 * @brief set the default values of the executor
76 * @param value0 the first default value
77 * @param value1 the second default value
78 * @param value2 the third default value
79 * @param value3 the fourth default value
80 * @param value4 the fifth default value
81 */
82CLoadParam& CLoadParam::defaultValues(const MultiType& value0, const MultiType& value1,
83                                      const MultiType& value2, const MultiType& value3,
84                                      const MultiType& value4)
85{
86  assert(this->executor != NULL);
87  this->executor->defaultValues(value0, value1, value2, value3, value4);
88
89  return *this;
90}
91
92
93
94/**
95 * @param descriptionText The text to set as a description for this Parameter
96 * @returns a pointer to itself.
97*/
98CLoadParam& CLoadParam::describe(const std::string& descriptionText)
99{
100  if (LoadClassDescription::parametersDescription && this->paramDesc && this->paramDesc->getDescription().empty())
101  {
102    this->paramDesc->setDescription(descriptionText);
103  }
104  return *this;
105}
106
107// const LoadParamDescription* LoadParamDescription::getClass(const char* className)
108// {
109//   tIterator<LoadClassDescription>* iterator = LoadClassDescription::classList->getIterator();
110//   LoadClassDescription* enumClassDesc = iterator->firstElement();
111//   while (enumClassDesc)
112//   {
113//     if (!strcmp(enumClassDesc->className, classNameBegin, className))
114//     {
115//       delete iterator;
116//       return enumClassDesc;
117//     }
118//     enumClassDesc = iterator->nextElement();
119//   }
120//   delete iterator;
121//
122//   return NULL;
123// }
124
125
126
127
128/*
129 * @param object The object this Parameter is loaded too.
130 * @param root: the XML-element to load this option from.
131 * @param paramName: The name of the parameter loaded.
132 * @param paramCount: how many parameters this loading-function takes
133 * @param multi: if false LoadParam assumes only one occurence of this parameter in root, if true it assumes multiple occurences.
134 * @param ...: the parameter information (1. Parameter, 2. Default Value for the Parameter, ...)
135*/
136/*LoadParam::LoadParam(const TiXmlElement* root, BaseObject* object, const char* paramName,
137                             int paramCount, bool multi, const void* pointerToParam, ...)
138{
139  this->setClassID(CL_LOAD_PARAM, "LoadParam");
140  this->executor = NULL;
141
142  this->loadString = NULL;
143  this->pointerToParam = pointerToParam;
144
145  if (paramCount == 0 || this->pointerToParam != NULL)
146    this->loadString = "none";
147  else
148{
149      if (likely(!multi))
150        this->loadString = grabParameter(root, paramName);
151      else
152{
153          if (!strcmp(root->Value(), paramName))
154{
155              const TiXmlNode* val = root->FirstChild();
156              if( val->ToText())
157                this->loadString = val->Value();
158}
159}
160}
161
162  this->paramDesc = NULL;
163  if (LoadClassDescription::parametersDescription)
164{
165    // locating the class
166    this->classDesc = LoadClassDescription::addClass(object->getClassName());
167
168    if ((this->paramDesc = this->classDesc->addParam(paramName)) != NULL)
169{
170
171      this->paramDesc->paramCount = paramCount;
172      this->paramDesc->types = new int[paramCount];
173      this->paramDesc->defaultValues = new char*[paramCount];
174
175      va_list types;
176      va_start (types, pointerToParam);
177      char defaultVal[512];
178      for(int i = 0; i < paramCount; i++)
179{
180        defaultVal[0] = '\0';
181          // parameters parsed
182        int tmpType = va_arg (types, int);
183        this->paramDesc->types[i] = tmpType;
184        switch (tmpType)
185{
186  case MT_INT:
187            sprintf(defaultVal, "%d", va_arg(types, int));
188            break;
189//          case MT_LONG:
190//            sprintf(defaultVal, "%0.3f", va_arg(types, l_LONG_TYPE));
191//            break;
192  case MT_FLOAT:
193            sprintf(defaultVal, "%0.3f", va_arg(types, double));
194            break;
195  case MT_STRING:
196            sprintf(defaultVal, "%s", va_arg(types, l_STRING_TYPE));
197            break;
198  case MT_EXT1:
199            sprintf(defaultVal, "");
200            break;
201}
202        this->paramDesc->defaultValues[i] = new char[strlen(defaultVal)+1];
203        strcpy(this->paramDesc->defaultValues[i], defaultVal);
204}
205      va_end(types);
206
207      int argCount = 0;
208}
209}
210}*/
211
212
213
214
215
216
217
218
219
220
221//////////////////////
222// HELPER FUNCTIONS //
223//////////////////////
224/**
225 * @param root: The XML-element to grab a parameter from
226 * @param parameterName: the parameter to grab
227 * @returns the Value of the parameter if found, NULL otherwise
228*/
229std::string grabParameter(const TiXmlElement* root, const std::string& parameterName)
230{
231  const TiXmlElement* element;
232  const TiXmlNode* node;
233
234  if (root == NULL)
235    return "";
236
237  element = root->FirstChildElement( parameterName);
238  if( element == NULL) return "";
239
240  node = element->FirstChild();
241  while( node != NULL)
242  {
243    if( node->ToText()) return node->Value();
244    node = node->NextSibling();
245  }
246  return "";
247}
248
249/**
250 * @param root: The XML-element to grab a parameter from
251 * @param parameterName: the parameter to grab
252 * @returns the Element of the parameter if found, NULL otherwise
253 */
254const TiXmlElement* grabParameterElement(const TiXmlElement* root, const std::string& parameterName)
255{
256  const TiXmlElement* element;
257  const TiXmlNode* node;
258
259  if (root == NULL)
260    return NULL;
261
262  element = root->FirstChildElement( parameterName);
263  if( element == NULL) return NULL;
264
265  node = element->FirstChild();
266  while( node != NULL)
267  {
268    if( node->ToText()) return (TiXmlElement*)node;
269    node = node->NextSibling();
270  }
271  return NULL;
272}
273
274
275
Note: See TracBrowser for help on using the repository browser.