Index: code/branches/network/src/util/Convert.h
===================================================================
--- code/branches/network/src/util/Convert.h	(revision 1414)
+++ code/branches/network/src/util/Convert.h	(revision 1446)
@@ -384,4 +384,6 @@
         else if (input.getType() == MT_vector3)
             return ConvertValue(output, input.getVector3());
+        else if (input.getType() == MT_vector4)
+            return ConvertValue(output, input.getVector4());
         else if (input.getType() == MT_quaternion)
             return ConvertValue(output, input.getQuaternion());
Index: code/branches/network/src/util/Math.h
===================================================================
--- code/branches/network/src/util/Math.h	(revision 1414)
+++ code/branches/network/src/util/Math.h	(revision 1446)
@@ -121,4 +121,13 @@
 
 template <typename T>
+inline int mod(T x, int max)
+{
+    if (x >= 0)
+        return (x % max);
+    else
+        return ((x % max) + max);
+}
+
+template <typename T>
 T interpolate(float time, const T& start, const T& end)
 {
Index: code/branches/network/src/util/MultiType.h
===================================================================
--- code/branches/network/src/util/MultiType.h	(revision 1414)
+++ code/branches/network/src/util/MultiType.h	(revision 1446)
@@ -54,4 +54,5 @@
     MT_vector2,
     MT_vector3,
+    MT_vector4,
     MT_colourvalue,
     MT_quaternion,
Index: code/branches/network/src/util/MultiTypeMath.cc
===================================================================
--- code/branches/network/src/util/MultiTypeMath.cc	(revision 1414)
+++ code/branches/network/src/util/MultiTypeMath.cc	(revision 1446)
@@ -37,4 +37,6 @@
     else if (type == MT_vector3)
         this->vector3_ = orxonox::Vector3(0, 0, 0);
+    else if (type == MT_vector4)
+        this->vector4_ = orxonox::Vector4(0, 0, 0, 0);
     else if (type == MT_colourvalue)
         this->colourvalue_ = orxonox::ColourValue(0, 0, 0, 0);
@@ -55,4 +57,6 @@
         else if (this->type_ == MT_vector3)
             return (this->vector3_ == mtm.vector3_);
+        else if (this->type_ == MT_vector4)
+            return (this->vector4_ == mtm.vector4_);
         else if (this->type_ == MT_colourvalue)
             return (this->colourvalue_ == mtm.colourvalue_);
@@ -68,4 +72,14 @@
 }
 
+bool MultiTypeMath::operator==(const MultiTypeString& mts) const
+{
+    return MultiTypeString::operator==(mts);
+}
+
+bool MultiTypeMath::operator==(const MultiTypePrimitive& mtp) const
+{
+    return MultiTypePrimitive::operator==(mtp);
+}
+
 bool MultiTypeMath::operator!=(const MultiTypeMath& mtm) const
 {
@@ -76,4 +90,6 @@
         else if (this->type_ == MT_vector3)
             return (this->vector3_ != mtm.vector3_);
+        else if (this->type_ == MT_vector4)
+            return (this->vector4_ != mtm.vector4_);
         else if (this->type_ == MT_colourvalue)
             return (this->colourvalue_ != mtm.colourvalue_);
@@ -87,4 +103,14 @@
 
     return true;
+}
+
+bool MultiTypeMath::operator!=(const MultiTypeString& mts) const
+{
+    return MultiTypeString::operator!=(mts);
+}
+
+bool MultiTypeMath::operator!=(const MultiTypePrimitive& mtp) const
+{
+    return MultiTypePrimitive::operator!=(mtp);
 }
 
@@ -123,4 +149,6 @@
 MultiTypeMath::operator orxonox::Vector3() const
 { return (this->type_ == MT_vector3) ? this->vector3_ : getConvertedValue<MultiTypeMath, orxonox::Vector3>(*this); }
+MultiTypeMath::operator orxonox::Vector4() const
+{ return (this->type_ == MT_vector4) ? this->vector4_ : getConvertedValue<MultiTypeMath, orxonox::Vector4>(*this); }
 MultiTypeMath::operator orxonox::Quaternion() const
 { return (this->type_ == MT_quaternion) ? this->quaternion_ : getConvertedValue<MultiTypeMath, orxonox::Quaternion>(*this); }
@@ -137,4 +165,5 @@
     this->vector2_ = mtm.vector2_;
     this->vector3_ = mtm.vector3_;
