Changeset 9869 in orxonox.OLD for trunk/src/lib/util/loading/load_param_description.cc

Timestamp:

Oct 3, 2006, 12:19:30 AM (19 years ago)

Author:

bensch

Message:

orxonox/trunk: merged the new_class_id branche back to the trunk.
merged with command:
svn merge ​https://svn.orxonox.net/orxonox/branches/new_class_id trunk -r9683:HEAD
no conflicts… puh..

File:

• trunk/src/lib/util/loading/load_param_description.cc (modified) (2 diffs)

trunk/src/lib/util/loading/load_param_description.cc

@@ -17 +17 @@
 
 #include "multi_type.h"
-#include <stdarg.h>
 #include "debug.h"
 
 /**
+ * @brief Creates a Description of a LoadParam
  * @param paramName the name of the parameter to load
  */
 LoadParamDescription::LoadParamDescription(const std::string& paramName)
-{
-  this->types = NULL;
-  this->defaultValues = NULL;
-  this->paramName = paramName;
-}
-
-/**
- *  removes all the alocated memory
- */
-LoadParamDescription::~LoadParamDescription()
-{
-  if (this->defaultValues != NULL)
-  {
-    for(int i = 0; i < this->paramCount; i++)
-    {
-      delete[] this->defaultValues[i];
-    }
-  }
-
-  delete[] this->types;
-  delete[] this->defaultValues;
-}
+    : _name(paramName), _parameterCount(0)
+{ }
 
 /**
@@ -52 +32 @@
 void LoadParamDescription::setDescription(const std::string& descriptionText)
 {
-  this->description = descriptionText;
+  this->_description = descriptionText;
 }
 
 /**
- *  prints out this parameter, its input method and the description (if availiable)
+ * @brief sets the Values of the LoadParam in the Description.
+ * @param paramCount the count of arguments the underlying paramDescription takes.
+ * @param defaultValues the default Values the underlying parameter takes.
+ * @param retVal if the underlying parameter has a return value
  */
-void LoadParamDescription::print() const
+void LoadParamDescription::setValues(unsigned int paramCount,
+                                     const MultiType* const defaultValues,
+                                     bool retVal)
 {
-  PRINT(3)(" <%s>", this->paramName.c_str());
-  for (int i = 0; i < this->paramCount; i++)
+  this->_parameterCount = paramCount;
+  for (unsigned int i = 0; i < paramCount; ++i)
   {
-    if (i > 0)
-      PRINT(3)(",");
-    // FIXME
-    //     switch (this->types[i])
-//     {
-//       default:
-//         PRINTF(3)("none");
-//         break;
-//       case ParameterBool:
-//         PRINT(3)("bool");
-//         break;
-//       case ParameterChar:
-//         PRINT(3)("char");
-//         break;
-//       case ParameterString:
-//         PRINT(3)("string");
-//         break;
-//       case ParameterInt:
-//         PRINT(3)("int");
-//         break;
-//       case ParameterUInt:
-//         PRINT(3)("Uint");
-//         break;
-//       case ParameterFloat:
-//         PRINT(3)("float");
-//         break;
-//       case ParameterLong:
-//         PRINT(3)("long");
-//         break;
-//       case ParameterXML:
-//         PRINT(3)("XML");
-//         break;
-//     }
+    this->_defaultValues.push_back(defaultValues[i].getString());
+    this->_types.push_back(MultiType::MultiTypeToString(defaultValues[i].getType()));
   }
-  PRINT(3)("</%s>", this->paramName.c_str());
-  if (!this->description.empty())
-    PRINT(3)(" -- %s", this->description.c_str());
-  // default values
-  if (this->paramCount > 0)
-  {
-    PRINT(3)(" (Default: ");
-    for (int i = 0; i < this->paramCount; i++)
-    {
-      if (i > 0)
-        PRINT(3)(", ");
-      if (this->types[i] & MT_STRING)
-      { // leave brackets !!
-        PRINT(3)("\"%s\"", this->defaultValues[i]);
-      }
-      else
-      {
-        PRINT(3)("%s", this->defaultValues[i]);
-      }
-    }
-    PRINT(3)(")");
-  }
-  PRINT(3)("\n");
-}
 
-/**
- *  A list, that holds all the classes that are loadable (classes not objects!!)
- */
-std::list<LoadClassDescription*>* LoadClassDescription::classList = NULL;
-
-/**
- *  if the description of Parameters should be executed
- */
-bool LoadClassDescription::parametersDescription = false;
-
-/**
- * @param className the name of the class to be loadable
- */
-LoadClassDescription::LoadClassDescription(const std::string& className)
-{
-  this->className = className;
-
-  if (LoadClassDescription::classList == NULL)
-    LoadClassDescription::classList = new std::list<LoadClassDescription*>;
-
-  LoadClassDescription::classList->push_back(this);
-}
-
-/**
- *  deletes a classDescription (deletes all the parameterDescriptions as well
- */
-LoadClassDescription::~LoadClassDescription()
-{
-  std::list<LoadParamDescription*>::iterator it = this->paramList.begin();
-  while (!this->paramList.empty())
-  {
-    delete this->paramList.front();
-    this->paramList.pop_front();
-  }
-}
-
-void LoadClassDescription::deleteAllDescriptions()
-{
-  if (LoadClassDescription::classList != NULL)
-  {
-    while (!LoadClassDescription::classList->empty())
-    {
-      delete LoadClassDescription::classList->front();
-      LoadClassDescription::classList->pop_front();
-    }
-    delete LoadClassDescription::classList;
-  }
-  LoadClassDescription::classList = NULL;
 }
 
 
 /**
- *  adds a class to the list of loadable classes
- * @param className The name of the class to add
-
-   this function searches for the className string, and if found just returns the appropriate Class.
-   Otherwise it returns a new classDescription
+ * @brief prints out this parameter, its input method and the description (if availiable)
+ * @param stream the stream to print to.
+ * @param withComments if the comments should be appended.
  */
