Index: /trunk/src/lib/util/executor/executor_functional.h
===================================================================
--- /trunk/src/lib/util/executor/executor_functional.h	(revision 7723)
+++ /trunk/src/lib/util/executor/executor_functional.h	(revision 7724)
@@ -51,8 +51,11 @@
 #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
 
@@ -80,10 +83,16 @@
 #endif /* EXECUTOR_FUNCTIONAL_USE_STATIC */
 
+//! @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()
@@ -93,4 +102,9 @@
   };
 
+  /**
+   * @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
   {
@@ -98,4 +112,8 @@
   };
 
+  /**
+   * @brief copies the Executor
+   * @returns a new Executor that's a copy of this one.
+   */
   virtual Executor* clone() const
   {
@@ -104,11 +122,16 @@
 };
 
-//! SINGLE VALUE
+//! @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>())
@@ -118,4 +141,9 @@
   };
 
+  /**
+   * @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
   {
@@ -130,4 +158,8 @@
   };
 
+  /**
+   * @brief copies the Executor
+   * @returns a new Executor that's a copy of this one.
+   */
   virtual Executor* clone() const
   {
@@ -136,11 +168,16 @@
 };
 
-//! DOUBLE VALUE
+//! @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>())
@@ -150,4 +187,9 @@
   };
 
+  /**
+   * @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
   {
@@ -157,4 +199,8 @@
   };
 
+  /**
+   * @brief copies the Executor
+   * @returns a new Executor that's a copy of this one.
+   */
   virtual Executor* clone() const
   {
@@ -164,11 +210,16 @@
 
 
-//! TRIPPLE VALUE
+//! @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>())
@@ -178,4 +229,9 @@
   };
 
+  /**
+   * @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
   {
@@ -186,4 +242,8 @@
   };
 
+  /**
+   * @brief copies the Executor
+   * @returns a new Executor that's a copy of this one.
+   */
   virtual Executor* clone() const
   {
@@ -194,18 +254,28 @@
 
 
-//! QUADRUPPEL VALUE
+//! @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;
-  };
-
+      : 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
   {
@@ -217,4 +287,8 @@
   };
 
+  /**
+   * @brief copies the Executor
+   * @returns a new Executor that's a copy of this one.
+   */
   virtual Executor* clone() const
   {
@@ -223,36 +297,53 @@
 };
 
-//! CHINQUE VALUE
+//! @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:
-    void (__EXECUTOR_FUNCTIONAL_FUNCTION_POINTER)(type0, type1, type2, type3, type4) __EXECUTOR_FUNCTIONAL_CONST;
-
-  public:
-    __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;
-    };
-
-    virtual void operator()(BaseObject* object, const SubString& sub = SubString()) const
-    {
-      (__EXECUTOR_FUNCTIONAL_FUNCTION_EXEC)(
-          fromString<type0>(sub[0], getDefault<type0>(this->defaultValue, 0)),
+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)(
+      fromString<type0>(sub[0], getDefault<type0>(this->defaultValue, 0)),
       fromString<type1>(sub[1], getDefault<type1>(this->defaultValue, 1)),
       fromString<type2>(sub[2], getDefault<type2>(this->defaultValue, 2)),
       fromString<type3>(sub[3], getDefault<type3>(this->defaultValue, 3)),
       fromString<type4>(sub[4], getDefault<type4>(this->defaultValue, 4)));
-    };
-
-    virtual Executor* clone() const
-    {
-      return new __EXECUTOR_FUNCTIONAL_NAME(5)<T, type0, type1, type2, type3, type4>(this->functionPointer);
-    };
-};
-
-
-
+  };
+
+  /**
+   * @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) \
@@ -261,4 +352,8 @@
 }
 
+/**
+ * @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) \
@@ -267,4 +362,9 @@
 }
 
+/**
+ * @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) \
@@ -273,4 +373,10 @@
 }
 
+/**
+ * @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) \
@@ -279,4 +385,11 @@
 }
 
+/**
+ * @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) \
@@ -285,4 +398,12 @@
 }
 
+/**
+ * @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) \
@@ -292,5 +413,7 @@
 
 
-
+/**
+ * Creates the FunctionCallers
+ */
 #define FUNCTOR_LIST(x) EXECUTOR_FUNCTIONAL_CREATOR ## x
 #include "functor_list.h"
