Index: code/branches/core3/src/orxonox/Orxonox.cc
===================================================================
--- code/branches/core3/src/orxonox/Orxonox.cc	(revision 1766)
+++ code/branches/core3/src/orxonox/Orxonox.cc	(revision 1768)
@@ -89,4 +89,6 @@
     static bool convert(orxonox::Radian* output, const char* input)
     {
+        //std::string asdf("asfd");
+        //std::cout << asdf;
         float temp;
         convertValue(&temp, input);
@@ -94,4 +96,6 @@
     }
 };
+
+class FooBar { };
 
 
@@ -217,10 +221,12 @@
     //convertValue(&str, 4.0f);
 
-
-    using ::operator<<;
+    //using ::operator<<;
     using std::string;
     int a = 3;
-    Radian asdf;
-    COUT(3) << asdf;
+    FooBar asdf;
+    std::string asdf2;
+    std::cout << asdf2;
+    ConvertValue(&asdf2, asdf);
+    //COUT(3) << asdf;
 
     TestConv(1, int, (3), float, 3.0);
@@ -232,5 +238,5 @@
     TestConv(7, const char*, ("4.3"), float, 4.3f);
     TestConv(8, const char*, ("4,3"), Vector2, Vector2(4,3));
-    TestConv(9, const char*, ("4.4"), Radian, Radian(4.4));
+    //TestConv(9, const char*, ("4.4"), Radian, Radian(4.4));
     TestConv(100, int, (3), const char*, "3");
     TestConv(101, Vector3, (1, 2, 3), float, 3.0);
Index: code/branches/core3/src/util/ArgReader.cc
===================================================================
--- code/branches/core3/src/util/ArgReader.cc	(revision 1766)
+++ code/branches/core3/src/util/ArgReader.cc	(revision 1768)
@@ -82,5 +82,7 @@
   CmdLineArg arg;
 
-  int a = ImplicitConversion<FooBar, const char*>::exists;
+  //std::cout << errorString_;
+
+  int a = conversionTests::ImplicitConversion<FooBar, const char*>::exists;
   int val1;
   long long val2 = conversion_cast<long long>(val1);
Index: code/branches/core3/src/util/Convert.h
===================================================================
--- code/branches/core3/src/util/Convert.h	(revision 1766)
+++ code/branches/core3/src/util/Convert.h	(revision 1768)
@@ -50,9 +50,4 @@
 #endif
 
-///////////////////////////////////
-// Explicit Conversion Functions //
-///////////////////////////////////
-
-
 ///////////////////////////////////////////////
 // Static detection for conversion functions //
@@ -96,10 +91,4 @@
 	    return *(new conversionTests::VeryBigStruct());
     }