-LoadClassDescription* LoadClassDescription::addClass(const std::string& className)
+void LoadParamDescription::print(FILE* stream, bool withComments) const
 {
-  if (LoadClassDescription::classList != NULL)
+  fprintf(stream, " <%s>", this->_name.c_str());
+  for (unsigned int i = 0; i < this->_parameterCount; i++)
   {
-    std::list<LoadClassDescription*>::iterator it = LoadClassDescription::classList->begin();
-    while (it != LoadClassDescription::classList->end())
+    if (i > 0)
+      fprintf(stream, ",");
+    fprintf(stream, "%s", this->_types[i].c_str());
+  }
+  fprintf(stream, "</%s>", this->_name.c_str());
+  // here the comments are printed out.
+  if (withComments)
+  {
+    if (!this->_description.empty())
+      fprintf(stream, " <!-- %s", this->_description.c_str());
+    // default values
+    if (this->_parameterCount > 0)
     {
-      if ((*it)->className == className)
+      fprintf(stream, " (Default: ");
+      for (unsigned int i = 0; i < this->_parameterCount; i++)
       {
-        return (*it);
+        if (i > 0)
+          fprintf(stream, ", ");
+        if (this->_types[i] == "string")
+        { // leave brackets !!
+          fprintf(stream, "\"%s\"", this->_defaultValues[i].c_str());
+        }
+        else
+        {
+          fprintf(stream, "%s", this->_defaultValues[i].c_str());
+        }
       }
-      it++;
+      fprintf(stream, ")");
     }
+    if (!this->_description.empty() || this->_parameterCount > 0)
+      fprintf(stream, " -->");
   }
-  return new LoadClassDescription(className);
+  fprintf(stream, "\n");
 }
 
-/**
- *  does the same as addClass(const std::string& className), but with params
- * @param paramName the name of the parameter to add.
- */
-LoadParamDescription* LoadClassDescription::addParam(const std::string& paramName)
-{
-  std::list<LoadParamDescription*>::iterator it = this->paramList.begin();
-  while (it != this->paramList.end())
-  {
-    if ((*it)->paramName == paramName)
-    {
-      return NULL;
-    }
-    it++;
-  }
 
-  LoadParamDescription* newParam = new LoadParamDescription(paramName);
-
-  this->paramList.push_back(newParam);
-  return newParam;
-}
-
-/**
- *  prints out all loadable Classes, and their parameters
- * @param fileName prints the output to a File
- * @todo implement it
- */
-void LoadClassDescription::printAll(const std::string& fileName)
-{
-  PRINT(3)("===============================================================\n");
-  PRINT(3)(" Listing all the Loadable Options (loaded since Game started).\n\n");
-  if (LoadClassDescription::classList != NULL)
-  {
-    std::list<LoadClassDescription*>::iterator classDesc = LoadClassDescription::classList->begin();
-    while (classDesc != LoadClassDescription::classList->end())
-    {
-      PRINT(3)("<%s>\n", (*classDesc)->className.c_str());
-      std::list<LoadParamDescription*>::iterator param = (*classDesc)->paramList.begin();
-      while (param != (*classDesc)->paramList.end())
-      {
-        (*param)->print();
-        param++;
-      }
-      PRINT(3)("</%s>\n\n", (*classDesc)->className.c_str());
-      classDesc++;
-    }
-  }
-  else
-    PRINT(3)("no Classes defined so far\n");
-  PRINT(3)("===============================================================\n");
-}
-
-/**
- * searches for classes, which beginn with classNameBegin
- * @param classNameBegin the beginning string of a Class
- * @return a NEW char-array with ClassNames. The LIST should be deleted afterwards,
- * !! The strings MUST NOT be deleted !!
- */
-std::list<std::string> LoadClassDescription::searchClassWithShort(const std::string& classNameBegin)
-{
-  /// FIXME
-  // NOT USED
-/*  unsigned int searchLength = strlen(classNameBegin);
-  std::list<const std::string&> retVal;
-
-  tIterator<LoadClassDescription>* iterator = LoadClassDescription::classList->getIterator();
-  LoadClassDescription* enumClassDesc = iterator->firstElement();
-  while (enumClassDesc)
-  {
-    if (strlen(enumClassDesc->className)>searchLength+1 &&
-        !strncasecmp(enumClassDesc->className, classNameBegin, searchLength))
-    {
-      retVal->add(enumClassDesc->className);
-    }
-    enumClassDesc = iterator->nextElement();
-  }
-  delete iterator;
-
-  return retVal;*/
-  std::list<std::string> a;
-  return a;
-}