Index: code/branches/core/src/util/Convert.h
===================================================================
--- code/branches/core/src/util/Convert.h	(revision 847)
+++ code/branches/core/src/util/Convert.h	(revision 848)
@@ -38,4 +38,7 @@
 #include "UtilPrereqs.h"
 #include "Math.h"
+#include "SubString.h"
+#include "MultiTypeMath.h"
+
 
 // DEFAULT CLASS
@@ -103,7 +106,193 @@
 }
 
-
-
-// MORE SPECIALISATIONS
+// THE SAME LIKE BEFORE, BUT NEEDS NO POINTER TO THE OUTPUT
+template<typename FromType, typename ToType>
+static ToType ConvertValueAndReturn(const FromType& input)
+{
+  ToType output;
+  ConvertValue(&output, input);
+  return output;
+}
+
+// THE SAME, BUT WITH DEFAULT VALUE
+template<typename FromType, typename ToType>
+static ToType ConvertValueAndReturn(const FromType& input, const FromType& fallback)
+{
+  ToType output;
+  ConvertValue(&output, input, fallback);
+  return output;
+}
+
+//////////////////////////
+// MORE SPECIALISATIONS //
+//////////////////////////
+
+// STRING TO STRING
+template<>
+class Converter<std::string, std::string>
+{
+  public:
+    bool operator()(std::string* output, const std::string& input) const
+    {
+        (*output) = std::string(input);
+        return true;
+    }
+};
+
+////////////////
+// MULTITYPES //
+////////////////
+
+// PARTIAL SPECIALIZATION TO CONVERT FROM MULTITYPEPRIMITIVE
+template<typename ToType>
+class Converter<MultiTypePrimitive, ToType>
+{
+  public:
+    bool operator()(ToType* output, const MultiTypePrimitive& input) const
+    {
+      if (input.getType() == MT_int)
+        return ConvertValue(output, input.getInt());
+      else if (input.getType() == MT_uint)
+        return ConvertValue(output, input.getUnsignedInt());
+      else if (input.getType() == MT_char)
+        return ConvertValue(output, input.getChar());
+      else if (input.getType() == MT_uchar)
+        return ConvertValue(output, input.getUnsignedChar());
+      else if (input.getType() == MT_short)
+        return ConvertValue(output, input.getShort());
+      else if (input.getType() == MT_ushort)
+        return ConvertValue(output, input.getUnsignedShort());
+      else if (input.getType() == MT_long)
+        return ConvertValue(output, input.getLong());
+      else if (input.getType() == MT_ulong)
+        return ConvertValue(output, input.getUnsignedLong());
+      else if (input.getType() == MT_float)
+        return ConvertValue(output, input.getFloat());
+      else if (input.getType() == MT_double)
+        return ConvertValue(output, input.getDouble());
+      else if (input.getType() == MT_longdouble)
+        return ConvertValue(output, input.getLongDouble());
+      else if (input.getType() == MT_bool)
+        return ConvertValue(output, input.getBool());
+      else
+        return false;
+    }
+};
+template<>
+class Converter<MultiTypePrimitive, std::string>
+{
+  public:
+    bool operator()(std::string* output, const MultiTypePrimitive& input) const
+    {
+      if (input.getType() == MT_int)
+        return ConvertValue(output, input.getInt());
+      else if (input.getType() == MT_uint)
+        return ConvertValue(output, input.getUnsignedInt());
+      else if (input.getType() == MT_char)
+        return ConvertValue(output, input.getChar());
+      else if (input.getType() == MT_uchar)
+        return ConvertValue(output, input.getUnsignedChar());
+      else if (input.getType() == MT_short)
+        return ConvertValue(output, input.getShort());
+      else if (input.getType() == MT_ushort)
+        return ConvertValue(output, input.getUnsignedShort());
+      else if (input.getType() == MT_long)
+        return ConvertValue(output, input.getLong());
+      else if (input.getType() == MT_ulong)
+        return ConvertValue(output, input.getUnsignedLong());
+      else if (input.getType() == MT_float)
+        return ConvertValue(output, input.getFloat());
+      else if (input.getType() == MT_double)
+        return ConvertValue(output, input.getDouble());
+      else if (input.getType() == MT_longdouble)
+        return ConvertValue(output, input.getLongDouble());
+      else if (input.getType() == MT_bool)
+        return ConvertValue(output, input.getBool());
+      else
+        return false;
+    }
+};
+
+// PARTIAL SPECIALIZATION TO CONVERT FROM MULTITYPESTRING
+template<typename ToType>
+class Converter<MultiTypeString, ToType>
+{
+  public:
+    bool operator()(ToType* output, const MultiTypeString& input) const
+    {
+      if (input.getType() == MT_constchar)
+        return ConvertValue(output, input.getConstChar());
+      else if (input.getType() == MT_string)
+        return ConvertValue(output, input.getString());
+      else
+        return false;
+    }
+};
+template<>
+class Converter<MultiTypeString, std::string>
+{
+  public:
+    bool operator()(std::string* output, const MultiTypeString& input) const
+    {
+      if (input.getType() == MT_constchar)
+        return ConvertValue(output, input.getConstChar());
+      else if (input.getType() == MT_string)
+        return ConvertValue(output, input.getString());
+      else
+        return false;
+    }
+};
+
+// PARTIAL SPECIALIZATION TO CONVERT FROM MULTITYPEMATH
+template<typename ToType>
+class Converter<MultiTypeMath, ToType>
+{
+  public:
+    bool operator()(ToType* output, const MultiTypeMath& input) const
+    {
+      if (input.getType() == MT_vector2)
+        return ConvertValue(output, input.getVector2());
+      else if (input.getType() == MT_vector3)
+        return ConvertValue(output, input.getVector3());
+      else if (input.getType() == MT_quaternion)
+        return ConvertValue(output, input.getQuaternion());
+      else if (input.getType() == MT_colourvalue)
+        return ConvertValue(output, input.getColourValue());
+      else if (input.getType() == MT_radian)
+        return ConvertValue(output, input.getRadian());
+      else if (input.getType() == MT_degree)
+        return ConvertValue(output, input.getDegree());
+      else
+        return false;
+    }
+};
+template<>
+class Converter<MultiTypeMath, std::string>
+{
+  public:
+    bool operator()(std::string* output, const MultiTypeMath& input) const
+    {
+      if (input.getType() == MT_vector2)
+        return ConvertValue(output, input.getVector2());
+      else if (input.getType() == MT_vector3)
+        return ConvertValue(output, input.getVector3());
+      else if (input.getType() == MT_quaternion)
+        return ConvertValue(output, input.getQuaternion());
+      else if (input.getType() == MT_colourvalue)
+        return ConvertValue(output, input.getColourValue());
+      else if (input.getType() == MT_radian)
+        return ConvertValue(output, input.getRadian());
+      else if (input.getType() == MT_degree)
+        return ConvertValue(output, input.getDegree());
+      else
+        return false;
+    }
+};
+
+
+////////////////////
+// MATH TO STRING //
+////////////////////
+
 // Vector2 to std::string
 template <>
