Index: /branches/new_class_id/src/lib/shell/shell_command.h
===================================================================
--- /branches/new_class_id/src/lib/shell/shell_command.h	(revision 9768)
+++ /branches/new_class_id/src/lib/shell/shell_command.h	(revision 9769)
@@ -40,5 +40,5 @@
    */
 #define SHELL_COMMAND(command, class, function) \
-           OrxShell::ShellCommand* shell_command_##class##_##command = OrxShell::ShellCommand::registerCommand(#command, #class, createExecutor<class>(&class::function))
+           OrxShell::ShellCommand* shell_command_##class##_##command = OrxShell::ShellCommand::registerCommand(#command, #class, createExecutor<class, BaseObject>(&class::function))
 
   /**
@@ -56,5 +56,5 @@
    */
 #define SHELL_COMMAND_STATIC(command, class, function) \
-           OrxShell::ShellCommand* shell_command_##class##_##command = OrxShell::ShellCommand::registerCommand(#command, #class, createExecutor<class>(function))
+           OrxShell::ShellCommand* shell_command_##class##_##command = OrxShell::ShellCommand::registerCommand(#command, #class, createExecutor<class, BaseObject>(function))
 
 
Index: /branches/new_class_id/src/lib/util/executor/executor.h
===================================================================
--- /branches/new_class_id/src/lib/util/executor/executor.h	(revision 9768)
+++ /branches/new_class_id/src/lib/util/executor/executor.h	(revision 9769)
@@ -112,5 +112,5 @@
 
   /** @returns the Clone as a new Copy of the Executor. */
-  virtual Executor<CallType>* clone () const = 0;
+  virtual Executor<CallType, BaseClass>* clone () const = 0;
 
 
Index: /branches/new_class_id/src/lib/util/executor/executor_generic.h
===================================================================
--- /branches/new_class_id/src/lib/util/executor/executor_generic.h	(revision 9768)
+++ /branches/new_class_id/src/lib/util/executor/executor_generic.h	(revision 9769)
@@ -68,5 +68,5 @@
 ///////////
 //! @brief ExecutorClass, that can execute Functions without any parameters.
