Changeset 9869 in orxonox.OLD for trunk/src/lib/util/loading/load_param.h

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.h (modified) (3 diffs)

trunk/src/lib/util/loading/load_param.h

@@ -22 +22 @@
 #define _LOAD_PARAM_H
 
-#include "base_object.h"
+#include "util/executor/executor_substring.h"
+#include "util/executor/executor_member.h"
+#include "util/executor/functor_member.h"
 
-#include "executor/executor.h"
-#include "executor/executor_xml.h"
+#include "parser/tinyxml/tinyxml.h"
 
 // Forward Declaration //
 class LoadClassDescription;
 class LoadParamDescription;
-class MultiType;
-
+class TiXmlElement;
 
 /**
  * Loads a Parameter from ROOT named PARAMETER_NAME
- * onto OBJECT of CLASS, trough the FUNCTION
+ * onto OBJECT of CLASS, trough FUNCTION
  * @param ROOT the TiXmlElement to load the Parameter from
  * @param PARAMETER_NAME the Name of the Parameter to load
@@ -43 +43 @@
  */
 #define LoadParam(ROOT, PARAMETER_NAME, OBJECT, CLASS, FUNCTION) \
-         CLoadParam(ROOT, PARAMETER_NAME, OBJECT, createExecutor<CLASS>(&CLASS::FUNCTION), false)
+         CLoadParam<CLASS>(ROOT, PARAMETER_NAME, OBJECT, createExecutor<CLASS, CLASS>(&CLASS::FUNCTION), false)
 
+/**
+ * @brief Does essentially the same as LoadParam, but within a Cycle in an ordered fashion.
+ *
+ * This Function looks in each Element, if the PARAMETER_NAME matches, and loads onto OBJECT
+ * of CLASS the ROOT through FUNCTION
+ *
+ * @see LoadParam(ROOT, PARAMETER_NAME, OBJECT, CLASS, FUNCTION)
+ */
 #define LoadParam_CYCLE(ROOT, PARAMETER_NAME, OBJECT, CLASS, FUNCTION) \
-         CLoadParam(ROOT, PARAMETER_NAME, OBJECT, createExecutor<CLASS>(&CLASS::FUNCTION), true)
-
-#define LoadParamXML(ROOT, PARAMETER_NAME, OBJECT, CLASS, FUNCTION) \
-         CLoadParam(ROOT, PARAMETER_NAME, OBJECT, new ExecutorXML<CLASS>(&CLASS::FUNCTION, ROOT, PARAMETER_NAME), false)
-
-#define LoadParamXML_CYCLE(ROOT, PARAMETER_NAME, OBJECT, CLASS, FUNCTION) \
-         CLoadParam(ROOT, PARAMETER_NAME, OBJECT, new ExecutorXML<CLASS>(&CLASS::FUNCTION, ROOT, PARAMETER_NAME), true)
-
+         CLoadParam<CLASS>(ROOT, PARAMETER_NAME, OBJECT, createExecutor<CLASS, CLASS>(&CLASS::FUNCTION), true)
 
 /**
@@ -78 +79 @@
 }
 
+
 /**************************
 **** REAL DECLARATIONS ****
 **************************/
