Index: trunk/src/lib/util/executor/executor.cc
===================================================================
--- trunk/src/lib/util/executor/executor.cc	(revision 9406)
+++ 	(revision )
@@ -1,120 +1,0 @@
-/*
-   orxonox - the future of 3D-vertical-scrollers
-
-   Copyright (C) 2004 orx
-
-   This program is free software; you can redistribute it and/or modify
-   it under the terms of the GNU General Public License as published by
-   the Free Software Foundation; either version 2, or (at your option)
-   any later version.
-
-   ### File Specific:
-   main-programmer: Benjamin Grauer
-   co-programmer: ...
-*/
-
-//#define DEBUG_SPECIAL_MODULE DEBUG_MODULE_
-
-#include "executor.h"
-
-////////////////////////
-// SHELL COMMAND BASE //
-////////////////////////
-/**
- * @brief constructs and registers a new Command
- * @param commandName the name of the Command
- * @param className the name of the class to apply this command to
- * @param paramCount the count of parameters this command takes
- */
-Executor::Executor(const MultiType& param0,
-                   const MultiType& param1,
-                   const MultiType& param2,
-                   const MultiType& param3,
-                   const MultiType& param4,
-                   const MultiType& param5,
-                   const MultiType& param6)
-{
-  this->setClassID(CL_EXECUTOR, "Executor");
-
-  // What Parameters have we got
-  this->defaultValue[0] = param0;
-  this->defaultValue[1] = param1;
-  this->defaultValue[2] = param2;
-  this->defaultValue[3] = param3;
-  this->defaultValue[4] = param4;
-  this->defaultValue[5] = param5;
-  this->defaultValue[6] = param6;
-
-  this->paramCount = 0;
-  for (unsigned int i = 0; i <= FUNCTOR_MAX_ARGUMENTS; i++)
-  {
-    if (this->defaultValue[i] == MT_NULL || i == FUNCTOR_MAX_ARGUMENTS)
-    {
-      this->paramCount = i;
-      break;
-    }
-  }
-}
-
-/**
- * deconstructs a Executor
- */
-Executor::~Executor()
-{}
-
-/**
- * clones this element into executor.
- */
-void Executor::cloning(Executor* executor) const
-{
-  executor->functorType  = this->functorType;
-  executor->paramCount   = this->paramCount;
-  for (unsigned int i = 0; i < this->paramCount; i++)
-    executor->defaultValue[i] =  this->defaultValue[i];
-}
-
-/**
- * @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
- * @returns itself
- */
-Executor* Executor::defaultValues(const MultiType& value0,
-                                  const MultiType& value1,
-                                  const MultiType& value2,
-                                  const MultiType& value3,
-                                  const MultiType& value4,
-                                  const MultiType& value5,
-                                  const MultiType& value6)
-{
-  if (this == NULL)
-    return NULL;
-
-  const MultiType* value[5];
-  value[0] = &value0;
-  value[1] = &value1;
-  value[2] = &value2;
-  value[3] = &value3;
-  value[4] = &value4;
-  value[5] = &value5;
-  value[6] = &value6;
-  for (unsigned int i = 0; i < this->paramCount; i++)
-  {
-    if (*value[i] != MT_NULL)
-    {
-      this->defaultValue[i].setValueOf(*value[i]);
-    }
-  }
-  return this;
-}
-
-/**
- * @brief prints out nice information about the Executor
- */
-void Executor::debug()
-{
-
-}
Index: trunk/src/lib/util/executor/executor.h
===================================================================
--- trunk/src/lib/util/executor/executor.h	(revision 9406)
+++ trunk/src/lib/util/executor/executor.h	(revision 9869)
@@ -9,16 +9,25 @@
 #include "base_object.h"
 
-#include "helper_functions.h"
 #include "multi_type.h"
-#include "substring.h"
-#include "functor_list.h" //< MUST BE INCLUDED HERE AT LEAST ONCE.
-
-//! an enumerator for the definition of the Type.
-typedef enum {
-  Executor_Objective         = 1,
-  Executor_Static            = 2,
-
-  Executor_NoLoadString      = 8,
-} Executor_Type;
+
+//! The maximum Count of Arguments of the Executor
+/** This is Hardcoded, for each Executor. */
+#define EXECUTOR_MAX_ARGUMENTS                7
+
+
+/** @returns the Type of an Argument taken by the Executor */
+template<typename type> inline MT_Type ExecutorParamType() { return MT_EXT1; };
+/** @returns the Type of an Argument taken by the Executor in this case MT_BOOL */
+template<> inline MT_Type ExecutorParamType<bool>() { return MT_BOOL; };
+/** @returns the Type of an Argument taken by the Executor in this case MT_INT*/
+template<> inline MT_Type ExecutorParamType<int>() { return MT_INT; };
+/** @returns the Type of an Argument taken by the Executor in this case MT_UINT*/
+template<> inline MT_Type ExecutorParamType<unsigned int>() { return MT_UINT; };
+/** @returns the Type of an Argument taken by the Executor in this case MT_FLOAT*/
+template<> inline MT_Type ExecutorParamType<float>() { return MT_FLOAT; };
+/** @returns the Type of an Argument taken by the Executor in this case MT_CHAR*/
+template<> inline MT_Type ExecutorParamType<char>() { return MT_CHAR; };
+/** @returns the Type of an Argument taken by the Executor in this case MT_STRING*/
+template<> inline MT_Type ExecutorParamType<const std::string&>() { return MT_STRING; };
 
 ////////////////
@@ -36,53 +45,174 @@
  *  Functions with many types (@see functor_list.h)
  */
-class Executor : public BaseObject
+template <typename CallType, class BaseClass = BaseObject> class Executor
 {
-  public:
-    virtual ~Executor();
-
-    virtual Executor* clone () const = 0;
-//    virtual bool operator==(const Executor* executor) const = 0;
-
-    // SETTING up the EXECUTOR
-    Executor* 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& param5 = MT_NULL,
-                            const MultiType& param6 = MT_NULL);
-    /** @param i the i'th defaultValue, @returns reference to the MultiType */
-    inline MultiType& getDefaultValue(unsigned int i) { return defaultValue[i]; };
-
-    // EXECUTE
-    /** executes a Command. @param objec the Object, @param count how many values, @param values the Values */
-    virtual void operator()(BaseObject* object, int& count, void* values) const = 0;
-    /** executes a Command @param object the object to apply this to @param parameters the parameters the command takes */
-    virtual void operator()(BaseObject* object, const SubString& sub = SubString()) const = 0;
-
-    // RETRIEVE INFORMATION
-    /** @returns the Type of this Function (either static or objective) */
-    inline long getType() const { return this->functorType; };
-    /** @returns the Count of Parameters this Executor takes */
-    inline unsigned int getParamCount() const { return this->paramCount; };
-
-    static void debug();
-
-  protected:
-    Executor(const MultiType& param0 = MT_NULL, const MultiType& param1 = MT_NULL,
-             const MultiType& param2 = MT_NULL, const MultiType& param3 = MT_NULL,
-             const MultiType& param4 = MT_NULL, const MultiType& param5 = MT_NULL,
-             const MultiType& param6 = MT_NULL);
-
-    void cloning(Executor* executor) const;
-
-  protected:
-    short                       functorType;      //!< The type of Function we've got (either static or objective).
-    unsigned int                paramCount;       //!< the count of parameters.
-    MultiType                   defaultValue[7];  //!< Default Values.
+public:
+  //! an enumerator for the definition of the Type.
+  typedef enum {
+    FunctionMember,      //!< The function is neither Static nor Constant
+    FunctionStatic,      //!< The Function is Static and pointing to either a Static Member or a C-style function.
+    FunctionConstMember, //!< The Function is Constant and pointing to a Member that does not change the Object.
+  } FunctionType;
+
+public:
+  virtual ~Executor() {};
+
+  // RETRIEVE INFORMATION
+  /** @param i the i'th defaultValue, @returns reference to the MultiType */
+  inline MultiType& getDefaultValue(unsigned int i) { return defaultValue[i]; };
+  /** @returns the default Values as a List */
+  inline const MultiType* const getDefaultValues() { return defaultValue; };
+
+  /** @returns the Type of this Function (either static or objective) */
+  inline FunctionType getType() const { return this->functionType; };
+
+  /** @returns the Count of Parameters this Executor takes */
+  inline unsigned int getParamCount() const { return this->paramCount; };
+  /** @returns true if the Executor has a return Value. */
+  inline bool hasRetVal() const { return bRetVal; };
+
+  /** executes a Command. @param object the Object, @param values The Value of type CallType to pass to the Executor. */
+  virtual void operator()(BaseClass* object, CallType& values) const = 0;
+
+  /**
+   * @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
+   * @param value5 the sixth default value
+   * @param value6 the seventh default value
+   * @returns itself
+   * @note: THIS FUNCTION WILL BE REPLACED BY A CONFIGURATOR (most probably).
+  */
+  Executor* 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& value5 = MT_NULL,
+                          const MultiType& value6 = MT_NULL)
+  {
+    const MultiType* value[5];
+    value[0] = &value0;
+    value[1] = &value1;
+    value[2] = &value2;
+    value[3] = &value3;
+    value[4] = &value4;
+    value[5] = &value5;
+    value[6] = &value6;
+    for (unsigned int i = 0; i < this->paramCount; i++)
+    {
+      if (*value[i] != MT_NULL)
+      {
+        this->defaultValue[i].setValueOf(*value[i]);
+        this->defaultValue[i].storeString();
+      }
+    }
+    return this;
+  }
+
+  /** @returns the Clone as a new Copy of the Executor. */
+  virtual Executor<CallType, BaseClass>* clone () const = 0;
+
+
+protected:
+  //! Now follows a List of Executor Constructors, to be fast in creating.
+  //! Creates an Executor with no Argument.
+  Executor(bool hasRetVal, FunctionType functionType = FunctionMember)
+  : bRetVal(hasRetVal), paramCount(0), functionType(functionType)
+  { };
+
+  //! Creates an Executor with 1 Argument.
+  Executor(bool hasRetVal, const MultiType& param0,
+	   FunctionType functionType = FunctionMember)
+  : bRetVal(hasRetVal), paramCount(1), functionType(functionType)
+  {
+    this->defaultValue[0] = param0;
+  };
+
+  //! Creates an Executor with 2 Arguments.
+  Executor(bool hasRetVal, const MultiType& param0, const MultiType& param1,
+	   FunctionType functionType = FunctionMember)
+  : bRetVal(hasRetVal), paramCount(2), functionType(functionType)
+  {
+    this->defaultValue[0] = param0;
+    this->defaultValue[1] = param1;
+  };
+
+  //! Creates an Executor with 3 Arguments.
+  Executor(bool hasRetVal, const MultiType& param0, const MultiType& param1,
+	   const MultiType& param2,
+	   FunctionType functionType = FunctionMember)
+  : bRetVal(hasRetVal), paramCount(3), functionType(functionType)
+  {
+    this->defaultValue[0] = param0;
+    this->defaultValue[1] = param1;
+    this->defaultValue[2] = param2;
+  };
+
+  //! Creates an Executor with 4 Arguments.
+  Executor(bool hasRetVal, const MultiType& param0, const MultiType& param1,
+	   const MultiType& param2, const MultiType& param3,
+	   FunctionType functionType = FunctionMember)
+  : bRetVal(hasRetVal), paramCount(4), functionType(functionType)
+  {
+    this->defaultValue[0] = param0;
+    this->defaultValue[1] = param1;
+    this->defaultValue[2] = param2;
+    this->defaultValue[3] = param3;
+  };
+
+  //! Creates an Executor with 5 Arguments.
+  Executor(bool hasRetVal, const MultiType& param0, const MultiType& param1,
+	   const MultiType& param2, const MultiType& param3,
+	   const MultiType& param4,
+	   FunctionType functionType = FunctionMember)
+  : bRetVal(hasRetVal), paramCount(5), functionType(functionType)
+  {
+    this->defaultValue[0] = param0;
+    this->defaultValue[1] = param1;
+    this->defaultValue[2] = param2;
+    this->defaultValue[3] = param3;
+    this->defaultValue[4] = param4;
+  };
+
+  //! Creates an Executor with 6 Arguments.
+  Executor(bool hasRetVal, const MultiType& param0, const MultiType& param1,
+	   const MultiType& param2, const MultiType& param3,
+	   const MultiType& param4, const MultiType& param5,
+	   FunctionType functionType = FunctionMember)
+  : bRetVal(hasRetVal), paramCount(6), functionType(functionType)
+  {
+    this->defaultValue[0] = param0;
+    this->defaultValue[1] = param1;
+    this->defaultValue[2] = param2;
+    this->defaultValue[3] = param3;
+    this->defaultValue[4] = param4;
+    this->defaultValue[5] = param5;
+  };
+
+  //! Creates an Executor with 7 Arguments.
+  Executor(bool hasRetVal, const MultiType& param0, const MultiType& param1,
+	   const MultiType& param2, const MultiType& param3,
+	   const MultiType& param4, const MultiType& param5,
+	   const MultiType& param6,
+	   FunctionType functionType = FunctionMember)
+  : bRetVal(hasRetVal), paramCount(7), functionType(functionType)
+  {
+    this->defaultValue[0] = param0;
+    this->defaultValue[1] = param1;
+    this->defaultValue[2] = param2;
+    this->defaultValue[3] = param3;
+    this->defaultValue[4] = param4;
+    this->defaultValue[5] = param5;
+    this->defaultValue[6] = param6;
+  };
+
+protected:
+  const bool                  bRetVal;          //!< True if the Executor has a return Value.
+  const unsigned int          paramCount;       //!< the count of parameters.
+  MultiType                   defaultValue[7];  //!< Default Values.
+
+  const FunctionType          functionType;     //!< What Type of Function it is.
 };
 
-#include "executor/executor_functional.h"
-#define EXECUTOR_FUNCTIONAL_USE_CONST
-#include "executor/executor_functional.h"
-#define EXECUTOR_FUNCTIONAL_USE_STATIC
-#include "executor/executor_functional.h"
-
 #endif /* _EXECUTOR_H */
