Index: trunk/src/lib/util/executor/executor.h
===================================================================
--- trunk/src/lib/util/executor/executor.h	(revision 7919)
+++ trunk/src/lib/util/executor/executor.h	(revision 8035)
@@ -38,41 +38,45 @@
 class Executor : public BaseObject
 {
-public:
-  virtual ~Executor();
+  public:
+    virtual ~Executor();
 
-  virtual Executor* clone () const = 0;
+    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);
-  /** @param i the i'th defaultValue, @returns reference to the MultiType */
-  inline MultiType& getDefaultValue(unsigned int i) { return defaultValue[i]; };
+    // 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);
+    /** @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 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;
-  /** executes a Command @param object the object to apply this to @param parameters the parameters the command takes @brief here for your convenience*/
-  void execute (BaseObject* object, const std::string& parameters = "") const { (*this)(object, parameters); };
+    // EXECUTE
+    /** executes a Command. @param objec the Object, @param count how many values, @param values the Values */
+    virtual void operator()(BaseObject* object, unsigned int count, const MultiType* 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;
+    /** executes a Command @param object the object to apply this to @param parameters the parameters the command takes @brief here for your convenience*/
+    void execute (BaseObject* object, const std::string& parameters = "") const { (*this)(object, parameters); };
 
-  // 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();
+    // 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; };
 
-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);
+    static void debug();
 
-  void cloning(Executor* executor) const;
+  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);
 
-protected:
-  short                       functorType;      //!< The type of Function we've got (either static or objective).
-  unsigned int                paramCount;       //!< the count of parameters.
-  MultiType                   defaultValue[5];  //!< Default Values.
+    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[5];  //!< Default Values.
 };
 
Index: trunk/src/lib/util/executor/executor_functional.cc
===================================================================
--- trunk/src/lib/util/executor/executor_functional.cc	(revision 7919)
+++ trunk/src/lib/util/executor/executor_functional.cc	(revision 8035)
@@ -34,4 +34,13 @@
 template<> const std::string& fromString<const std::string&>(const std::string& input, const std::string& defaultValue) { return ExecutorFunctional_returningString_from = isString(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(); };
@@ -40,4 +49,6 @@
 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_default = defaultValues[i].getString(); };
+
+
 
 
Index: trunk/src/lib/util/executor/executor_functional.h
===================================================================
--- trunk/src/lib/util/executor/executor_functional.h	(revision 7919)
+++ trunk/src/lib/util/executor/executor_functional.h	(revision 8035)
@@ -33,5 +33,5 @@
 template<> MT_Type ExecutorParamType<const std::string&>();
 
-template<typename type> type fromString(const std::string& input, type defaultValue) {return 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);
@@ -40,4 +40,13 @@
 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; };
@@ -81,4 +90,7 @@
 #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
@@ -110,4 +122,10 @@
   };
 
+  /** executes a Command. @param objec the Object, @param count how many values, @param values the Values */
+  virtual void operator()(BaseObject* object, unsigned int count, const MultiType* values) const
+  {
+    (__EXECUTOR_FUNCTIONAL_FUNCTION_EXEC)();
+  }
+
   /**
    * @brief copies the Executor
@@ -120,4 +138,9 @@
 };
 
+
+
+///////////
+//// 1 ////
+///////////
 //! @brief ExecutorClass, that can execute Functions with one parameter.
 template<class T, typename type0> class __EXECUTOR_FUNCTIONAL_NAME(1) : public Executor
@@ -139,4 +162,12 @@
   };
 
+  /** executes a Command. @param objec the Object, @param count how many values, @param values the Values */
+  virtual void operator()(BaseObject* object, unsigned int count, const MultiType* values) const
+  {
+    return (__EXECUTOR_FUNCTIONAL_FUNCTION_EXEC)(
+             fromMulti<type0>((count > 0)? values[0] : this->defaultValue[0]) );
+  }
+
+
   /**
    * @brief executes the Functional
@@ -146,10 +177,4 @@
   virtual void operator()(BaseObject* object, const SubString& sub = SubString()) const
   {
-
-    /* // THE VERY COOL DEBUG
-      printf("SUB[0] : %s\n", sub[0].c_str());
-      printf("getDefault<type0>(this->defaultValue, 0):::: %d\n", getDefault<type0>(this->defaultValue, 0));
-      printf("VALUE: %d\n", fromString<type0>(sub[0], getDefault<type0>(this->defaultValue, 0)));
-    */
     (__EXECUTOR_FUNCTIONAL_FUNCTION_EXEC)(
       fromString<type0>(sub[0], getDefault<type0>(this->defaultValue, 0)) );