+    this->vector4_ = mtm.vector4_;
     this->quaternion_ = mtm.quaternion_;
     this->colourvalue_ = mtm.colourvalue_;
@@ -143,4 +172,14 @@
 }
 
+void MultiTypeMath::setValue(const MultiTypeString& mts)
+{
+    MultiTypeString::setValue(mts);
+}
+
+void MultiTypeMath::setValue(const MultiTypePrimitive& mtp)
+{
+    MultiTypePrimitive::setValue(mtp);
+}
+
 std::string MultiTypeMath::getTypename() const
 {
@@ -149,4 +188,6 @@
     else if (this->type_ == MT_vector3)
         return "Vector3";
+    else if (this->type_ == MT_vector4)
+        return "Vector4";
     else if (this->type_ == MT_colourvalue)
         return "ColourValue";
@@ -169,4 +210,6 @@
     else if (this->type_ == MT_vector3)
         ConvertValue(&output, this->vector3_);
+    else if (this->type_ == MT_vector4)
+        ConvertValue(&output, this->vector4_);
     else if (this->type_ == MT_colourvalue)
         ConvertValue(&output, this->colourvalue_);
@@ -189,4 +232,6 @@
     else if (this->type_ == MT_vector3)
         return ConvertValue(&this->vector3_, value, orxonox::Vector3(0, 0, 0));
+    else if (this->type_ == MT_vector4)
+        return ConvertValue(&this->vector4_, value, orxonox::Vector4(0, 0, 0, 0));
     else if (this->type_ == MT_colourvalue)
         return ConvertValue(&this->colourvalue_, value, orxonox::ColourValue(0, 0, 0, 0));
@@ -201,4 +246,54 @@
 }
 
