Changeset 9771 in orxonox.OLD for branches/new_class_id/src/lib

Timestamp:

Sep 19, 2006, 11:33:27 PM (18 years ago)

Author:

bensch

Message:

first step in the direction of parameter descriptions… again

Location:

branches/new_class_id/src/lib/util/loading

Files:

• load_param.cc (modified) (2 diffs)
• load_param.h (modified) (4 diffs)
• load_param_class_description.cc (modified) (3 diffs)
• load_param_class_description.h (modified) (3 diffs)
• load_param_description.h (modified) (2 diffs)
• load_param_xml.h (modified) (1 diff)

branches/new_class_id/src/lib/util/loading/load_param.cc

@@ -49 +49 @@
   classID.name().c_str(), classID.id(), paramName.c_str(), descriptionText.c_str());
 
-//  LoadParamDescription
-
-  /// TODO REIMPLEMENT
-  /*  if (LoadParamClassDescription::parametersDescription && this->paramDesc && this->paramDesc->getDescription().empty())
-  {
-    this->paramDesc->setDescription(descriptionText);
-  }*/
+  LoadParamClassDescription::describeClass(classID, paramName, descriptionText);
 }
 
-
-
+/**
+ * @brief sets the Values of the Description to a usefull text.
+ */
+void LoadParamBase::setDescriptionValues(const ClassID& classID, unsigned int paramCount, const MultiType* const defaultValues, bool retVal)
+{
+  LoadParamClassDescription::setValuesOf(classID, paramName, paramCount, defaultValues, retVal);
+}
 
 
@@ -70 +69 @@
  * @returns the Value of the parameter if found, NULL otherwise
 */
-const std::string& LoadParamBase::grabParameter(const TiXmlElement* root, const std::string& parameterName)
+std::string LoadParamBase::grabParameter(const TiXmlElement* root, const std::string& parameterName)
 {
   const TiXmlElement* const element = grabParameterElement(root, parameterName);

branches/new_class_id/src/lib/util/loading/load_param.h

@@ -92 +92 @@
 
 protected:
-  void describe(const ClassID& id, const std::string& descriptionText);
+  void describe(const ClassID& classID, const std::string& descriptionText);
+  void setDescriptionValues(const ClassID& classID, unsigned int paramCount, const MultiType* const defaultValues, bool retVal = false);
 
-private:
-  const std::string& grabParameter(const TiXmlElement* root, const std::string& parameterName);
-  const TiXmlElement* grabParameterElement(const TiXmlElement* root, const std::string& parameterName);
-
+public:
+  static std::string grabParameter(const TiXmlElement* root, const std::string& parameterName);
+  static const TiXmlElement* grabParameterElement(const TiXmlElement* root, const std::string& parameterName);
 
 protected:
@@ -112 +112 @@
 public:
   /**
-   * @brief generates a LoadParam based on
-   * @param root the Root Element to load onto the object.
-   * @param paramName the Parameter name that is loaded.
-   * @param object the Object to apply the changes on.
-   * @param executor the Functional Object, that actually executes the function Call.
+   * @brief generates a LoadParam based on:
+   * @param root the Root Element to load onto the object. @param paramName the Parameter name that is loaded.
+   * @param object the Object to apply the changes on. @param executor the Functional Object, that actually executes the function Call.
    * @param inLoadCycle If we are inside of a loading cycle. (Loading will be different here)
    */
@@ -139 +137 @@
       }
     }
+    this->setDescriptionValues(OperateClass::staticClassID(), executor->getParamCount(), executor->getDefaultValues(), executor->hasRetVal());
     delete this->executor;
   }
@@ -159 +158 @@
 };
 
-// helper function
-
-
 #endif /* _LOAD_PARAM_H */

branches/new_class_id/src/lib/util/loading/load_param_class_description.cc

@@ -22 +22 @@
  *  A list, that holds all the classes that are loadable (classes not objects!!)
  */