@@ -196,3 +385,137 @@
 };
 
+
+////////////////////
+// STRING TO MATH //
+////////////////////
+
+// std::string to Vector2
+template <>
+class Converter<std::string, orxonox::Vector2>
+{
+  public:
+    bool operator()(orxonox::Vector2* output, const std::string& input) const
+    {
+      SubString tokens(input, ",", SubString::WhiteSpaces, false, '\\', '"', '(', ')', '\0');
+
+      if (tokens.size() >= 2)
+      {
+        if (!ConvertValue(&(output->x), tokens[0]))
+          return false;
+        if (!ConvertValue(&(output->y), tokens[1]))
+          return false;
+
+        return true;
+      }
+
+      return false;
+    }
+};
+
+// std::string to Vector3
+template <>
+class Converter<std::string, orxonox::Vector3>
+{
+  public:
+    bool operator()(orxonox::Vector3* output, const std::string& input) const
+    {
+      SubString tokens(input, ",", SubString::WhiteSpaces, false, '\\', '"', '(', ')', '\0');
+
+      if (tokens.size() >= 3)
+      {
+        if (!ConvertValue(&(output->x), tokens[0]))
+          return false;
+        if (!ConvertValue(&(output->y), tokens[1]))
+          return false;
+        if (!ConvertValue(&(output->z), tokens[2]))
+          return false;
+
+        return true;
+      }
+
+      return false;
+    }
+};
+
+// std::string to Vector4
+template <>
+class Converter<std::string, orxonox::Vector4>
+{
+  public:
+    bool operator()(orxonox::Vector4* output, const std::string& input) const
+    {
+      SubString tokens(input, ",", SubString::WhiteSpaces, false, '\\', '"', '(', ')', '\0');
+
+      if (tokens.size() >= 4)
+      {
+        if (!ConvertValue(&(output->x), tokens[0]))
+          return false;
+        if (!ConvertValue(&(output->y), tokens[1]))
+          return false;
+        if (!ConvertValue(&(output->z), tokens[2]))
+          return false;
+        if (!ConvertValue(&(output->w), tokens[3]))
+          return false;
+
+        return true;
+      }
+
+      return false;
+    }
+};
+
+// std::string to Quaternion
+template <>
+class Converter<std::string, orxonox::Quaternion>
+{
+  public:
+    bool operator()(orxonox::Quaternion* output, const std::string& input) const
+    {
+      SubString tokens(input, ",", SubString::WhiteSpaces, false, '\\', '"', '(', ')', '\0');
+
+      if (tokens.size() >= 4)
+      {
+        if (!ConvertValue(&(output->w), tokens[0]))
+          return false;
+        if (!ConvertValue(&(output->x), tokens[1]))
+          return false;
+        if (!ConvertValue(&(output->y), tokens[2]))
+          return false;
+        if (!ConvertValue(&(output->z), tokens[3]))
+          return false;
+
+        return true;
+      }
+
+      return false;
+    }
+};
+
+// std::string to ColourValue
+template <>
+class Converter<std::string, orxonox::ColourValue>
+{
+  public:
+    bool operator()(orxonox::ColourValue* output, const std::string& input) const
+    {
+      SubString tokens(input, ",", SubString::WhiteSpaces, false, '\\', '"', '(', ')', '\0');
+
+      if (tokens.size() >= 4)
+      {
+        if (!ConvertValue(&(output->r), tokens[0]))
+          return false;
+        if (!ConvertValue(&(output->g), tokens[1]))
+          return false;
+        if (!ConvertValue(&(output->b), tokens[2]))
+          return false;
+        if (!ConvertValue(&(output->a), tokens[3]))
+          return false;
+
+        return true;
+      }
+
+      return false;
+    }
+};
+
 #endif /* _Convert_H__ */