+bool MultiTypeMath::assimilate(const MultiTypeMath& mtm, const MultiTypeMath& defvalue)
+{
+    if (this->type_ == MT_void)
+        return ConvertValue(&this->value_.void_, mtm, defvalue.value_.void_);
+    else if (this->type_ == MT_int)
+        return ConvertValue(&this->value_.int_, mtm, defvalue.value_.int_);
+    else if (this->type_ == MT_uint)
+        return ConvertValue(&this->value_.uint_, mtm, defvalue.value_.uint_);
+    else if (this->type_ == MT_char)
+        return ConvertValue(&this->value_.char_, mtm, defvalue.value_.char_);
+    else if (this->type_ == MT_uchar)
+        return ConvertValue(&this->value_.uchar_, mtm, defvalue.value_.uchar_);
+    else if (this->type_ == MT_short)
+        return ConvertValue(&this->value_.short_, mtm, defvalue.value_.short_);
+    else if (this->type_ == MT_ushort)
+        return ConvertValue(&this->value_.ushort_, mtm, defvalue.value_.ushort_);
+    else if (this->type_ == MT_long)
+        return ConvertValue(&this->value_.long_, mtm, defvalue.value_.long_);
+    else if (this->type_ == MT_ulong)
+        return ConvertValue(&this->value_.ulong_, mtm, defvalue.value_.ulong_);
+    else if (this->type_ == MT_float)
+        return ConvertValue(&this->value_.float_, mtm, defvalue.value_.float_);
+    else if (this->type_ == MT_double)
+        return ConvertValue(&this->value_.double_, mtm, defvalue.value_.double_);
+    else if (this->type_ == MT_longdouble)
+        return ConvertValue(&this->value_.longdouble_, mtm, defvalue.value_.longdouble_);
+    else if (this->type_ == MT_bool)
+        return ConvertValue(&this->value_.bool_, mtm, defvalue.value_.bool_);
+    else if (this->type_ == MT_constchar)
+        return ConvertValue(&this->string_, mtm, defvalue.string_);
+    else if (this->type_ == MT_string)
+        return ConvertValue(&this->string_, mtm, defvalue.string_);
+    else if (this->type_ == MT_vector2)
+        return ConvertValue(&this->vector2_, mtm, defvalue.vector2_);
+    else if (this->type_ == MT_vector3)
+        return ConvertValue(&this->vector3_, mtm, defvalue.vector3_);
+    else if (this->type_ == MT_vector4)
+        return ConvertValue(&this->vector4_, mtm, defvalue.vector4_);
+    else if (this->type_ == MT_colourvalue)
+        return ConvertValue(&this->colourvalue_, mtm, defvalue.colourvalue_);
+    else if (this->type_ == MT_quaternion)
+        return ConvertValue(&this->quaternion_, mtm, defvalue.quaternion_);
+    else if (this->type_ == MT_radian)
+        return ConvertValue(&this->radian_, mtm, defvalue.radian_);
+    else if (this->type_ == MT_degree)
+        return ConvertValue(&this->degree_, mtm, defvalue.degree_);
+    else
+        return false;
+}
+
 std::ostream& operator<<(std::ostream& out, MultiTypeMath& mtm)
 {
Index: code/branches/network/src/util/MultiTypeMath.h
===================================================================
--- code/branches/network/src/util/MultiTypeMath.h	(revision 1414)
+++ code/branches/network/src/util/MultiTypeMath.h	(revision 1446)
@@ -63,4 +63,5 @@
         inline MultiTypeMath(const orxonox::Vector2&     value) { this->setValue(value); }
         inline MultiTypeMath(const orxonox::Vector3&     value) { this->setValue(value); }
+        inline MultiTypeMath(const orxonox::Vector4&     value) { this->setValue(value); }
         inline MultiTypeMath(const orxonox::ColourValue& value) { this->setValue(value); }
         inline MultiTypeMath(const orxonox::Quaternion&  value) { this->setValue(value); }
@@ -68,4 +69,6 @@
         inline MultiTypeMath(const orxonox::Degree&      value) { this->setValue(value); }
         inline MultiTypeMath(const MultiTypeMath& mtm)          { this->setValue(mtm);   }
+        inline MultiTypeMath(const MultiTypeString& mts)        { this->setValue(mts);   }
+        inline MultiTypeMath(const MultiTypePrimitive& mtp)     { this->setValue(mtp);   }
         virtual inline ~MultiTypeMath() {}
 
@@ -73,4 +76,5 @@
         inline MultiTypeMath& operator=(const orxonox::Vector2&     value) { this->setValue(value); return *this; }
         inline MultiTypeMath& operator=(const orxonox::Vector3&     value) { this->setValue(value); return *this; }
+        inline MultiTypeMath& operator=(const orxonox::Vector4&     value) { this->setValue(value); return *this; }
         inline MultiTypeMath& operator=(const orxonox::ColourValue& value) { this->setValue(value); return *this; }
         inline MultiTypeMath& operator=(const orxonox::Quaternion&  value) { this->setValue(value); return *this; }
@@ -78,8 +82,11 @@
         inline MultiTypeMath& operator=(const orxonox::Degree&      value) { this->setValue(value); return *this; }
         inline MultiTypeMath& operator=(const MultiTypeMath& mtm)          { this->setValue(mtm);   return *this; }
+        inline MultiTypeMath& operator=(const MultiTypeString& mts)        { this->setValue(mts);   return *this; }
+        inline MultiTypeMath& operator=(const MultiTypePrimitive mtp)      { this->setValue(mtp);   return *this; }
 
         using MultiTypeString::operator==;
         inline bool operator==(const orxonox::Vector2&     value) const { return (this->vector2_     == value); }
         inline bool operator==(const orxonox::Vector3&     value) const { return (this->vector3_     == value); }
+        inline bool operator==(const orxonox::Vector4&     value) const { return (this->vector4_     == value); }
         inline bool operator==(const orxonox::ColourValue& value) const { return (this->colourvalue_ == value); }
         inline bool operator==(const orxonox::Quaternion&  value) const { return (this->quaternion_  == value); }
@@ -87,8 +94,11 @@
         inline bool operator==(const orxonox::Degree&      value) const { return (this->degree_      == value); }
         bool operator==(const MultiTypeMath& mtm) const;
+        bool operator==(const MultiTypeString& mts) const;
+        bool operator==(const MultiTypePrimitive& mtp) const;
 
         using MultiTypeString::operator!=;
         inline bool operator!=(const orxonox::Vector2&     value) const { return (this->vector2_     != value); }
         inline bool operator!=(const orxonox::Vector3&     value) const { return (this->vector3_     != value); }
+        inline bool operator!=(const orxonox::Vector4&     value) const { return (this->vector4_     != value); }
         inline bool operator!=(const orxonox::ColourValue& value) const { return (this->colourvalue_ != value); }
         inline bool operator!=(const orxonox::Quaternion&  value) const { return (this->quaternion_  != value); }
@@ -96,4 +106,6 @@
         inline bool operator!=(const orxonox::Degree&      value) const { return (this->degree_      != value); }
         bool operator!=(const MultiTypeMath& mtm) const;
+        bool operator!=(const MultiTypeString& mts) const;
+        bool operator!=(const MultiTypePrimitive& mtp) const;
 
         virtual operator void*()                const;
@@ -114,4 +126,5 @@
         virtual operator orxonox::Vector2()     const;
         virtual operator orxonox::Vector3()     const;
+        virtual operator orxonox::Vector4()     const;
         virtual operator orxonox::ColourValue() const;
         virtual operator orxonox::Quaternion()  const;
@@ -122,4 +135,5 @@
         inline void setValue(const orxonox::Vector2&     value) { this->type_ = MT_vector2;     this->vector2_     = value; }
         inline void setValue(const orxonox::Vector3&     value) { this->type_ = MT_vector3;     this->vector3_     = value; }
+        inline void setValue(const orxonox::Vector4&     value) { this->type_ = MT_vector4;     this->vector4_     = value; }
         inline void setValue(const orxonox::ColourValue& value) { this->type_ = MT_colourvalue; this->colourvalue_ = value; }
         inline void setValue(const orxonox::Quaternion&  value) { this->type_ = MT_quaternion;  this->quaternion_  = value; }
@@ -127,7 +141,10 @@
         inline void setValue(const orxonox::Degree&      value) { this->type_ = MT_degree;      this->degree_      = value; }
         void setValue(const MultiTypeMath& mtm);
+        void setValue(const MultiTypeString& mts);
+        void setValue(const MultiTypePrimitive& mtp);
 
         inline orxonox::Vector2     getVector2()     const { return this->vector2_;     }
         inline orxonox::Vector3     getVector3()     const { return this->vector3_;     }
+        inline orxonox::Vector4     getVector4()     const { return this->vector4_;     }
         inline orxonox::ColourValue getColourValue() const { return this->colourvalue_; }
         inline orxonox::Quaternion  getQuaternion()  const { return this->quaternion_;  }
@@ -137,4 +154,5 @@
         inline orxonox::Vector2&     getVector2()     { return this->vector2_;     }
         inline orxonox::Vector3&     getVector3()     { return this->vector3_;     }
+        inline orxonox::Vector4&     getVector4()     { return this->vector4_;     }
         inline orxonox::ColourValue& getColourValue() { return this->colourvalue_; }
         inline orxonox::Quaternion&  getQuaternion()  { return this->quaternion_;  }
@@ -145,4 +163,5 @@
         inline void getValue(orxonox::Vector2*     variable) const { (*variable) = orxonox::Vector2     (this->vector2_);     }
         inline void getValue(orxonox::Vector3*     variable) const { (*variable) = orxonox::Vector3     (this->vector3_);     }
+        inline void getValue(orxonox::Vector4*     variable) const { (*variable) = orxonox::Vector4     (this->vector4_);     }
         inline void getValue(orxonox::ColourValue* variable) const { (*variable) = orxonox::ColourValue (this->colourvalue_); }
         inline void getValue(orxonox::Quaternion*  variable) const { (*variable) = orxonox::Quaternion  (this->quaternion_);  }
@@ -155,7 +174,10 @@
         virtual bool fromString(const std::string value);
 
+        virtual bool assimilate(const MultiTypeMath& mtm, const MultiTypeMath& defvalue = MultiTypeMath());
+
     protected:
         orxonox::Vector2      vector2_;
         orxonox::Vector3      vector3_;
+        orxonox::Vector4      vector4_;
         orxonox::ColourValue  colourvalue_;
         orxonox::Quaternion   quaternion_;
Index: code/branches/network/src/util/MultiTypePrimitive.cc
===================================================================
--- code/branches/network/src/util/MultiTypePrimitive.cc	(revision 1414)
+++ code/branches/network/src/util/MultiTypePrimitive.cc	(revision 1446)
@@ -266,4 +266,37 @@
 }
 