-}
-
-namespace conversionTests
-{
-    // Part of the msvc hack. See above in the namespace for more explanations.
-    using namespace separate_namespace;
 
     // These operators simply accept anything but have lower priority than specialisations
@@ -111,4 +100,10 @@
     template <class Any>
     conversionTests::VeryBigStruct operator>>(std::istream& instream,  const Any anything);
+}
+
+namespace conversionTests
+{
+    // Part of the msvc hack. See above in the namespace for more explanations.
+    using namespace separate_namespace;
 
     template <class FromType, class ToType>
@@ -144,5 +139,5 @@
     {
         IStringStreamOperator(); IStringStreamOperator(const IStringStreamOperator&); ~IStringStreamOperator();
-        static std::istringstream istream_; // helper object to perform the '>>' operation
+        static std::istream istream_; // helper object to perform the '>>' operation
         static Type object;                 // helper object to handle private c'tor and d'tor
     public:
@@ -154,5 +149,5 @@
     {
         OStringStreamOperator(); OStringStreamOperator(const OStringStreamOperator&); ~OStringStreamOperator();
-        static std::ostringstream ostream_; // helper object to perform the '<<' operation
+        static std::ostream ostream_; // helper object to perform the '<<' operation
         static Type object;                 // helper object to handle private c'tor and d'tor
     public:
@@ -169,7 +164,7 @@
     Usage: ImplicitConversion<FromType, ToType>::exists
 */
-template <class FromType, class ToType>
-struct ImplicitConversion
-{ enum { exists = conversionTests::ImplicitConversion<FromType, ToType>::exists }; };
+//template <class FromType, class ToType>
+//struct ImplicitConversion
+//{ enum { exists = conversionTests::asdf::ImplicitConversion<FromType, ToType>::exists }; };
 
 /**
@@ -179,7 +174,7 @@
     Usage: ExplicitConversion<FromType, ToType>::exists
 */
-template <class FromType, class ToType>
-struct ExplicitConversion
-{ enum { exists = conversionTests::ExplicitConversion<FromType, ToType>::exists }; };
+//template <class FromType, class ToType>
+//struct ExplicitConversion
+//{ enum { exists = conversionTests::asdf::ExplicitConversion<FromType, ToType>::exists }; };
 
 /**
@@ -189,7 +184,7 @@
     Usage: IStringStreamConversion<FromType, ToType>::exists
 */
-template <class Type>
-struct IStringStreamOperator
-{ enum { exists = conversionTests::IStringStreamOperator<Type>::exists }; };
+//template <class Type>
+//struct IStringStreamOperator
+//{ enum { exists = conversionTests::asdf::IStringStreamOperator<Type>::exists }; };
 
 /**
@@ -199,7 +194,7 @@
     Usage: OStringStreamConversion<FromType, ToType>::exists
 */
-template <class Type>
-struct OStringStreamOperator
-{ enum { exists = conversionTests::OStringStreamOperator<Type>::exists }; };
+//template <class Type>
+//struct OStringStreamOperator
+//{ enum { exists = conversionTests::asdf::OStringStreamOperator<Type>::exists }; };
 
 
@@ -286,5 +281,5 @@
         static bool convert(std::string* output, const FromType& input)
         {
-            const bool probe = OStringStreamOperator<FromType>::exists;
+            const bool probe = conversionTests::OStringStreamOperator<FromType>::exists;
             return convert(output, input, StringStreamPossible<probe>());
         }
@@ -328,5 +323,5 @@
         static bool convert(ToType* output, const std::string& input)
         {
-            const bool probe = IStringStreamOperator<ToType>::exists;
+            const bool probe = conversionTests::IStringStreamOperator<ToType>::exists;
             return convert(output, input, StringStreamPossible<probe>());
         }
@@ -381,5 +376,5 @@
     inline bool convert(ToType* output, const FromType& input, ExplicitPossible<false>)
     {
-        const bool probe = ImplicitConversion<FromType, ToType>::exists;
+        const bool probe = conversionTests::ImplicitConversion<FromType, ToType>::exists;
         return convert(output, input, ImplicitPossible<probe>());
     }
@@ -398,5 +393,5 @@
     {
         // check for explicit conversion via function overloading
-        const bool probe = ExplicitConversion<FromType, ToType>::exists;
+        const bool probe = conversionTests::ExplicitConversion<FromType, ToType>::exists;
         return conversion::convert(output, input, conversion::ExplicitPossible<probe>());
     }
Index: code/branches/core3/src/util/Math.h
===================================================================
--- code/branches/core3/src/util/Math.h	(revision 1766)
+++ code/branches/core3/src/util/Math.h	(revision 1768)
@@ -70,14 +70,14 @@
 
 // Vector2 to std::string
-inline bool explicitConversion(std::string* output, const orxonox::Vector2& input)
-{
-    std::ostringstream ostream;
-    if (ostream << input.x << "," << input.y)
-    {
-        (*output) = ostream.str();
-        return true;
-    }
-    return false;
-}
+//inline bool explicitConversion(std::string* output, const orxonox::Vector2& input)
+//{
+//    std::ostringstream ostream;
+//    if (ostream << input.x << "," << input.y)
+//    {
+//        (*output) = ostream.str();
+//        return true;
+//    }
+//    return false;
+//}
 
 // Vector3 to std::string
Index: code/branches/core3/src/util/MultiType.h
===================================================================
--- code/branches/core3/src/util/MultiType.h	(revision 1766)
+++ code/branches/core3/src/util/MultiType.h	(revision 1768)
@@ -129,4 +129,6 @@
 
         virtual void toString(std::ostream& outstream) const = 0;
+        //virtual void toString(std::ostream& outstream) const = 0;
+        //inline friend virtual std::ostream& operator <<(std::ostream& outstream, const MT_ValueBase& mtb);
 
         MT_Type type_;
@@ -238,4 +240,6 @@
         template <class T> operator T*() const { return ((T*)this->operator void*()); }
 
+        inline friend std::ostream& operator<<(std::ostream& outstream, const MultiType& mt) { if (mt.value_) { mt.value_->toString(outstream); } return outstream; }
+
         inline void getValue(char*                 value) const { if (this->value_) { (*value) = (*this->value_); } }
         inline void getValue(unsigned char*        value) const { if (this->value_) { (*value) = (*this->value_); } }
@@ -318,5 +322,5 @@
 };
 
-_UtilExport inline std::ostream& operator<<(std::ostream& outstream, const MultiType& mt) { if (mt.value_) { mt.value_->toString(outstream); } return outstream; }
+//_UtilExport inline std::ostream& operator<<(std::ostream& outstream, const MultiType& mt) { if (mt.value_) { mt.value_->toString(outstream); } return outstream; }
 
 template <> inline bool MultiType::isType<char>()                 const { return (this->value_ && this->value_->type_ == MT_char);        }
Index: code/branches/core3/src/util/MultiTypeValue.h
===================================================================
--- code/branches/core3/src/util/MultiTypeValue.h	(revision 1766)
+++ code/branches/core3/src/util/MultiTypeValue.h	(revision 1768)
@@ -91,5 +91,6 @@
     inline operator orxonox::Degree()      const { return getConvertedValue<T, orxonox::Degree>     (this->value_); }
 
-    inline void toString(std::ostream& outstream) const { outstream << this->value_; }
+    inline void toString(std::ostream& outstream) const { std::operator <<(outstream, conversion_cast<std::string>(this->value_)); }
+    //inline friend std::ostream& operator <<(std::ostream& outstream, const MT_Value& mtv) { outstream << conversion_cast<std::string>(this->value_); return outsream; }
 
     T value_;
