Changeset 1768 for code

Timestamp:

Sep 11, 2008, 4:40:01 PM (16 years ago)

Author:

rgrieder

Message:

gcc test commit again

Location:

code/branches/core3/src

Files:

• orxonox/Orxonox.cc (modified) (4 diffs)
• util/ArgReader.cc (modified) (1 diff)
• util/Convert.h (modified) (13 diffs)
• util/Math.h (modified) (1 diff)
• util/MultiType.h (modified) (3 diffs)
• util/MultiTypeValue.h (modified) (1 diff)

code/branches/core3/src/orxonox/Orxonox.cc

@@ -89 +89 @@
     static bool convert(orxonox::Radian* output, const char* input)
     {
+        //std::string asdf("asfd");
+        //std::cout << asdf;
         float temp;
         convertValue(&temp, input);
@@ -94 +96 @@
     }
 };
+
+class FooBar { };
 
 
@@ -217 +221 @@
     //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 +238 @@
     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);

code/branches/core3/src/util/ArgReader.cc

@@ -82 +82 @@
   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);

code/branches/core3/src/util/Convert.h

@@ -50 +50 @@
 #endif
 
-///////////////////////////////////
-// Explicit Conversion Functions //
-///////////////////////////////////
-
-
 ///////////////////////////////////////////////
 // Static detection for conversion functions //
@@ -96 +91 @@
             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 +100 @@
     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 +139 @@
     {
         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 +149 @@
     {
         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 +164 @@
     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 +174 @@
     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 +184 @@
     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 +194 @@
     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 +281 @@
         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 +323 @@
         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 +376 @@
     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 +393 @@
     {
         // 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>());
     }

code/branches/core3/src/util/Math.h

@@ -70 +70 @@
 
 // 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

code/branches/core3/src/util/MultiType.h

@@ -129 +129 @@
 
         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 +240 @@
         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 +322 @@
 };
 
-_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);        }

code/branches/core3/src/util/MultiTypeValue.h

@@ -91 +91 @@
     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_;