+bool MultiTypePrimitive::assimilate(const MultiTypePrimitive& mtp, const MultiTypePrimitive& defvalue)
+{
+    if (this->type_ == MT_void)
+        return ConvertValue(&this->value_.void_, mtp, defvalue.value_.void_);
+    else if (this->type_ == MT_int)
+        return ConvertValue(&this->value_.int_, mtp, defvalue.value_.int_);
+    else if (this->type_ == MT_uint)
+        return ConvertValue(&this->value_.uint_, mtp, defvalue.value_.uint_);
+    else if (this->type_ == MT_char)
+        return ConvertValue(&this->value_.char_, mtp, defvalue.value_.char_);
+    else if (this->type_ == MT_uchar)
+        return ConvertValue(&this->value_.uchar_, mtp, defvalue.value_.uchar_);
+    else if (this->type_ == MT_short)
+        return ConvertValue(&this->value_.short_, mtp, defvalue.value_.short_);
+    else if (this->type_ == MT_ushort)
+        return ConvertValue(&this->value_.ushort_, mtp, defvalue.value_.ushort_);
+    else if (this->type_ == MT_long)
+        return ConvertValue(&this->value_.long_, mtp, defvalue.value_.long_);
+    else if (this->type_ == MT_ulong)
+        return ConvertValue(&this->value_.ulong_, mtp, defvalue.value_.ulong_);
+    else if (this->type_ == MT_float)
+        return ConvertValue(&this->value_.float_, mtp, defvalue.value_.float_);
+    else if (this->type_ == MT_double)
+        return ConvertValue(&this->value_.double_, mtp, defvalue.value_.double_);
+    else if (this->type_ == MT_longdouble)
+        return ConvertValue(&this->value_.longdouble_, mtp, defvalue.value_.longdouble_);
+    else if (this->type_ == MT_bool)
+        return ConvertValue(&this->value_.bool_, mtp, defvalue.value_.bool_);
+    else
+        return false;
+
+}
+
 std::ostream& operator<<(std::ostream& out, const MultiTypePrimitive& mtp)
 {
Index: code/branches/network/src/util/MultiTypePrimitive.h
===================================================================
--- code/branches/network/src/util/MultiTypePrimitive.h	(revision 1414)
+++ code/branches/network/src/util/MultiTypePrimitive.h	(revision 1446)
@@ -138,5 +138,5 @@
         void setValue(const MultiTypePrimitive& mtp);
 
-        inline void*          getVoid()          const { return this->value_.void_;        }
+        inline void*          getVoid()          const { return this->value_.void_;       }
         inline int            getInt()           const { return this->value_.int_;        }
         inline unsigned int   getUnsignedInt()   const { return this->value_.uint_;       }
@@ -187,4 +187,6 @@
         virtual bool fromString(const std::string value);
 
+        virtual bool assimilate(const MultiTypePrimitive& mtp, const MultiTypePrimitive& defvalue = MultiTypePrimitive());
+
     protected:
         MultiTypeValue  value_;
Index: code/branches/network/src/util/MultiTypeString.cc
===================================================================
--- code/branches/network/src/util/MultiTypeString.cc	(revision 1414)
+++ code/branches/network/src/util/MultiTypeString.cc	(revision 1446)
@@ -33,5 +33,5 @@
 MultiTypeString::MultiTypeString(MultiType type) : MultiTypePrimitive(type)
 {
-    // Nothing to do for string and xml-element
+    // Nothing to do for string
 }
 
@@ -49,4 +49,9 @@
 }
 