-LoadParamClassDescription::ClassDescriptionSet LoadParamClassDescription::_classList;
+LoadParamClassDescription::ClassDescriptionMap LoadParamClassDescription::_classList;
 
 /**
@@ -48 +48 @@
 
 
+
+void LoadParamClassDescription::describeClass(const ClassID& classID,
+    const std::string& paramName,
+    const std::string& descriptionText)
+{
+  ParamDescriptionMap::iterator it = LoadParamClassDescription::getParamDescription(classID, paramName);
+
+}
+
+
+void LoadParamClassDescription::setValuesOf(const ClassID& classID,
+    const std::string& paramName,
+    unsigned int paramCount,
+    const MultiType* const defaultValues,
+    bool retVal)
+{
+  ParamDescriptionMap::iterator it = LoadParamClassDescription::getParamDescription(classID, paramName);
+
+}
+
+
 /**
- *  prints out all loadable Classes, and their parameters
+ * @brief finds the Iterator to the ParameterDescription paramName matching classID
+ * @param classID the ClassID to match.
+ * @param paramName the name of the parameter in the Class.
+ * @returns the iterator on match.
+ *
+ * @note this function creates the Element classID.name()::paramName on the go if it does not exist.
+ */
+LoadParamClassDescription::ParamDescriptionMap::iterator
+LoadParamClassDescription::getParamDescription(const ClassID& classID, const std::string& paramName)
+{
+  /// Locate the ClassDescription first
+  ClassDescriptionMap::iterator classIt = LoadParamClassDescription::_classList.find(classID);
+  if (classIt == LoadParamClassDescription::_classList.end())
+  {
+    LoadParamClassDescription::_classList[classID] = LoadParamClassDescription(classID.name());
+    classIt = LoadParamClassDescription::_classList.find(classID);
+    printf("Inserted %s\n", classID.name().c_str());
+    printAll("");
+  }
+  // At this position the class-iterator should point to a valid usefull position.
+  assert(classIt != LoadParamClassDescription::_classList.end());
+
+  /// Now locate the description with paramName.
+  ParamDescriptionMap::iterator paramIt = (*classIt).second._parameters.find(paramName);
+  if (paramIt == (*classIt).second._parameters.end())
+  {
+    (*classIt).second._parameters[paramName] = LoadParamDescription(paramName);
+    paramIt = (*classIt).second._parameters.find(paramName);
+  }
+  // at this position the param-iterator should
+  assert (paramIt != (*classIt).second._parameters.end());
+
+  return (paramIt);
+}
+
+
+
+
+/**
+ * @brief prints out all loadable Classes, and their parameters
  * @param fileName prints the output to a File
  * @todo implement it
@@ -55 +115 @@
 void LoadParamClassDescription::printAll(const std::string& fileName)
 {
-  PRINT(3)("===============================================================\n");
-  PRINT(3)(" Listing all the Loadable Options (loaded since Game started).\n\n");
-  for (ClassDescriptionSet::const_iterator classIt = LoadParamClassDescription::_classList.begin();
-       classIt != LoadParamClassDescription::_classList.begin();
+  PRINT(0)("===============================================================\n");
+  PRINT(0)(" Listing all the Loadable Options (loaded since Game started).\n\n");
+  for (ClassDescriptionMap::const_iterator classIt = LoadParamClassDescription::_classList.begin();
+       classIt != LoadParamClassDescription::_classList.end();
        classIt ++)
   {
-    PRINT(3)("<%s>\n", (*classIt)._className.c_str());
-    for (ParamDescriptionSet::const_iterator param = (*classIt)._parameters.begin();
-         param != (*classIt)._parameters.end();
+    PRINT(0)("<%s>\n", (*classIt).second._className.c_str());
+    for (ParamDescriptionMap::const_iterator param = (*classIt).second._parameters.begin();
+         param != (*classIt).second._parameters.end();
          ++param)
     {
-      (*param).print();
+    ///  (*param).second.print();
     }
-    PRINT(3)("</%s>\n\n", (*classIt)._className.c_str());
+    PRINT(0)("</%s>\n\n", (*classIt).second._className.c_str());
   }
-  PRINT(3)("===============================================================\n");
+  PRINT(0)("===============================================================\n");
 }

branches/new_class_id/src/lib/util/loading/load_param_class_description.h

@@ -23 +23 @@
 
 #include "load_param_description.h"
+#include "class_id.h"
+#include <map>
 #include <set>
-
 // Forward Declaration //
 class MultiType;
@@ -32 +33 @@
 {
 public:
-  LoadParamClassDescription(const std::string& className);
+  LoadParamClassDescription(const std::string& className = "");
   ~LoadParamClassDescription();
 
@@ -39 +40 @@
   bool operator<(const LoadParamClassDescription& classDescr) const { return this->_className < classDescr._className; }
 
+
+  static void describeClass(const ClassID& classID,
+                            const std::string& paramName,
+                            const std::string& descriptionText);
+  static void setValuesOf(const ClassID& classID,
+                          const std::string& paramName,
+                          unsigned int paramCount,
+                          const MultiType* const defaultValues,
+                          bool retVal = false);
+
   static void deleteAllDescriptions();
-
-
 
   static void printAll(const std::string& fileName = "");
 
 private:
-  typedef std::set<LoadParamClassDescription>  ClassDescriptionSet;
-  typedef std::set<LoadParamDescription>       ParamDescriptionSet;
+  typedef std::map<ClassID, LoadParamClassDescription>  ClassDescriptionMap;
+  typedef std::map<std::string, LoadParamDescription>   ParamDescriptionMap;
+
+private:
+  static ParamDescriptionMap::iterator getParamDescription(const ClassID& classID, const std::string& paramName);
+
+private:
 
   static bool                                  _parametersDescription;  //!< if parameter-description should be enabled globally.
 
-  static ClassDescriptionSet                   _classList;              //!< a list, that stores all the loadable classes. (after one instance has been loaded)
+  static ClassDescriptionMap                   _classList;              //!< a list, that stores all the loadable classes. (after one instance has been loaded)
 
 private:
   std::string                                  _className;              //!< name of the class
-  ParamDescriptionSet                          _parameters;              //!< List of parameters this class knows.
+  ParamDescriptionMap                          _parameters;             //!< List of parameters this class knows.
 };
 

branches/new_class_id/src/lib/util/loading/load_param_description.h

@@ -35 +35 @@
 {
 public:
-  LoadParamDescription(const std::string& paramName);
+  LoadParamDescription(const std::string& paramName = "");
   ~LoadParamDescription();
 
@@ -49 +49 @@
 
 private:
-  const std::string          _name;                  //!< The Name of the Parameter.
+  std::string                _name;                  //!< The Name of the Parameter.
   unsigned int               _parameterCount;        //!< The Count of parameters.
   std::string                _description;           //!< A longer description about this function.

branches/new_class_id/src/lib/util/loading/load_param_xml.h

@@ -71 +71 @@
   virtual ~XmlLoadParam()
   {
+    this->setDescriptionValues(OperateClass::staticClassID(), executor->getParamCount(), executor->getDefaultValues(), executor->hasRetVal());
     (*this->executor)(this->object, this->loadElem);
     delete this->executor;