Planet
navi homePPSaboutscreenshotsdownloaddevelopmentforum

source: orxonox.OLD/trunk/src/lib/util/loading/load_param_description.cc @ 8536

Last change on this file since 8536 was 8362, checked in by bensch, 18 years ago

orxonox/trunk: removed stupid included in base_object.h
this should lead to faster compile-times

File size: 7.3 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#include "load_param_description.h"
17
18#include "multi_type.h"
19#include <stdarg.h>
20#include "debug.h"
21
22/**
23 * @param paramName the name of the parameter to load
24 */
25LoadParamDescription::LoadParamDescription(const std::string& paramName)
26{
27  this->types = NULL;
28  this->defaultValues = NULL;
29  this->paramName = paramName;
30}
31
32/**
33 *  removes all the alocated memory
34 */
35LoadParamDescription::~LoadParamDescription()
36{
37  if (this->defaultValues != NULL)
38  {
39    for(int i = 0; i < this->paramCount; i++)
40    {
41      delete[] this->defaultValues[i];
42    }
43  }
44
45  delete[] this->types;
46  delete[] this->defaultValues;
47}
48
49/**
50 * @param descriptionText The text to set as a description for this Parameter
51 */
52void LoadParamDescription::setDescription(const std::string& descriptionText)
53{
54  this->description = descriptionText;
55}
56
57/**
58 *  prints out this parameter, its input method and the description (if availiable)
59 */
60void LoadParamDescription::print() const
61{
62  PRINT(3)(" <%s>", this->paramName.c_str());
63  for (int i = 0; i < this->paramCount; i++)
64  {
65    if (i > 0)
66      PRINT(3)(",");
67    // FIXME
68    //     switch (this->types[i])
69//     {
70//       default:
71//         PRINTF(3)("none");
72//         break;
73//       case ParameterBool:
74//         PRINT(3)("bool");
75//         break;
76//       case ParameterChar:
77//         PRINT(3)("char");
78//         break;
79//       case ParameterString:
80//         PRINT(3)("string");
81//         break;
82//       case ParameterInt:
83//         PRINT(3)("int");
84//         break;
85//       case ParameterUInt:
86//         PRINT(3)("Uint");
87//         break;
88//       case ParameterFloat:
89//         PRINT(3)("float");
90//         break;
91//       case ParameterLong:
92//         PRINT(3)("long");
93//         break;
94//       case ParameterXML:
95//         PRINT(3)("XML");
96//         break;
97//     }
98  }
99  PRINT(3)("</%s>", this->paramName.c_str());
100  if (!this->description.empty())
101    PRINT(3)(" -- %s", this->description.c_str());
102  // default values
103  if (this->paramCount > 0)
104  {
105    PRINT(3)(" (Default: ");
106    for (int i = 0; i < this->paramCount; i++)
107    {
108      if (i > 0)
109        PRINT(3)(", ");
110      if (this->types[i] & MT_STRING)
111      { // leave brackets !!
112        PRINT(3)("\"%s\"", this->defaultValues[i]);
113      }
114      else
115      {
116        PRINT(3)("%s", this->defaultValues[i]);
117      }
118    }
119    PRINT(3)(")");
120  }
121  PRINT(3)("\n");
122}
123
124/**
125 *  A list, that holds all the classes that are loadable (classes not objects!!)
126 */
127std::list<LoadClassDescription*>* LoadClassDescription::classList = NULL;
128
129/**
130 *  if the description of Parameters should be executed
131 */
132bool LoadClassDescription::parametersDescription = false;
133
134/**
135 * @param className the name of the class to be loadable
136 */
137LoadClassDescription::LoadClassDescription(const std::string& className)
138{
139  this->className = className;
140
141  if (LoadClassDescription::classList == NULL)
142    LoadClassDescription::classList = new std::list<LoadClassDescription*>;
143
144  LoadClassDescription::classList->push_back(this);
145}
146
147/**
148 *  deletes a classDescription (deletes all the parameterDescriptions as well
149 */
150LoadClassDescription::~LoadClassDescription()
151{
152  std::list<LoadParamDescription*>::iterator it = this->paramList.begin();
153  while (!this->paramList.empty())
154  {
155    delete this->paramList.front();
156    this->paramList.pop_front();
157  }
158}
159
160void LoadClassDescription::deleteAllDescriptions()
161{
162  if (LoadClassDescription::classList != NULL)
163  {
164    while (!LoadClassDescription::classList->empty())
165    {
166      delete LoadClassDescription::classList->front();
167      LoadClassDescription::classList->pop_front();
168    }
169    delete LoadClassDescription::classList;
170  }
171  LoadClassDescription::classList = NULL;
172}
173
174
175/**
176 *  adds a class to the list of loadable classes
177 * @param className The name of the class to add
178
179   this function searches for the className string, and if found just returns the appropriate Class.
180   Otherwise it returns a new classDescription
181 */
182LoadClassDescription* LoadClassDescription::addClass(const std::string& className)
183{
184  if (LoadClassDescription::classList != NULL)
185  {
186    std::list<LoadClassDescription*>::iterator it = LoadClassDescription::classList->begin();
187    while (it != LoadClassDescription::classList->end())
188    {
189      if ((*it)->className == className)
190      {
191        return (*it);
192      }
193      it++;
194    }
195  }
196  return new LoadClassDescription(className);
197}
198
199/**
200 *  does the same as addClass(const std::string& className), but with params
201 * @param paramName the name of the parameter to add.
202 */
203LoadParamDescription* LoadClassDescription::addParam(const std::string& paramName)
204{
205  std::list<LoadParamDescription*>::iterator it = this->paramList.begin();
206  while (it != this->paramList.end())
207  {
208    if ((*it)->paramName == paramName)
209    {
210      return NULL;
211    }
212    it++;
213  }
214
215  LoadParamDescription* newParam = new LoadParamDescription(paramName);
216
217  this->paramList.push_back(newParam);
218  return newParam;
219}
220
221/**
222 *  prints out all loadable Classes, and their parameters
223 * @param fileName prints the output to a File
224 * @todo implement it
225 */
226void LoadClassDescription::printAll(const std::string& fileName)
227{
228  PRINT(3)("===============================================================\n");
229  PRINT(3)(" Listing all the Loadable Options (loaded since Game started).\n\n");
230  if (LoadClassDescription::classList != NULL)
231  {
232    std::list<LoadClassDescription*>::iterator classDesc = LoadClassDescription::classList->begin();
233    while (classDesc != LoadClassDescription::classList->end())
234    {
235      PRINT(3)("<%s>\n", (*classDesc)->className.c_str());
236      std::list<LoadParamDescription*>::iterator param = (*classDesc)->paramList.begin();
237      while (param != (*classDesc)->paramList.end())
238      {
239        (*param)->print();
240        param++;
241      }
242      PRINT(3)("</%s>\n\n", (*classDesc)->className.c_str());
243      classDesc++;
244    }
245  }
246  else
247    PRINT(3)("no Classes defined so far\n");
248  PRINT(3)("===============================================================\n");
249}
250
251/**
252 * searches for classes, which beginn with classNameBegin
253 * @param classNameBegin the beginning string of a Class
254 * @return a NEW char-array with ClassNames. The LIST should be deleted afterwards,
255 * !! The strings MUST NOT be deleted !!
256 */
257std::list<std::string> LoadClassDescription::searchClassWithShort(const std::string& classNameBegin)
258{
259  /// FIXME
260  // NOT USED
261/*  unsigned int searchLength = strlen(classNameBegin);
262  std::list<const std::string&> retVal;
263
264  tIterator<LoadClassDescription>* iterator = LoadClassDescription::classList->getIterator();
265  LoadClassDescription* enumClassDesc = iterator->firstElement();
266  while (enumClassDesc)
267  {
268    if (strlen(enumClassDesc->className)>searchLength+1 &&
269        !strncasecmp(enumClassDesc->className, classNameBegin, searchLength))
270    {
271      retVal->add(enumClassDesc->className);
272    }
273    enumClassDesc = iterator->nextElement();
274  }
275  delete iterator;
276
277  return retVal;*/
278  std::list<std::string> a;
279  return a;
280}
Note: See TracBrowser for help on using the repository browser.