@@ -166,4 +191,7 @@
 };
 
+///////////
+//// 2 ////
+///////////
 //! @brief ExecutorClass, that can execute Functions with two parameters.
 template<class T, typename type0, typename type1> class __EXECUTOR_FUNCTIONAL_NAME(2) : public Executor
@@ -197,4 +225,12 @@
   };
 
+  /** executes a Command. @param objec the Object, @param count how many values, @param values the Values */
+  virtual void operator()(BaseObject* object, unsigned int count, const MultiType* values) const
+  {
+    return (__EXECUTOR_FUNCTIONAL_FUNCTION_EXEC)(
+             fromMulti<type0>((count > 0) ? values[0] : this->defaultValue[0]),
+             fromMulti<type1>((count > 1) ? values[1] : this->defaultValue[1]) );
+  }
+
   /**
    * @brief copies the Executor
@@ -208,4 +244,7 @@
 
 
+///////////
+//// 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
@@ -240,4 +279,13 @@
   };
 
+  /** executes a Command. @param objec the Object, @param count how many values, @param values the Values */
+  virtual void operator()(BaseObject* object, unsigned int count, const MultiType* values) const
+  {
+    return (__EXECUTOR_FUNCTIONAL_FUNCTION_EXEC)(
+             fromMulti<type0>((count > 0) ? values[0] : this->defaultValue[0]),
+             fromMulti<type1>((count > 1) ? values[1] : this->defaultValue[1]),
+             fromMulti<type2>((count > 2) ? values[2] : this->defaultValue[2]) );
+  }
+
   /**
    * @brief copies the Executor
@@ -252,4 +300,7 @@
 
 
+///////////
+//// 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
@@ -285,4 +336,14 @@
   };
 
+  /** executes a Command. @param objec the Object, @param count how many values, @param values the Values */
+  virtual void operator()(BaseObject* object, unsigned int count, const MultiType* values) const
+  {
+    return (__EXECUTOR_FUNCTIONAL_FUNCTION_EXEC)(
+             fromMulti<type0>((count > 0) ? values[0] : this->defaultValue[0]),
+             fromMulti<type1>((count > 1) ? values[1] : this->defaultValue[1]),
+             fromMulti<type2>((count > 2) ? values[2] : this->defaultValue[2]),
+             fromMulti<type3>((count > 3) ? values[3] : this->defaultValue[3]) );
+  }
+
   /**
    * @brief copies the Executor
@@ -295,4 +356,9 @@
 };
 
+
+
+///////////
+//// 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
@@ -329,4 +395,15 @@
   };
 
+  /** executes a Command. @param objec the Object, @param count how many values, @param values the Values */
+  virtual void operator()(BaseObject* object, unsigned int count, const MultiType* values) const
+  {
+    return (__EXECUTOR_FUNCTIONAL_FUNCTION_EXEC)(
+             fromMulti<type0>((count > 0) ? values[0] : this->defaultValue[0]),
+             fromMulti<type1>((count > 1) ? values[1] : this->defaultValue[1]),
+             fromMulti<type2>((count > 2) ? values[2] : this->defaultValue[2]),
+             fromMulti<type3>((count > 3) ? values[3] : this->defaultValue[3]),
+             fromMulti<type4>((count > 4) ? values[4] : this->defaultValue[4]) );
+  }
+
   /**
    * @brief copies the Executor
@@ -344,6 +421,6 @@
  * @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) \
+#define EXECUTOR_FUNCTIONAL_CREATOR0(ret) \
+template<class T> Executor* createExecutor(ret (__EXECUTOR_FUNCTIONAL_FUNCTION_POINTER)() __EXECUTOR_FUNCTIONAL_CONST) \
 { \
   return new __EXECUTOR_FUNCTIONAL_NAME(0)<T>(functionPointer); \
@@ -354,6 +431,6 @@
  * @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) \
+#define EXECUTOR_FUNCTIONAL_CREATOR1(ret, type0) \
+template<class T> Executor* createExecutor(ret (__EXECUTOR_FUNCTIONAL_FUNCTION_POINTER)(type0##_TYPE) __EXECUTOR_FUNCTIONAL_CONST) \
 { \
   return new __EXECUTOR_FUNCTIONAL_NAME(1)<T, type0##_TYPE>(functionPointer); \
@@ -365,6 +442,6 @@
  * @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) \
+#define EXECUTOR_FUNCTIONAL_CREATOR2(ret, type0, type1) \
+template<class T> Executor* createExecutor(ret (__EXECUTOR_FUNCTIONAL_FUNCTION_POINTER)(type0##_TYPE, type1##_TYPE) __EXECUTOR_FUNCTIONAL_CONST) \
 { \
   return new __EXECUTOR_FUNCTIONAL_NAME(2)<T, type0##_TYPE, type1##_TYPE>(functionPointer); \
@@ -377,6 +454,6 @@
  * @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) \
+#define EXECUTOR_FUNCTIONAL_CREATOR3(ret, type0, type1, type2) \
+template<class T> Executor* createExecutor(ret (__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); \
@@ -390,6 +467,6 @@
  * @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) \
+#define EXECUTOR_FUNCTIONAL_CREATOR4(ret, type0, type1, type2, type3) \
+template<class T> Executor* createExecutor(ret (__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); \
@@ -404,6 +481,6 @@
  * @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) \
+#define EXECUTOR_FUNCTIONAL_CREATOR5(ret, type0, type1, type2, type3, type4) \
+template<class T> Executor* createExecutor(ret (__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); \
Index: trunk/src/lib/util/executor/executor_specials.h
===================================================================
--- trunk/src/lib/util/executor/executor_specials.h	(revision 7919)
+++ trunk/src/lib/util/executor/executor_specials.h	(revision 8035)
@@ -67,4 +67,9 @@
     }
 
+    virtual void operator()(BaseObject* object, unsigned int count, const MultiType* values) const
+    {
+
+    }
+
   private:
     /**
Index: trunk/src/lib/util/executor/functor_list.h
===================================================================
--- trunk/src/lib/util/executor/functor_list.h	(revision 7919)
+++ trunk/src/lib/util/executor/functor_list.h	(revision 8035)
@@ -90,57 +90,57 @@
 #ifdef FUNCTOR_LIST
 
-  FUNCTOR_LIST(0)();
+  FUNCTOR_LIST(0)(void);
   //! makes functions with one string
-  FUNCTOR_LIST(1)(l_STRING);
+  FUNCTOR_LIST(1)(void, l_STRING);
   //! makes functions with two strings
-  FUNCTOR_LIST(2)(l_STRING, l_STRING);
+  FUNCTOR_LIST(2)(void, l_STRING, l_STRING);
   //! makes functions with three strings
-  FUNCTOR_LIST(3)(l_STRING, l_STRING, l_STRING);
+  FUNCTOR_LIST(3)(void, l_STRING, l_STRING, l_STRING);
   //! makes functions with four strings
-  FUNCTOR_LIST(4)(l_STRING, l_STRING, l_STRING, l_STRING);
+  FUNCTOR_LIST(4)(void, l_STRING, l_STRING, l_STRING, l_STRING);
 
 
   //! makes functions with one bool
-  FUNCTOR_LIST(1)(l_BOOL);
+  FUNCTOR_LIST(1)(void, l_BOOL);
 
   //! makes functions with one int
-  FUNCTOR_LIST(1)(l_INT);
+  FUNCTOR_LIST(1)(void, l_INT);
   //! makes functions with two ints
-  FUNCTOR_LIST(2)(l_INT, l_INT);
+  FUNCTOR_LIST(2)(void, l_INT, l_INT);
   //! makes functions with three ints
-  FUNCTOR_LIST(3)(l_INT, l_INT, l_INT);
+  FUNCTOR_LIST(3)(void, l_INT, l_INT, l_INT);
   //! makes functions with four ints
-  FUNCTOR_LIST(4)(l_INT, l_INT, l_INT, l_INT);
+  FUNCTOR_LIST(4)(void, l_INT, l_INT, l_INT, l_INT);
 
 
   //! makes functions with one unsigned int
-  FUNCTOR_LIST(1)(l_UINT);
+  FUNCTOR_LIST(1)(void, l_UINT);
   //! makes functions with two unsigned ints
-  FUNCTOR_LIST(2)(l_UINT, l_UINT);
+  FUNCTOR_LIST(2)(void, l_UINT, l_UINT);
   //! makes functions with three unsigned ints
-  FUNCTOR_LIST(3)(l_UINT, l_UINT, l_UINT);
+  FUNCTOR_LIST(3)(void, l_UINT, l_UINT, l_UINT);
   //! makes functions with four unsigned ints
-  FUNCTOR_LIST(4)(l_UINT, l_UINT, l_UINT, l_UINT);
+  FUNCTOR_LIST(4)(void, l_UINT, l_UINT, l_UINT, l_UINT);
 
   //! makes functions with one float
-  FUNCTOR_LIST(1)(l_FLOAT);
+  FUNCTOR_LIST(1)(void, l_FLOAT);
   //! makes functions with two floats
-  FUNCTOR_LIST(2)(l_FLOAT, l_FLOAT);
+  FUNCTOR_LIST(2)(void, l_FLOAT, l_FLOAT);
   //! makes functions with three floats
-  FUNCTOR_LIST(3)(l_FLOAT, l_FLOAT, l_FLOAT);
+  FUNCTOR_LIST(3)(void, l_FLOAT, l_FLOAT, l_FLOAT);
   //! makes functions with four floats
-  FUNCTOR_LIST(4)(l_FLOAT, l_FLOAT, l_FLOAT, l_FLOAT);
+  FUNCTOR_LIST(4)(void, l_FLOAT, l_FLOAT, l_FLOAT, l_FLOAT);
   //! makes functions with four floats
-  FUNCTOR_LIST(5)(l_FLOAT, l_FLOAT, l_FLOAT, l_FLOAT, l_FLOAT);
+  FUNCTOR_LIST(5)(void, l_FLOAT, l_FLOAT, l_FLOAT, l_FLOAT, l_FLOAT);
 
   //! mixed values:
-  FUNCTOR_LIST(2)(l_STRING, l_FLOAT);
-  FUNCTOR_LIST(2)(l_UINT, l_LONG);
-  FUNCTOR_LIST(2)(l_STRING, l_UINT);
+  FUNCTOR_LIST(2)(void, l_STRING, l_FLOAT);
+  FUNCTOR_LIST(2)(void, l_UINT, l_LONG);
+  FUNCTOR_LIST(2)(void, l_STRING, l_UINT);
 
-  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)(void, l_STRING, l_FLOAT, l_UINT);
+  FUNCTOR_LIST(4)(void, l_STRING, l_FLOAT, l_UINT, l_UINT);
+  FUNCTOR_LIST(3)(void, l_STRING, l_INT, l_UINT);
+  FUNCTOR_LIST(3)(void, l_STRING, l_UINT, l_UINT);
 
 #endif /* FUNCTOR_LIST */