Index: code/branches/core/src/util/MultiTypeMath.cc
===================================================================
--- code/branches/core/src/util/MultiTypeMath.cc	(revision 847)
+++ code/branches/core/src/util/MultiTypeMath.cc	(revision 848)
@@ -28,4 +28,5 @@
 
 #include "MultiTypeMath.h"
+#include "Convert.h"
 
 MultiTypeMath::MultiTypeMath(MultiType type) : MultiTypeString(type)
@@ -100,8 +101,78 @@
 }
 
+MultiTypeMath::operator orxonox::Vector2() const
+{
+    return (this->type_ == MT_vector2) ? this->vector2_ : ConvertValueAndReturn<MultiTypePrimitive, orxonox::Vector2>(*this);
+}
+
+MultiTypeMath::operator orxonox::Vector3() const
+{
+    return (this->type_ == MT_vector3) ? this->vector3_ : ConvertValueAndReturn<MultiTypePrimitive, orxonox::Vector3>(*this);
+}
+
+MultiTypeMath::operator orxonox::Quaternion() const
+{
+    return (this->type_ == MT_quaternion) ? this->quaternion_ : ConvertValueAndReturn<MultiTypePrimitive, orxonox::Quaternion>(*this);
+}
+
+MultiTypeMath::operator orxonox::ColourValue() const
+{
+    return (this->type_ == MT_colourvalue) ? this->colourvalue_ : ConvertValueAndReturn<MultiTypePrimitive, orxonox::ColourValue>(*this);
+}
+
+MultiTypeMath::operator orxonox::Radian() const
+{
+    return (this->type_ == MT_radian) ? this->radian_ : ConvertValueAndReturn<MultiTypePrimitive, orxonox::Radian>(*this);
+}
+
+MultiTypeMath::operator orxonox::Degree() const
+{
+    return (this->type_ == MT_degree) ? this->degree_ : ConvertValueAndReturn<MultiTypePrimitive, orxonox::Degree>(*this);
+}
+
 void MultiTypeMath::setValue(const MultiTypeMath& mtm)
 {
     this->type_ = mtm.type_;
     this->value_ = mtm.value_;
+}
+
+std::string MultiTypeMath::toString() const
+{
+    std::string output;
+
+    if (this->type_ == MT_vector2)
+        ConvertValue(&output, this->vector2_);
+    else if (this->type_ == MT_vector3)
+        ConvertValue(&output, this->vector3_);
+    else if (this->type_ == MT_colourvalue)
+        ConvertValue(&output, this->colourvalue_);
+    else if (this->type_ == MT_quaternion)
+        ConvertValue(&output, this->quaternion_);
+    else if (this->type_ == MT_radian)
+        ConvertValue(&output, this->radian_);
+    else if (this->type_ == MT_degree)
+        ConvertValue(&output, this->degree_);
+    else
+        return MultiTypeString::toString();
+
+    return output;
+}
+
+bool MultiTypeMath::fromString(const std::string value)
+{
+    if (this->type_ == MT_vector2)
+        return ConvertValue(&this->vector2_, value, orxonox::Vector2(0, 0));
+    else if (this->type_ == MT_vector3)
+        return ConvertValue(&this->vector3_, value, orxonox::Vector3(0, 0, 0));
+    else if (this->type_ == MT_colourvalue)
+        return ConvertValue(&this->colourvalue_, value, orxonox::ColourValue(0, 0, 0, 0));
+    else if (this->type_ == MT_quaternion)
+        return ConvertValue(&this->quaternion_, value, orxonox::Quaternion(1, 0, 0, 0));
+    else if (this->type_ == MT_radian)
+        return ConvertValue(&this->radian_, value, orxonox::Radian(0));
+    else if (this->type_ == MT_degree)
+        return ConvertValue(&this->degree_, value, orxonox::Degree(0));
+    else
+        return MultiTypeString::fromString(value);
 }
 