-template<class T, typename CallType, template<typename> class Evaluater = ExecutorEvaluater, class BaseClass = BaseObject>
+template<class T, typename CallType, class BaseClass = BaseObject, template<typename> class Evaluater = ExecutorEvaluater>
 class __EXECUTOR_FUNCTIONAL_NAME(0,) :public Executor<CallType, BaseClass>
 {
@@ -89,5 +89,5 @@
    * @param eval the CallType to get the Parameters from.
    */
-  virtual void operator()(BaseObject* object, CallType& eval = Evaluater<CallType>::defaultValue()) const
+  virtual void operator()(BaseClass* object, CallType& eval = Evaluater<CallType>::defaultValue()) const
   {
     (__EXECUTOR_FUNCTIONAL_FUNCTION_EXEC)();
@@ -100,5 +100,5 @@
   virtual Executor<CallType, BaseClass>* clone() const
   {
-    return new __EXECUTOR_FUNCTIONAL_NAME(0,)<T, CallType>(this->functionPointer);
+    return new __EXECUTOR_FUNCTIONAL_NAME(0,)<T, CallType, BaseClass>(this->functionPointer);
   };
 };
@@ -110,5 +110,5 @@
 ///////////
 //! @brief ExecutorClass, that can execute Functions with one parameter.
-template<class T, typename CallType, typename type0, template<typename> class Evaluater = ExecutorEvaluater, class BaseClass = BaseObject>
+template<class T, typename CallType, typename type0, class BaseClass = BaseObject, template<typename> class Evaluater = ExecutorEvaluater>
 class __EXECUTOR_FUNCTIONAL_NAME(1,) : public Executor<CallType, BaseClass>
 {
@@ -131,5 +131,5 @@
    * @param eval the CallType to get the Parameters from.
    */
-  virtual void operator()(BaseObject* object, CallType& eval = Evaluater<CallType>::defaultValue()) const
+  virtual void operator()(BaseClass* object, CallType& eval = Evaluater<CallType>::defaultValue()) const
   {
     (__EXECUTOR_FUNCTIONAL_FUNCTION_EXEC)(
@@ -143,5 +143,5 @@
   virtual Executor<CallType, BaseClass>* clone() const
   {
-    return  new __EXECUTOR_FUNCTIONAL_NAME(1,)<T, CallType, type0>(this->functionPointer);
+    return  new __EXECUTOR_FUNCTIONAL_NAME(1,)<T, CallType, type0, BaseClass>(this->functionPointer);
   };
 };
@@ -153,5 +153,5 @@
 ///////////
 //! @brief ExecutorClass, that can execute Functions with two parameters.
-template<class T, typename CallType, typename type0, typename type1, template<typename> class Evaluater = ExecutorEvaluater, class BaseClass = BaseObject>
+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>
 {
@@ -174,5 +174,5 @@
    * @param eval the CallType to get the Parameters from.
    */
-  virtual void operator()(BaseObject* object, CallType& eval = Evaluater<CallType>::defaultValue()) const
+  virtual void operator()(BaseClass* object, CallType& eval = Evaluater<CallType>::defaultValue()) const
   {
     (__EXECUTOR_FUNCTIONAL_FUNCTION_EXEC)(
@@ -187,5 +187,5 @@
   virtual Executor<CallType, BaseClass>* clone() const
   {
-    return new __EXECUTOR_FUNCTIONAL_NAME(2,)<T, CallType, type0, type1>(this->functionPointer);
+    return new __EXECUTOR_FUNCTIONAL_NAME(2,)<T, CallType, type0, type1, BaseClass>(this->functionPointer);
   };
 };
@@ -197,5 +197,5 @@
 ///////////
 //! @brief ExecutorClass, that can execute Functions with three parameters.
-template<class T, typename CallType, typename type0, typename type1, typename type2, template<typename> class Evaluater = ExecutorEvaluater, class BaseClass = BaseObject>
+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>
 {
@@ -218,5 +218,5 @@
    * @param eval the CallType to get the Parameters from.
    */
-  virtual void operator()(BaseObject* object, CallType& eval = Evaluater<CallType>::defaultValue()) const
+  virtual void operator()(BaseClass* object, CallType& eval = Evaluater<CallType>::defaultValue()) const
   {
     (__EXECUTOR_FUNCTIONAL_FUNCTION_EXEC)(
@@ -232,5 +232,5 @@
   virtual Executor<CallType, BaseClass>* clone() const
   {
-    return new __EXECUTOR_FUNCTIONAL_NAME(3,)<T, CallType, type0, type1, type2>(this->functionPointer);
+    return new __EXECUTOR_FUNCTIONAL_NAME(3,)<T, CallType, type0, type1, type2, BaseClass>(this->functionPointer);
   };
 };
@@ -242,5 +242,5 @@
 ///////////
 //! @brief ExecutorClass, that can execute Functions with four parameters.
-template<class T, typename CallType, typename type0, typename type1, typename type2, typename type3, template<typename> class Evaluater = ExecutorEvaluater, class BaseClass = BaseObject>
+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>
 {
@@ -263,5 +263,5 @@
   * @param eval the CallType to get the Parameters from.
    */
-  virtual void operator()(BaseObject* object, CallType& eval = Evaluater<CallType>::defaultValue()) const
+  virtual void operator()(BaseClass* object, CallType& eval = Evaluater<CallType>::defaultValue()) const
   {
     (__EXECUTOR_FUNCTIONAL_FUNCTION_EXEC)(
@@ -278,5 +278,5 @@
   virtual Executor<CallType, BaseClass>* clone() const
   {
-    return new __EXECUTOR_FUNCTIONAL_NAME(4,)<T, CallType, type0, type1, type2, type3>(this->functionPointer);
+    return new __EXECUTOR_FUNCTIONAL_NAME(4,)<T, CallType, type0, type1, type2, type3, BaseClass>(this->functionPointer);
   };
 };
@@ -288,5 +288,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, template<typename> class Evaluater = ExecutorEvaluater, class BaseClass = BaseObject>
+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>
 {
@@ -309,5 +309,5 @@
   * @param eval the CallType to get the Parameters from.
    */
-  virtual void operator()(BaseObject* object, CallType& eval = Evaluater<CallType>::defaultValue()) const
+  virtual void operator()(BaseClass* object, CallType& eval = Evaluater<CallType>::defaultValue()) const
   {
     (__EXECUTOR_FUNCTIONAL_FUNCTION_EXEC)(
@@ -325,5 +325,5 @@
   virtual Executor<CallType, BaseClass>* clone() const
   {
-    return new __EXECUTOR_FUNCTIONAL_NAME(5,)<T, CallType, type0, type1, type2, type3, type4>(this->functionPointer);
+    return new __EXECUTOR_FUNCTIONAL_NAME(5,)<T, CallType, type0, type1, type2, type3, type4, BaseClass>(this->functionPointer);
   };
 };
@@ -334,5 +334,5 @@
 ////////////////////
 //! @brief ExecutorClass, that can execute Functions with one parameter.
-template<class T, typename CallType, typename ReturnType, template<typename> class Evaluater = ExecutorEvaluater, class BaseClass = BaseObject>
+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>
 {
@@ -355,5 +355,5 @@
      * @param eval the CallType to get the Parameters from.
    */
-  virtual void operator()(BaseObject* object, CallType& eval = Evaluater<CallType>::defaultValue()) const
+  virtual void operator()(BaseClass* object, CallType& eval = Evaluater<CallType>::defaultValue()) const
   {
     Evaluater<CallType>::template storeRet<ReturnType>(eval, (__EXECUTOR_FUNCTIONAL_FUNCTION_EXEC)());
@@ -366,5 +366,5 @@
   virtual Executor<CallType, BaseClass>* clone() const
   {
-    return  new __EXECUTOR_FUNCTIONAL_NAME(0,ret)<T, CallType, ReturnType>(this->functionPointer);
+    return  new __EXECUTOR_FUNCTIONAL_NAME(0,ret)<T, CallType, ReturnType, BaseClass>(this->functionPointer);
   };
 };
@@ -374,5 +374,5 @@
 ////////////////////
 //! @brief ExecutorClass, that can execute Functions with one parameter.
-template<class T, typename CallType, typename ReturnType, typename type0, template<typename> class Evaluater = ExecutorEvaluater, class BaseClass = BaseObject>
+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>
 {
@@ -395,5 +395,5 @@
      * @param eval the CallType to get the Parameters from.
    */
-  virtual void operator()(BaseObject* object, CallType& eval = Evaluater<CallType>::defaultValue()) const
+  virtual void operator()(BaseClass* object, CallType& eval = Evaluater<CallType>::defaultValue()) const
   {
     Evaluater<CallType>::template storeRet<ReturnType>(eval, (__EXECUTOR_FUNCTIONAL_FUNCTION_EXEC)(
@@ -407,5 +407,5 @@
   virtual Executor<CallType, BaseClass>* clone() const
   {
-    return  new __EXECUTOR_FUNCTIONAL_NAME(1,ret)<T, CallType, ReturnType, type0>(this->functionPointer);
+    return  new __EXECUTOR_FUNCTIONAL_NAME(1,ret)<T, CallType, ReturnType, type0, BaseClass>(this->functionPointer);
   };
 };
@@ -416,5 +416,5 @@
 ////////////////////
 //! @brief ExecutorClass, that can execute Functions with one parameter.
-template<class T, typename CallType, typename ReturnType, typename type0, typename type1, template<typename> class Evaluater = ExecutorEvaluater, class BaseClass = BaseObject>
+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>
 {
@@ -437,5 +437,5 @@
      * @param eval the CallType to get the Parameters from.
    */
-  virtual void operator()(BaseObject* object, CallType& eval = Evaluater<CallType>::defaultValue()) const
+  virtual void operator()(BaseClass* object, CallType& eval = Evaluater<CallType>::defaultValue()) const
   {
     Evaluater<CallType>::template storeRet<ReturnType>(eval, (__EXECUTOR_FUNCTIONAL_FUNCTION_EXEC)(
@@ -450,5 +450,5 @@
   virtual Executor<CallType, BaseClass>* clone() const
   {
-    return  new __EXECUTOR_FUNCTIONAL_NAME(2,ret)<T, CallType, ReturnType, type0, type1>(this->functionPointer);
+    return  new __EXECUTOR_FUNCTIONAL_NAME(2,ret)<T, CallType, ReturnType, type0, type1, BaseClass>(this->functionPointer);
   };
 };
Index: /branches/new_class_id/src/lib/util/executor/functor_generic.h
===================================================================
--- /branches/new_class_id/src/lib/util/executor/functor_generic.h	(revision 9768)
+++ /branches/new_class_id/src/lib/util/executor/functor_generic.h	(revision 9769)
@@ -27,7 +27,7 @@
  */
 #define EXECUTOR_FUNCTIONAL_CREATOR0(CallType) \
-template<class T> Executor<CallType>* createExecutor(void (__EXECUTOR_FUNCTIONAL_FUNCTION_POINTER)() __EXECUTOR_FUNCTIONAL_CONST) \
+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>(functionPointer); \
+  return new __EXECUTOR_FUNCTIONAL_NAME(0,)<T, CallType, BaseClass>(functionPointer); \
 }
 
@@ -38,7 +38,7 @@
  */
 #define EXECUTOR_FUNCTIONAL_CREATOR1(CallType, type0) \
-template<class T> Executor<CallType>* createExecutor(void (__EXECUTOR_FUNCTIONAL_FUNCTION_POINTER)(type0) __EXECUTOR_FUNCTIONAL_CONST) \
+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>(functionPointer); \
+  return new __EXECUTOR_FUNCTIONAL_NAME(1,)<T, CallType, type0, BaseClass>(functionPointer); \
 }
 
@@ -50,7 +50,7 @@
  */
 #define EXECUTOR_FUNCTIONAL_CREATOR2(CallType, type0, type1) \
-template<class T> Executor<CallType>* createExecutor(void (__EXECUTOR_FUNCTIONAL_FUNCTION_POINTER)(type0, type1) __EXECUTOR_FUNCTIONAL_CONST) \
+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>(functionPointer); \
+  return new __EXECUTOR_FUNCTIONAL_NAME(2,)<T, CallType, type0, type1, BaseClass>(functionPointer); \
 }
 
@@ -63,7 +63,7 @@
  */
 #define EXECUTOR_FUNCTIONAL_CREATOR3(CallType, type0, type1, type2) \
-template<class T> Executor<CallType>* createExecutor(void (__EXECUTOR_FUNCTIONAL_FUNCTION_POINTER)(type0, type1, type2) __EXECUTOR_FUNCTIONAL_CONST) \
+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>(functionPointer); \
+  return new __EXECUTOR_FUNCTIONAL_NAME(3,)<T, CallType, type0, type1, type2, BaseClass>(functionPointer); \
 }
 
@@ -77,7 +77,7 @@
  */
 #define EXECUTOR_FUNCTIONAL_CREATOR4(CallType, type0, type1, type2, type3) \
-template<class T> Executor<CallType>* createExecutor(void (__EXECUTOR_FUNCTIONAL_FUNCTION_POINTER)(type0, type1, type2, type3) __EXECUTOR_FUNCTIONAL_CONST) \
+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>(functionPointer); \
+  return new __EXECUTOR_FUNCTIONAL_NAME(4,)<T, CallType, type0, type1, type2, type3, BaseClass>(functionPointer); \
 }
 
@@ -92,7 +92,7 @@
  */
 #define EXECUTOR_FUNCTIONAL_CREATOR5(CallType, type0, type1, type2, type3, type4) \
-template<class T> Executor<CallType>* createExecutor(void (__EXECUTOR_FUNCTIONAL_FUNCTION_POINTER)(type0, type1, type2, type3, type4) __EXECUTOR_FUNCTIONAL_CONST) \
+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>(functionPointer); \
+    return new __EXECUTOR_FUNCTIONAL_NAME(5,)<T, CallType, type0, type1, type2, type3, type4, BaseClass>(functionPointer); \
 }
 
Index: /branches/new_class_id/src/lib/util/loading/load_param.cc
===================================================================
--- /branches/new_class_id/src/lib/util/loading/load_param.cc	(revision 9768)
+++ /branches/new_class_id/src/lib/util/loading/load_param.cc	(revision 9769)
@@ -27,6 +27,6 @@
  * @param inLoadCycle If we are in a LoadCycle (loading differs.).
  */
-LoadParamBase::LoadParamBase(const TiXmlElement* root, const std::string& paramName, BaseObject* object, bool inLoadCycle)
-    :  object(object), paramName(paramName), inLoadCycle(inLoadCycle)
+LoadParamBase::LoadParamBase(const TiXmlElement* root, const std::string& paramName, bool inLoadCycle)
+    :  paramName(paramName), inLoadCycle(inLoadCycle)
 {
   // determin the LoadString.
@@ -55,63 +55,4 @@
 
 
-/**
- * @brief generates a LoadParam based on
- * @param root the Root Element to load onto the object.
- * @param paramName the Parameter name that is loaded.
- * @param object the Object to apply the changes on.
- * @param executor the Functional Object, that actually executes the function Call.
- * @param inLoadCycle If we are inside of a loading cycle. (Loading will be different here)
- */
-CLoadParam::CLoadParam(const TiXmlElement* root, const std::string& paramName, BaseObject* object, Executor<const SubString>* executor, bool inLoadCycle)
-    : LoadParamBase(root, paramName, object, inLoadCycle)
-{
-  assert (executor != NULL);
-  // set the Executor.
-  this->executor = executor;
-  //if (this->executor)
-  //  this->executor->setName(paramName);
-}
-
-/**
- * This is a VERY SPECIAL deconsrtuctor.
- * It is made, so that it loads the Parameters on destruction.
- * meaning, if an Executor a valid Object exist, and all
- * Execution-Conditions are met, they are executed here.
- */
-CLoadParam::~CLoadParam()
-{
-  assert(this->object != NULL);
-
-  std::string loadString;
-  if (this->loadElem != NULL &&  this->loadElem->ToText())
-  {
-    loadString = this->loadElem->Value();
-    if (!loadString.empty())
-    {
-      PRINTF(4)("Loading value '%s' with Parameters '%s' onto: %s::%s\n",
-                this->paramName.c_str(), loadString.c_str(), this->object->getClassCName(), this->object->getCName());
-      (*this->executor)(this->object, SubString(loadString, ",", SubString::WhiteSpaces, false, '\\'));
-    }
-  }
-  delete this->executor;
-}
-
-/**
- * @brief set the default values of the executor
- * @param value0 the first default value
- * @param value1 the second default value
- * @param value2 the third default value
- * @param value3 the fourth default value
- * @param value4 the fifth default value
- */
-CLoadParam& CLoadParam::defaultValues(const MultiType& value0, const MultiType& value1,
-                                      const MultiType& value2, const MultiType& value3,
-                                      const MultiType& value4)
-{
-  assert(this->executor != NULL);
-  this->executor->defaultValues(value0, value1, value2, value3, value4);
-
-  return *this;
-}
 
 
Index: /branches/new_class_id/src/lib/util/loading/load_param.h
===================================================================
--- /branches/new_class_id/src/lib/util/loading/load_param.h	(revision 9768)
+++ /branches/new_class_id/src/lib/util/loading/load_param.h	(revision 9769)
@@ -45,5 +45,5 @@
  */
 #define LoadParam(ROOT, PARAMETER_NAME, OBJECT, CLASS, FUNCTION) \
-         CLoadParam(ROOT, PARAMETER_NAME, OBJECT, createExecutor<CLASS>(&CLASS::FUNCTION), false)
+         CLoadParam<CLASS>(ROOT, PARAMETER_NAME, OBJECT, createExecutor<CLASS, CLASS>(&CLASS::FUNCTION), false)
 
 /**
@@ -56,5 +56,5 @@
  */
 #define LoadParam_CYCLE(ROOT, PARAMETER_NAME, OBJECT, CLASS, FUNCTION) \
-         CLoadParam(ROOT, PARAMETER_NAME, OBJECT, createExecutor<CLASS>(&CLASS::FUNCTION), true)
+         CLoadParam<CLASS>(ROOT, PARAMETER_NAME, OBJECT, createExecutor<CLASS, CLASS>(&CLASS::FUNCTION), true)
 
 /**
@@ -89,5 +89,5 @@
 {
 protected:
-  LoadParamBase(const TiXmlElement* root, const std::string& paramName, BaseObject* object, bool inLoadCycle = false);
+  LoadParamBase(const TiXmlElement* root, const std::string& paramName, bool inLoadCycle = false);
 
 protected:
@@ -95,5 +95,4 @@
 
 protected:
-  BaseObject*              object;               //!< The Object to work on
   const std::string        paramName;            //!< The Name of the Parameter this LoadParams applies to.
   bool                     inLoadCycle;          //!< If the Parameter is in a LoadCycle.
@@ -104,13 +103,47 @@
 
 //! The Loading Class of the LoadParam, that acctually executes the loading process.
-class CLoadParam : public LoadParamBase
+template <class OperateClass> class CLoadParam : public LoadParamBase
 {
 public:
-  CLoadParam(const TiXmlElement* root, const std::string& paramName, BaseObject* object, Executor<const SubString>* executor, bool inLoadCycle = false);
-  virtual ~CLoadParam();
-
+  /**
+   * @brief generates a LoadParam based on
+   * @param root the Root Element to load onto the object.
+   * @param paramName the Parameter name that is loaded.
+   * @param object the Object to apply the changes on.
+   * @param executor the Functional Object, that actually executes the function Call.
+   * @param inLoadCycle If we are inside of a loading cycle. (Loading will be different here)
+   */
+  CLoadParam(const TiXmlElement* root, const std::string& paramName, OperateClass* object, Executor<const SubString, OperateClass>* executor, bool inLoadCycle = false)
+      : LoadParamBase(root, paramName, inLoadCycle)
+  {
+    assert (executor != NULL);
+    this->object = object;
+    this->executor = executor;
+  }
+  virtual ~CLoadParam()
+  {
+    std::string loadString;
+    if (this->loadElem != NULL &&  this->loadElem->ToText())
+    {
+      loadString = this->loadElem->Value();
+      if (!loadString.empty())
+      {
+        /*	PRINTF(4)("Loading value '%s' with Parameters '%s' onto: %s::%s\n",
+        	this->paramName.c_str(), loadString.c_str(), this->object->getClassCName(), this->object->getCName());*/
+        (*this->executor)(this->object, SubString(loadString, ",", SubString::WhiteSpaces, false, '\\'));
+      }
+    }
+    delete this->executor;
+  }
+  /**
+   * @brief set the default values of the executor
+   * @param value0 the first default value   @param value1 the second default value
+   * @param value2 the third default value   @param value3 the fourth default value
+   * @param value4 the fifth default value
+   */
   CLoadParam& defaultValues(const MultiType& value0 = MT_NULL, const MultiType& value1 = MT_NULL,
                             const MultiType& value2 = MT_NULL, const MultiType& value3 = MT_NULL,
-                            const MultiType& value4 = MT_NULL);
+                            const MultiType& value4 = MT_NULL)
+  { this->executor->defaultValues(value0, value1, value2, value3, value4); return *this;  };
   CLoadParam& describe(const std::string& descriptionText) { LoadParamBase::describe(descriptionText); return *this; };
   //     CLoadParam& attribute(const std::string& attributeName, const Executor<SubString>& executor);
@@ -118,5 +151,6 @@
 
 private:
-  Executor<const SubString>*         executor;            //!< The Executor, that actually executes the Loading process.
+  Executor<const SubString, OperateClass>*         executor;            //!< The Executor, that actually executes the Loading process.
+  OperateClass*                                    object;
 };
 
Index: /branches/new_class_id/src/lib/util/loading/load_param_xml.cc
===================================================================
--- /branches/new_class_id/src/lib/util/loading/load_param_xml.cc	(revision 9768)
+++ /branches/new_class_id/src/lib/util/loading/load_param_xml.cc	(revision 9769)
@@ -1,16 +1,2 @@
-/*
-   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_LOADING
@@ -19,26 +5,2 @@
 #include "load_param_description.h"
 
-
-/**
- * @brief generates a LoadParam based on
- * @param root the Root Element to load onto the object.
- * @param paramName the Parameter name that is loaded.
- * @param object the Object to apply the changes on.
- * @param executor the Functional Object, that actually executes the function Call.
- * @param inLoadCycle If we are inside of a loading cycle. (Loading will be different here)
- */
-XmlLoadParam::XmlLoadParam(const TiXmlElement* root, const std::string& paramName, BaseObject* object, Executor<const TiXmlElement*>* executor, bool inLoadCycle )
-    : LoadParamBase(root, paramName, object, inLoadCycle)
-{
-  this->executor = executor;
-}
-
-
-XmlLoadParam::~XmlLoadParam()
-{
-  assert(this->object != NULL);
-
-  (*this->executor)(this->object, this->loadElem);
-
-  delete this->executor;
-}
Index: /branches/new_class_id/src/lib/util/loading/load_param_xml.h
===================================================================
--- /branches/new_class_id/src/lib/util/loading/load_param_xml.h	(revision 9768)
+++ /branches/new_class_id/src/lib/util/loading/load_param_xml.h	(revision 9769)
@@ -35,5 +35,5 @@
  */
 #define LoadParamXML(ROOT, PARAMETER_NAME, OBJECT, CLASS, FUNCTION) \
-         XmlLoadParam(ROOT, PARAMETER_NAME, OBJECT, new ExecutorXML<CLASS>(&CLASS::FUNCTION, ROOT, PARAMETER_NAME), false)
+         XmlLoadParam<CLASS>(ROOT, PARAMETER_NAME, OBJECT, new ExecutorXML<CLASS, CLASS>(&CLASS::FUNCTION, ROOT, PARAMETER_NAME), false)
 
 
@@ -47,18 +47,38 @@
  */
 #define LoadParamXML_CYCLE(ROOT, PARAMETER_NAME, OBJECT, CLASS, FUNCTION) \
-         XmlLoadParam(ROOT, PARAMETER_NAME, OBJECT, new ExecutorXML<CLASS>(&CLASS::FUNCTION, ROOT, PARAMETER_NAME), true)
+         XmlLoadParam<CLASS>(ROOT, PARAMETER_NAME, OBJECT, new ExecutorXML<CLASS, CLASS>(&CLASS::FUNCTION, ROOT, PARAMETER_NAME), true)
 
 //! A Class that can load XML tags onto an Object.
-class XmlLoadParam : public LoadParamBase
+template <class BaseClass = BaseObject> class XmlLoadParam : public LoadParamBase
 {
-  public:
-    XmlLoadParam(const TiXmlElement* root, const std::string& paramName, BaseObject* object, Executor<const TiXmlElement*>* executor, bool inLoadCycle = false);
-    virtual ~XmlLoadParam();
+public:
+  /**
+   * @brief generates a LoadParam based on
+   * @param root the Root Element to load onto the object.
+   * @param paramName the Parameter name that is loaded.
+   * @param object the Object to apply the changes on.
+   * @param executor the Functional Object, that actually executes the function Call.
+   * @param inLoadCycle If we are inside of a loading cycle. (Loading will be different here)
+   */
+  XmlLoadParam(const TiXmlElement* root, const std::string& paramName, BaseClass* object, Executor<const TiXmlElement*>* executor, bool inLoadCycle = false)
+      : LoadParamBase(root, paramName, inLoadCycle), object(object) , executor(executor)
+  {
+    assert(this->object != NULL);
+    assert(this->executor != NULL);
+  }
 
-    /** @param descriptionText the description @returns self @brief describes the Loading parameter. */
-    XmlLoadParam& describe(const std::string& descriptionText) { LoadParamBase::describe(descriptionText); return *this; };
+  /** @brief executes and destroys the executor */
+  virtual ~XmlLoadParam()
+  {
+    (*this->executor)(this->object, this->loadElem);
+    delete this->executor;
+  }
 
-  private:
-    Executor<const TiXmlElement*>*    executor;       //!< The Executor, that does the actual loading process.
+  /** @param descriptionText the description @returns self @brief describes the Loading parameter. */
+  XmlLoadParam& describe(const std::string& descriptionText) { LoadParamBase::describe(descriptionText); return *this; };
+
+private:
+  BaseClass*                        object;         //!< The Object to apply this to.
+  Executor<const TiXmlElement*>*    executor;       //!< The Executor, that does the actual loading process.
 };
 