Index: trunk/src/lib/util/executor/executor_const_member.h
===================================================================
--- trunk/src/lib/util/executor/executor_const_member.h	(revision 9869)
+++ trunk/src/lib/util/executor/executor_const_member.h	(revision 9869)
@@ -0,0 +1,49 @@
+/*!
+ * @file executor_const_member.h
+ * Definition of an Executor to Member Functions
+ */
+/*
+   orxonox - the future of 3D-vertical-scrollers
+
+   Copyright (C) 2004 orx
+
+   This program is free software; you can redistribute it and/or modify
+   it under the terms of the GNU General Public License as published by
+   the Free Software Foundation; either version 2, or (at your option)
+   any later version.
+
+### File Specific:
+   main-programmer: Benjamin Grauer
+   co-programmer: ...
+*/
+
+
+#ifndef __EXECUTOR_CONST_MEMBER_H_
+#define __EXECUTOR_CONST_MEMBER_H_
+
+/// Define all Constructs, that define an Executor.
+//! The Name to be attached to the functional (for normal, static, and const modes)
+#define __EXECUTOR_FUNCTIONAL_NAME(ParamCount, Ext)   Executor##ParamCount##Ext##_const
+
+//! if Functional is constant calling
+#define __EXECUTOR_FUNCTIONAL_CONST              const
+//! The Execution-mode (either static or objective)
+#define __EXECUTOR_FUNCTIONAL_FUNCTION_EXEC      dynamic_cast<T*>(object)->*(functionPointer)
+//! The Function-Pointer, and how to save it internally.
+#define __EXECUTOR_FUNCTIONAL_FUNCTION_POINTER   T::*functionPointer
+//! The Type of Function
+#define __EXECUTOR_FUNCTIONAL_FUNCTIONTYPE       Executor<CallType, BaseClass>::FunctionConstMember
+
+
+/// We want to include __EXECUTOR_GENERIC_H again, with current settings.
+
+#include "executor_generic.h"
+
+#undef __EXECUTOR_FUNCTIONAL_NAME
+
+#undef __EXECUTOR_FUNCTIONAL_CONST
+#undef __EXECUTOR_FUNCTIONAL_FUNCTION_EXEC
+#undef __EXECUTOR_FUNCTIONAL_FUNCTION_POINTER
+#undef __EXECUTOR_FUNCTIONAL_FUNCTIONTYPE
+
+#endif /* __EXECUTOR_CONST_MEMBER_H_ */
Index: trunk/src/lib/util/executor/executor_functional.cc
===================================================================
--- trunk/src/lib/util/executor/executor_functional.cc	(revision 9406)
+++ 	(revision )
@@ -1,89 +1,0 @@
-/*
-   orxonox - the future of 3D-vertical-scrollers
-
-   Copyright (C) 2004 orx
-
-   This program is free software; you can redistribute it and/or modify
-   it under the terms of the GNU General Public License as published by
-   the Free Software Foundation; either version 2, or (at your option)
-   any later version.
-
-### File Specific:
-   main-programmer: Benjamin Grauer
-   co-programmer: ...
-*/
-
-#include "executor.h"
-std::string ExecutorFunctional_returningString_from[7];
-
-
-template<> MT_Type ExecutorParamType<bool>() { return MT_BOOL; };
-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<> 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) { return (input.size() > 0) ? input : defaultValue; };
-
-
-template<> bool fromMulti<bool>(const MultiType& multi) { return multi.getBool(); };
-template<> int fromMulti<int>(const MultiType& multi) { return multi.getInt(); }
-template<> unsigned int fromMulti<unsigned int>(const MultiType& multi) { return multi.getInt(); };
-template<> float fromMulti<float>(const MultiType& multi) { return multi.getFloat(); };
-template<> char fromMulti<char>(const MultiType& multi) { return multi.getChar(); };
-template<> const std::string& fromMulti<const std::string&>(const MultiType& multi) { return multi.getConstString(); };
-
-
-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) { return ExecutorFunctional_returningString_from[i] = defaultValues[i].getString(); };
-
-
-
-
-
-
-
-/**
- * A LITTLE TESTING SUITE FOR THE EXECUTOR.
- *
-#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 SCHEISSE, 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);
-
-}
-*/
Index: trunk/src/lib/util/executor/executor_functional.h
===================================================================
--- trunk/src/lib/util/executor/executor_functional.h	(revision 9406)
+++ 	(revision )
@@ -1,514 +1,0 @@
-/*!
- * @file executor_functional.h
- * Definition of an Executor
- */
-
-/*
-   orxonox - the future of 3D-vertical-scrollers
-
-   Copyright (C) 2004 orx
-
-   This program is free software; you can redistribute it and/or modify
-   it under the terms of the GNU General Public License as published by
-   the Free Software Foundation; either version 2, or (at your option)
-   any later version.
-
-### File Specific:
-   main-programmer: Benjamin Grauer
-   co-programmer: ...
-*/
-
-
-#ifndef __EXECUTOR_FUNCTIONAL_H_
-#define __EXECUTOR_FUNCTIONAL_H_
-
-#include "executor.h"
-
-template<typename type> MT_Type ExecutorParamType() { return MT_EXT1; };
-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);
-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 fromMulti(const MultiType& multi) { /* return defaultValue; */ };
-template<> bool fromMulti<bool>(const MultiType& multi);
-template<> int fromMulti<int>(const MultiType& multi);
-template<> unsigned int fromMulti<unsigned int>(const MultiType& multi);
-template<> float fromMulti<float>(const MultiType& multi);
-template<> char fromMulti<char>(const MultiType& multi);
-template<> const std::string& fromMulti<const std::string&>(const MultiType& multi);
-
-
-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);
-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_ */
-
-//! if Functional is constant calling
-#define __EXECUTOR_FUNCTIONAL_CONST
-//! The Name to be attached to the functional (for normal, static, and const modes)
-#define __EXECUTOR_FUNCTIONAL_NAME(ParamCount)   Executor##ParamCount##Params
-//! The Execution-mode (either static or objective)
-#define __EXECUTOR_FUNCTIONAL_FUNCTION_EXEC      dynamic_cast<T*>(object)->*(functionPointer)
-//! The Function-Pointer, and how to save it internally.
-#define __EXECUTOR_FUNCTIONAL_FUNCTION_POINTER   T::*functionPointer
-
-#ifdef EXECUTOR_FUNCTIONAL_USE_CONST
- #undef __EXECUTOR_FUNCTIONAL_CONST
- #define __EXECUTOR_FUNCTIONAL_CONST const
- #undef __EXECUTOR_FUNCTIONAL_NAME
- #define __EXECUTOR_FUNCTIONAL_NAME(ParamCount) Executor##ParamCount##Params_const
-#endif
-
-#ifdef EXECUTOR_FUNCTIONAL_USE_STATIC
- #ifdef EXECUTOR_FUNCTIONAL_USE_CONST
-  #error you obviously do not know what you are doing !! ask the bensch
- #endif /* EXECUTOR_FUNCTIONAL_USE_CONST */
-
-#undef __EXECUTOR_FUNCTIONAL_FUNCTION_EXEC
- #define __EXECUTOR_FUNCTIONAL_FUNCTION_EXEC       functionPointer
- #undef __EXECUTOR_FUNCTIONAL_NAME
- #define __EXECUTOR_FUNCTIONAL_NAME(ParamCount)    Executor##ParamCount##Params_static
- #undef __EXECUTOR_FUNCTIONAL_FUNCTION_POINTER
- #define __EXECUTOR_FUNCTIONAL_FUNCTION_POINTER    *functionPointer
-
-#endif /* EXECUTOR_FUNCTIONAL_USE_STATIC */
-
-///////////
-//// 0 ////
-///////////
-//! @brief ExecutorClass, that can execute Functions without any parameters.
-template<class T> class __EXECUTOR_FUNCTIONAL_NAME(0) : public Executor
-{
-private:
-  /** @brief the FunctioPointer. */
-  void (__EXECUTOR_FUNCTIONAL_FUNCTION_POINTER)() __EXECUTOR_FUNCTIONAL_CONST;
-
-public:
-  /**
-   * @brief constructs the Executor.
-   * @param __EXECUTOR_FUNCTIONAL_FUNCTION_POINTER the FunctionPointer to the Calling Function.
-   */
-  __EXECUTOR_FUNCTIONAL_NAME(0) (void (__EXECUTOR_FUNCTIONAL_FUNCTION_POINTER)() __EXECUTOR_FUNCTIONAL_CONST )
-      : Executor()
-  {
-    this->functorType = Executor_Objective;
-    this->functionPointer = functionPointer;
-  };
-
-  /**
-   * @brief executes the Functional
-   * @param object the Object the action should be executed on.
-   * @param sub the SubString to get the Parameters from.
-   */
-  virtual void operator()(BaseObject* object, const SubString& sub = SubString()) const
-  {
-    (__EXECUTOR_FUNCTIONAL_FUNCTION_EXEC)();
-  };
-
-  /** executes a Command. @param objec the Object, @param count how many values, @param values the Values */
-  virtual void operator()(BaseObject* object, int& count, void* values) const
-  {
-    (__EXECUTOR_FUNCTIONAL_FUNCTION_EXEC)();
-  }
-
-  /**
-   * @brief copies the Executor
-   * @returns a new Executor that's a copy of this one.
-   */
-  virtual Executor* clone() const
-  {
-    return new __EXECUTOR_FUNCTIONAL_NAME(0)<T>(this->functionPointer);
-  };
-};
-
-
-
-///////////
-//// 1 ////
-///////////
-//! @brief ExecutorClass, that can execute Functions with one parameter.
-template<class T, typename type0> class __EXECUTOR_FUNCTIONAL_NAME(1) : public Executor
-{
-private:
-  /** @brief the FunctioPointer. */
-  void (__EXECUTOR_FUNCTIONAL_FUNCTION_POINTER)(type0) __EXECUTOR_FUNCTIONAL_CONST;
-
-public:
-  /**
-   * @brief constructs the Executor.
-   * @param __EXECUTOR_FUNCTIONAL_FUNCTION_POINTER the FunctionPointer to the Calling Function.
-   */
-  __EXECUTOR_FUNCTIONAL_NAME(1) (void (__EXECUTOR_FUNCTIONAL_FUNCTION_POINTER)(type0) __EXECUTOR_FUNCTIONAL_CONST)
-      : Executor(ExecutorParamType<type0>())
-  {
-    this->functorType = Executor_Objective;
-    this->functionPointer = functionPointer;
-  };
-
-  /** executes a Command. @param objec the Object, @param count how many values, @param values the Values */
-  virtual void operator()(BaseObject* object, int& count, void* values) const
-  {
-    const MultiType* mt = (const MultiType*)values;
-    return (__EXECUTOR_FUNCTIONAL_FUNCTION_EXEC)(
-             fromMulti<type0>((count > 0)? mt[0] : this->defaultValue[0]) );
-  }
-
-
-  /**
-   * @brief executes the Functional
-   * @param object the Object the action should be executed on.
-   * @param sub the SubString to get the Parameters from.
-   */
-  virtual void operator()(BaseObject* object, const SubString& sub = SubString()) const
-  {
-    (__EXECUTOR_FUNCTIONAL_FUNCTION_EXEC)(
-      (sub.size() > 0) ? fromString<type0>(sub[0], getDefault<type0>(this->defaultValue, 0)) : (fromMulti<type0>(this->defaultValue[0])));
-  };
-
-  /**
-   * @brief copies the Executor
-   * @returns a new Executor that's a copy of this one.
-   */
-  virtual Executor* clone() const
-  {
-    return  new __EXECUTOR_FUNCTIONAL_NAME(1)<T, type0>(this->functionPointer);
-  };
-};
-
-///////////
-//// 2 ////
-///////////
-//! @brief ExecutorClass, that can execute Functions with two parameters.
-template<class T, typename type0, typename type1> class __EXECUTOR_FUNCTIONAL_NAME(2) : public Executor
-{
-private:
-  /** @brief the FunctioPointer. */
-  void (__EXECUTOR_FUNCTIONAL_FUNCTION_POINTER)(type0, type1) __EXECUTOR_FUNCTIONAL_CONST;
-
-public:
-  /**
-   * @brief constructs the Executor.
-   * @param __EXECUTOR_FUNCTIONAL_FUNCTION_POINTER the FunctionPointer to the Calling Function.
-   */
-  __EXECUTOR_FUNCTIONAL_NAME(2) (void (__EXECUTOR_FUNCTIONAL_FUNCTION_POINTER)(type0, type1) __EXECUTOR_FUNCTIONAL_CONST)
-      : Executor(ExecutorParamType<type0>(), ExecutorParamType<type1>())
-  {
-    this->functorType = Executor_Objective;
-    this->functionPointer = functionPointer;
-  };
-
-  /**
-   * @brief executes the Functional
-   * @param object the Object the action should be executed on.
-   * @param sub the SubString to get the Parameters from.
-   */
-  virtual void operator()(BaseObject* object, const SubString& sub = SubString()) const
-  {
-    (__EXECUTOR_FUNCTIONAL_FUNCTION_EXEC)(
-      (sub.size() > 0) ? fromString<type0>(sub[0], getDefault<type0>(this->defaultValue, 0)) : (fromMulti<type0>(this->defaultValue[0])),
-      (sub.size() > 1) ? fromString<type1>(sub[1], getDefault<type1>(this->defaultValue, 1)) : (fromMulti<type1>(this->defaultValue[1])));
-  };
-
-  /** executes a Command. @param objec the Object, @param count how many values, @param values the Values */
-  virtual void operator()(BaseObject* object, int& count, void* values) const
-  {
-    const MultiType* mt = (const MultiType*)values;
-    return (__EXECUTOR_FUNCTIONAL_FUNCTION_EXEC)(
-             fromMulti<type0>((count > 0) ? mt[0] : this->defaultValue[0]),
-             fromMulti<type1>((count > 1) ? mt[1] : this->defaultValue[1]) );
-  }
-
-  /**
-   * @brief copies the Executor
-   * @returns a new Executor that's a copy of this one.
-   */
-  virtual Executor* clone() const
-  {
-    return new __EXECUTOR_FUNCTIONAL_NAME(2)<T, type0, type1>(this->functionPointer);
-  };
-};
-
-
-///////////
-//// 3 ////
-///////////
-//! @brief ExecutorClass, that can execute Functions with three parameters.
-template<class T, typename type0, typename type1, typename type2> class __EXECUTOR_FUNCTIONAL_NAME(3) : public Executor
-{
-private:
-  /** @brief the FunctioPointer. */
-  void (__EXECUTOR_FUNCTIONAL_FUNCTION_POINTER)(type0, type1, type2) __EXECUTOR_FUNCTIONAL_CONST;
-
-public:
-  /**
-   * @brief constructs the Executor.
-   * @param __EXECUTOR_FUNCTIONAL_FUNCTION_POINTER the FunctionPointer to the Calling Function.
-   */
-  __EXECUTOR_FUNCTIONAL_NAME(3) (void (__EXECUTOR_FUNCTIONAL_FUNCTION_POINTER)(type0, type1, type2) __EXECUTOR_FUNCTIONAL_CONST)
-      : Executor(ExecutorParamType<type0>(), ExecutorParamType<type1>(), ExecutorParamType<type2>())
-  {
-    this->functorType = Executor_Objective;
-    this->functionPointer = functionPointer;
-  };
-
-  /**
-   * @brief executes the Functional
-   * @param object the Object the action should be executed on.
-   * @param sub the SubString to get the Parameters from.
-   */
-  virtual void operator()(BaseObject* object, const SubString& sub = SubString()) const
-  {
-    (__EXECUTOR_FUNCTIONAL_FUNCTION_EXEC)(
-      (sub.size() > 0) ? fromString<type0>(sub[0], getDefault<type0>(this->defaultValue, 0)) : (fromMulti<type0>(this->defaultValue[0])),
-      (sub.size() > 1) ? fromString<type1>(sub[1], getDefault<type1>(this->defaultValue, 1)) : (fromMulti<type1>(this->defaultValue[1])),
-      (sub.size() > 2) ? fromString<type2>(sub[2], getDefault<type2>(this->defaultValue, 2)) : (fromMulti<type2>(this->defaultValue[2])));
-  };
-
-  /** executes a Command. @param objec the Object, @param count how many values, @param values the Values */
-  virtual void operator()(BaseObject* object, int& count, void* values) const
-  {
-    const MultiType* mt = (const MultiType*)values;
-    return (__EXECUTOR_FUNCTIONAL_FUNCTION_EXEC)(
-             fromMulti<type0>((count > 0) ? mt[0] : this->defaultValue[0]),
-             fromMulti<type1>((count > 1) ? mt[1] : this->defaultValue[1]),
-             fromMulti<type2>((count > 2) ? mt[2] : this->defaultValue[2]) );
-  }
-
-  /**
-   * @brief copies the Executor
-   * @returns a new Executor that's a copy of this one.
-   */
-  virtual Executor* clone() const
-  {
-    return new __EXECUTOR_FUNCTIONAL_NAME(3)<T, type0, type1, type2>(this->functionPointer);
-  };
-};
-
-
-
-///////////
-//// 4 ////
-///////////
-//! @brief ExecutorClass, that can execute Functions with four parameters.
-template<class T, typename type0, typename type1, typename type2, typename type3> class __EXECUTOR_FUNCTIONAL_NAME(4) : public Executor
-{
-private:
-  /** @brief the FunctioPointer. */
-  void (__EXECUTOR_FUNCTIONAL_FUNCTION_POINTER)(type0, type1, type2, type3) __EXECUTOR_FUNCTIONAL_CONST;
-
-public:
-  /**
-   * @brief constructs the Executor.
-   * @param __EXECUTOR_FUNCTIONAL_FUNCTION_POINTER the FunctionPointer to the Calling Function.
-   */
-  __EXECUTOR_FUNCTIONAL_NAME(4) (void (__EXECUTOR_FUNCTIONAL_FUNCTION_POINTER)(type0, type1, type2, type3) __EXECUTOR_FUNCTIONAL_CONST)
-      : Executor(ExecutorParamType<type0>(), ExecutorParamType<type1>(), ExecutorParamType<type2>(), ExecutorParamType<type3>())
-  {
-    this->functorType = Executor_Objective;
-    this->functionPointer = functionPointer;
-  };
-
-  /**
-  * @brief executes the Functional
-  * @param object the Object the action should be executed on.
-  * @param sub the SubString to get the Parameters from.
-   */
-  virtual void operator()(BaseObject* object, const SubString& sub = SubString()) const
-  {
-    (__EXECUTOR_FUNCTIONAL_FUNCTION_EXEC)(
-      (sub.size() > 0) ? fromString<type0>(sub[0], getDefault<type0>(this->defaultValue, 0)) : (fromMulti<type0>(this->defaultValue[0])),
-      (sub.size() > 1) ? fromString<type1>(sub[1], getDefault<type1>(this->defaultValue, 1)) : (fromMulti<type1>(this->defaultValue[1])),
-      (sub.size() > 2) ? fromString<type2>(sub[2], getDefault<type2>(this->defaultValue, 2)) : (fromMulti<type2>(this->defaultValue[2])),
-      (sub.size() > 3) ? fromString<type3>(sub[3], getDefault<type3>(this->defaultValue, 3)) : (fromMulti<type3>(this->defaultValue[3])));
-  };
-
-  /** executes a Command. @param objec the Object, @param count how many values, @param values the Values */
-  virtual void operator()(BaseObject* object, int& count, void* values) const
-  {
-    const MultiType* mt = (const MultiType*)values;
-    return (__EXECUTOR_FUNCTIONAL_FUNCTION_EXEC)(
-             fromMulti<type0>((count > 0) ? mt[0] : this->defaultValue[0]),
-             fromMulti<type1>((count > 1) ? mt[1] : this->defaultValue[1]),
-             fromMulti<type2>((count > 2) ? mt[2] : this->defaultValue[2]),
-             fromMulti<type3>((count > 3) ? mt[3] : this->defaultValue[3]) );
-  }
-
-  /**
-   * @brief copies the Executor
-   * @returns a new Executor that's a copy of this one.
-   */
-  virtual Executor* clone() const
-  {
-    return new __EXECUTOR_FUNCTIONAL_NAME(4)<T, type0, type1, type2, type3>(this->functionPointer);
-  };
-};
-
-
-
-///////////
-//// 5 ////
-///////////
-//! @brief ExecutorClass, that can execute Functions with five parameters.
-template<class T, typename type0, typename type1, typename type2, typename type3, typename type4> class __EXECUTOR_FUNCTIONAL_NAME(5) : public Executor
-{
-private:
-  /** @brief the FunctioPointer. */
-  void (__EXECUTOR_FUNCTIONAL_FUNCTION_POINTER)(type0, type1, type2, type3, type4) __EXECUTOR_FUNCTIONAL_CONST;
-
-public:
-  /**
-   * @brief constructs the Executor.
-   * @param __EXECUTOR_FUNCTIONAL_FUNCTION_POINTER the FunctionPointer to the Calling Function.
-   */
-  __EXECUTOR_FUNCTIONAL_NAME(5) (void (__EXECUTOR_FUNCTIONAL_FUNCTION_POINTER)(type0, type1, type2, type3, type4) __EXECUTOR_FUNCTIONAL_CONST)
-      : Executor(ExecutorParamType<type0>(), ExecutorParamType<type1>(), ExecutorParamType<type2>(), ExecutorParamType<type3>(), ExecutorParamType<type4>())
-  {
-    this->functorType = Executor_Objective;
-    this->functionPointer = functionPointer;
-  };
-
-  /**
-  * @brief executes the Functional
-  * @param object the Object the action should be executed on.
-  * @param sub the SubString to get the Parameters from.
-   */
-  virtual void operator()(BaseObject* object, const SubString& sub = SubString()) const
-  {
-    (__EXECUTOR_FUNCTIONAL_FUNCTION_EXEC)(
-      (sub.size() > 0) ? fromString<type0>(sub[0], getDefault<type0>(this->defaultValue, 0)) : (fromMulti<type0>(this->defaultValue[0])),
-      (sub.size() > 1) ? fromString<type1>(sub[1], getDefault<type1>(this->defaultValue, 1)) : (fromMulti<type1>(this->defaultValue[1])),
-      (sub.size() > 2) ? fromString<type2>(sub[2], getDefault<type2>(this->defaultValue, 2)) : (fromMulti<type2>(this->defaultValue[2])),
-      (sub.size() > 3) ? fromString<type3>(sub[3], getDefault<type3>(this->defaultValue, 3)) : (fromMulti<type3>(this->defaultValue[3])),
-      (sub.size() > 4) ? fromString<type4>(sub[4], getDefault<type4>(this->defaultValue, 4)) : (fromMulti<type4>(this->defaultValue[4])));
-  };
-
-  /** executes a Command. @param objec the Object, @param count how many values, @param values the Values */
-  virtual void operator()(BaseObject* object, int& count, void* values) const
-  {
-    const MultiType* mt = (const MultiType*)values;
-    return (__EXECUTOR_FUNCTIONAL_FUNCTION_EXEC)(
-             fromMulti<type0>((count > 0) ? mt[0] : this->defaultValue[0]),
-             fromMulti<type1>((count > 1) ? mt[1] : this->defaultValue[1]),
-             fromMulti<type2>((count > 2) ? mt[2] : this->defaultValue[2]),
-             fromMulti<type3>((count > 3) ? mt[3] : this->defaultValue[3]),
-             fromMulti<type4>((count > 4) ? mt[4] : this->defaultValue[4]) );
-  }
-
-  /**
-   * @brief copies the Executor
-   * @returns a new Executor that's a copy of this one.
-   */
-  virtual Executor* clone() const
-  {
-    return new __EXECUTOR_FUNCTIONAL_NAME(5)<T, type0, type1, type2, type3, type4>(this->functionPointer);
-  };
-};
-
-
-
-/**
- * @brief enables us to easily retrieve an Executor of Class T with modular Argument-count, (without thinking about args at all)
- */
-#define EXECUTOR_FUNCTIONAL_CREATOR0() \
-template<class T> Executor* createExecutor(void (__EXECUTOR_FUNCTIONAL_FUNCTION_POINTER)() __EXECUTOR_FUNCTIONAL_CONST) \
-{ \
-  return new __EXECUTOR_FUNCTIONAL_NAME(0)<T>(functionPointer); \
-}
-
-/**
- * @brief enables us to easily retrieve an Executor of Class T with modular Argument-count, (without thinking about args at all)
- * @param type0 for internal usage: the first Argument
- */
-#define EXECUTOR_FUNCTIONAL_CREATOR1(type0) \
-template<class T> Executor* createExecutor(void (__EXECUTOR_FUNCTIONAL_FUNCTION_POINTER)(type0##_TYPE) __EXECUTOR_FUNCTIONAL_CONST) \
-{ \
-  return new __EXECUTOR_FUNCTIONAL_NAME(1)<T, type0##_TYPE>(functionPointer); \
-}
-
-/**
- * @brief enables us to easily retrieve an Executor of Class T with modular Argument-count, (without thinking about args at all)
- * @param type0 for internal usage: the first Argument
- * @param type1 for internal usage: the second Argument
- */
-#define EXECUTOR_FUNCTIONAL_CREATOR2(type0, type1) \
-template<class T> Executor* createExecutor(void (__EXECUTOR_FUNCTIONAL_FUNCTION_POINTER)(type0##_TYPE, type1##_TYPE) __EXECUTOR_FUNCTIONAL_CONST) \
-{ \
-  return new __EXECUTOR_FUNCTIONAL_NAME(2)<T, type0##_TYPE, type1##_TYPE>(functionPointer); \
-}
-
-/**
- * @brief enables us to easily retrieve an Executor of Class T with modular Argument-count, (without thinking about args at all)
- * @param type0 for internal usage: the first Argument
- * @param type1 for internal usage: the second Argument
- * @param type2 for internal usage: the third Argument
- */
-#define EXECUTOR_FUNCTIONAL_CREATOR3(type0, type1, type2) \
-template<class T> Executor* createExecutor(void (__EXECUTOR_FUNCTIONAL_FUNCTION_POINTER)(type0##_TYPE, type1##_TYPE, type2##_TYPE) __EXECUTOR_FUNCTIONAL_CONST) \
-{ \
-  return new __EXECUTOR_FUNCTIONAL_NAME(3)<T, type0##_TYPE, type1##_TYPE, type2##_TYPE>(functionPointer); \
-}
-
-/**
- * @brief enables us to easily retrieve an Executor of Class T with modular Argument-count, (without thinking about args at all)
- * @param type0 for internal usage: the first Argument
- * @param type1 for internal usage: the second Argument
- * @param type2 for internal usage: the third Argument
- * @param type3 for internal usage: the fourth Argument
- */
-#define EXECUTOR_FUNCTIONAL_CREATOR4(type0, type1, type2, type3) \
-template<class T> Executor* createExecutor(void (__EXECUTOR_FUNCTIONAL_FUNCTION_POINTER)(type0##_TYPE, type1##_TYPE, type2##_TYPE, type3##_TYPE) __EXECUTOR_FUNCTIONAL_CONST) \
-{ \
-  return new __EXECUTOR_FUNCTIONAL_NAME(4)<T, type0##_TYPE, type1##_TYPE, type2##_TYPE, type3##_TYPE>(functionPointer); \
-}
-
-/**
- * @brief enables us to easily retrieve an Executor of Class T with modular Argument-count, (without thinking about args at all)
- * @param type0 for internal usage: the first Argument
- * @param type1 for internal usage: the second Argument
- * @param type2 for internal usage: the third Argument
- * @param type3 for internal usage: the fourth Argument
- * @param type4 for internal usage: the fifth Argument
- */
-#define EXECUTOR_FUNCTIONAL_CREATOR5(type0, type1, type2, type3, type4) \
-template<class T> Executor* createExecutor(void (__EXECUTOR_FUNCTIONAL_FUNCTION_POINTER)(type0##_TYPE, type1##_TYPE, type2##_TYPE, type3##_TYPE, type4##_TYPE) __EXECUTOR_FUNCTIONAL_CONST) \
-{ \
-    return new __EXECUTOR_FUNCTIONAL_NAME(5)<T, type0##_TYPE, type1##_TYPE, type2##_TYPE, type3##_TYPE, type4##_TYPE>(functionPointer); \
-}
-
-
-/**
- * Creates the FunctionCallers
- */
-#define FUNCTOR_LIST(x) EXECUTOR_FUNCTIONAL_CREATOR ## x
-#include "functor_list.h"
-#undef FUNCTOR_LIST
-
-
-
-#undef __EXECUTOR_FUNCTIONAL_CONST
-#undef __EXECUTOR_FUNCTIONAL_NAME
-#undef __EXECUTOR_FUNCTIONAL_FUNCTION_EXEC
-#undef __EXECUTOR_FUNCTIONAL_FUNCTION_POINTER
-
-#ifdef EXECUTOR_FUNCTIONAL_USE_CONST
- #undef EXECUTOR_FUNCTIONAL_USE_CONST
-#endif
-#ifdef EXECUTOR_FUNCTIONAL_USE_STATIC
- #undef EXECUTOR_FUNCTIONAL_USE_STATIC
-#endif
Index: trunk/src/lib/util/executor/executor_generic.h
===================================================================
--- trunk/src/lib/util/executor/executor_generic.h	(revision 9869)
+++ trunk/src/lib/util/executor/executor_generic.h	(revision 9869)
@@ -0,0 +1,456 @@
+/*!
+ * @file executor_generic.h
+ * Definition of a Generic Executor
+ */
+
+/*
+   orxonox - the future of 3D-vertical-scrollers
+
+   Copyright (C) 2004 orx
+
+   This program is free software; you can redistribute it and/or modify
+   it under the terms of the GNU General Public License as published by
+   the Free Software Foundation; either version 2, or (at your option)
+   any later version.
+
+### File Specific:
+   main-programmer: Benjamin Grauer
+   co-programmer: ...
+*/
+
+
+
+#ifndef __EXECUTOR_GENERIC_H_
+#define __EXECUTOR_GENERIC_H_
+
+
+#include "executor.h"
+/**
+ * @brief this is a Template Class used as an evaluater.
+ *
+ * Trait to determine a default Value for any Type,
+ * and to define the Convertible, and how it is transformed into the
+ * corresponding SubTypes over the operator().
+ *
+ * This Class must be reimplemented for each Convertible and all of its
+ *  conversion-members.
+ *
+ * e.g: Convertible SubSting, that splits up into many Stings
+ *      conversion-members: (int) can be transformed from a String.
+ */
+template<typename FromType> class ExecutorEvaluater
+{
+public:
+  /** @brief Executes the Evaluater
+   * @param CallValue the Value that should be converted
+   * @param defaults the default Values.
+   */
+  template <typename ToType, int index>
+  static ToType getValue(FromType& CallValue, const MultiType* const defaults)
+  {
+    assert(0 && "Might want to extend the ExecutorEvaluater::getValue function in an 'Explicit Specialized Template Class'");
+    return defaultValue;
+  }
+  /** @param @storeTo Stores the returned value here. @param value The Value to Store. @note invers of getValue */
+  static void storeRet(FromType& storeTo, FromType value)
+  {
+    assert (0 && "Might want to extend the ExecutorEvaluater::storeRet function in an 'Explicit Specialized Template Class'");
+  }
+  /** @returns the Default Value of ToType */
+  static FromType& defaultValue() { static FromType defaultValue; return defaultValue; };
+};
+#endif /* __EXECUTOR_GENERIC_H_ */
+
+
+#ifdef __EXECUTOR_FUNCTIONAL_NAME
+///////////
+//// 0 ////
+///////////
+//! @brief ExecutorClass, that can execute Functions without any parameters.
+template<class T, typename CallType, class BaseClass = BaseObject, template<typename> class Evaluater = ExecutorEvaluater>
+class __EXECUTOR_FUNCTIONAL_NAME(0,) :public Executor<CallType, BaseClass>
+{
+private:
+  /** @brief the FunctioPointer. */
+  void (__EXECUTOR_FUNCTIONAL_FUNCTION_POINTER)() __EXECUTOR_FUNCTIONAL_CONST;
+
+public:
+  /**
+   * @brief constructs the Executor.
+   * @param __EXECUTOR_FUNCTIONAL_FUNCTION_POINTER the FunctionPointer to the Calling Function.
+   */
+  __EXECUTOR_FUNCTIONAL_NAME(0,) (void (__EXECUTOR_FUNCTIONAL_FUNCTION_POINTER)() __EXECUTOR_FUNCTIONAL_CONST )
+      : Executor<CallType, BaseClass>(false, __EXECUTOR_FUNCTIONAL_FUNCTIONTYPE), functionPointer(functionPointer)
+  {};
+
+  /**
+   * @brief executes the Functional
+   * @param object the Object the action should be executed on.
+   * @param eval the CallType to get the Parameters from.
+   */
+  virtual void operator()(BaseClass* object, CallType& eval = Evaluater<CallType>::defaultValue()) const
+  {
+    (__EXECUTOR_FUNCTIONAL_FUNCTION_EXEC)();
+  };
+
+  /**
+   * @brief copies the Executor
+   * @returns a new Executor that's a copy of this one.
+   */
+  virtual Executor<CallType, BaseClass>* clone() const
+  {
+    return new __EXECUTOR_FUNCTIONAL_NAME(0,)<T, CallType, BaseClass>(this->functionPointer);
+  };
+};
+
+
+
+///////////
+//// 1 ////
+///////////
+//! @brief ExecutorClass, that can execute Functions with one parameter.
+template<class T, typename CallType, typename type0, class BaseClass = BaseObject, template<typename> class Evaluater = ExecutorEvaluater>
+class __EXECUTOR_FUNCTIONAL_NAME(1,) : public Executor<CallType, BaseClass>
+{
+private:
+  /** @brief the FunctioPointer. */
+  void (__EXECUTOR_FUNCTIONAL_FUNCTION_POINTER)(type0) __EXECUTOR_FUNCTIONAL_CONST;
+
+public:
+  /**
+   * @brief constructs the Executor.
+   * @param __EXECUTOR_FUNCTIONAL_FUNCTION_POINTER the FunctionPointer to the Calling Function.
+   */
+  __EXECUTOR_FUNCTIONAL_NAME(1,) (void (__EXECUTOR_FUNCTIONAL_FUNCTION_POINTER)(type0) __EXECUTOR_FUNCTIONAL_CONST)
+      : Executor<CallType, BaseClass>(false, ExecutorParamType<type0>(), __EXECUTOR_FUNCTIONAL_FUNCTIONTYPE), functionPointer(functionPointer)
+  {};
+
+  /**
+   * @brief executes the Functional
+   * @param object the Object the action should be executed on.
+   * @param eval the CallType to get the Parameters from.
+   */
+  virtual void operator()(BaseClass* object, CallType& eval = Evaluater<CallType>::defaultValue()) const
+  {
+    (__EXECUTOR_FUNCTIONAL_FUNCTION_EXEC)(
+	Evaluater<CallType>::template getValue<type0, 0>(eval, this->defaultValue));
+  };
+
+  /**
+   * @brief copies the Executor
+   * @returns a new Executor that's a copy of this one.
+   */
+  virtual Executor<CallType, BaseClass>* clone() const
+  {
+    return  new __EXECUTOR_FUNCTIONAL_NAME(1,)<T, CallType, type0, BaseClass>(this->functionPointer);
+  };
+};
+
+
+
+///////////
+//// 2 ////
+///////////
+//! @brief ExecutorClass, that can execute Functions with two parameters.
+template<class T, typename CallType, typename type0, typename type1, class BaseClass = BaseObject, template<typename> class Evaluater = ExecutorEvaluater>
+class __EXECUTOR_FUNCTIONAL_NAME(2,) : public Executor<CallType, BaseClass>
+{
+private:
+  /** @brief the FunctioPointer. */
+  void (__EXECUTOR_FUNCTIONAL_FUNCTION_POINTER)(type0, type1) __EXECUTOR_FUNCTIONAL_CONST;
+
+public:
+  /**
+   * @brief constructs the Executor.
+   * @param __EXECUTOR_FUNCTIONAL_FUNCTION_POINTER the FunctionPointer to the Calling Function.
+   */
+  __EXECUTOR_FUNCTIONAL_NAME(2,) (void (__EXECUTOR_FUNCTIONAL_FUNCTION_POINTER)(type0, type1) __EXECUTOR_FUNCTIONAL_CONST)
+      : Executor<CallType, BaseClass>(false, ExecutorParamType<type0>(), ExecutorParamType<type1>(), __EXECUTOR_FUNCTIONAL_FUNCTIONTYPE), functionPointer(functionPointer)
+  {};
+
+  /**
+   * @brief executes the Functional
+   * @param object the Object the action should be executed on.
+   * @param eval the CallType to get the Parameters from.
+   */
+  virtual void operator()(BaseClass* object, CallType& eval = Evaluater<CallType>::defaultValue()) const
+  {
+    (__EXECUTOR_FUNCTIONAL_FUNCTION_EXEC)(
+      Evaluater<CallType>::template getValue<type0, 0>(eval, this->defaultValue),
+      Evaluater<CallType>::template getValue<type1, 1>(eval, this->defaultValue));
+  };
+
+  /**
+   * @brief copies the Executor
+   * @returns a new Executor that's a copy of this one.
+   */
+  virtual Executor<CallType, BaseClass>* clone() const
+  {
+    return new __EXECUTOR_FUNCTIONAL_NAME(2,)<T, CallType, type0, type1, BaseClass>(this->functionPointer);
+  };
+};
+
+
+
+///////////
+//// 3 ////
+///////////
+//! @brief ExecutorClass, that can execute Functions with three parameters.
+template<class T, typename CallType, typename type0, typename type1, typename type2, class BaseClass = BaseObject, template<typename> class Evaluater = ExecutorEvaluater>
+class __EXECUTOR_FUNCTIONAL_NAME(3,) : public Executor<CallType, BaseClass>
+{
+private:
+  /** @brief the FunctioPointer. */
+  void (__EXECUTOR_FUNCTIONAL_FUNCTION_POINTER)(type0, type1, type2) __EXECUTOR_FUNCTIONAL_CONST;
+
+public:
+  /**
+   * @brief constructs the Executor.
+   * @param __EXECUTOR_FUNCTIONAL_FUNCTION_POINTER the FunctionPointer to the Calling Function.
+   */
+  __EXECUTOR_FUNCTIONAL_NAME(3,) (void (__EXECUTOR_FUNCTIONAL_FUNCTION_POINTER)(type0, type1, type2) __EXECUTOR_FUNCTIONAL_CONST)
+      : Executor<CallType, BaseClass>(false, ExecutorParamType<type0>(), ExecutorParamType<type1>(), ExecutorParamType<type2>(), __EXECUTOR_FUNCTIONAL_FUNCTIONTYPE), functionPointer(functionPointer)
+  {};
+
+  /**
+   * @brief executes the Functional
+   * @param object the Object the action should be executed on.
+   * @param eval the CallType to get the Parameters from.
+   */
+  virtual void operator()(BaseClass* object, CallType& eval = Evaluater<CallType>::defaultValue()) const
+  {
+    (__EXECUTOR_FUNCTIONAL_FUNCTION_EXEC)(
+      Evaluater<CallType>::template getValue<type0, 0>(eval, this->defaultValue),
+      Evaluater<CallType>::template getValue<type1, 1>(eval, this->defaultValue),
+      Evaluater<CallType>::template getValue<type2, 2>(eval, this->defaultValue));
+  };
+
+  /**
+   * @brief copies the Executor
+   * @returns a new Executor that's a copy of this one.
+   */
+  virtual Executor<CallType, BaseClass>* clone() const
+  {
+    return new __EXECUTOR_FUNCTIONAL_NAME(3,)<T, CallType, type0, type1, type2, BaseClass>(this->functionPointer);
+  };
+};
+
+
+
+///////////
+//// 4 ////
+///////////
+//! @brief ExecutorClass, that can execute Functions with four parameters.
+template<class T, typename CallType, typename type0, typename type1, typename type2, typename type3, class BaseClass = BaseObject, template<typename> class Evaluater = ExecutorEvaluater>
+class __EXECUTOR_FUNCTIONAL_NAME(4,) : public Executor<CallType, BaseClass>
+{
+private:
+  /** @brief the FunctioPointer. */
+  void (__EXECUTOR_FUNCTIONAL_FUNCTION_POINTER)(type0, type1, type2, type3) __EXECUTOR_FUNCTIONAL_CONST;
+
+public:
+  /**
+   * @brief constructs the Executor.
+   * @param __EXECUTOR_FUNCTIONAL_FUNCTION_POINTER the FunctionPointer to the Calling Function.
+   */
+  __EXECUTOR_FUNCTIONAL_NAME(4,) (void (__EXECUTOR_FUNCTIONAL_FUNCTION_POINTER)(type0, type1, type2, type3) __EXECUTOR_FUNCTIONAL_CONST)
+      : Executor<CallType, BaseClass>(false, ExecutorParamType<type0>(), ExecutorParamType<type1>(), ExecutorParamType<type2>(), ExecutorParamType<type3>(), __EXECUTOR_FUNCTIONAL_FUNCTIONTYPE), functionPointer(functionPointer)
+  {};
+
+  /**
+  * @brief executes the Functional
+  * @param object the Object the action should be executed on.
+  * @param eval the CallType to get the Parameters from.
+   */
+  virtual void operator()(BaseClass* object, CallType& eval = Evaluater<CallType>::defaultValue()) const
+  {
+    (__EXECUTOR_FUNCTIONAL_FUNCTION_EXEC)(
+      Evaluater<CallType>::template getValue<type0, 0>(eval, this->defaultValue),
+      Evaluater<CallType>::template getValue<type1, 1>(eval, this->defaultValue),
+      Evaluater<CallType>::template getValue<type2, 2>(eval, this->defaultValue),
+      Evaluater<CallType>::template getValue<type3, 3>(eval, this->defaultValue));
+  };
+
+  /**
+   * @brief copies the Executor
+   * @returns a new Executor that's a copy of this one.
+   */
+  virtual Executor<CallType, BaseClass>* clone() const
+  {
+    return new __EXECUTOR_FUNCTIONAL_NAME(4,)<T, CallType, type0, type1, type2, type3, BaseClass>(this->functionPointer);
+  };
+};
+
+
+
+///////////
+//// 5 ////
+///////////
+//! @brief ExecutorClass, that can execute Functions with five parameters.
+template<class T, typename CallType, typename type0, typename type1, typename type2, typename type3, typename type4, class BaseClass = BaseObject, template<typename> class Evaluater = ExecutorEvaluater>
+class __EXECUTOR_FUNCTIONAL_NAME(5,) : public Executor<CallType, BaseClass>
+{
+private:
+  /** @brief the FunctioPointer. */
+  void (__EXECUTOR_FUNCTIONAL_FUNCTION_POINTER)(type0, type1, type2, type3, type4) __EXECUTOR_FUNCTIONAL_CONST;
+
+public:
+  /**
+   * @brief constructs the Executor.
+   * @param __EXECUTOR_FUNCTIONAL_FUNCTION_POINTER the FunctionPointer to the Calling Function.
+   */
+  __EXECUTOR_FUNCTIONAL_NAME(5,) (void (__EXECUTOR_FUNCTIONAL_FUNCTION_POINTER)(type0, type1, type2, type3, type4) __EXECUTOR_FUNCTIONAL_CONST)
+      : Executor<CallType, BaseClass>(false, ExecutorParamType<type0>(), ExecutorParamType<type1>(), ExecutorParamType<type2>(), ExecutorParamType<type3>(), ExecutorParamType<type4>(), __EXECUTOR_FUNCTIONAL_FUNCTIONTYPE), functionPointer(functionPointer)
+  {};
+
+  /**
+  * @brief executes the Functional
+  * @param object the Object the action should be executed on.
+  * @param eval the CallType to get the Parameters from.
+   */
+  virtual void operator()(BaseClass* object, CallType& eval = Evaluater<CallType>::defaultValue()) const
+  {
+    (__EXECUTOR_FUNCTIONAL_FUNCTION_EXEC)(
+      Evaluater<CallType>::template getValue<type0, 0>(eval, this->defaultValue),
+      Evaluater<CallType>::template getValue<type1, 1>(eval, this->defaultValue),
+      Evaluater<CallType>::template getValue<type2, 2>(eval, this->defaultValue),
+      Evaluater<CallType>::template getValue<type3, 3>(eval, this->defaultValue),
+      Evaluater<CallType>::template getValue<type4, 4>(eval, this->defaultValue));
+  };
+
+  /**
+   * @brief copies the Executor
+   * @returns a new Executor that's a copy of this one.
+   */
+  virtual Executor<CallType, BaseClass>* clone() const
+  {
+    return new __EXECUTOR_FUNCTIONAL_NAME(5,)<T, CallType, type0, type1, type2, type3, type4, BaseClass>(this->functionPointer);
+  };
+};
+
+
+////////////////////
+//// 0 & RETURN ////
+////////////////////
+//! @brief ExecutorClass, that can execute Functions with one parameter.
+template<class T, typename CallType, typename ReturnType, class BaseClass = BaseObject, template<typename> class Evaluater = ExecutorEvaluater>
+class __EXECUTOR_FUNCTIONAL_NAME(0,ret) : public Executor<CallType, BaseClass>
+{
+private:
+  /** @brief the FunctioPointer. */
+  ReturnType (__EXECUTOR_FUNCTIONAL_FUNCTION_POINTER)() __EXECUTOR_FUNCTIONAL_CONST;
+
+public:
+  /**
+   * @brief constructs the Executor.
+   * @param __EXECUTOR_FUNCTIONAL_FUNCTION_POINTER the FunctionPointer to the Calling Function.
+   */
+  __EXECUTOR_FUNCTIONAL_NAME(0,ret) (ReturnType (__EXECUTOR_FUNCTIONAL_FUNCTION_POINTER)() __EXECUTOR_FUNCTIONAL_CONST)
+      : Executor<CallType, BaseClass>(true, __EXECUTOR_FUNCTIONAL_FUNCTIONTYPE), functionPointer(functionPointer)
+  {};
+
+  /**
+     * @brief executes the Functional
+     * @param object the Object the action should be executed on.
+     * @param eval the CallType to get the Parameters from.
+   */
+  virtual void operator()(BaseClass* object, CallType& eval = Evaluater<CallType>::defaultValue()) const
+  {
+    Evaluater<CallType>::template storeRet<ReturnType>(eval, (__EXECUTOR_FUNCTIONAL_FUNCTION_EXEC)());
+  };
+
+  /**
+     * @brief copies the Executor
+     * @returns a new Executor that's a copy of this one.
+   */
+  virtual Executor<CallType, BaseClass>* clone() const
+  {
+    return  new __EXECUTOR_FUNCTIONAL_NAME(0,ret)<T, CallType, ReturnType, BaseClass>(this->functionPointer);
+  };
+};
+
+////////////////////
+//// 1 & RETURN ////
+////////////////////
+//! @brief ExecutorClass, that can execute Functions with one parameter.
+template<class T, typename CallType, typename ReturnType, typename type0, class BaseClass = BaseObject, template<typename> class Evaluater = ExecutorEvaluater>
+class __EXECUTOR_FUNCTIONAL_NAME(1,ret) : public Executor<CallType, BaseClass>
+{
+private:
+  /** @brief the FunctioPointer. */
+  ReturnType (__EXECUTOR_FUNCTIONAL_FUNCTION_POINTER)(type0) __EXECUTOR_FUNCTIONAL_CONST;
+
+public:
+  /**
+   * @brief constructs the Executor.
+   * @param __EXECUTOR_FUNCTIONAL_FUNCTION_POINTER the FunctionPointer to the Calling Function.
+   */
+  __EXECUTOR_FUNCTIONAL_NAME(1,ret) (ReturnType (__EXECUTOR_FUNCTIONAL_FUNCTION_POINTER)(type0) __EXECUTOR_FUNCTIONAL_CONST)
+      : Executor<CallType, BaseClass>(true, ExecutorParamType<type0>(), __EXECUTOR_FUNCTIONAL_FUNCTIONTYPE), functionPointer(functionPointer)
+  {};
+
+  /**
+     * @brief executes the Functional
+     * @param object the Object the action should be executed on.
+     * @param eval the CallType to get the Parameters from.
+   */
+  virtual void operator()(BaseClass* object, CallType& eval = Evaluater<CallType>::defaultValue()) const
+  {
+    Evaluater<CallType>::template storeRet<ReturnType>(eval, (__EXECUTOR_FUNCTIONAL_FUNCTION_EXEC)(
+          Evaluater<CallType>::template getValue<type0, 0>(eval, this->defaultValue)));
+  };
+
+  /**
+     * @brief copies the Executor
+     * @returns a new Executor that's a copy of this one.
+   */
+  virtual Executor<CallType, BaseClass>* clone() const
+  {
+    return  new __EXECUTOR_FUNCTIONAL_NAME(1,ret)<T, CallType, ReturnType, type0, BaseClass>(this->functionPointer);
+  };
+};
+
+
+////////////////////
+//// 2 & RETURN ////
+////////////////////
+//! @brief ExecutorClass, that can execute Functions with one parameter.
+template<class T, typename CallType, typename ReturnType, typename type0, typename type1, class BaseClass = BaseObject, template<typename> class Evaluater = ExecutorEvaluater>
+class __EXECUTOR_FUNCTIONAL_NAME(2,ret) : public Executor<CallType, BaseClass>
+{
+private:
+  /** @brief the FunctioPointer. */
+  ReturnType (__EXECUTOR_FUNCTIONAL_FUNCTION_POINTER)(type0, type1) __EXECUTOR_FUNCTIONAL_CONST;
+
+public:
+  /**
+   * @brief constructs the Executor.
+   * @param __EXECUTOR_FUNCTIONAL_FUNCTION_POINTER the FunctionPointer to the Calling Function.
+   */
+  __EXECUTOR_FUNCTIONAL_NAME(2,ret) (ReturnType (__EXECUTOR_FUNCTIONAL_FUNCTION_POINTER)(type0, type1) __EXECUTOR_FUNCTIONAL_CONST)
+      : Executor<CallType, BaseClass>(true, ExecutorParamType<type0>(), __EXECUTOR_FUNCTIONAL_FUNCTIONTYPE), functionPointer(functionPointer)
+  {};
+
+  /**
+     * @brief executes the Functional
+     * @param object the Object the action should be executed on.
+     * @param eval the CallType to get the Parameters from.
+   */
+  virtual void operator()(BaseClass* object, CallType& eval = Evaluater<CallType>::defaultValue()) const
+  {
+    Evaluater<CallType>::template storeRet<ReturnType>(eval, (__EXECUTOR_FUNCTIONAL_FUNCTION_EXEC)(
+          Evaluater<CallType>::template getValue<type0, 0>(eval, this->defaultValue),
+          Evaluater<CallType>::template getValue<type1, 1>(eval, this->defaultValue)));
+  };
+
+  /**
+     * @brief copies the Executor
+     * @returns a new Executor that's a copy of this one.
+   */
+  virtual Executor<CallType, BaseClass>* clone() const
+  {
+    return  new __EXECUTOR_FUNCTIONAL_NAME(2,ret)<T, CallType, ReturnType, type0, type1, BaseClass>(this->functionPointer);
+  };
+};
+
+#endif /* __EXECUTOR_FUNCTIONAL_NAME */
Index: trunk/src/lib/util/executor/executor_lua.cc
===================================================================
--- trunk/src/lib/util/executor/executor_lua.cc	(revision 9406)
+++ 	(revision )
@@ -1,39 +1,0 @@
-/*
-   orxonox - the future of 3D-vertical-scrollers
-
-   Copyright (C) 2004 orx
-
-   This program is free software; you can redistribute it and/or modify
-   it under the terms of the GNU General Public License as published by
-   the Free Software Foundation; either version 2, or (at your option)
-   any later version.
-
-   ### File Specific:
-   main-programmer: ...
-   co-programmer: ...
-*/
-
-//#define DEBUG_SPECIAL_MODULE DEBUG_MODULE_
-
-#include "executor_lua.h"
-
-#include "lunar.h"
-
-std::string temp[7];
-
-template<typename type> type fromLua(lua_State* state, int index) { type *obj = Lunar<type>::check(state, 1); lua_remove(state, 1); return obj;};
-template<> bool fromLua<bool>(lua_State* state, int index) { return lua_toboolean(state, index); };
-template<> int fromLua<int>(lua_State* state, int index) { return (int)lua_tonumber(state, index); };
-template<> unsigned int fromLua<unsigned int>(lua_State* state, int index) { return (unsigned int)lua_tonumber(state, index); };
-template<> float fromLua<float>(lua_State* state, int index) { return (float)lua_tonumber(state, index); };
-template<> char fromLua<char>(lua_State* state, int index) { return (char)lua_tonumber(state, index); };
-template<> const std::string& fromLua<const std::string&>(lua_State* state, int index) { temp[index] = lua_tostring(state, index); return temp[index]; };
-
-
-template<typename type> void toLua(lua_State* state, type value) { Lunar<type>::push(state, value, false); };
-template<> void toLua<bool>(lua_State* state, bool value) { lua_pushboolean(state, (int) value); };
-template<> void toLua<int>(lua_State* state, int value)  { lua_pushnumber(state, (lua_Number) value); };
-template<> void toLua<unsigned int>(lua_State* state, unsigned int value){ lua_pushnumber(state, (lua_Number) value); };
-template<> void toLua<float>(lua_State* state, float value) { lua_pushnumber(state, (lua_Number) value); };
-template<> void toLua<char>(lua_State* state, char value) { lua_pushnumber(state, (lua_Number) value); };
-template<> void toLua<const std::string&>(lua_State* state, const std::string& value) { lua_pushstring (state, value.c_str()); }
Index: trunk/src/lib/util/executor/executor_lua.h
===================================================================
--- trunk/src/lib/util/executor/executor_lua.h	(revision 9406)
+++ 	(revision )
@@ -1,708 +1,0 @@
-/*!
- * @file executor.h
- * Definition of a on-screen-shell
- */
-
-#ifndef _EXECUTOR_LUA_H
-#define _EXECUTOR_LUA_H
-
-#include "executor.h"
-#include "compiler.h"
-#include "debug.h"
-#include "luaincl.h"
-
-
-
-template<typename type> type fromLua(lua_State* state, int index);
-template<> bool fromLua<bool>(lua_State* state, int index);
-template<> int fromLua<int>(lua_State* state, int index);
-template<> unsigned int fromLua<unsigned int>(lua_State* state, int index);
-template<> float fromLua<float>(lua_State* state, int index);
-template<> char fromLua<char>(lua_State* state, int index);
-template<> const std::string& fromLua<const std::string&>(lua_State* state, int index);
-
-template<typename type> void toLua(lua_State* state, type value);
-template<> void toLua<bool>(lua_State* state, bool value);
-template<> void toLua<int>(lua_State* state, int value);
-template<> void toLua<unsigned int>(lua_State* state, unsigned int value);
-template<> void toLua<float>(lua_State* state, float value);
-template<> void toLua<char>(lua_State* state, char value);
-template<> void toLua<const std::string&>(lua_State* state, const std::string& value);
-
-// FORWARD DECLARATION
-
-///////////////////////
-///// WITHOUT RET /////
-///////////////////////
-
-///////////
-//// 0 ////
-///////////
-//! Executes a Function with a lua_State* parameter.
-template<class T> class ExecutorLua0 : public Executor
-{
-  public:
-    /**
-   * @brief Constructor of a ExecutorXML
-   * @param function a Function to call
-     */
-    ExecutorLua0(void(T::*function)())
-  : Executor()
-    {
-      this->functionPointer = function;
-      this->functorType = Executor_Objective | Executor_NoLoadString;
-    }
-
-    /**
-     * @brief executes the Command on BaseObject
-     * @param object the BaseObject to execute this Executor on
-     * @param loadString ignored in this case
-     */
-    virtual void operator()(BaseObject* object, const SubString& = SubString()) const
-    {
-      PRINTF(1)("no usefull executor\n");
-    }
-
-    virtual void operator()(BaseObject* object, int& count, void* values) const
-    {
-      (dynamic_cast<T*>(object)->*(functionPointer))();
-      count = 0;
-    }
-
-    /**
-     * @returns a _new_ Copy of this Executor
-     */
-    virtual Executor* clone () const
-    {
-      return new ExecutorLua0<T>(ExecutorLua0<T>(this->functionPointer));
-    }
-  private:
-    void          (T::*functionPointer)();
-};
-
-
-
-///////////
-//// 1 ////
-///////////
-//! Executes a Function with a lua_State* parameter.
-template<class T, typename type0> class ExecutorLua1 : public Executor
-{
-  public:
-    /**
-   * @brief Constructor of a ExecutorXML
-   * @param function a Function to call
-     */
-    ExecutorLua1(void(T::*function)(type0))
-  : Executor(ExecutorParamType<type0>())
-    {
-      this->functionPointer = function;
-      this->functorType = Executor_Objective | Executor_NoLoadString;
-    }
-
-    /**
-     * @brief executes the Command on BaseObject
-     * @param object the BaseObject to execute this Executor on
-     * @param loadString ignored in this case
-     */
-    virtual void operator()(BaseObject* object, const SubString& = SubString()) const
-    {
-      PRINTF(1)("no usefull executor\n");
-    }
-
-    virtual void operator()(BaseObject* object, int& count, void* values) const
-    {
-      lua_State* state = (lua_State*)values;
-      count = 0;
-
-      (dynamic_cast<T*>(object)->*(functionPointer))(fromLua<type0>(state, 1));
-    }
-
-    /**
-     * @returns a _new_ Copy of this Executor
-     */
-    virtual Executor* clone () const
-    {
-      return new ExecutorLua1<T, type0>((this->functionPointer));
-    }
-  private:
-    void          (T::*functionPointer)(type0);
-};
-
-
-
-///////////
-//// 2 ////
-///////////
-//! Executes a Function with a lua_State* parameter.
-template<class T, typename type0, typename type1> class ExecutorLua2 : public Executor
-{
-  public:
-    /**
-   * @brief Constructor of a ExecutorXML
-   * @param function a Function to call
-     */
-    ExecutorLua2(void(T::*function)(type0, type1))
-  : Executor(ExecutorParamType<type0>(), ExecutorParamType<type1>())
-    {
-      this->functionPointer = function;
-      this->functorType = Executor_Objective | Executor_NoLoadString;
-    }
-
-    /**
-     * @brief executes the Command on BaseObject
-     * @param object the BaseObject to execute this Executor on
-     * @param loadString ignored in this case
-     */
-    virtual void operator()(BaseObject* object, const SubString& = SubString()) const
-    {
-      PRINTF(1)("no usefull executor\n");
-    }
-
-    virtual void operator()(BaseObject* object, int& count, void* values) const
-    {
-      lua_State* state = (lua_State*)values;
-      count = 0;
-
-      (dynamic_cast<T*>(object)->*(functionPointer))(
-          fromLua<type0>(state, 1),
-      fromLua<type1>(state, 2) );
-    }
-
-    /**
-     * @returns a _new_ Copy of this Executor
-     */
-    virtual Executor* clone () const
-    {
-      return new ExecutorLua2<T, type0, type1>(this->functionPointer);
-    }
-  private:
-    void          (T::*functionPointer)(type0, type1);
-};
-
-
-///////////
-//// 3 ////
-///////////
-//! Executes a Function with a lua_State* parameter.
-template<class T, typename type0, typename type1, typename type2> class ExecutorLua3 : public Executor
-{
-  public:
-    /**
-   * @brief Constructor of a ExecutorXML
-   * @param function a Function to call
-     */
-    ExecutorLua3(void(T::*function)(type0, type1, type2))
-  : Executor(ExecutorParamType<type0>(), ExecutorParamType<type1>(), ExecutorParamType<type2>())
-    {
-      this->functionPointer = function;
-      this->functorType = Executor_Objective | Executor_NoLoadString;
-    }
-
-    /**
-     * @brief executes the Command on BaseObject
-     * @param object the BaseObject to execute this Executor on
-     * @param loadString ignored in this case
-     */
-    virtual void operator()(BaseObject* object, const SubString& = SubString()) const
-    {
-      PRINTF(1)("no usefull executor\n");
-    }
-
-    virtual void operator()(BaseObject* object, int& count, void* values) const
-    {
-      lua_State* state = (lua_State*)values;
-      count = 0;
-
-      (dynamic_cast<T*>(object)->*(functionPointer))(
-          fromLua<type0>(state, 1),
-      fromLua<type1>(state, 2),
-      fromLua<type2>(state, 3) );
-    }
-
-    /**
-     * @returns a _new_ Copy of this Executor
-     */
-    virtual Executor* clone () const
-    {
-      return new ExecutorLua3<T, type0, type1, type2>(this->functionPointer);
-    }
-  private:
-    void          (T::*functionPointer)(type0, type1, type2);
-};
-
-
-///////////
-//// 4 ////
-///////////
-//! Executes a Function with a lua_State* parameter.
-template<class T, typename type0, typename type1, typename type2, typename type3> class ExecutorLua4 : public Executor
-{
-  public:
-    /**
-   * @brief Constructor of a ExecutorXML
-   * @param function a Function to call
-     */
-    ExecutorLua4(void(T::*function)(type0, type1, type2, type3))
-  : Executor(ExecutorParamType<type0>(), ExecutorParamType<type1>(), ExecutorParamType<type2>(), ExecutorParamType<type3>())
-    {
-      this->functionPointer = function;
-      this->functorType = Executor_Objective | Executor_NoLoadString;
-    }
-
-    /**
-     * @brief executes the Command on BaseObject
-     * @param object the BaseObject to execute this Executor on
-     * @param loadString ignored in this case
-     */
-    virtual void operator()(BaseObject* object, const SubString& = SubString()) const
-    {
-      PRINTF(1)("no usefull executor\n");
-    }
-
-    virtual void operator()(BaseObject* object, int& count, void* values) const
-    {
-      lua_State* state = (lua_State*)values;
-      count = 0;
-
-      (dynamic_cast<T*>(object)->*(functionPointer))(
-          fromLua<type0>(state, 1),
-      fromLua<type1>(state, 2),
-      fromLua<type2>(state, 3),
-      fromLua<type3>(state, 4) );
-    }
-
-    /**
-     * @returns a _new_ Copy of this Executor
-     */
-    virtual Executor* clone () const
-    {
-      return new ExecutorLua4<T, type0, type1, type2, type3>(this->functionPointer);
-    }
-  private:
-    void          (T::*functionPointer)(type0, type1, type2, type3);
-};
-
-
-
-
-////////////////////
-///// WITH RET /////
-////////////////////
-
-
-///////////
-//// 0 ////
-///////////
-//! Executes a Function with a lua_State* parameter.
-template<class T, typename ret> class ExecutorLua0ret : public Executor
-{
-  public:
-    /**
-   * @brief Constructor of a ExecutorXML
-   * @param function a Function to call
-     */
-    ExecutorLua0ret(ret (T::*function)())
-  : Executor()
-    {
-      this->functionPointer = function;
-      this->functorType = Executor_Objective | Executor_NoLoadString;
-    }
-    
-    /**
-     * @brief executes the Command on BaseObject
-     * @param object the BaseObject to execute this Executor on
-     * @param loadString ignored in this case
-     */
-    virtual void operator()(BaseObject* object, const SubString& = SubString()) const
-    {
-      PRINTF(1)("no usefull executor\n");
-    }
-
-    virtual void operator()(BaseObject* object, int& count, void* values) const
-    {
-      lua_State* state = (lua_State*)values;
-      count = 1;
-
-      toLua<ret>(state, (dynamic_cast<T*>(object)->*(functionPointer))());
-    }
-
-    /**
-     * @returns a _new_ Copy of this Executor
-     */
-    virtual Executor* clone () const
-    {
-      return new ExecutorLua0ret<T, ret>(this->functionPointer);
-    }
-  private:
-    ret           (T::*functionPointer)();
-};
-
-
-
-///////////
-//// 1 ////
-///////////
-//! Executes a Function with a lua_State* parameter.
-template<class T, typename ret, typename type0> class ExecutorLua1ret : public Executor
-{
-  public:
-    /**
-   * @brief Constructor of a ExecutorXML
-   * @param function a Function to call
-     */
-    ExecutorLua1ret(ret (T::*function)(type0))
-  : Executor(ExecutorParamType<type0>())
-    {
-      this->functionPointer = function;
-      this->functorType = Executor_Objective | Executor_NoLoadString;
-    }
-
-    /**
-     * @brief executes the Command on BaseObject
-     * @param object the BaseObject to execute this Executor on
-     * @param loadString ignored in this case
-     */
-    virtual void operator()(BaseObject* object, const SubString& = SubString()) const
-    {
-      PRINTF(1)("no usefull executor\n");
-    }
-
-    virtual void operator()(BaseObject* object, int& count, void* values) const
-    {
-      lua_State* state = (lua_State*)values;
-      count = 1;
-
-      toLua<ret>(state, (dynamic_cast<T*>(object)->*(functionPointer))(
-          fromLua<type0>(state, 1)));
-    }
-
-    /**
-     * @returns a _new_ Copy of this Executor
-     */
-    virtual Executor* clone () const
-    {
-      return new ExecutorLua1ret<T, ret, type0>(this->functionPointer);
-    }
-  private:
-    ret           (T::*functionPointer)(type0);
-};
-
-///////////
-//// 2 ////
-///////////
-//! Executes a Function with a lua_State* parameter.
-template<class T, typename ret, typename type0, typename type1> class ExecutorLua2ret : public Executor
-{
-  public:
-    /**
-   * @brief Constructor of a ExecutorXML
-   * @param function a Function to call
-     */
-    ExecutorLua2ret(ret (T::*function)(type0, type1))
-  : Executor(ExecutorParamType<type0>(), ExecutorParamType<type1>())
-    {
-      this->functionPointer = function;
-      this->functorType = Executor_Objective | Executor_NoLoadString;
-    }
-
-    /**
-     * @brief executes the Command on BaseObject
-     * @param object the BaseObject to execute this Executor on
-     * @param loadString ignored in this case
-     */
-    virtual void operator()(BaseObject* object, const SubString& = SubString()) const
-    {
-      PRINTF(1)("no usefull executor\n");
-    }
-
-    virtual void operator()(BaseObject* object, int& count, void* values) const
-    {
-      lua_State* state = (lua_State*)values;
-      count = 1;
-
-      toLua<ret>(state, (dynamic_cast<T*>(object)->*(functionPointer))(
-          fromLua<type0>(state, 1),
-          fromLua<type1>(state, 2) ));
-    }
-
-    /**
-     * @returns a _new_ Copy of this Executor
-     */
-    virtual Executor* clone () const
-    {
-      return new ExecutorLua2ret<T, ret, type0, type1>(this->functionPointer);
-    }
-  private:
-    ret           (T::*functionPointer)(type0, type1);
-};
-
-
-///////////
-//// 3 ////
-///////////
-//! Executes a Function with a lua_State* parameter.
-template<class T, typename ret, typename type0, typename type1, typename type2> class ExecutorLua3ret : public Executor
-{
-  public:
-    /**
-   * @brief Constructor of a ExecutorXML
-   * @param function a Function to call
-     */
-    ExecutorLua3ret(ret (T::*function)(type0, type1, type2))
-  : Executor(ExecutorParamType<type0>(), ExecutorParamType<type1>(), ExecutorParamType<type2>())
-    {
-      this->functionPointer = function;
-      this->functorType = Executor_Objective | Executor_NoLoadString;
-    }
-
-    /**
-     * @brief executes the Command on BaseObject
-     * @param object the BaseObject to execute this Executor on
-     * @param loadString ignored in this case
-     */
-    virtual void operator()(BaseObject* object, const SubString& = SubString()) const
-    {
-      PRINTF(1)("no usefull executor\n");
-    }
-
-    virtual void operator()(BaseObject* object, int& count, void* values) const
-    {
-      lua_State* state = (lua_State*)values;
-      count = 1;
-
-      toLua<ret>(state, (dynamic_cast<T*>(object)->*(functionPointer))(
-          fromLua<type0>(state, 1),
-          fromLua<type1>(state, 2),
-          fromLua<type2>(state, 3) ));
-    }
-
-    /**
-     * @returns a _new_ Copy of this Executor
-     */
-    virtual Executor* clone () const
-    {
-      return new ExecutorLua3ret<T, ret, type0, type1, type2>(this->functionPointer);
-    }
-  private:
-    ret          (T::*functionPointer)(type0, type1, type2);
-};
-
-
-///////////
-//// 4 ////
-///////////
-//! Executes a Function with a lua_State* parameter.
-template<class T, typename ret, typename type0, typename type1, typename type2, typename type3> class ExecutorLua4ret : public Executor
-{
-  public:
-    /**
-   * @brief Constructor of a ExecutorXML
-   * @param function a Function to call
-     */
-    ExecutorLua4ret(ret (T::*function)(type0, type1, type2, type3))
-  : Executor(ExecutorParamType<type0>(), ExecutorParamType<type1>(), ExecutorParamType<type2>(), ExecutorParamType<type3>())
-    {
-      this->functionPointer = function;
-      this->functorType = Executor_Objective | Executor_NoLoadString;
-    }
-
-    /**
-     * @brief executes the Command on BaseObject
-     * @param object the BaseObject to execute this Executor on
-     * @param loadString ignored in this case
-     */
-    virtual void operator()(BaseObject* object, const SubString& = SubString()) const
-    {
-      PRINTF(1)("no usefull executor\n");
-    }
-
-    virtual void operator()(BaseObject* object, int& count, void* values) const
-    {
-      lua_State* state = (lua_State*)values;
-      count = 1;
-
-      toLua<ret>(state, (dynamic_cast<T*>(object)->*(functionPointer))(
-          fromLua<type0>(state, 1),
-          fromLua<type1>(state, 2),
-          fromLua<type2>(state, 3),
-          fromLua<type3>(state, 4) ));
-    }
-
-    /**
-     * @returns a _new_ Copy of this Executor
-     */
-    virtual Executor* clone () const
-    {
-      return new ExecutorLua4ret<T, ret, type0, type1, type2, type3>(this->functionPointer);
-    }
-  private:
-    ret          (T::*functionPointer)(type0, type1, type2, type3);
-};
-
-///////////
-//// 5 ////
-///////////
-//! Executes a Function with a lua_State* parameter.
-template<class T, typename ret, typename type0, typename type1, typename type2, typename type3, typename type4> class ExecutorLua5ret : public Executor
-{
-  public:
-    /**
-   * @brief Constructor of a ExecutorXML
-   * @param function a Function to call
-     */
-    ExecutorLua5ret(ret (T::*function)(type0, type1, type2, type3, type4))
-  : Executor(ExecutorParamType<type0>(), ExecutorParamType<type1>(), ExecutorParamType<type2>(), ExecutorParamType<type3>(), ExecutorParamType<type4>())
-    {
-      this->functionPointer = function;
-      this->functorType = Executor_Objective | Executor_NoLoadString;
-    }
-
-    /**
-     * @brief executes the Command on BaseObject
-     * @param object the BaseObject to execute this Executor on
-     * @param loadString ignored in this case
-     */
-    virtual void operator()(BaseObject* object, const SubString& = SubString()) const
-    {
-      PRINTF(1)("no usefull executor\n");
-    }
-
-    virtual void operator()(BaseObject* object, int& count, void* values) const
-    {
-      lua_State* state = (lua_State*)values;
-      count = 1;
-
-      toLua<ret>(state, (dynamic_cast<T*>(object)->*(functionPointer))(
-          fromLua<type0>(state, 1),
-          fromLua<type1>(state, 2),
-          fromLua<type2>(state, 3),
-          fromLua<type3>(state, 4),
-          fromLua<type4>(state, 5) ));
-    }
-
-    /**
-     * @returns a _new_ Copy of this Executor
-     */
-    virtual Executor* clone () const
-    {
-      return new ExecutorLua5ret<T, ret, type0, type1, type2, type3, type4>(this->functionPointer);
-    }
-  private:
-    ret          (T::*functionPointer)(type0, type1, type2, type3, type4);
-};
-
-///////////
-//// 6 ////
-///////////
-//! Executes a Function with a lua_State* parameter.
-template<class T, typename ret, typename type0, typename type1, typename type2, typename type3, typename type4, typename type5> class ExecutorLua6ret : public Executor
-{
-  public:
-    /**
-   * @brief Constructor of a ExecutorXML
-   * @param function a Function to call
-     */
-    ExecutorLua6ret(ret (T::*function)(type0, type1, type2, type3, type4, type5))
-  : Executor(ExecutorParamType<type0>(), ExecutorParamType<type1>(),
-             ExecutorParamType<type2>(), ExecutorParamType<type3>(),
-             ExecutorParamType<type4>(), ExecutorParamType<type5>())
-             {
-               this->functionPointer = function;
-               this->functorType = Executor_Objective | Executor_NoLoadString;
-             }
-
-    /**
-              * @brief executes the Command on BaseObject
-              * @param object the BaseObject to execute this Executor on
-              * @param loadString ignored in this case
-     */
-             virtual void operator()(BaseObject* object, const SubString& = SubString()) const
-             {
-               PRINTF(1)("no usefull executor\n");
-             }
-
-             virtual void operator()(BaseObject* object, int& count, void* values) const
-             {
-               lua_State* state = (lua_State*)values;
-               count = 1;
-
-               toLua<ret>(state, (dynamic_cast<T*>(object)->*(functionPointer))(
-                   fromLua<type0>(state, 1),
-                   fromLua<type1>(state, 2),
-                   fromLua<type2>(state, 3),
-                   fromLua<type3>(state, 4),
-                   fromLua<type4>(state, 5),
-                   fromLua<type5>(state, 6) ));
-             }
-
-    /**
-              * @returns a _new_ Copy of this Executor
-     */
-             virtual Executor* clone () const
-             {
-               return new ExecutorLua6ret<T, ret, type0, type1, type2, type3, type4, type5>(this->functionPointer);
-             }
-  private:
-    ret           (T::*functionPointer)(type0, type1, type2, type3, type4, type5);
-};
-
-///////////
-//// 7 ////
-///////////
-//! Executes a Function with a lua_State* parameter.
-template<class T, typename ret, typename type0, typename type1, typename type2, typename type3, typename type4, typename type5, typename type6> class ExecutorLua7ret : public Executor
-{
-  public:
-    /**
-   * @brief Constructor of a ExecutorXML
-   * @param function a Function to call
-     */
-    ExecutorLua7ret(ret (T::*function)(type0, type1, type2, type3, type4, type5, type6))
-  : Executor(ExecutorParamType<type0>(), ExecutorParamType<type1>(),
-             ExecutorParamType<type2>(), ExecutorParamType<type3>(),
-             ExecutorParamType<type4>(), ExecutorParamType<type5>(),
-             ExecutorParamType<type6>())
-             {
-               this->functionPointer = function;
-               this->functorType = Executor_Objective | Executor_NoLoadString;
-             }
-
-    /**
-              * @brief executes the Command on BaseObject
-              * @param object the BaseObject to execute this Executor on
-              * @param loadString ignored in this case
-     */
-             virtual void operator()(BaseObject* object, const SubString& = SubString()) const
-             {
-               PRINTF(1)("no usefull executor\n");
-             }
-
-             virtual void operator()(BaseObject* object, int& count, void* values) const
-             {
-               lua_State* state = (lua_State*)values;
-               count = 1;
-
-               toLua<ret>(state, (dynamic_cast<T*>(object)->*(functionPointer))(
-                   fromLua<type0>(state, 1),
-                   fromLua<type1>(state, 2),
-                   fromLua<type2>(state, 3),
-                   fromLua<type3>(state, 4),
-                   fromLua<type4>(state, 5),
-                   fromLua<type5>(state, 6),
-                   fromLua<type6>(state, 7) ));
-             }
-
-    /**
-              * @returns a _new_ Copy of this Executor
-     */
-             virtual Executor* clone () const
-             {
-               return new ExecutorLua7ret<T, ret, type0, type1, type2, type3, type4, type5, type6>(this->functionPointer);
-             }
-  private:
-    ret           (T::*functionPointer)(type0, type1, type2, type3, type4, type5, type6);
-};
-
-
-#endif /* _EXECUTOR_LUA_H */
Index: trunk/src/lib/util/executor/executor_member.h
===================================================================
--- trunk/src/lib/util/executor/executor_member.h	(revision 9869)
+++ trunk/src/lib/util/executor/executor_member.h	(revision 9869)
@@ -0,0 +1,47 @@
+/*!
+ * @file executor_member.h
+ * Definition of an Executor to Member Functions
+ */
+/*
+   orxonox - the future of 3D-vertical-scrollers
+
+   Copyright (C) 2004 orx
+
+   This program is free software; you can redistribute it and/or modify
+   it under the terms of the GNU General Public License as published by
+   the Free Software Foundation; either version 2, or (at your option)
+   any later version.
+
+### File Specific:
+   main-programmer: Benjamin Grauer
+   co-programmer: ...
+*/
+
+
+#ifndef __EXECUTOR_MEMBER_H_
+#define __EXECUTOR_MEMBER_H_
+
+/// Define all Constructs, that define an Executor.
+//! The Name to be attached to the functional (for normal, static, and const modes)
+#define __EXECUTOR_FUNCTIONAL_NAME(ParamCount, Ext)   Executor##ParamCount##Ext
+//! if Functional is constant calling
+#define __EXECUTOR_FUNCTIONAL_CONST
+//! The Execution-mode (either static or objective)
+#define __EXECUTOR_FUNCTIONAL_FUNCTION_EXEC      dynamic_cast<T*>(object)->*(functionPointer)
+//! The Function-Pointer, and how to save it internally.
+#define __EXECUTOR_FUNCTIONAL_FUNCTION_POINTER   T::*functionPointer
+//! The Type of Function
+#define __EXECUTOR_FUNCTIONAL_FUNCTIONTYPE       Executor<CallType, BaseClass>::FunctionMember
+
+
+/// We want to include __EXECUTOR_GENERIC_H again, with current settings.
+#include "executor_generic.h"
+
+
+#undef __EXECUTOR_FUNCTIONAL_NAME
+#undef __EXECUTOR_FUNCTIONAL_CONST
+#undef __EXECUTOR_FUNCTIONAL_FUNCTION_EXEC
+#undef __EXECUTOR_FUNCTIONAL_FUNCTION_POINTER
+#undef __EXECUTOR_FUNCTIONAL_FUNCTIONTYPE
+
+#endif /* __EXECUTOR_MEMBER_H_ */
Index: trunk/src/lib/util/executor/executor_static.h
===================================================================
--- trunk/src/lib/util/executor/executor_static.h	(revision 9869)
+++ trunk/src/lib/util/executor/executor_static.h	(revision 9869)
@@ -0,0 +1,49 @@
+/*!
+ * @file executor_static.h
+ * Definition of an Executor to Static Functions (either Static-Class or C-Style)
+ */
+/*
+   orxonox - the future of 3D-vertical-scrollers
+
+   Copyright (C) 2004 orx
+
+   This program is free software; you can redistribute it and/or modify
+   it under the terms of the GNU General Public License as published by
+   the Free Software Foundation; either version 2, or (at your option)
+   any later version.
+
+### File Specific:
+   main-programmer: Benjamin Grauer
+   co-programmer: ...
+*/
+
+
+#ifndef __EXECUTOR_STATIC_H_
+#define __EXECUTOR_STATIC_H_
+
+/// Define all Constructs, that define an Executor.
+
+//! The Name to be attached to the functional (for normal, static, and const modes)
+#define __EXECUTOR_FUNCTIONAL_NAME(ParamCount, Ext)   Executor##ParamCount##Ext##_static
+
+//! if Functional is constant calling
+#define __EXECUTOR_FUNCTIONAL_CONST
+//! The Execution-mode (either static or objective)
+#define __EXECUTOR_FUNCTIONAL_FUNCTION_EXEC      functionPointer
+//! The Function-Pointer, and how to save it internally.
+#define __EXECUTOR_FUNCTIONAL_FUNCTION_POINTER   *functionPointer
+//! The Type of Function
+#define __EXECUTOR_FUNCTIONAL_FUNCTIONTYPE       Executor<CallType, BaseClass>::FunctionStatic
+
+
+/// We want to include __EXECUTOR_GENERIC_H again, with current settings.
+#include "executor_generic.h"
+
+#undef __EXECUTOR_FUNCTIONAL_NAME
+
+#undef __EXECUTOR_FUNCTIONAL_CONST
+#undef __EXECUTOR_FUNCTIONAL_FUNCTION_EXEC
+#undef __EXECUTOR_FUNCTIONAL_FUNCTION_POINTER
+#undef __EXECUTOR_FUNCTIONAL_FUNCTIONTYPE
+
+#endif /* __EXECUTOR_STATIC_H_ */
Index: trunk/src/lib/util/executor/executor_substring.cc
===================================================================
--- trunk/src/lib/util/executor/executor_substring.cc	(revision 9869)
+++ trunk/src/lib/util/executor/executor_substring.cc	(revision 9869)
@@ -0,0 +1,142 @@
+/*
+   orxonox - the future of 3D-vertical-scrollers
+
+   Copyright (C) 2004 orx
+
+   This program is free software; you can redistribute it and/or modify
+   it under the terms of the GNU General Public License as published by
+   the Free Software Foundation; either version 2, or (at your option)
+   any later version.
+
+### File Specific:
+   main-programmer: Benjamin Grauer
+   co-programmer: ...
+*/
+
+#include "executor_substring.h"
+#include "helper_functions.h"
+
+/**
+ * @brief converts an input string into a value, if no value was converted, uses defaultValue.
+ * @param input the input as a String.
+ * @param defaultValue the Default Value set, if the input could not be converted into type.
+ * @returns either the converted value or defaultValue.
+ */
+template<> bool fromString<bool>(const std::string& input, bool defaultValue) { return isBool(input, defaultValue); };
+/**
+ * @brief converts an input string into a value, if no value was converted, uses defaultValue.
+ * @param input the input as a String.
+ * @param defaultValue the Default Value set, if the input could not be converted into type.
+ * @returns either the converted value or defaultValue.
+ */
+template<> int fromString<int>(const std::string& input, int defaultValue) { return isInt(input, defaultValue); };
+/**
+ * @brief converts an input string into a value, if no value was converted, uses defaultValue.
+ * @param input the input as a String.
+ * @param defaultValue the Default Value set, if the input could not be converted into type.
+ * @returns either the converted value or defaultValue.
+ */
+template<> unsigned int fromString<unsigned int>(const std::string& input, unsigned int defaultValue) { return isInt(input, defaultValue); };
+/**
+ * @brief converts an input string into a value, if no value was converted, uses defaultValue.
+ * @param input the input as a String.
+ * @param defaultValue the Default Value set, if the input could not be converted into type.
+ * @returns either the converted value or defaultValue.
+ */
+template<> float fromString<float>(const std::string& input, float defaultValue) { return isFloat(input, defaultValue); };
+/**
+ * @brief converts an input string into a value, if no value was converted, uses defaultValue.
+ * @param input the input as a String.
+ * @param defaultValue the Default Value set, if the input could not be converted into type.
+ * @returns either the converted value or defaultValue.
+ */
+template<> char fromString<char>(const std::string& input, char defaultValue) { return isInt(input, defaultValue); };
+/**
+ * @brief converts an input string into a value, if no value was converted, uses defaultValue.
+ * @param input the input as a String.
+ * @param defaultValue the Default Value set, if the input could not be converted into type.
+ * @returns either the converted value or defaultValue.
+ */
+template<> const std::string& fromString<const std::string&>(const std::string& input, const std::string& defaultValue) { return (input.size() > 0) ? input : defaultValue; };
+
+
+/**
+ * @brief converts to any type from a MultiType
+ * @param multi the MultiType to convert.
+ * @returns the converted Value.
+ */
+template<> bool fromMulti<bool>(const MultiType& multi) { return multi.getBool(); };
+/**
+ * @brief converts to any type from a MultiType
+ * @param multi the MultiType to convert.
+ * @returns the converted Value.
+ */
+template<> int fromMulti<int>(const MultiType& multi) { return multi.getInt(); }
+/**
+ * @brief converts to any type from a MultiType
+ * @param multi the MultiType to convert.
+ * @returns the converted Value.
+ */
+template<> unsigned int fromMulti<unsigned int>(const MultiType& multi) { return multi.getInt(); };
+/**
+ * @brief converts to any type from a MultiType
+ * @param multi the MultiType to convert.
+ * @returns the converted Value.
+ */
+template<> float fromMulti<float>(const MultiType& multi) { return multi.getFloat(); };
+/**
+ * @brief converts to any type from a MultiType
+ * @param multi the MultiType to convert.
+ * @returns the converted Value.
+ */
+template<> char fromMulti<char>(const MultiType& multi) { return multi.getChar(); };
+/**
+ * @brief converts to any type from a MultiType
+ * @param multi the MultiType to convert.
+ * @returns the converted Value.
+ */
+template<> const std::string& fromMulti<const std::string&>(const MultiType& multi) { return multi.getConstString(); };
+
+
+/**
+ * @brief retrieves a default value from an array of default values, at possition i.
+ * @param defaultValues the Array of default values.
+ * @param i the index.
+ * @returns the Default Value at Position i
+ */
+template<> bool getDefault<bool>(const MultiType* const defaultValues, unsigned int i) { return defaultValues[i].getBool(); };
+/**
+ * @brief retrieves a default value from an array of default values, at possition i.
+ * @param defaultValues the Array of default values.
+ * @param i the index.
+ * @returns the Default Value at Position i
+ */
+template<> int getDefault<int>(const MultiType* const defaultValues, unsigned int i) { return defaultValues[i].getInt(); };
+/**
+ * @brief retrieves a default value from an array of default values, at possition i.
+ * @param defaultValues the Array of default values.
+ * @param i the index.
+ * @returns the Default Value at Position i
+ */
+template<> unsigned int getDefault<unsigned int>(const MultiType* const defaultValues, unsigned int i) { return defaultValues[i].getInt(); };
+/**
+ * @brief retrieves a default value from an array of default values, at possition i.
+ * @param defaultValues the Array of default values.
+ * @param i the index.
+ * @returns the Default Value at Position i
+ */
+template<> float getDefault<float>(const MultiType* const defaultValues, unsigned int i) { return defaultValues[i].getFloat(); };
+/**
+ * @brief retrieves a default value from an array of default values, at possition i.
+ * @param defaultValues the Array of default values.
+ * @param i the index.
+ * @returns the Default Value at Position i
+ */
+template<> char getDefault<char>(const MultiType* const defaultValues, unsigned int i) { return defaultValues[i].getChar(); };
+/**
+ * @brief retrieves a default value from an array of default values, at possition i.
+ * @param defaultValues the Array of default values.
+ * @param i the index.
+ * @returns the Default Value at Position i
+ */
+template<> const std::string& getDefault<const std::string&>(const MultiType* const defaultValues, unsigned int i) { return defaultValues[i].getStoredString(); };
Index: trunk/src/lib/util/executor/executor_substring.h
===================================================================
--- trunk/src/lib/util/executor/executor_substring.h	(revision 9869)
+++ trunk/src/lib/util/executor/executor_substring.h	(revision 9869)
@@ -0,0 +1,100 @@
+/*!
+ * @file executor_substring.h
+ * Definition of a Generic Executor
+ */
+
+/*
+   orxonox - the future of 3D-vertical-scrollers
+
+   Copyright (C) 2004 orx
+
+   This program is free software; you can redistribute it and/or modify
+   it under the terms of the GNU General Public License as published by
+   the Free Software Foundation; either version 2, or (at your option)
+   any later version.
+
+### File Specific:
+   main-programmer: Benjamin Grauer
+   co-programmer: ...
+*/
+
+
+
+#ifndef __EXECUTOR_SUBSTRING_H_
+#define __EXECUTOR_SUBSTRING_H_
+
+
+#include "executor_generic.h"
+#include "substring.h"
+#ifdef FUNCTOR_CALL_TYPE
+ #undef FUNCTOR_CALL_TYPE
+#endif
+//! Use SubString as the FUNCTION_CALL_TYPE so that we can easily extend the Engine.
+#define FUNCTOR_CALL_TYPE const SubString
+
+/**
+ * @brief converts an input string into a value, if no value was converted, uses defaultValue.
+ * @param input the input as a String.
+ * @param defaultValue the Default Value set, if the input could not be converted into type.
+ * @returns either the converted value or defaultValue.
+ */
+template<typename type> type fromString(const std::string& input, type defaultValue) { return defaultValue; };
+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);
+
+/**
+ * @brief converts to any type from a MultiType
+ * @param multi the MultiType to convert.
+ * @returns the converted Value.
+ */
+template<typename type> type fromMulti(const MultiType& multi) { /* return defaultValue; */ };
+template<> bool fromMulti<bool>(const MultiType& multi);
+template<> int fromMulti<int>(const MultiType& multi);
+template<> unsigned int fromMulti<unsigned int>(const MultiType& multi);
+template<> float fromMulti<float>(const MultiType& multi);
+template<> char fromMulti<char>(const MultiType& multi);
+template<> const std::string& fromMulti<const std::string&>(const MultiType& multi);
+
+/**
+ * @brief retrieves a default value from an array of default values, at possition i.
+ * @param defaultValues the Array of default values.
+ * @param i the index.
+ * @returns the Default Value at Position i
+ */
+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);
+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);
+
+
+/**
+ * @brief to remove writing errors, this function is Used.
+ * @param sub The SubString to use
+ * @param default The default Values.
+ */
+template<> class ExecutorEvaluater <const SubString>
+{
+public:
+  /** @brief Executes the Evaluater
+   * @param CallValue the Value that should be converted
+   * @param defaults the default Values.
+   */
+  template <typename ToType, int index>
+  static ToType getValue(const SubString& CallValue, const MultiType* const defaults)
+  {
+    return (CallValue.size() > index) ?
+           fromString<ToType>(CallValue[index], getDefault<ToType>(defaults, index)) :
+           fromMulti<ToType>(defaults[index]);
+  }
+  /** @returns the default Value of a SubString, namely NullSubString or SubString() */
+  static const SubString& defaultValue() { return SubString::NullSubString; };
+};
+
+#endif /* __EXECUTOR_SUBSTRING_H_ */
Index: trunk/src/lib/util/executor/executor_xml.h
===================================================================
--- trunk/src/lib/util/executor/executor_xml.h	(revision 9406)
+++ trunk/src/lib/util/executor/executor_xml.h	(revision 9869)
@@ -19,66 +19,52 @@
  * What must be defined is a XML-root to search the ParameterName under an  a Function to call.
  */
-template<class T> class ExecutorXML : public Executor
+template<class T, class BaseClass = BaseObject> class ExecutorXML : public Executor<const TiXmlElement*>
 {
-  public:
-    /**
+public:
+  /**
    * @brief Constructor of a ExecutorXML
-     * @param function a Function to call
-     * @param root The XML root to search paramName under
-     * @param paramName the ParameterName the search in root, and lookup the TiXmlElement from
-     */
-    ExecutorXML(void(T::*function)(const TiXmlElement*), const TiXmlElement* root, const char* paramName)
-      : Executor(MT_EXT1)
-    {
-      PRINTF(4)("Loading %s from XML-element %p\n", paramName, root);
+   * @param function a Function to call
+   * @param root The XML root to search paramName under
+   * @param paramName the ParameterName the search in root, and lookup the TiXmlElement from
+   */
+  ExecutorXML(void(T::*function)(const TiXmlElement*), const TiXmlElement* root, const std::string& paramName)
+      : Executor<const TiXmlElement*>(false, MT_EXT1)
+  {
+    PRINTF(4)("Loading %s from XML-element %p\n", paramName.c_str(), root);
 
-      if (likely(root != NULL && paramName != NULL))
-        this->element = root->FirstChildElement(paramName);
-      else
-        this->element = NULL;
+    if (likely(root != NULL))
+      this->element = root->FirstChildElement(paramName);
+    else
+      this->element = NULL;
 
-      this->functionPointer = function;
-      this->functorType = Executor_Objective | Executor_NoLoadString;
-    }
+    this->paramName = paramName;
+    this->functionPointer = function;
+  }
 
-    /**
-     * @brief clones an ExecutorXML, used to copy this Element.
-     * @returns a _new_ Copy of this Executor
-     */
-    virtual Executor* clone () const
-    {
-      ExecutorXML<T>* executor = new ExecutorXML<T>();
-      this->cloning(executor);
-      executor->functionPointer = this->functionPointer;
-      executor->element = this->element;
-      return executor;
-    }
+  /**
+   * @brief clones an ExecutorXML, used to copy this Element.
+   * @returns a _new_ Copy of this Executor
+   */
+  virtual Executor<const TiXmlElement*>* clone () const
+  {
+    return new ExecutorXML<T>(functionPointer, element, paramName);
+  }
 
-    /**
-     * @brief executes the Command on BaseObject
-     * @param object the BaseObject to execute this Executor on
-     * @param loadString ignored in this case
-     */
-    virtual void operator()(BaseObject* object, const SubString& = SubString()) const
-    {
-      if (object != NULL && this->element != NULL)
-        (dynamic_cast<T*>(object)->*(functionPointer))(this->element);
-    }
+  /**
+   * @brief executes the Command on BaseObject
+   * @param object the BaseObject to execute this Executor on
+   * @param element ignored in this case
+   */
+  virtual void operator()(BaseObject* object, const TiXmlElement*& element) const
+  {
+    assert (object != NULL);
+    if (this->element != NULL)
+      (dynamic_cast<T*>(object)->*(functionPointer))(this->element);
+  }
 
-    virtual void operator()(BaseObject* object, int& count, void* values) const
-    {
-      PRINTF(1)("missuse of XML-operator, OR IMPLEMENT.\n");
-    }
-
-  private:
-    /**
-   * @brief used for the copy-(Clone)-constructor
-     */
-    ExecutorXML() : Executor() { };
-
-
-  private:
-    void    (T::*functionPointer)(const TiXmlElement*);  //!< The functionPointer to the function to be called
-    const   TiXmlElement* element;                       //!< The XML-element to call.
+private:
+  void    (T::*functionPointer)(const TiXmlElement*);  //!< The functionPointer to the function to be called.
+  const   TiXmlElement* element;                       //!< The XML-element to call.
+  std::string           paramName;                     //!< The Name of the Parameter this Executor should call.
 };
 
Index: trunk/src/lib/util/executor/functor_const_member.h
===================================================================
--- trunk/src/lib/util/executor/functor_const_member.h	(revision 9869)
+++ trunk/src/lib/util/executor/functor_const_member.h	(revision 9869)
@@ -0,0 +1,47 @@
+/*!
+ * @file functor_const_member.h
+ * Definition of an Functor
+ */
+
+/*
+   orxonox - the future of 3D-vertical-scrollers
+
+   Copyright (C) 2004 orx
+
+   This program is free software; you can redistribute it and/or modify
+   it under the terms of the GNU General Public License as published by
+   the Free Software Foundation; either version 2, or (at your option)
+   any later version.
+
+### File Specific:
+   main-programmer: Benjamin Grauer
+   co-programmer: ...
+*/
+
+
+#ifndef __FUNCTOR_CONST_MEMBER_H_
+#define __FUNCTOR_CONST_MEMBER_H_
+
+#include "executor_const_member.h"
+
+/// Define all Constructs, that define an Executor.
+//! The Name to be attached to the functional (for normal, static, and const modes)
+#define __EXECUTOR_FUNCTIONAL_NAME(ParamCount, Ext)   Executor##ParamCount##Ext##_const
+//! if Functional is constant calling
+#define __EXECUTOR_FUNCTIONAL_CONST              const
+//! The Function-Pointer, and how to save it internally.
+#define __EXECUTOR_FUNCTIONAL_FUNCTION_POINTER   T::*functionPointer
+//! The Type of Function
+#define __EXECUTOR_FUNCTIONAL_FUNCTIONTYPE       Executor<CallType, BaseClass>::FunctionMember
+
+/// Now we include The generic Functor, that generate the functions.
+#include "functor_generic.h"
+
+#undef __EXECUTOR_FUNCTIONAL_NAME
+#undef __EXECUTOR_FUNCTIONAL_CONST
+#undef __EXECUTOR_FUNCTIONAL_FUNCTION_POINTER
+#undef __EXECUTOR_FUNCTIONAL_FUNCTIONTYPE
+
+
+
+#endif /* __FUNCTOR_CONST_MEMBER_H_ */
Index: trunk/src/lib/util/executor/functor_generic.h
===================================================================
--- trunk/src/lib/util/executor/functor_generic.h	(revision 9869)
+++ trunk/src/lib/util/executor/functor_generic.h	(revision 9869)
@@ -0,0 +1,105 @@
+/*!
+ * @file functor_generic.h
+ * Definition of an Executor
+ */
+
+/*
+   orxonox - the future of 3D-vertical-scrollers
+
+   Copyright (C) 2004 orx
+
+   This program is free software; you can redistribute it and/or modify
+   it under the terms of the GNU General Public License as published by
+   the Free Software Foundation; either version 2, or (at your option)
+   any later version.
+
+### File Specific:
+   main-programmer: Benjamin Grauer
+   co-programmer: ...
+*/
+
+// // // // // // // // // // // // //
+//// EXTENSION TO HIDE CONSTRUCT /////
+// // // // // // // // // // // // //
+/**
+ * @brief enables us to easily retrieve an Executor of Class T with modular Argument-count, (without thinking about args at all)
+ * @param CallType the Type of Executor to generate
+ */
+#define EXECUTOR_FUNCTIONAL_CREATOR0(CallType) \
+template<class T, class BaseClass> Executor<CallType, BaseClass>* createExecutor(void (__EXECUTOR_FUNCTIONAL_FUNCTION_POINTER)() __EXECUTOR_FUNCTIONAL_CONST) \
+{ \
+  return new __EXECUTOR_FUNCTIONAL_NAME(0,)<T, CallType, BaseClass>(functionPointer); \
+}
+
+/**
+ * @brief enables us to easily retrieve an Executor of Class T with modular Argument-count, (without thinking about args at all)
+ * @param CallType the Type of Executor to generate
+ * @param type0 for internal usage: the first Argument
+ */
+#define EXECUTOR_FUNCTIONAL_CREATOR1(CallType, type0) \
+template<class T, class BaseClass> Executor<CallType, BaseClass>* createExecutor(void (__EXECUTOR_FUNCTIONAL_FUNCTION_POINTER)(type0) __EXECUTOR_FUNCTIONAL_CONST) \
+{ \
+  return new __EXECUTOR_FUNCTIONAL_NAME(1,)<T, CallType, type0, BaseClass>(functionPointer); \
+}
+
+/**
+ * @brief enables us to easily retrieve an Executor of Class T with modular Argument-count, (without thinking about args at all)
+ * @param CallType the Type of Executor to generate
+ * @param type0 for internal usage: the first Argument
+ * @param type1 for internal usage: the second Argument
+ */
+#define EXECUTOR_FUNCTIONAL_CREATOR2(CallType, type0, type1) \
+template<class T, class BaseClass> Executor<CallType, BaseClass>* createExecutor(void (__EXECUTOR_FUNCTIONAL_FUNCTION_POINTER)(type0, type1) __EXECUTOR_FUNCTIONAL_CONST) \
+{ \
+  return new __EXECUTOR_FUNCTIONAL_NAME(2,)<T, CallType, type0, type1, BaseClass>(functionPointer); \
+}
+
+/**
+ * @brief enables us to easily retrieve an Executor of Class T with modular Argument-count, (without thinking about args at all)
+ * @param CallType the Type of Executor to generate
+ * @param type0 for internal usage: the first Argument
+ * @param type1 for internal usage: the second Argument
+ * @param type2 for internal usage: the third Argument
+ */
+#define EXECUTOR_FUNCTIONAL_CREATOR3(CallType, type0, type1, type2) \
+template<class T, class BaseClass> Executor<CallType, BaseClass>* createExecutor(void (__EXECUTOR_FUNCTIONAL_FUNCTION_POINTER)(type0, type1, type2) __EXECUTOR_FUNCTIONAL_CONST) \
+{ \
+  return new __EXECUTOR_FUNCTIONAL_NAME(3,)<T, CallType, type0, type1, type2, BaseClass>(functionPointer); \
+}
+
+/**
+ * @brief enables us to easily retrieve an Executor of Class T with modular Argument-count, (without thinking about args at all)
+ * @param CallType the Type of Executor to generate
+ * @param type0 for internal usage: the first Argument
+ * @param type1 for internal usage: the second Argument
+ * @param type2 for internal usage: the third Argument
+ * @param type3 for internal usage: the fourth Argument
+ */
+#define EXECUTOR_FUNCTIONAL_CREATOR4(CallType, type0, type1, type2, type3) \
+template<class T, class BaseClass> Executor<CallType, BaseClass>* createExecutor(void (__EXECUTOR_FUNCTIONAL_FUNCTION_POINTER)(type0, type1, type2, type3) __EXECUTOR_FUNCTIONAL_CONST) \
+{ \
+  return new __EXECUTOR_FUNCTIONAL_NAME(4,)<T, CallType, type0, type1, type2, type3, BaseClass>(functionPointer); \
+}
+
+/**
+ * @brief enables us to easily retrieve an Executor of Class T with modular Argument-count, (without thinking about args at all)
+ * @param CallType the Type of Executor to generate
+ * @param type0 for internal usage: the first Argument
+ * @param type1 for internal usage: the second Argument
+ * @param type2 for internal usage: the third Argument
+ * @param type3 for internal usage: the fourth Argument
+ * @param type4 for internal usage: the fifth Argument
+ */
+#define EXECUTOR_FUNCTIONAL_CREATOR5(CallType, type0, type1, type2, type3, type4) \
+template<class T, class BaseClass> Executor<CallType, BaseClass>* createExecutor(void (__EXECUTOR_FUNCTIONAL_FUNCTION_POINTER)(type0, type1, type2, type3, type4) __EXECUTOR_FUNCTIONAL_CONST) \
+{ \
+    return new __EXECUTOR_FUNCTIONAL_NAME(5,)<T, CallType, type0, type1, type2, type3, type4, BaseClass>(functionPointer); \
+}
+
+/**
+ * Creates the FunctionCallers imediately
+ */
+#define FUNCTOR_LIST(x) EXECUTOR_FUNCTIONAL_CREATOR ## x
+#include "functor_list.h"
+#undef FUNCTOR_LIST
+
Index: trunk/src/lib/util/executor/functor_list.h
===================================================================
--- trunk/src/lib/util/executor/functor_list.h	(revision 9406)
+++ trunk/src/lib/util/executor/functor_list.h	(revision 9869)
@@ -1,2 +1,7 @@
+/*!
+ * @file functor_list.h
+ * all the Different types of Functions one can include by using a simple createExecutor call
+ * with a FunctionPointer as Argument
+ */
 /*
    orxonox - the future of 3D-vertical-scrollers
@@ -8,142 +13,65 @@
    the Free Software Foundation; either version 2, or (at your option)
    any later version.
-   */
-
-/*!
- * @file functors_list.h
- * all the Different types of Functions one can include
 */
-
-/**
-   useable FunctionParameters are:
-   l_INT:       int
-   l_LONG:      long
-   l_SHORT:     short
-   l_FLOAT:     float
-   l_STRING:    const std::string&
-   l_XML_ELEM:  TiXmlElement*
- */
-
-#ifndef __FUNCTOR_PARAMETERS__
-#define __FUNCTOR_PARAMETERS__
-
-//! defines the maximum count of arguments function pointers might have
-#define FUNCTOR_MAX_ARGUMENTS                7
-#include "multi_type.h"
-
-
-#define l_BOOL_TYPE        bool                 //!< The type of an BOOL
-#define l_BOOL_FUNC        isBool               //!< The function to call to parse BOOL
-#define l_BOOL_PARAM       MT_BOOL              //!< the type of the parameter BOOL
-#define l_BOOL_DEFAULT     false                //!< a default Value for an BOOL
-#define l_BOOL_DEFGRAB(i)  this->defaultValue[i].getBool()
-
-#define l_INT_TYPE         int                  //!< The type of an INT
-#define l_INT_FUNC         isInt                //!< The function to call to parse INT
-#define l_INT_PARAM        MT_INT               //!< the type of the parameter INT
-#define l_INT_DEFAULT      0                    //!< a default Value for an INT
-#define l_INT_DEFGRAB(i)   this->defaultValue[i].getInt()
-
-#define l_UINT_TYPE        unsigned int         //!< The type of an UINT
-#define l_UINT_FUNC        isInt                //!< The function to call to parse UINT
-#define l_UINT_PARAM       MT_INT        //!< the type of the parameter UINT
-#define l_UINT_DEFAULT     0                    //!< a default Value for an UINT
-#define l_UINT_DEFGRAB(i)  (unsigned int)this->defaultValue[i].getInt()
-
-#define l_LONG_TYPE        long                 //!< The type of a LONG
-#define l_LONG_FUNC        isInt                //!< The function to parse a LONG
-#define l_LONG_PARAM       MT_INT //!< the type of the parameter LONG
-#define l_LONG_DEFAULT     0                    //!< a default Value for a LONG
-#define l_LONG_DEFGRAB(i)  (long)this->defaultValue[i].getInt()
-
-// #define l_SHORT_TYPE       short                //!< The type of a SHORT
-// #define l_SHORT_FUNC       atoi                 //!< The function to parse a SHORT
-// #define l_SHORT_NAME       "short"              //!< The name of a SHORT
-// #define l_SHORT_PARAM      ParameterShort       //!< the type of the parameter SHORT
-// #define l_SHORT_DEFAULT    0                    //!< a default Value for a SHORT
-
-#define l_FLOAT_TYPE       float                //!< The type of a FLOAT
-#define l_FLOAT_FUNC       isFloat              //!< The function to parse a FLOAT
-#define l_FLOAT_PARAM      MT_FLOAT             //!< the type of the parameter FLOAT
-#define l_FLOAT_DEFAULT    0.0                  //!< a default Value for a FLOAT
-#define l_FLOAT_DEFGRAB(i) this->defaultValue[i].getFloat()
-
-//#define l_VECTOR_TYPE      const Vector&        //!< The type of a VECTOR
-//#define l_VECTOR_FUNC      isVector             //!< The function to parse a VECTOR
-//#define l_VECTOR_NAME      "Vector[x/y/z]"      //!< The name of a VECTOR
-//#define l_VECTOR_DEFAULT   Vector(0,0,0)        //!< Default value for a VECTOR
-
-#define l_STRING_TYPE      const std::string&   //!< The type of a STRING
-#define l_STRING_FUNC      isString             //!< The function to parse a STRING
-#define l_STRING_PARAM     MT_STRING            //!< the type of the parameter STRING
-#define l_STRING_DEFAULT   ""                   //!< a default Value for an STRING
-#define l_STRING_DEFGRAB(i) this->defaultValue[i].getString()
-
-#define l_XML_ELEM_TYPE    const TiXmlElement*  //!< The type of an XML_ELEM
-#define l_XML_ELEM_FUNC                         //!< The function to parse an XML_ELEM
-//#define l_XML_ELEM_PARAM   Parameter            //!< the type of the parameter XML_ELEM
-#define l_XML_ELEM_DEFAULT NULL                 //!< The dafault Value for an XML_ELEM
-
-#endif /* __FUNCTOR_PARAMETERS__ */
 
 
 #ifdef FUNCTOR_LIST
-
-  FUNCTOR_LIST(0)();
+  FUNCTOR_LIST(0)(FUNCTOR_CALL_TYPE);
   //! makes functions with one string
-  FUNCTOR_LIST(1)(l_STRING);
+  FUNCTOR_LIST(1)(FUNCTOR_CALL_TYPE, const std::string&);
   //! makes functions with two strings
-  FUNCTOR_LIST(2)(l_STRING, l_STRING);
+  FUNCTOR_LIST(2)(FUNCTOR_CALL_TYPE, const std::string&, const std::string&);
   //! makes functions with three strings
-  FUNCTOR_LIST(3)(l_STRING, l_STRING, l_STRING);
+  FUNCTOR_LIST(3)(FUNCTOR_CALL_TYPE, const std::string&, const std::string&, const std::string&);
   //! makes functions with four strings
-  FUNCTOR_LIST(4)(l_STRING, l_STRING, l_STRING, l_STRING);
+  FUNCTOR_LIST(4)(FUNCTOR_CALL_TYPE, const std::string&, const std::string&, const std::string&, const std::string&);
 
 
   //! makes functions with one bool
-  FUNCTOR_LIST(1)(l_BOOL);
+  FUNCTOR_LIST(1)(FUNCTOR_CALL_TYPE, bool);
 
   //! makes functions with one int
-  FUNCTOR_LIST(1)(l_INT);
+  FUNCTOR_LIST(1)(FUNCTOR_CALL_TYPE, int);
   //! makes functions with two ints
-  FUNCTOR_LIST(2)(l_INT, l_INT);
+  FUNCTOR_LIST(2)(FUNCTOR_CALL_TYPE, int, int);
   //! makes functions with three ints
-  FUNCTOR_LIST(3)(l_INT, l_INT, l_INT);
+  FUNCTOR_LIST(3)(FUNCTOR_CALL_TYPE, int, int, int);
   //! makes functions with four ints
-  FUNCTOR_LIST(4)(l_INT, l_INT, l_INT, l_INT);
+  FUNCTOR_LIST(4)(FUNCTOR_CALL_TYPE, int, int, int, int);
 
 
   //! makes functions with one unsigned int
-  FUNCTOR_LIST(1)(l_UINT);
+  FUNCTOR_LIST(1)(FUNCTOR_CALL_TYPE, unsigned int);
   //! makes functions with two unsigned ints
-  FUNCTOR_LIST(2)(l_UINT, l_UINT);
+  FUNCTOR_LIST(2)(FUNCTOR_CALL_TYPE, unsigned int, unsigned int);
   //! makes functions with three unsigned ints
-  FUNCTOR_LIST(3)(l_UINT, l_UINT, l_UINT);
+  FUNCTOR_LIST(3)(FUNCTOR_CALL_TYPE, unsigned int, unsigned int, unsigned int);
   //! makes functions with four unsigned ints
-  FUNCTOR_LIST(4)(l_UINT, l_UINT, l_UINT, l_UINT);
+  FUNCTOR_LIST(4)(FUNCTOR_CALL_TYPE, unsigned int, unsigned int, unsigned int, unsigned int);
 
   //! makes functions with one float
-  FUNCTOR_LIST(1)(l_FLOAT);
+  FUNCTOR_LIST(1)(FUNCTOR_CALL_TYPE, float);
   //! makes functions with two floats
-  FUNCTOR_LIST(2)(l_FLOAT, l_FLOAT);
+  FUNCTOR_LIST(2)(FUNCTOR_CALL_TYPE, float, float);
   //! makes functions with three floats
-  FUNCTOR_LIST(3)(l_FLOAT, l_FLOAT, l_FLOAT);
+  FUNCTOR_LIST(3)(FUNCTOR_CALL_TYPE, float, float, float);
   //! makes functions with four floats
-  FUNCTOR_LIST(4)(l_FLOAT, l_FLOAT, l_FLOAT, l_FLOAT);
+  FUNCTOR_LIST(4)(FUNCTOR_CALL_TYPE, float, float, float, float);
   //! makes functions with four floats
-  FUNCTOR_LIST(5)(l_FLOAT, l_FLOAT, l_FLOAT, l_FLOAT, l_FLOAT);
+  FUNCTOR_LIST(5)(FUNCTOR_CALL_TYPE, float, float, float, float, float);
 
   //! mixed values:
-  FUNCTOR_LIST(2)(l_STRING, l_INT);
-  FUNCTOR_LIST(2)(l_STRING, l_FLOAT);
-  FUNCTOR_LIST(2)(l_UINT, l_LONG);
-  FUNCTOR_LIST(2)(l_STRING, l_UINT);
+  FUNCTOR_LIST(2)(FUNCTOR_CALL_TYPE, const std::string&, bool);
+  FUNCTOR_LIST(2)(FUNCTOR_CALL_TYPE, const std::string&, int);
+  FUNCTOR_LIST(2)(FUNCTOR_CALL_TYPE, const std::string&, float);
+  FUNCTOR_LIST(2)(FUNCTOR_CALL_TYPE, unsigned int, long);
+  FUNCTOR_LIST(2)(FUNCTOR_CALL_TYPE, const std::string&, unsigned int);
 
-  FUNCTOR_LIST(3)(l_STRING, l_FLOAT, l_UINT);
-  FUNCTOR_LIST(4)(l_STRING, l_FLOAT, l_UINT, l_UINT);
-  FUNCTOR_LIST(3)(l_STRING, l_INT, l_UINT);
-  FUNCTOR_LIST(3)(l_STRING, l_UINT, l_UINT);
+  FUNCTOR_LIST(3)(FUNCTOR_CALL_TYPE, const std::string&, float, unsigned int);
+  FUNCTOR_LIST(4)(FUNCTOR_CALL_TYPE, const std::string&, float, unsigned int, unsigned int);
+  FUNCTOR_LIST(3)(FUNCTOR_CALL_TYPE, const std::string&, int, unsigned int);
+  FUNCTOR_LIST(3)(FUNCTOR_CALL_TYPE, const std::string&, unsigned int, unsigned int);
 
-  FUNCTOR_LIST(5)(l_FLOAT, l_FLOAT, l_FLOAT, l_FLOAT, l_STRING);
+  FUNCTOR_LIST(5)(FUNCTOR_CALL_TYPE, float, float, float, float, const std::string&);
 
 #endif /* FUNCTOR_LIST */
Index: trunk/src/lib/util/executor/functor_member.h
===================================================================
--- trunk/src/lib/util/executor/functor_member.h	(revision 9869)
+++ trunk/src/lib/util/executor/functor_member.h	(revision 9869)
@@ -0,0 +1,49 @@
+/*!
+ * @file functor_member.h
+ * Definition of an Functor
+ */
+
+/*
+   orxonox - the future of 3D-vertical-scrollers
+
+   Copyright (C) 2004 orx
+
+   This program is free software; you can redistribute it and/or modify
+   it under the terms of the GNU General Public License as published by
+   the Free Software Foundation; either version 2, or (at your option)
+   any later version.
+
+### File Specific:
+   main-programmer: Benjamin Grauer
+   co-programmer: ...
+*/
+
+
+#ifndef __FUNCTOR_MEMBER_H_
+#define __FUNCTOR_MEMBER_H_
+
+#include "executor_member.h"
+
+/// Define all Constructs, that define an Executor.
+//! The Name to be attached to the functional (for normal, static, and const modes)
+#define __EXECUTOR_FUNCTIONAL_NAME(ParamCount, Ext)   Executor##ParamCount##Ext
+//! if Functional is constant calling
+#define __EXECUTOR_FUNCTIONAL_CONST
+//! The Function-Pointer, and how to save it internally.
+#define __EXECUTOR_FUNCTIONAL_FUNCTION_POINTER   T::*functionPointer
+//! The Type of Function
+#define __EXECUTOR_FUNCTIONAL_FUNCTIONTYPE       Executor<CallType, BaseClass>::FunctionMember
+
+
+/// Now we include The generic Functor, that generate the functions.
+#include "functor_generic.h"
+
+
+#undef __EXECUTOR_FUNCTIONAL_NAME
+#undef __EXECUTOR_FUNCTIONAL_CONST
+#undef __EXECUTOR_FUNCTIONAL_FUNCTION_POINTER
+#undef __EXECUTOR_FUNCTIONAL_FUNCTIONTYPE
+
+
+
+#endif /* __FUNCTOR_MEMBER_H_ */
Index: trunk/src/lib/util/executor/functor_static.h
===================================================================
--- trunk/src/lib/util/executor/functor_static.h	(revision 9869)
+++ trunk/src/lib/util/executor/functor_static.h	(revision 9869)
@@ -0,0 +1,48 @@
+/*!
+ * @file functor_static.h
+ * Definition of Functors to Functions of Static Type
+ */
+
+/*
+   orxonox - the future of 3D-vertical-scrollers
+
+   Copyright (C) 2004 orx
+
+   This program is free software; you can redistribute it and/or modify
+   it under the terms of the GNU General Public License as published by
+   the Free Software Foundation; either version 2, or (at your option)
+   any later version.
+
+### File Specific:
+   main-programmer: Benjamin Grauer
+   co-programmer: ...
+*/
+
+
+#ifndef __FUNCTOR_STATIC_H_
+#define __FUNCTOR_STATIC_H_
+
+#include "executor_static.h"
+
+/// Define all Constructs, that define an Executor.
+//! The Name to be attached to the functional (for normal, static, and const modes)
+#define __EXECUTOR_FUNCTIONAL_NAME(ParamCount, Ext)   Executor##ParamCount##Ext##_static
+//! if Functional is constant calling
+#define __EXECUTOR_FUNCTIONAL_CONST
+//! The Function-Pointer, and how to save it internally.
+#define __EXECUTOR_FUNCTIONAL_FUNCTION_POINTER   *functionPointer
+//! The Type of Function
+#define __EXECUTOR_FUNCTIONAL_FUNCTIONTYPE       Executor<CallType, BaseClass>::FunctionStatic
+
+/// Now we include The generic Functor, that generate the functions.
+#include "functor_generic.h"
+
+
+#undef __EXECUTOR_FUNCTIONAL_NAME
+#undef __EXECUTOR_FUNCTIONAL_CONST
+#undef __EXECUTOR_FUNCTIONAL_FUNCTION_POINTER
+#undef __EXECUTOR_FUNCTIONAL_FUNCTIONTYPE
+
+
+
+#endif /* __FUNCTOR_STATIC_H_ */