+bool MultiTypeString::operator==(const MultiTypePrimitive& mtp) const
+{
+    return MultiTypePrimitive::operator==(mtp);
+}
+
 bool MultiTypeString::operator!=(const MultiTypeString& mts) const
 {
@@ -60,4 +65,9 @@
 
     return true;
+}
+
+bool MultiTypeString::operator!=(const MultiTypePrimitive& mtp) const
+{
+    return MultiTypePrimitive::operator!=(mtp);
 }
 
@@ -99,4 +109,9 @@
 }
 
+void MultiTypeString::setValue(const MultiTypePrimitive& mtp)
+{
+    MultiTypePrimitive::setValue(mtp);
+}
+
 std::string MultiTypeString::getTypename() const
 {
@@ -136,4 +151,40 @@
 }
 
+bool MultiTypeString::assimilate(const MultiTypeString& mts, const MultiTypeString& defvalue)
+{
+    if (this->type_ == MT_void)
+        return ConvertValue(&this->value_.void_, mts, defvalue.value_.void_);
+    else if (this->type_ == MT_int)
+        return ConvertValue(&this->value_.int_, mts, defvalue.value_.int_);
+    else if (this->type_ == MT_uint)
+        return ConvertValue(&this->value_.uint_, mts, defvalue.value_.uint_);
+    else if (this->type_ == MT_char)
+        return ConvertValue(&this->value_.char_, mts, defvalue.value_.char_);
+    else if (this->type_ == MT_uchar)
+        return ConvertValue(&this->value_.uchar_, mts, defvalue.value_.uchar_);
+    else if (this->type_ == MT_short)
+        return ConvertValue(&this->value_.short_, mts, defvalue.value_.short_);
+    else if (this->type_ == MT_ushort)
+        return ConvertValue(&this->value_.ushort_, mts, defvalue.value_.ushort_);
+    else if (this->type_ == MT_long)
+        return ConvertValue(&this->value_.long_, mts, defvalue.value_.long_);
+    else if (this->type_ == MT_ulong)
+        return ConvertValue(&this->value_.ulong_, mts, defvalue.value_.ulong_);
+    else if (this->type_ == MT_float)
+        return ConvertValue(&this->value_.float_, mts, defvalue.value_.float_);
+    else if (this->type_ == MT_double)
+        return ConvertValue(&this->value_.double_, mts, defvalue.value_.double_);
+    else if (this->type_ == MT_longdouble)
+        return ConvertValue(&this->value_.longdouble_, mts, defvalue.value_.longdouble_);
+    else if (this->type_ == MT_bool)
+        return ConvertValue(&this->value_.bool_, mts, defvalue.value_.bool_);
+    else if (this->type_ == MT_constchar)
+        return ConvertValue(&this->string_, mts, defvalue.string_);
+    else if (this->type_ == MT_string)
+        return ConvertValue(&this->string_, mts, defvalue.string_);
+    else
+        return false;
+}
+
 std::ostream& operator<<(std::ostream& out, MultiTypeString& mts)
 {
Index: code/branches/network/src/util/MultiTypeString.h
===================================================================
--- code/branches/network/src/util/MultiTypeString.h	(revision 1414)
+++ code/branches/network/src/util/MultiTypeString.h	(revision 1446)
@@ -61,54 +61,59 @@
         inline MultiTypeString(long double    value) : MultiTypePrimitive(value) {}
         inline MultiTypeString(bool           value) : MultiTypePrimitive(value) {}
-        inline MultiTypeString(const char*           value)   { this->setValue(value); }
-        inline MultiTypeString(const std::string&    value)   { this->setValue(value); }
-        inline MultiTypeString(const MultiTypeString& mts)    { this->setValue(mts);   }
+        inline MultiTypeString(const char*             value) { this->setValue(value); }
+        inline MultiTypeString(const std::string&      value) { this->setValue(value); }
+        inline MultiTypeString(const MultiTypeString&    mts)  { this->setValue(mts);   }
+        inline MultiTypeString(const MultiTypePrimitive& mtp)  { this->setValue(mtp);   }
         virtual inline ~MultiTypeString() {}
 
         using MultiTypePrimitive::operator=;
-        inline MultiTypeString& operator=(const char*             value)   { this->setValue(value); return *this; }
-        inline MultiTypeString& operator=(const std::string&      value)   { this->setValue(value); return *this; }
-        inline MultiTypeString& operator=(const MultiTypeString& mts)      { this->setValue(mts);   return *this; }
+        inline MultiTypeString& operator=(const char*             value) { this->setValue(value); return *this; }
+        inline MultiTypeString& operator=(const std::string&      value) { this->setValue(value); return *this; }
+        inline MultiTypeString& operator=(const MultiTypeString&    mts) { this->setValue(mts);   return *this; }
+        inline MultiTypeString& operator=(const MultiTypePrimitive& mtp) { this->setValue(mtp);   return *this; }
 
         using MultiTypePrimitive::operator==;
-        inline bool operator==(const char*             value) const { return (this->string_      == std::string(value)); }
-        inline bool operator==(const std::string&      value) const { return (this->string_      == value);              }
-        bool operator==(const MultiTypeString& mts) const;
+        inline bool operator==(const char*        value) const { return (this->string_ == std::string(value)); }
+        inline bool operator==(const std::string& value) const { return (this->string_ == value);              }
+        bool operator==(const MultiTypeString&    mts) const;
+        bool operator==(const MultiTypePrimitive& mtp) const;
 
         using MultiTypePrimitive::operator!=;
-        inline bool operator!=(const char*             value) const { return (this->string_      != std::string(value)); }
-        inline bool operator!=(const std::string&      value) const { return (this->string_      != value);              }
-        bool operator!=(const MultiTypeString& mts) const;
+        inline bool operator!=(const char*        value) const { return (this->string_ != std::string(value)); }
+        inline bool operator!=(const std::string& value) const { return (this->string_ != value);              }
+        bool operator!=(const MultiTypeString&    mts) const;
+        bool operator!=(const MultiTypePrimitive& mtp) const;
 
-        virtual operator void*()                const;
-        virtual operator int()                  const;
-        virtual operator unsigned int()         const;
-        virtual operator char()                 const;
-        virtual operator unsigned char()        const;
-        virtual operator short()                const;
-        virtual operator unsigned short()       const;
-        virtual operator long()                 const;
-        virtual operator unsigned long()        const;
-        virtual operator float ()               const;
-        virtual operator double ()              const;
-        virtual operator long double()          const;
-        virtual operator bool()                 const;
-        virtual operator std::string()          const;
-        virtual operator const char*()          const;
+        virtual operator void*()          const;
+        virtual operator int()            const;
+        virtual operator unsigned int()   const;
+        virtual operator char()           const;
+        virtual operator unsigned char()  const;
+        virtual operator short()          const;
+        virtual operator unsigned short() const;
+        virtual operator long()           const;
+        virtual operator unsigned long()  const;
+        virtual operator float ()         const;
+        virtual operator double ()        const;
+        virtual operator long double()    const;
+        virtual operator bool()           const;
+        virtual operator std::string()    const;
+        virtual operator const char*()    const;
 
         using MultiTypePrimitive::setValue;
-        inline void setValue(const char*             value) { this->type_ = MT_string;     this->string_     = std::string(value); }
-        inline void setValue(const std::string&      value) { this->type_ = MT_string;     this->string_     = value;              }
-        void setValue(const MultiTypeString& mts);
+        inline void setValue(const char*        value) { this->type_ = MT_string; this->string_ = std::string(value); }
+        inline void setValue(const std::string& value) { this->type_ = MT_string; this->string_ = value;              }
+        void setValue(const MultiTypeString&    mts);
+        void setValue(const MultiTypePrimitive& mtp);
 
-        inline std::string getString()          const { return this->string_;         }
-        inline const char*  getConstChar()      const { return this->string_.c_str(); }
+        inline std::string getString()     const { return this->string_;         }
+        inline const char*  getConstChar() const { return this->string_.c_str(); }
 
-        inline std::string& getString()          { return this->string_;         }
-        inline const char*  getConstChar()       { return this->string_.c_str(); }
+        inline 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(); }
+        inline void getValue(std::string* variable) const { (*variable) = this->string_;         }
+        inline void getValue(const char** variable) const { (*variable) = this->string_.c_str(); }
 
         virtual std::string getTypename() const;