Index: code/branches/core/src/util/MultiTypeMath.h
===================================================================
--- code/branches/core/src/util/MultiTypeMath.h	(revision 847)
+++ code/branches/core/src/util/MultiTypeMath.h	(revision 848)
@@ -88,10 +88,10 @@
         bool operator!=(const MultiTypeMath& mtm) const;
 
-        inline operator orxonox::Vector2()     const { return this->vector2_;     }
-        inline operator orxonox::Vector3()     const { return this->vector3_;     }
-        inline operator orxonox::ColourValue() const { return this->colourvalue_; }
-        inline operator orxonox::Quaternion()  const { return this->quaternion_;  }
-        inline operator orxonox::Radian()      const { return this->radian_;      }
-        inline operator orxonox::Degree()      const { return this->degree_;      }
+        operator orxonox::Vector2()     const;
+        operator orxonox::Vector3()     const;
+        operator orxonox::ColourValue() const;
+        operator orxonox::Quaternion()  const;
+        operator orxonox::Radian()      const;
+        operator orxonox::Degree()      const;
 
         using MultiTypeString::setValue;
@@ -103,4 +103,11 @@
         inline void setValue(const orxonox::Degree&      value) { this->type_ = MT_degree;      this->degree_      = value; }
         void setValue(const MultiTypeMath& mtm);
+
+        inline orxonox::Vector2     getVector2()     const { return this->vector2_;     }
+        inline orxonox::Vector3     getVector3()     const { return this->vector3_;     }
+        inline orxonox::ColourValue getColourValue() const { return this->colourvalue_; }
+        inline orxonox::Quaternion  getQuaternion()  const { return this->quaternion_;  }
+        inline orxonox::Radian      getRadian()      const { return this->radian_;      }
+        inline orxonox::Degree      getDegree()      const { return this->degree_;      }
 
         inline orxonox::Vector2&     getVector2()     { return this->vector2_;     }
@@ -119,4 +126,7 @@
         inline void getValue(orxonox::Degree*      variable) const { (*variable) = orxonox::Degree      (this->degree_);      }
 
+        std::string toString() const;
+        bool fromString(const std::string value);
+
     protected:
         orxonox::Vector2      vector2_;
Index: code/branches/core/src/util/MultiTypePrimitive.cc
===================================================================
--- code/branches/core/src/util/MultiTypePrimitive.cc	(revision 847)
+++ code/branches/core/src/util/MultiTypePrimitive.cc	(revision 848)
@@ -28,4 +28,5 @@
 
 #include "MultiTypePrimitive.h"
