Changeset 7721 in orxonox.OLD

Timestamp:

May 19, 2006, 4:05:41 AM (18 years ago)

Author:

bensch

Message:

orxonox/trunk: introduced the absolutely new, much faster, more templated, and easier to look at Executor, and use it directly inside the LoadParam-Class

Location:

trunk/src

Files:

• lib/Makefile.am (modified) (1 diff)
• lib/util/executor/executor.cc (modified) (1 diff)
• lib/util/executor/executor_functional.h (modified) (1 diff)
• lib/util/loading/load_param.cc (modified) (2 diffs)
• lib/util/loading/load_param.h (modified) (3 diffs)
• orxonox.cc (modified) (2 diffs)

trunk/src/lib/Makefile.am

@@ -15 +15 @@
                 util/multi_type.cc \
                 util/executor/executor.cc \
+                util/executor/executor_functional.cc \
                 \
                 util/loading/resource_manager.cc \

trunk/src/lib/util/executor/executor.cc

@@ -33 +33 @@
                    const MultiType& param4)
 {
-//  this->setClassID(CL_EXECUTOR, "Executor");
+  this->setClassID(CL_EXECUTOR, "Executor");
 
   // What Parameters have we got

trunk/src/lib/util/executor/executor_functional.h

@@ -23 +23 @@
 #define __EXECUTOR_FUNCTIONAL_H_
 
-
+#include "base_object.h"
+#include "multi_type.h"
+#include "executor.h"
 
 template<typename type> MT_Type ExecutorParamType() { return MT_EXT1; };
-template<> MT_Type ExecutorParamType<bool>() { return MT_EXT1; };
-template<> MT_Type ExecutorParamType<int>() { return MT_INT; };
-template<> MT_Type ExecutorParamType<unsigned int>() { return MT_UINT; };
-template<> MT_Type ExecutorParamType<float>() { return MT_FLOAT; };
-template<> MT_Type ExecutorParamType<char>() { return MT_CHAR; };
-template<> MT_Type ExecutorParamType<const std::string&>() { return MT_STRING; };
+template<> MT_Type ExecutorParamType<bool>();
+template<> MT_Type ExecutorParamType<int>();
+template<> MT_Type ExecutorParamType<unsigned int>();
+template<> MT_Type ExecutorParamType<float>();
+template<> MT_Type ExecutorParamType<char>();
+template<> MT_Type ExecutorParamType<const std::string&>();
 
 template<typename type> type fromString(const std::string& input, type defaultValue) {return defaultValue; };
-template<> bool fromString<bool>(const std::string& input, bool defaultValue) { return isBool(input, defaultValue); };
-template<> int fromString<int>(const std::string& input, int defaultValue) { return isInt(input, defaultValue); };
-template<> unsigned int fromString<unsigned int>(const std::string& input, unsigned int defaultValue) { return isInt(input, defaultValue); };
-template<> float fromString<float>(const std::string& input, float defaultValue) { return isFloat(input, defaultValue); };
-template<> char fromString<char>(const std::string& input, char defaultValue) { return isInt(input, defaultValue); };
-template<> const std::string& fromString<const std::string&>(const std::string& input, const std::string& defaultValue) { static std::string retVal = isString(input, defaultValue); return retVal; };
+template<> bool fromString<bool>(const std::string& input, bool defaultValue);
+template<> int fromString<int>(const std::string& input, int defaultValue);
+template<> unsigned int fromString<unsigned int>(const std::string& input, unsigned int defaultValue);
+template<> float fromString<float>(const std::string& input, float defaultValue);
+template<> char fromString<char>(const std::string& input, char defaultValue);
+template<> const std::string& fromString<const std::string&>(const std::string& input, const std::string& defaultValue);
 
 template<typename type> type getDefault(const MultiType* const defaultValues, unsigned int i) { return (type)0; };
-template<> bool getDefault<bool>(const MultiType* const defaultValues, unsigned int i) { return defaultValues[i].getBool(); };
-template<> int getDefault<int>(const MultiType* const defaultValues, unsigned int i) { return defaultValues[i].getInt(); };
-template<> unsigned int getDefault<unsigned int>(const MultiType* const defaultValues, unsigned int i) { return defaultValues[i].getInt(); };
-template<> float getDefault<float>(const MultiType* const defaultValues, unsigned int i) { return defaultValues[i].getFloat(); };
-template<> char getDefault<char>(const MultiType* const defaultValues, unsigned int i) { return defaultValues[i].getChar(); };
-template<> const std::string& getDefault<const std::string&>(const MultiType* const defaultValues, unsigned int i) { static std::string retVal = defaultValues[i].getString(); return retVal; };
+template<> bool getDefault<bool>(const MultiType* const defaultValues, unsigned int i);
+template<> int getDefault<int>(const MultiType* const defaultValues, unsigned int i);
+template<> unsigned int getDefault<unsigned int>(const MultiType* const defaultValues, unsigned int i);
+template<> float getDefault<float>(const MultiType* const defaultValues, unsigned int i);
+template<> char getDefault<char>(const MultiType* const defaultValues, unsigned int i);
+template<> const std::string& getDefault<const std::string&>(const MultiType* const defaultValues, unsigned int i);
 
 #endif /* __EXECUTOR_FUNCTIONAL_H_ */

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

@@ -28 +28 @@
  * @param executor the Executor, that executes the loading procedure.
  */
-CLoadParam::CLoadParam(const TiXmlElement* root, const std::string& paramName, BaseObject* object, const Executor& executor, bool inLoadCycle)
+CLoadParam::CLoadParam(const TiXmlElement* root, const std::string& paramName, BaseObject* object, Executor* executor, bool inLoadCycle)
   :  paramName(paramName), object(object)
 {
@@ -43 +43 @@
 
   // set the Executor.
-  this->executor = executor.clone();
+  this->executor = executor;
 
   //if (this->executor)

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

@@ -25 +25 @@
 
 #include "executor/executor.h"
+
+/// HACK HACK TAKE THIS INTO THE EXECUTOR
+#include "executor/executor_functional.h"
+#define EXECUTOR_FUNCTIONAL_USE_STATIC
+#include "executor/executor_functional.h"
+
 #include "executor/executor_specials.h"
 
@@ -45 +51 @@
  */
 #define LoadParam(ROOT, PARAMETER_NAME, OBJECT, CLASS, FUNCTION) \
-         CLoadParam(ROOT, PARAMETER_NAME, OBJECT, ExecutorObjective<CLASS>(&CLASS::FUNCTION), false)
+         CLoadParam(ROOT, PARAMETER_NAME, OBJECT, createExecutor<CLASS>(&CLASS::FUNCTION), false)
 
 #define LoadParam_CYCLE(ROOT, PARAMETER_NAME, OBJECT, CLASS, FUNCTION) \
-         CLoadParam(ROOT, PARAMETER_NAME, OBJECT, ExecutorObjective<CLASS>(&CLASS::FUNCTION), true)
+         CLoadParam(ROOT, PARAMETER_NAME, OBJECT, createExecutor<CLASS>(&CLASS::FUNCTION), true)
 
 #define LoadParamXML(ROOT, PARAMETER_NAME, OBJECT, CLASS, FUNCTION) \
-         CLoadParam(ROOT, PARAMETER_NAME, OBJECT, ExecutorXML<CLASS>(&CLASS::FUNCTION, ROOT, PARAMETER_NAME), false)
+         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, ExecutorXML<CLASS>(&CLASS::FUNCTION, ROOT, PARAMETER_NAME), true)
+         CLoadParam(ROOT, PARAMETER_NAME, OBJECT, new ExecutorXML<CLASS>(&CLASS::FUNCTION, ROOT, PARAMETER_NAME), true)
 
 
@@ -87 +93 @@
 {
   public:
-    CLoadParam(const TiXmlElement* root, const std::string& paramName, BaseObject* object, const Executor& executor, bool inLoadCycle = false);
+    CLoadParam(const TiXmlElement* root, const std::string& paramName, BaseObject* object, Executor* executor, bool inLoadCycle = false);
     virtual ~CLoadParam();
 

trunk/src/orxonox.cc

@@ -414 +414 @@
 bool showGui = false;
 
-/// HACK HACK TEST
-
-
-#include "executor/executor_functional.h"
-
-#define EXECUTOR_FUNCTIONAL_USE_STATIC
-#include "executor/executor_functional.h"
-
-class TestClass : public BaseObject
-{
-public:
-  TestClass() {};
-
-  void printTest() { printf ("TEST\n"); };
-  void printTestInt(int i) { printf ("%d\n", i); };
-  void printTestBool(bool b) { printf("%d\n", (int)b); };
-  void printTwoVals(int b, int i) { printf ("%d %d\n", b, i); };
-  void printStrings(const std::string& name) { printf("String:: '%s'\n", name.c_str()); };
-  static void printStatic() { printf("STATIC\n");};
-};
-
-void TEST()
-{
-  TestClass test;
-  SubString testStrings("1, 2, 3", ",", SubString::WhiteSpaces, false);
-  (*createExecutor<TestClass>(&TestClass::printTest))(&test, testStrings);
-  (*createExecutor<TestClass>(&TestClass::printTestInt))(&test, testStrings);
-  (*createExecutor<TestClass>(&TestClass::printTestBool))(&test, testStrings);
-  (*createExecutor<TestClass>(&TestClass::printTwoVals))(&test, testStrings);
-  (*createExecutor<TestClass>(&TestClass::printStatic))(&test, testStrings);
-  (*createExecutor<TestClass>(&TestClass::printStrings))(&test, testStrings);
-
-}
-
-//// HACK HACK
-
 /**********************************
 *** ORXONOX MAIN STARTING POINT ***
@@ -461 +425 @@
 int main(int argc, char** argv)
 {
-  TEST();
   CmdLinePrefsReader prefs;