@@ -116,4 +121,6 @@
         virtual std::string toString() const;
         virtual bool fromString(const std::string value);
+
+        virtual bool assimilate(const MultiTypeString& mts, const MultiTypeString& defvalue = MultiTypeString());
 
     protected:
Index: code/branches/network/src/util/String.cc
===================================================================
--- code/branches/network/src/util/String.cc	(revision 1414)
+++ code/branches/network/src/util/String.cc	(revision 1446)
@@ -185,4 +185,19 @@
     else
         return str;
+}
+
+/**
+    @brief Removes enclosing {braces}.
+    @param str The string to strip
+    @return The striped string
+*/
+std::string stripEnclosingBraces(const std::string& str)
+{
+    std::string output = str;
+
+    while (output.size() >= 2 && output[0] == '{' && output[output.size() - 1] == '}')
+        output = output.substr(1, output.size() - 2);
+
+    return output;
 }
 
Index: code/branches/network/src/util/String.h
===================================================================
--- code/branches/network/src/util/String.h	(revision 1414)
+++ code/branches/network/src/util/String.h	(revision 1446)
@@ -47,4 +47,5 @@
 
 _UtilExport std::string  stripEnclosingQuotes(const std::string& str);
+_UtilExport std::string  stripEnclosingBraces(const std::string& str);
 
 _UtilExport bool         isEmpty(const std::string& str);