+#include "Convert.h"
 
 MultiTypePrimitive::MultiTypePrimitive(MultiType type)
@@ -140,8 +141,130 @@
 }
 
+MultiTypePrimitive::operator int() const
+{
+    return (this->type_ == MT_int) ? this->value_.int_ : ConvertValueAndReturn<MultiTypePrimitive, int>(*this);
+}
+
+MultiTypePrimitive::operator unsigned int() const
+{
+    return (this->type_ == MT_uint) ? this->value_.uint_ : ConvertValueAndReturn<MultiTypePrimitive, unsigned int>(*this);
+}
+
+MultiTypePrimitive::operator char() const
+{
+    return (this->type_ == MT_char) ? this->value_.char_ : ConvertValueAndReturn<MultiTypePrimitive, char>(*this);
+}
+
+MultiTypePrimitive::operator unsigned char() const
+{
+    return (this->type_ == MT_uchar) ? this->value_.uchar_ : ConvertValueAndReturn<MultiTypePrimitive, unsigned char>(*this);
+}
+
+MultiTypePrimitive::operator short() const
+{
+    return (this->type_ == MT_short) ? this->value_.short_ : ConvertValueAndReturn<MultiTypePrimitive, short>(*this);
+}
+
+MultiTypePrimitive::operator unsigned short() const
+{
+    return (this->type_ == MT_ushort) ? this->value_.ushort_ : ConvertValueAndReturn<MultiTypePrimitive, unsigned short>(*this);
+}
+
+MultiTypePrimitive::operator long() const
+{
+    return (this->type_ == MT_long) ? this->value_.long_ : ConvertValueAndReturn<MultiTypePrimitive, long>(*this);
+}
+
+MultiTypePrimitive::operator unsigned long() const
+{
+    return (this->type_ == MT_ulong) ? this->value_.ulong_ : ConvertValueAndReturn<MultiTypePrimitive, unsigned long>(*this);
+}
+
+MultiTypePrimitive::operator float() const
+{
+    return (this->type_ == MT_float) ? this->value_.float_ : ConvertValueAndReturn<MultiTypePrimitive, float>(*this);
+}
+
+MultiTypePrimitive::operator double() const
+{
+    return (this->type_ == MT_double) ? this->value_.double_ : ConvertValueAndReturn<MultiTypePrimitive, double>(*this);
+}
+
+MultiTypePrimitive::operator long double() const
+{
+    return (this->type_ == MT_longdouble) ? this->value_.longdouble_ : ConvertValueAndReturn<MultiTypePrimitive, long double>(*this);
+}
+
+MultiTypePrimitive::operator bool() const
+{
+    return (this->type_ == MT_bool) ? this->value_.bool_ : ConvertValueAndReturn<MultiTypePrimitive, bool>(*this);
+}
+
 void MultiTypePrimitive::setValue(const MultiTypePrimitive& mtp)
 {
     this->type_ = mtp.type_;
     this->value_ = mtp.value_;
+}
+
+std::string MultiTypePrimitive::toString() const
+{
+    std::string output;
+
+    if (this->type_ == MT_int)
+        ConvertValue(&output, this->value_.int_);
+    else if (this->type_ == MT_uint)
+        ConvertValue(&output, this->value_.uint_);
+    else if (this->type_ == MT_char)
+        ConvertValue(&output, this->value_.char_);
+    else if (this->type_ == MT_uchar)
+        ConvertValue(&output, this->value_.uchar_);
+    else if (this->type_ == MT_short)
+        ConvertValue(&output, this->value_.short_);
+    else if (this->type_ == MT_ushort)
+        ConvertValue(&output, this->value_.ushort_);
+    else if (this->type_ == MT_long)
+        ConvertValue(&output, this->value_.long_);
+    else if (this->type_ == MT_ulong)
+        ConvertValue(&output, this->value_.ulong_);
+    else if (this->type_ == MT_float)
+        ConvertValue(&output, this->value_.float_);
+    else if (this->type_ == MT_double)
+        ConvertValue(&output, this->value_.double_);
+    else if (this->type_ == MT_longdouble)
+        ConvertValue(&output, this->value_.longdouble_);
+    else if (this->type_ == MT_bool)
+        ConvertValue(&output, this->value_.bool_);
+
+    return output;
+}
+
+bool MultiTypePrimitive::fromString(const std::string value)
+{
+    if (this->type_ == MT_int)
+        return ConvertValue(&this->value_.int_, value, (int)0);
+    else if (this->type_ == MT_uint)
+        return ConvertValue(&this->value_.uint_, value, (unsigned int)0);
+    else if (this->type_ == MT_char)
+        return ConvertValue(&this->value_.char_, value, (char)0);
+    else if (this->type_ == MT_uchar)
+        return ConvertValue(&this->value_.uchar_, value, (unsigned char)0);
+    else if (this->type_ == MT_short)
+        return ConvertValue(&this->value_.short_, value, (short)0);
+    else if (this->type_ == MT_ushort)
+        return ConvertValue(&this->value_.ushort_, value, (unsigned short)0);
+    else if (this->type_ == MT_long)
+        return ConvertValue(&this->value_.long_, value, (long)0);
+    else if (this->type_ == MT_ulong)
+        return ConvertValue(&this->value_.ulong_, value, (unsigned long)0);
+    else if (this->type_ == MT_float)
+        return ConvertValue(&this->value_.float_, value, (float)0.0);
+    else if (this->type_ == MT_double)
+        return ConvertValue(&this->value_.double_, value, (double)0.0);
+    else if (this->type_ == MT_longdouble)
+        return ConvertValue(&this->value_.longdouble_, value, (long double)0.0);
+    else if (this->type_ == MT_bool)
+        return ConvertValue(&this->value_.bool_, value, false);
+    else
+        return false;
 }
 