Index: trunk/src/lib/util/multi_type.cc
===================================================================
--- trunk/src/lib/util/multi_type.cc	(revision 7919)
+++ trunk/src/lib/util/multi_type.cc	(revision 8035)
@@ -39,20 +39,20 @@
   switch (this->type)
   {
-      default:
+    default:
       this->value.Float = 0.0f;
       break;
-      case MT_BOOL:
+    case MT_BOOL:
       this->value.Bool = false;
       break;
-      case MT_INT:
+    case MT_INT:
       this->value.Int = 0;
       break;
-      case MT_FLOAT:
+    case MT_FLOAT:
       this->value.Float = 0.0f;
       break;
-      case MT_CHAR:
+    case MT_CHAR:
       this->value.Char = '\0';
       break;
-      case MT_STRING:
+    case MT_STRING:
       this->storedString = "";
       break;
@@ -148,15 +148,15 @@
   switch (this->type)
   {
-      case MT_NULL:
+    case MT_NULL:
       return true;
-      case MT_BOOL:
+    case MT_BOOL:
       return (this->value.Bool == mt.value.Bool);
-      case MT_INT:
+    case MT_INT:
       return (this->value.Int == mt.value.Int);
-      case MT_CHAR:
+    case MT_CHAR:
       return (this->value.Char == mt.value.Char);
-      case MT_FLOAT:
+    case MT_FLOAT:
       return (this->value.Float == mt.value.Float);
-      case MT_STRING:
+    case MT_STRING:
       return (this->storedString == mt.storedString);
   }
@@ -175,17 +175,17 @@
   switch (type)
   {
-      case MT_BOOL:
+    case MT_BOOL:
       this->setBool(this->getBool());
       break;
-      case MT_INT:
+    case MT_INT:
       this->setInt(this->getInt());
       break;
-      case MT_FLOAT:
+    case MT_FLOAT:
       this->setFloat(this->getFloat());
       break;
-      case MT_CHAR:
+    case MT_CHAR:
       this->setChar(this->getChar());
       break;
-      case MT_STRING:
+    case MT_STRING:
       this->setString(this->getString());
       break;
@@ -382,4 +382,17 @@
 
 /**
+ * @brief returns a Constant string (actually this is slower than getString()
+ * @returns a constant string of the stored version's one.
+ * @note this  could lead to a inconsistency of data
+ */
+const std::string& MultiType::getConstString() const
+{
+
+  MultiType::constString = this->getString();
+  return MultiType::constString;
+}
+
+
+/**
  * @returns a formated c-string of the held value
  */
@@ -422,20 +435,20 @@
   switch ( this->type )
   {
-      case MT_BOOL:
+    case MT_BOOL:
       this->setBool(false);
       break;
-      case MT_INT:
+    case MT_INT:
       this->setInt(0);
       break;
-      case MT_FLOAT:
+    case MT_FLOAT:
       this->setFloat(0.0f);
       break;
-      case MT_CHAR:
+    case MT_CHAR:
       this->setChar('\0');
       break;
-      case MT_STRING:
+    case MT_STRING:
       this->setString("");
       break;
-      default:
+    default:
 #ifdef DEBUG
       PRINTF(2)("Unknown Type not reseting\n");
@@ -454,13 +467,13 @@
   switch ( type )
   {
-      case MT_BOOL:
+    case MT_BOOL:
       return MultiType::typeNames[1];
-      case MT_INT:
+    case MT_INT:
       return MultiType::typeNames[2];
-      case MT_FLOAT:
+    case MT_FLOAT:
       return MultiType::typeNames[3];
-      case MT_CHAR:
+    case MT_CHAR:
       return MultiType::typeNames[4];
-      case MT_STRING:
+    case MT_STRING:
       return MultiType::typeNames[5];
   }
@@ -490,4 +503,5 @@
 
 
+std::string MultiType::constString = "";
 const std::string MultiType::typeNames[] =
   {
Index: trunk/src/lib/util/multi_type.h
===================================================================
--- trunk/src/lib/util/multi_type.h	(revision 7919)
+++ trunk/src/lib/util/multi_type.h	(revision 8035)
@@ -87,4 +87,5 @@
     const char* getCString();
     std::string getString() const;
+    const std::string& getConstString() const;
 
     void reset();
@@ -107,4 +108,7 @@
     MT_Type                      type;              //!< The Type stored in this MultiType
 
+
+    static std::string           constString;       //!< A String for returning Constant strings.
+
     static const std::string     typeNames[];       //!< List of TypeNames for conversion.
 };
