Index: code/branches/testing/src/libraries/core/CommandLineParser.cc
===================================================================
--- code/branches/testing/src/libraries/core/CommandLineParser.cc	(revision 9223)
+++ code/branches/testing/src/libraries/core/CommandLineParser.cc	(revision 9224)
@@ -69,7 +69,7 @@
         else
         {
-            if (!value_.setValue(value))
-            {
-                value_.setValue(defaultValue_);
+            if (!value_.set(value))
+            {
+                value_.set(defaultValue_);
                 ThrowException(Argument, "Could not read command line argument '" + getName() + "'.");
             }
Index: code/branches/testing/src/libraries/core/CommandLineParser.h
===================================================================
--- code/branches/testing/src/libraries/core/CommandLineParser.h	(revision 9223)
+++ code/branches/testing/src/libraries/core/CommandLineParser.h	(revision 9224)
@@ -200,5 +200,5 @@
     inline void CommandLineParser::getValue<std::string>(const std::string& name, std::string* value)
     {
-        *value = getArgument(name)->getValue().getString();
+        *value = getArgument(name)->getValue().get<std::string>();
     }
 
@@ -217,5 +217,5 @@
         OrxAssert(!_getInstance().existsArgument(name),
             "Cannot add a command line argument with name '" + name + "' twice.");
-        OrxAssert(!MultiType(defaultValue).isType<bool>() || MultiType(defaultValue).getBool() != true,
+        OrxAssert(!MultiType(defaultValue).isType<bool>() || MultiType(defaultValue).get<bool>() != true,
                "Boolean command line arguments with positive default values are not supported." << endl
             << "Please use SetCommandLineSwitch and adjust your argument: " << name);
Index: code/branches/testing/src/libraries/core/ConfigValueContainer.cc
===================================================================
--- code/branches/testing/src/libraries/core/ConfigValueContainer.cc	(revision 9223)
+++ code/branches/testing/src/libraries/core/ConfigValueContainer.cc	(revision 9224)
@@ -70,5 +70,5 @@
         this->bIsVector_ = false;
 
-        this->defvalueString_ = this->value_.getString();
+        this->defvalueString_ = this->value_.get<std::string>();
         this->update();
     }
Index: code/branches/testing/src/libraries/core/Core.cc
===================================================================
--- code/branches/testing/src/libraries/core/Core.cc	(revision 9223)
+++ code/branches/testing/src/libraries/core/Core.cc	(revision 9224)
@@ -167,5 +167,5 @@
         this->configFileManager_ = new ConfigFileManager();
         this->configFileManager_->setFilename(ConfigFileType::Settings,
-            CommandLineParser::getValue("settingsFile").getString());
+            CommandLineParser::getValue("settingsFile").get<std::string>());
 
         // Required as well for the config values
@@ -184,5 +184,5 @@
 #if !defined(ORXONOX_PLATFORM_APPLE) && !defined(ORXONOX_USE_WINMAIN)
         // Create persistent IO console
-        if (CommandLineParser::getValue("noIOConsole").getBool())
+        if (CommandLineParser::getValue("noIOConsole").get<bool>())
         {
             ModifyConfigValue(bStartIOConsole_, tset, false);
@@ -337,5 +337,5 @@
     {
         orxout(internal_info) << "loading graphics in Core" << endl;
-        
+
         // Any exception should trigger this, even in upgradeToGraphics (see its remarks)
         Loki::ScopeGuard unloader = Loki::MakeObjGuard(*this, &Core::unloadGraphics);
Index: code/branches/testing/src/libraries/core/PathConfig.cc
===================================================================
--- code/branches/testing/src/libraries/core/PathConfig.cc	(revision 9223)
+++ code/branches/testing/src/libraries/core/PathConfig.cc	(revision 9224)
@@ -188,5 +188,5 @@
             // Check for data path override by the command line
             if (!CommandLineParser::getArgument("externalDataPath")->hasDefaultValue())
-                externalDataPath_ = CommandLineParser::getValue("externalDataPath").getString();
+                externalDataPath_ = CommandLineParser::getValue("externalDataPath").get<std::string>();
             else
                 externalDataPath_ = specialConfig::externalDataDevDirectory;
@@ -227,5 +227,5 @@
         if (!CommandLineParser::getArgument("writingPathSuffix")->hasDefaultValue())
         {
-            const std::string& directory(CommandLineParser::getValue("writingPathSuffix").getString());
+            const std::string& directory(CommandLineParser::getValue("writingPathSuffix").get<std::string>());
             configPath_ = configPath_ / directory;
             logPath_    = logPath_    / directory;
Index: code/branches/testing/src/libraries/core/command/CommandEvaluation.cc
===================================================================
--- code/branches/testing/src/libraries/core/command/CommandEvaluation.cc	(revision 9223)
+++ code/branches/testing/src/libraries/core/command/CommandEvaluation.cc	(revision 9224)
@@ -600,5 +600,5 @@
             // print the default value if available
             if (command->getExecutor()->defaultValueSet(i))
-                output += '=' + command->getExecutor()->getDefaultValue(i).getString() + ']';
+                output += '=' + command->getExecutor()->getDefaultValue(i).get<std::string>() + ']';
             else
                 output += '}';
Index: code/branches/testing/src/libraries/core/command/CommandExecutor.cc
===================================================================
--- code/branches/testing/src/libraries/core/command/CommandExecutor.cc	(revision 9223)
+++ code/branches/testing/src/libraries/core/command/CommandExecutor.cc	(revision 9224)
@@ -133,5 +133,5 @@
     /* static */ std::string CommandExecutor::query(const std::string& command, int* error, bool useTcl)
     {
-        return CommandExecutor::queryMT(command, error, useTcl).getString();
+        return CommandExecutor::queryMT(command, error, useTcl).get<std::string>();
     }
 
Index: code/branches/testing/src/libraries/core/command/TclBind.cc
===================================================================
--- code/branches/testing/src/libraries/core/command/TclBind.cc	(revision 9223)
+++ code/branches/testing/src/libraries/core/command/TclBind.cc	(revision 9224)
@@ -183,5 +183,5 @@
 
         if (bQuery)
-            result = evaluation.query(&error).getString();
+            result = evaluation.query(&error).get<std::string>();
         else
             error = evaluation.execute();
Index: code/branches/testing/src/libraries/network/Client.cc
===================================================================
--- code/branches/testing/src/libraries/network/Client.cc	(revision 9223)
+++ code/branches/testing/src/libraries/network/Client.cc	(revision 9224)
@@ -68,5 +68,5 @@
       timeSinceLastUpdate_(0)
   {
-    this->setDestination( CommandLineParser::getValue("dest").getString(), CommandLineParser::getValue("port") );
+    this->setDestination( CommandLineParser::getValue("dest").get<std::string>(), CommandLineParser::getValue("port") );
   }
 
Index: code/branches/testing/src/libraries/tools/Shader.cc
===================================================================
--- code/branches/testing/src/libraries/tools/Shader.cc	(revision 9223)
+++ code/branches/testing/src/libraries/tools/Shader.cc	(revision 9224)
@@ -205,7 +205,7 @@
                     // change the value of the parameter depending on its type
                     if (it->value_.isType<int>())
-                        passPtr->getFragmentProgramParameters()->setNamedConstant(it->parameter_, it->value_.getInt());
+                        passPtr->getFragmentProgramParameters()->setNamedConstant(it->parameter_, it->value_.get<int>());
                     else if (it->value_.isType<float>())
-                        passPtr->getFragmentProgramParameters()->setNamedConstant(it->parameter_, it->value_.getFloat());
+                        passPtr->getFragmentProgramParameters()->setNamedConstant(it->parameter_, it->value_.get<float>());
                 }
                 else
Index: code/branches/testing/src/libraries/util/MultiType.h
===================================================================
--- code/branches/testing/src/libraries/util/MultiType.h	(revision 9223)
+++ code/branches/testing/src/libraries/util/MultiType.h	(revision 9224)
@@ -297,40 +297,40 @@
             inline MultiType(const orxonox::Degree& value)      : value_(0) { this->assignValue(value); }           ///< Constructor: Assigns the given value and sets the type.
             inline MultiType(const orxonox::mbool& value)       : value_(0) { this->assignValue((bool)value); }     ///< Constructor: Assigns the given mbool and converts it to bool.
-            inline MultiType(const char* value)                 : value_(0) { this->setValue(std::string(value)); } ///< Constructor: Converts the char array to a std::string, assigns the value and sets the type.
-            inline MultiType(const MultiType& other)            : value_(0) { this->setValue(other); }              ///< Copyconstructor: Assigns value and type of the other MultiType.
+            inline MultiType(const char* value)                 : value_(0) { this->set(std::string(value)); }      ///< Constructor: Converts the char array to a std::string, assigns the value and sets the type.
+            inline MultiType(const MultiType& other)            : value_(0) { this->set(other); }                   ///< Copyconstructor: Assigns value and type of the other MultiType.
 
             /// Destructor: Deletes the MT_Value.
             inline ~MultiType() { if (this->value_) { delete this->value_; } }
 
-            template <typename V> inline MultiType& operator=(const V& value)         { this->setValue(value); return (*this); } ///< Assigns a new value. The value will be converted to the current type of the MultiType.
-            template <typename V> inline MultiType& operator=(V* value)               { this->setValue(value); return (*this); } ///< Assigns a pointer.
-            inline                       MultiType& operator=(const MultiType& other) { this->setValue(other); return (*this); } ///< Assigns the value of the other MultiType and converts it to the current type of the MultiType.
-
-            inline bool                                   setValue(const char& value);
-            inline bool                                   setValue(const unsigned char& value);
-            inline bool                                   setValue(const short& value);
-            inline bool                                   setValue(const unsigned short& value);
-            inline bool                                   setValue(const int& value);
-            inline bool                                   setValue(const unsigned int& value);
-            inline bool                                   setValue(const long& value);
-            inline bool                                   setValue(const unsigned long& value);
-            inline bool                                   setValue(const long long& value);
-            inline bool                                   setValue(const unsigned long long& value);
-            inline bool                                   setValue(const float& value);
-            inline bool                                   setValue(const double& value);
-            inline bool                                   setValue(const long double& value);
-            inline bool                                   setValue(const bool& value);
-            inline bool                                   setValue(      void* const& value);
-            inline bool                                   setValue(const std::string& value);
-            inline bool                                   setValue(const orxonox::Vector2& value);
-            inline bool                                   setValue(const orxonox::Vector3& value);
-            inline bool                                   setValue(const orxonox::Vector4& value);
-            inline bool                                   setValue(const orxonox::ColourValue& value);
-            inline bool                                   setValue(const orxonox::Quaternion& value);
-            inline bool                                   setValue(const orxonox::Radian& value);
-            inline bool                                   setValue(const orxonox::Degree& value);
-            inline bool                                   setValue(const char* value);
+            template <typename V> inline MultiType& operator=(const V& value)         { this->set(value); return (*this); } ///< Assigns a new value. The value will be converted to the current type of the MultiType.
+            template <typename V> inline MultiType& operator=(V* value)               { this->set(value); return (*this); } ///< Assigns a pointer.
+            inline                       MultiType& operator=(const MultiType& other) { this->set(other); return (*this); } ///< Assigns the value of the other MultiType and converts it to the current type of the MultiType.
+
+            inline bool                                   set(const char& value);
+            inline bool                                   set(const unsigned char& value);
+            inline bool                                   set(const short& value);
+            inline bool                                   set(const unsigned short& value);
+            inline bool                                   set(const int& value);
+            inline bool                                   set(const unsigned int& value);
+            inline bool                                   set(const long& value);
+            inline bool                                   set(const unsigned long& value);
+            inline bool                                   set(const long long& value);
+            inline bool                                   set(const unsigned long long& value);
+            inline bool                                   set(const float& value);
+            inline bool                                   set(const double& value);
+            inline bool                                   set(const long double& value);
+            inline bool                                   set(const bool& value);
+            inline bool                                   set(      void* const& value);
+            inline bool                                   set(const std::string& value);
+            inline bool                                   set(const orxonox::Vector2& value);
+            inline bool                                   set(const orxonox::Vector3& value);
+            inline bool                                   set(const orxonox::Vector4& value);
+            inline bool                                   set(const orxonox::ColourValue& value);
+            inline bool                                   set(const orxonox::Quaternion& value);
+            inline bool                                   set(const orxonox::Radian& value);
+            inline bool                                   set(const orxonox::Degree& value);
+            inline bool                                   set(const char* value);
             /// Assigns a pointer.
-            template <typename V> inline bool setValue(V* value)
+            template <typename V> inline bool set(V* value)
             {
                 if (this->value_)
@@ -340,7 +340,7 @@
             }
             /// Changes the type to T and assigns the new value (which might be of another type than T - it gets converted).
-            template <typename T, typename V> inline bool setValue(const V& value) { this->reset<T>(); return this->setValue(value); }
+            template <typename T, typename V> inline bool set(const V& value) { this->reset<T>(); return this->set(value); }
             /// Assigns the value of the other MultiType and converts it to the current type.
-            bool                                          setValue(const MultiType& other) { if (this->value_) { return this->value_->assimilate(other); } else { if (other.value_) { this->value_ = other.value_->clone(); } return true; } }
+            bool                                          set(const MultiType& other) { if (this->value_) { return this->value_->assimilate(other); } else { if (other.value_) { this->value_ = other.value_->clone(); } return true; } }
 
             /// Copies the other MultiType by assigning value and type.
@@ -348,5 +348,5 @@
 
             /// Converts the current value to type T.
-            template <typename T> inline bool convert()                    { return this->setValue<T>((typename Loki::TypeTraits<T>::UnqualifiedReferredType)(*this));  }
+            template <typename T> inline bool convert()                    { return this->set<T>((typename Loki::TypeTraits<T>::UnqualifiedReferredType)(*this));  }
 
             /// Resets value and type. Type will be void afterwards and null() returns true.
@@ -427,28 +427,6 @@
             inline bool getValue(orxonox::Degree*      value) const { if (this->value_) { return this->value_->getValue(value); } return false; } ///< Assigns the value to the given pointer. The value gets converted if the types don't match.
 
-            inline char                     getChar()             const { return this->operator char();                 } ///< Returns the current value, converted to the requested type.
-            inline unsigned char            getUnsignedChar()     const { return this->operator unsigned char();        } ///< Returns the current value, converted to the requested type.
-            inline short                    getShort()            const { return this->operator short();                } ///< Returns the current value, converted to the requested type.
-            inline unsigned short           getUnsignedShort()    const { return this->operator unsigned short();       } ///< Returns the current value, converted to the requested type.
-            inline int                      getInt()              const { return this->operator int();                  } ///< Returns the current value, converted to the requested type.
-            inline unsigned int             getUnsignedInt()      const { return this->operator unsigned int();         } ///< Returns the current value, converted to the requested type.
-            inline long                     getLong()             const { return this->operator long();                 } ///< Returns the current value, converted to the requested type.
-            inline unsigned long            getUnsignedLong()     const { return this->operator unsigned long();        } ///< Returns the current value, converted to the requested type.
-            inline long long                getLongLong()         const { return this->operator long long();            } ///< Returns the current value, converted to the requested type.
-            inline unsigned long long       getUnsignedLongLong() const { return this->operator unsigned long long();   } ///< Returns the current value, converted to the requested type.
-            inline float                    getFloat()            const { return this->operator float();                } ///< Returns the current value, converted to the requested type.
-            inline double                   getDouble()           const { return this->operator double();               } ///< Returns the current value, converted to the requested type.
-            inline long double              getLongDouble()       const { return this->operator long double();          } ///< Returns the current value, converted to the requested type.
-            inline bool                     getBool()             const { return this->operator bool();                 } ///< Returns the current value, converted to the requested type.
-            inline void*                    getVoid()             const { return this->operator void*();                } ///< Returns the current value, converted to the requested type.
-            inline std::string              getString()           const { return this->operator std::string();          } ///< Returns the current value, converted to the requested type.
-            inline orxonox::Vector2         getVector2()          const { return this->operator orxonox::Vector2();     } ///< Returns the current value, converted to the requested type.
-            inline orxonox::Vector3         getVector3()          const { return this->operator orxonox::Vector3();     } ///< Returns the current value, converted to the requested type.
-            inline orxonox::Vector4         getVector4()          const { return this->operator orxonox::Vector4();     } ///< Returns the current value, converted to the requested type.
-            inline orxonox::ColourValue     getColourValue()      const { return this->operator orxonox::ColourValue(); } ///< Returns the current value, converted to the requested type.
-            inline orxonox::Quaternion      getQuaternion()       const { return this->operator orxonox::Quaternion();  } ///< Returns the current value, converted to the requested type.
-            inline orxonox::Radian          getRadian()           const { return this->operator orxonox::Radian();      } ///< Returns the current value, converted to the requested type.
-            inline orxonox::Degree          getDegree()           const { return this->operator orxonox::Degree();      } ///< Returns the current value, converted to the requested type.
-            template <typename T> inline T* getPointer()          const { return static_cast<T*>(this->getVoid());      } ///< Returns the current value, converted to a T* pointer.
+            /// Returns the current value, converted to the requested type.
+            template <typename T> inline T get() const { return T(); }
 
         private:
@@ -524,12 +502,12 @@
 
     // Specialization to avoid ambiguities with the conversion operator
-    template <> inline bool MultiType::convert<std::string>()          { return this->setValue<std::string>         (this->operator std::string());          } ///< Converts the current value to the given type.
-    template <> inline bool MultiType::convert<orxonox::Vector2>()     { return this->setValue<orxonox::Vector2>    (this->operator orxonox::Vector2());     } ///< Converts the current value to the given type.
-    template <> inline bool MultiType::convert<orxonox::Vector3>()     { return this->setValue<orxonox::Vector3>    (this->operator orxonox::Vector3());     } ///< Converts the current value to the given type.
-    template <> inline bool MultiType::convert<orxonox::Vector4>()     { return this->setValue<orxonox::Vector4>    (this->operator orxonox::Vector4());     } ///< Converts the current value to the given type.
-    template <> inline bool MultiType::convert<orxonox::ColourValue>() { return this->setValue<orxonox::ColourValue>(this->operator orxonox::ColourValue()); } ///< Converts the current value to the given type.
-    template <> inline bool MultiType::convert<orxonox::Quaternion>()  { return this->setValue<orxonox::Quaternion> (this->operator orxonox::Quaternion());  } ///< Converts the current value to the given type.
-    template <> inline bool MultiType::convert<orxonox::Radian>()      { return this->setValue<orxonox::Radian>     (this->operator orxonox::Radian());      } ///< Converts the current value to the given type.
-    template <> inline bool MultiType::convert<orxonox::Degree>()      { return this->setValue<orxonox::Degree>     (this->operator orxonox::Degree());      } ///< Converts the current value to the given type.
+    template <> inline bool MultiType::convert<std::string>()          { return this->set<std::string>         (this->operator std::string());          } ///< Converts the current value to the given type.
+    template <> inline bool MultiType::convert<orxonox::Vector2>()     { return this->set<orxonox::Vector2>    (this->operator orxonox::Vector2());     } ///< Converts the current value to the given type.
+    template <> inline bool MultiType::convert<orxonox::Vector3>()     { return this->set<orxonox::Vector3>    (this->operator orxonox::Vector3());     } ///< Converts the current value to the given type.
+    template <> inline bool MultiType::convert<orxonox::Vector4>()     { return this->set<orxonox::Vector4>    (this->operator orxonox::Vector4());     } ///< Converts the current value to the given type.
+    template <> inline bool MultiType::convert<orxonox::ColourValue>() { return this->set<orxonox::ColourValue>(this->operator orxonox::ColourValue()); } ///< Converts the current value to the given type.
+    template <> inline bool MultiType::convert<orxonox::Quaternion>()  { return this->set<orxonox::Quaternion> (this->operator orxonox::Quaternion());  } ///< Converts the current value to the given type.
+    template <> inline bool MultiType::convert<orxonox::Radian>()      { return this->set<orxonox::Radian>     (this->operator orxonox::Radian());      } ///< Converts the current value to the given type.
+    template <> inline bool MultiType::convert<orxonox::Degree>()      { return this->set<orxonox::Degree>     (this->operator orxonox::Degree());      } ///< Converts the current value to the given type.
 
     // Specialization to avoid ambiguities with the conversion operator
@@ -567,30 +545,54 @@
     template <> _UtilExport void MultiType::createNewValueContainer(const orxonox::Degree& value);
 
-    inline bool MultiType::setValue(const char& value)                  { if (this->value_) { return this->value_->setValue(value); } else { return this->assignValue(value); } } ///< Assigns the given value and converts it to the current type.
-    inline bool MultiType::setValue(const unsigned char& value)         { if (this->value_) { return this->value_->setValue(value); } else { return this->assignValue(value); } } ///< Assigns the given value and converts it to the current type.
-    inline bool MultiType::setValue(const short& value)                 { if (this->value_) { return this->value_->setValue(value); } else { return this->assignValue(value); } } ///< Assigns the given value and converts it to the current type.
-    inline bool MultiType::setValue(const unsigned short& value)        { if (this->value_) { return this->value_->setValue(value); } else { return this->assignValue(value); } } ///< Assigns the given value and converts it to the current type.
-    inline bool MultiType::setValue(const int& value)                   { if (this->value_) { return this->value_->setValue(value); } else { return this->assignValue(value); } } ///< Assigns the given value and converts it to the current type.
-    inline bool MultiType::setValue(const unsigned int& value)          { if (this->value_) { return this->value_->setValue(value); } else { return this->assignValue(value); } } ///< Assigns the given value and converts it to the current type.
-    inline bool MultiType::setValue(const long& value)                  { if (this->value_) { return this->value_->setValue(value); } else { return this->assignValue(value); } } ///< Assigns the given value and converts it to the current type.
-    inline bool MultiType::setValue(const unsigned long& value)         { if (this->value_) { return this->value_->setValue(value); } else { return this->assignValue(value); } } ///< Assigns the given value and converts it to the current type.
-    inline bool MultiType::setValue(const long long& value)             { if (this->value_) { return this->value_->setValue(value); } else { return this->assignValue(value); } } ///< Assigns the given value and converts it to the current type.
-    inline bool MultiType::setValue(const unsigned long long& value)    { if (this->value_) { return this->value_->setValue(value); } else { return this->assignValue(value); } } ///< Assigns the given value and converts it to the current type.
-    inline bool MultiType::setValue(const float& value)                 { if (this->value_) { return this->value_->setValue(value); } else { return this->assignValue(value); } } ///< Assigns the given value and converts it to the current type.
-    inline bool MultiType::setValue(const double& value)                { if (this->value_) { return this->value_->setValue(value); } else { return this->assignValue(value); } } ///< Assigns the given value and converts it to the current type.
-    inline bool MultiType::setValue(const long double& value)           { if (this->value_) { return this->value_->setValue(value); } else { return this->assignValue(value); } } ///< Assigns the given value and converts it to the current type.
-    inline bool MultiType::setValue(const bool& value)                  { if (this->value_) { return this->value_->setValue(value); } else { return this->assignValue(value); } } ///< Assigns the given value and converts it to the current type.
-    inline bool MultiType::setValue(      void* const& value)           { if (this->value_) { return this->value_->setValue(value); } else { return this->assignValue(value); } } ///< Assigns the given value and converts it to the current type.
-    inline bool MultiType::setValue(const std::string& value)           { if (this->value_) { return this->value_->setValue(value); } else { return this->assignValue(value); } } ///< Assigns the given value and converts it to the current type.
-    inline bool MultiType::setValue(const orxonox::Vector2& value)      { if (this->value_) { return this->value_->setValue(value); } else { return this->assignValue(value); } } ///< Assigns the given value and converts it to the current type.
-    inline bool MultiType::setValue(const orxonox::Vector3& value)      { if (this->value_) { return this->value_->setValue(value); } else { return this->assignValue(value); } } ///< Assigns the given value and converts it to the current type.
-    inline bool MultiType::setValue(const orxonox::Vector4& value)      { if (this->value_) { return this->value_->setValue(value); } else { return this->assignValue(value); } } ///< Assigns the given value and converts it to the current type.
-    inline bool MultiType::setValue(const orxonox::ColourValue& value)  { if (this->value_) { return this->value_->setValue(value); } else { return this->assignValue(value); } } ///< Assigns the given value and converts it to the current type.
-    inline bool MultiType::setValue(const orxonox::Quaternion& value)   { if (this->value_) { return this->value_->setValue(value); } else { return this->assignValue(value); } } ///< Assigns the given value and converts it to the current type.
-    inline bool MultiType::setValue(const orxonox::Radian& value)       { if (this->value_) { return this->value_->setValue(value); } else { return this->assignValue(value); } } ///< Assigns the given value and converts it to the current type.
-    inline bool MultiType::setValue(const orxonox::Degree& value)       { if (this->value_) { return this->value_->setValue(value); } else { return this->assignValue(value); } } ///< Assigns the given value and converts it to the current type.
+    inline bool MultiType::set(const char& value)                  { if (this->value_) { return this->value_->setValue(value); } else { return this->assignValue(value); } } ///< Assigns the given value and converts it to the current type.
+    inline bool MultiType::set(const unsigned char& value)         { if (this->value_) { return this->value_->setValue(value); } else { return this->assignValue(value); } } ///< Assigns the given value and converts it to the current type.
+    inline bool MultiType::set(const short& value)                 { if (this->value_) { return this->value_->setValue(value); } else { return this->assignValue(value); } } ///< Assigns the given value and converts it to the current type.
+    inline bool MultiType::set(const unsigned short& value)        { if (this->value_) { return this->value_->setValue(value); } else { return this->assignValue(value); } } ///< Assigns the given value and converts it to the current type.
+    inline bool MultiType::set(const int& value)                   { if (this->value_) { return this->value_->setValue(value); } else { return this->assignValue(value); } } ///< Assigns the given value and converts it to the current type.
+    inline bool MultiType::set(const unsigned int& value)          { if (this->value_) { return this->value_->setValue(value); } else { return this->assignValue(value); } } ///< Assigns the given value and converts it to the current type.
+    inline bool MultiType::set(const long& value)                  { if (this->value_) { return this->value_->setValue(value); } else { return this->assignValue(value); } } ///< Assigns the given value and converts it to the current type.
+    inline bool MultiType::set(const unsigned long& value)         { if (this->value_) { return this->value_->setValue(value); } else { return this->assignValue(value); } } ///< Assigns the given value and converts it to the current type.
+    inline bool MultiType::set(const long long& value)             { if (this->value_) { return this->value_->setValue(value); } else { return this->assignValue(value); } } ///< Assigns the given value and converts it to the current type.
+    inline bool MultiType::set(const unsigned long long& value)    { if (this->value_) { return this->value_->setValue(value); } else { return this->assignValue(value); } } ///< Assigns the given value and converts it to the current type.
+    inline bool MultiType::set(const float& value)                 { if (this->value_) { return this->value_->setValue(value); } else { return this->assignValue(value); } } ///< Assigns the given value and converts it to the current type.
+    inline bool MultiType::set(const double& value)                { if (this->value_) { return this->value_->setValue(value); } else { return this->assignValue(value); } } ///< Assigns the given value and converts it to the current type.
+    inline bool MultiType::set(const long double& value)           { if (this->value_) { return this->value_->setValue(value); } else { return this->assignValue(value); } } ///< Assigns the given value and converts it to the current type.
+    inline bool MultiType::set(const bool& value)                  { if (this->value_) { return this->value_->setValue(value); } else { return this->assignValue(value); } } ///< Assigns the given value and converts it to the current type.
+    inline bool MultiType::set(      void* const& value)           { if (this->value_) { return this->value_->setValue(value); } else { return this->assignValue(value); } } ///< Assigns the given value and converts it to the current type.
+    inline bool MultiType::set(const std::string& value)           { if (this->value_) { return this->value_->setValue(value); } else { return this->assignValue(value); } } ///< Assigns the given value and converts it to the current type.
+    inline bool MultiType::set(const orxonox::Vector2& value)      { if (this->value_) { return this->value_->setValue(value); } else { return this->assignValue(value); } } ///< Assigns the given value and converts it to the current type.
+    inline bool MultiType::set(const orxonox::Vector3& value)      { if (this->value_) { return this->value_->setValue(value); } else { return this->assignValue(value); } } ///< Assigns the given value and converts it to the current type.
+    inline bool MultiType::set(const orxonox::Vector4& value)      { if (this->value_) { return this->value_->setValue(value); } else { return this->assignValue(value); } } ///< Assigns the given value and converts it to the current type.
+    inline bool MultiType::set(const orxonox::ColourValue& value)  { if (this->value_) { return this->value_->setValue(value); } else { return this->assignValue(value); } } ///< Assigns the given value and converts it to the current type.
+    inline bool MultiType::set(const orxonox::Quaternion& value)   { if (this->value_) { return this->value_->setValue(value); } else { return this->assignValue(value); } } ///< Assigns the given value and converts it to the current type.
+    inline bool MultiType::set(const orxonox::Radian& value)       { if (this->value_) { return this->value_->setValue(value); } else { return this->assignValue(value); } } ///< Assigns the given value and converts it to the current type.
+    inline bool MultiType::set(const orxonox::Degree& value)       { if (this->value_) { return this->value_->setValue(value); } else { return this->assignValue(value); } } ///< Assigns the given value and converts it to the current type.
+
+    template <> inline char                     MultiType::get() const { return this->operator char();                 }
+    template <> inline unsigned char            MultiType::get() const { return this->operator unsigned char();        }
+    template <> inline short                    MultiType::get() const { return this->operator short();                }
+    template <> inline unsigned short           MultiType::get() const { return this->operator unsigned short();       }
+    template <> inline int                      MultiType::get() const { return this->operator int();                  }
+    template <> inline unsigned int             MultiType::get() const { return this->operator unsigned int();         }
+    template <> inline long                     MultiType::get() const { return this->operator long();                 }
+    template <> inline unsigned long            MultiType::get() const { return this->operator unsigned long();        }
+    template <> inline long long                MultiType::get() const { return this->operator long long();            }
+    template <> inline unsigned long long       MultiType::get() const { return this->operator unsigned long long();   }
+    template <> inline float                    MultiType::get() const { return this->operator float();                }
+    template <> inline double                   MultiType::get() const { return this->operator double();               }
+    template <> inline long double              MultiType::get() const { return this->operator long double();          }
+    template <> inline bool                     MultiType::get() const { return this->operator bool();                 }
+    template <> inline void*                    MultiType::get() const { return this->operator void*();                }
+    template <> inline std::string              MultiType::get() const { return this->operator std::string();          }
+    template <> inline orxonox::Vector2         MultiType::get() const { return this->operator orxonox::Vector2();     }
+    template <> inline orxonox::Vector3         MultiType::get() const { return this->operator orxonox::Vector3();     }
+    template <> inline orxonox::Vector4         MultiType::get() const { return this->operator orxonox::Vector4();     }
+    template <> inline orxonox::ColourValue     MultiType::get() const { return this->operator orxonox::ColourValue(); }
+    template <> inline orxonox::Quaternion      MultiType::get() const { return this->operator orxonox::Quaternion();  }
+    template <> inline orxonox::Radian          MultiType::get() const { return this->operator orxonox::Radian();      }
+    template <> inline orxonox::Degree          MultiType::get() const { return this->operator orxonox::Degree();      }
 
     /// Assigns the given value and converts it to the current type.
-    inline bool MultiType::setValue(const char* value)                  { if (this->value_) { return this->value_->setValue(std::string(value)); } else { return this->assignValue(std::string(value)); } }
+    inline bool MultiType::set(const char* value)                  { if (this->value_) { return this->value_->setValue(std::string(value)); } else { return this->assignValue(std::string(value)); } }
 }
 