Index: code/branches/core/src/util/MultiTypePrimitive.h
===================================================================
--- code/branches/core/src/util/MultiTypePrimitive.h	(revision 847)
+++ code/branches/core/src/util/MultiTypePrimitive.h	(revision 848)
@@ -97,16 +97,16 @@
         bool operator!=(const MultiTypePrimitive& mtp) const;
 
-        inline operator int()            const { return this->value_.int_;        }
-        inline operator unsigned int()   const { return this->value_.uint_;       }
-        inline operator char()           const { return this->value_.char_;       }
-        inline operator unsigned char()  const { return this->value_.uchar_;      }
-        inline operator short()          const { return this->value_.short_;      }
-        inline operator unsigned short() const { return this->value_.ushort_;     }
-        inline operator long()           const { return this->value_.long_;       }
-        inline operator unsigned long()  const { return this->value_.ulong_;      }
-        inline operator float ()         const { return this->value_.float_;      }
-        inline operator double ()        const { return this->value_.double_;     }
-        inline operator long double()    const { return this->value_.longdouble_; }
-        inline operator bool()           const { return this->value_.bool_;       }
+        operator int()            const;
+        operator unsigned int()   const;
+        operator char()           const;
+        operator unsigned char()  const;
+        operator short()          const;
+        operator unsigned short() const;
+        operator long()           const;
+        operator unsigned long()  const;
+        operator float ()         const;
+        operator double ()        const;
+        operator long double()    const;
+        operator bool()           const;
 
         inline void setValue(int            value) { this->type_ = MT_int;        this->value_.int_        = value; }
@@ -137,4 +137,17 @@
         inline bool           getBool()          const { return this->value_.bool_;       }
 
+        inline int&            getInt()           { return this->value_.int_;        }
+        inline unsigned int&   getUnsignedInt()   { return this->value_.uint_;       }
+        inline char&           getChar()          { return this->value_.char_;       }
+        inline unsigned char&  getUnsignedChar()  { return this->value_.uchar_;      }
+        inline short&          getShort()         { return this->value_.short_;      }
+        inline unsigned short& getUnsignedShort() { return this->value_.ushort_;     }
+        inline long&           getLong()          { return this->value_.long_;       }
+        inline unsigned long&  getUnsignedLong()  { return this->value_.ulong_;      }
+        inline float&          getFloat()         { return this->value_.float_;      }
+        inline double&         getDouble()        { return this->value_.double_;     }
+        inline long double&    getLongDouble()    { return this->value_.longdouble_; }
+        inline bool&           getBool()          { return this->value_.bool_;       }
+
         inline void getValue(int*            variable) const { (*variable) = this->value_.int_;        }
         inline void getValue(unsigned int*   variable) const { (*variable) = this->value_.uint_;       }