-//! abstract Base class for a Loadable parameter
-class CLoadParam : public BaseObject
+//!< A BaseClass for all LoadParam's.
+class LoadParamBase
 {
-  public:
-    CLoadParam(const TiXmlElement* root, const std::string& paramName, BaseObject* object, Executor* executor, bool inLoadCycle = false);
-    virtual ~CLoadParam();
+protected:
+  LoadParamBase(const TiXmlElement* root, const std::string& paramName, bool inLoadCycle = false);
 
-    CLoadParam& describe(const std::string& descriptionText);
-    CLoadParam& defaultValues(const MultiType& value0 = MT_NULL, const MultiType& value1 = MT_NULL,
-                              const MultiType& value2 = MT_NULL, const MultiType& value3 = MT_NULL,
-                              const MultiType& value4 = MT_NULL);
-    CLoadParam& attribute(const std::string& attributeName, const Executor& executor);
+protected:
+  void describe(const ClassID& classID, const std::string& descriptionText);
+  void setDescriptionValues(const ClassID& classID, unsigned int paramCount, const MultiType* const defaultValues, bool retVal = false);
+
+public:
+  static std::string grabParameter(const TiXmlElement* root, const std::string& parameterName);
+  static const TiXmlElement* grabParameterElement(const TiXmlElement* root, const std::string& parameterName);
+
+protected:
+  const std::string        paramName;            //!< The Name of the Parameter this LoadParams applies to.
+  bool                     inLoadCycle;          //!< If the Parameter is in a LoadCycle.
+
+  const TiXmlElement*      loadElem;             //!< The Element to load.
+};
 
 
-  private:
-    bool                     inLoadCycle;
-    Executor*                executor;
-    BaseObject*              object;
-    const std::string        paramName;
+//! The Loading Class of the LoadParam, that acctually executes the loading process.
+template <class OperateClass> class CLoadParam : public LoadParamBase
+{
+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.
+   * @param inLoadCycle If we are inside of a loading cycle. (Loading will be different here)
+   */
+  CLoadParam(const TiXmlElement* root, const std::string& paramName, OperateClass* object, Executor<const SubString, OperateClass>* executor, bool inLoadCycle = false)
+      : LoadParamBase(root, paramName, inLoadCycle)
+  {
+    assert (executor != NULL);
+    this->object = object;
+    this->executor = executor;
+  }
+  virtual ~CLoadParam()
+  {
+    std::string loadString;
+    if (this->loadElem != NULL &&  this->loadElem->ToText())
+    {
+      loadString = this->loadElem->Value();
+      if (!loadString.empty())
+      {
+        /*      PRINTF(4)("Loading value '%s' with Parameters '%s' onto: %s::%s\n",
+                this->paramName.c_str(), loadString.c_str(), this->object->getClassCName(), this->object->getCName());*/
+        (*this->executor)(this->object, SubString(loadString, ",", SubString::WhiteSpaces, false, '\\'));
+      }
+    }
+    this->setDescriptionValues(OperateClass::staticClassID(), executor->getParamCount(), executor->getDefaultValues(), executor->hasRetVal());
+    delete this->executor;
+  }
+  /**
+   * @brief set the default values of the executor
+   * @param value0 the first default value   @param value1 the second default value
+   * @param value2 the third default value   @param value3 the fourth default value
+   * @param value4 the fifth default value
+   */
+  CLoadParam& defaultValues(const MultiType& value0 = MT_NULL, const MultiType& value1 = MT_NULL,
+                            const MultiType& value2 = MT_NULL, const MultiType& value3 = MT_NULL,
+                            const MultiType& value4 = MT_NULL)
+  { this->executor->defaultValues(value0, value1, value2, value3, value4); return *this;  };
+  //! Describes a LoadParam
+  CLoadParam& describe(const std::string& descriptionText) { LoadParamBase::describe(OperateClass::staticClassID(), descriptionText); return *this; };
+  //     CLoadParam& attribute(const std::string& attributeName, const Executor<SubString>& executor);
 
-    LoadClassDescription*    classDesc;            //!< The LoadClassDescription of this CLoadParameter
-    LoadParamDescription*    paramDesc;            //!< The LoadParameterDescription of this LoadParameter
-    const TiXmlElement*      loadElem;             //!< The Element to load.
-    const void*              pointerToParam;       //!< A Pointer to a Parameter.
-
-    MultiType*               defaultValue;
+private:
+  Executor<const SubString, OperateClass>*         executor;            //!< The Executor, that actually executes the Loading process.
+  OperateClass*                                    object;              //!< The Object this LoadParam operates on.
 };
 
-// helper function
-
-std::string grabParameter(const TiXmlElement* root, const std::string& parameterName);
-const TiXmlElement* grabParameterElement(const TiXmlElement* root, const std::string& parameterName);
-
 #endif /* _LOAD_PARAM_H */