Changeset 9769 in orxonox.OLD for branches/new_class_id/src/lib/util/loading/load_param.h

Timestamp:

Sep 19, 2006, 9:35:11 PM (18 years ago)

Author:

bensch

Message:

orxonox/branches/new_class_id: even more templates (mostly to safe space)

File:

• branches/new_class_id/src/lib/util/loading/load_param.h (modified) (6 diffs)

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

@@ -45 +45 @@
  */
 #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)
 
 /**
@@ -56 +56 @@
  */
 #define LoadParam_CYCLE(ROOT, PARAMETER_NAME, OBJECT, CLASS, FUNCTION) \
-         CLoadParam(ROOT, PARAMETER_NAME, OBJECT, createExecutor<CLASS>(&CLASS::FUNCTION), true)
+         CLoadParam<CLASS>(ROOT, PARAMETER_NAME, OBJECT, createExecutor<CLASS, CLASS>(&CLASS::FUNCTION), true)
 
 /**
@@ -89 +89 @@
 {
 protected:
-  LoadParamBase(const TiXmlElement* root, const std::string& paramName, BaseObject* object, bool inLoadCycle = false);
+  LoadParamBase(const TiXmlElement* root, const std::string& paramName, bool inLoadCycle = false);
 
 protected:
@@ -95 +95 @@
 
 protected:
-  BaseObject*              object;               //!< The Object to work on
   const std::string        paramName;            //!< The Name of the Parameter this LoadParams applies to.
   bool                     inLoadCycle;          //!< If the Parameter is in a LoadCycle.
@@ -104 +103 @@
 
 //! The Loading Class of the LoadParam, that acctually executes the loading process.
-class CLoadParam : public LoadParamBase
+template <class OperateClass> class CLoadParam : public LoadParamBase
 {
 public:
-  CLoadParam(const TiXmlElement* root, const std::string& paramName, BaseObject* object, Executor<const SubString>* executor, bool inLoadCycle = false);
-  virtual ~CLoadParam();
-
+  /**
+   * @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, '\\'));
+      }
+    }
+    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);
+                            const MultiType& value4 = MT_NULL)
+  { this->executor->defaultValues(value0, value1, value2, value3, value4); return *this;  };
   CLoadParam& describe(const std::string& descriptionText) { LoadParamBase::describe(descriptionText); return *this; };
   //     CLoadParam& attribute(const std::string& attributeName, const Executor<SubString>& executor);
@@ -118 +151 @@
 
 private:
-  Executor<const SubString>*         executor;            //!< The Executor, that actually executes the Loading process.
+  Executor<const SubString, OperateClass>*         executor;            //!< The Executor, that actually executes the Loading process.
+  OperateClass*                                    object;
 };