@@ -153,4 +166,7 @@
         inline bool      isA(MultiType type) const { return (this->type_ == type); }
 
+        std::string toString() const;
+        bool fromString(const std::string value);
+
     protected:
         MultiTypeValue  value_;
Index: code/branches/core/src/util/MultiTypeString.cc
===================================================================
--- code/branches/core/src/util/MultiTypeString.cc	(revision 847)
+++ code/branches/core/src/util/MultiTypeString.cc	(revision 848)
@@ -28,4 +28,5 @@
 
 #include "MultiTypeString.h"
+#include "Convert.h"
 
 MultiTypeString::MultiTypeString(MultiType type) : MultiTypePrimitive(type)
@@ -76,8 +77,40 @@
 }
 
+MultiTypeString::operator std::string() const
+{
+    return (this->type_ == MT_string) ? this->string_ : ConvertValueAndReturn<MultiTypePrimitive, std::string>(*this);
+}
+
+MultiTypeString::operator const char*() const
+{
+    return (this->type_ == MT_constchar) ? this->string_.c_str() : ConvertValueAndReturn<MultiTypePrimitive, const char*>(*this);
+}
+
 void MultiTypeString::setValue(const MultiTypeString& mts)
 {
     this->type_ = mts.type_;
     this->value_ = mts.value_;
+}
+
+std::string MultiTypeString::toString() const
+{
+    if (this->type_ == MT_constchar)
+        return this->string_;
+    else if (this->type_ == MT_string)
+        return this->string_;
+    else
+        return MultiTypePrimitive::toString();
+}
+
+bool MultiTypeString::fromString(const std::string value)
+{
+    if (this->type_ == MT_constchar)
+        this->string_ = value;
+    else if (this->type_ == MT_string)
+        this->string_ = value;
+    else
+        return MultiTypePrimitive::fromString(value);
+
+    return true;
 }
 
Index: code/branches/core/src/util/MultiTypeString.h
===================================================================
--- code/branches/core/src/util/MultiTypeString.h	(revision 847)
+++ code/branches/core/src/util/MultiTypeString.h	(revision 848)
@@ -71,6 +71,6 @@
         bool operator!=(const MultiTypeString& mtp) const;
 
-        inline operator std::string() const { return this->string_;         }
-        inline operator const char*() const { return this->string_.c_str(); }
+        operator std::string() const;
+        operator const char*() const;
 
         using MultiTypePrimitive::setValue;
@@ -79,10 +79,16 @@
         void setValue(const MultiTypeString& mtp);
 
-        inline std::string& getString()    { return this->string_;         }
-        inline const char*  getConstChar() { return this->string_.c_str(); }
+        inline const std::string getString() const { return this->string_;         }
+        inline const char*  getConstChar()   const { return this->string_.c_str(); }
+
+        inline const std::string& getString() { return this->string_;         }
+        inline const char*  getConstChar()    { return this->string_.c_str(); }
 
         using MultiTypePrimitive::getValue;
         inline void getValue(std::string* variable) const { (*variable) = this->string_;         }
         inline void getValue(const char** variable) const { (*variable) = this->string_.c_str(); }
+
+        std::string toString() const;
+        bool fromString(const std::string value);
 
     protected:
Index: code/branches/core/src/util/String.h
===================================================================
--- code/branches/core/src/util/String.h	(revision 847)
+++ code/branches/core/src/util/String.h	(revision 848)
@@ -63,5 +63,5 @@
             float f = 3.14;
             std::string output;
-            bool success = Convert::ToString(output, f);
+            bool success = Convert::ToString(&output, f);
         */
         template <typename T>
@@ -88,5 +88,5 @@
             float f = 3.14;
             std::string output;
-            bool success = Convert::ToString(output, f, "0.000000");
+            bool success = Convert::ToString(&output, f, "0.000000");
         */
         template <typename T>
@@ -109,5 +109,5 @@
             std::string input = "3.14";
             float f;
-            bool success = string2Number(f, input);
+            bool success = string2Number(&f, input);
         */
         template <typename T>
@@ -131,5 +131,5 @@
             std::string input = "3.14";
             float f;
-            bool success = string2Number(f, input, 0.000000);
+            bool success = string2Number(&f, input, 0.000000);
         */
         template <typename T>
