Changeset 1766

Timestamp:

Sep 11, 2008, 12:25:11 AM (16 years ago)

Author:

rgrieder

Message:

test files, no real content.

Location:

code/branches/core3/src

Files:

• orxonox/Orxonox.cc (modified) (2 diffs)
• orxonox/Orxonox.h (modified) (1 diff)
• orxonox/OrxonoxStableHeaders.h (modified) (1 diff)
• util/ArgReader.cc (modified) (2 diffs)
• util/Convert.h (modified) (3 diffs)
• util/Math.cc (modified) (1 diff)
• util/Math.h (modified) (2 diffs)
• util/OutputHandler.h (modified) (1 diff)

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

@@ -77 +77 @@
 #include "Settings.h"
 
+#define TestConv(nr, Type1, var1, Type2, res) \
+    Type1 var##nr##1##var1; \
+    Type2 var##nr##2; \
+    assert(ConvertValue(&var##nr##2, var##nr##1)); \
+    COUT(0) << "Converting " << #var1 << " (" << #Type1 << ") to " << var##nr##2 << " (" #Type2 << ")." << std::endl; \
+    assert(res == var##nr##2)
+
+template <>
+struct ConverterExplicit<orxonox::Radian, const char*>
+{
+    static bool convert(orxonox::Radian* output, const char* input)
+    {
+        float temp;
+        convertValue(&temp, input);
+        *output = temp;
+    }
+};
+
 
 // FIXME: is this really file scope?
@@ -189 +207 @@
 #endif
     Factory::createClassHierarchy();
+
+    Radian nmbr;
+    float res;
+    //const char* nmbr;
+    //const char* str;
+    convertValue(&res, nmbr);
+    //const unsigned int blah = 4;
+    //convertValue(nmbr, blah);
+    //convertValue(&str, 4.0f);
+
+
+    using ::operator<<;
+    using std::string;
+    int a = 3;
+    Radian asdf;
+    COUT(3) << asdf;
+
+    TestConv(1, int, (3), float, 3.0);
+    TestConv(2, int, (3), string, "3");
+    TestConv(3, string, ("3.0"), float, 3.0f);
+    TestConv(4, char, ('a'), string, "a");
+    TestConv(5, string, ("df"), char, 'd');
+    TestConv(6, Vector2, (3,4), string, "3,4");
+    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(100, int, (3), const char*, "3");
+    TestConv(101, Vector3, (1, 2, 3), float, 3.0);
+
+    std::ostringstream out;
 
     std::string mode;

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

@@ -35 +35 @@
 #ifndef _Orxonox_H__
 #define _Orxonox_H__
+inline bool explicitConversion(float* output, const double input)
+{
+    *output = 2*input;
+    return true;
+}
 
 #include "OrxonoxPrereqs.h"

code/branches/core3/src/orxonox/OrxonoxStableHeaders.h

@@ -35 +35 @@
 #define _OrxonoxStableHeaders_H__
 
-#include "util/OrxonoxPlatform.h"
+#include "OrxonoxPrereqs.h"
 
 #if ORXONOX_COMPILER == ORXONOX_COMPILER_MSVC

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

@@ -34 +34 @@
 #include "ArgReader.h"
 #include "SubString.h"
+#include <ostream>
+#include <iostream>
+
+class FooBar
+{
+    //friend class ArgReader;
+public:
+    operator long long() const
+    {
+        return 0;
+    }
+    float float_;
+    static FooBar& createFooBar();
+private:
+    //FooBar();
+    //FooBar(const FooBar& instance);
+    //~FooBar();
+};
+
+inline std::ostream& operator<<(std::ostream& outstream, const FooBar& fb)
+{
+    return outstream << fb.float_;
+}
+inline std::istream& operator>>(std::istream& instream,  const FooBar& fb);
+//inline bool explicitConversion(const char** output, const FooBar input)
+//{
+//    return true;
+//}
+
+#include "Convert.h"
+
+template<>
+struct ConverterExplicit<const char*, FooBar>
+{
+    static bool convert(const char** output, const FooBar input)
+    {
+        return true;
+    }
+};
+
+#include "MultiType.h"
 
 ArgReader::ArgReader(int argc, char **argv)
@@ -40 +81 @@
   errorString_ = "";
   CmdLineArg arg;
+
+  int a = ImplicitConversion<FooBar, const char*>::exists;
+  int val1;
+  long long val2 = conversion_cast<long long>(val1);
+  //val2 = val1;
+  //convertValue(&val2, val1);
+  //explicitConversion(&FooBar(), val1);
+
+  //using namespace1::fooBar1;
+  //fooBar1();
+  //int val1;
+  //char val2;
+  //explicitConversion(&val1, val2);
+
+  std::istringstream asdf;
+  //asdf >> val2;
 
   int i = 1;

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

@@ -483 +483 @@
 ///////////////////////////////////////
 
-// delegate conversion from const char* via std::string
+// delegate conversion from const char* to std::string
 template <class ToType>
 struct ConverterExplicit<ToType, const char*>
 {
-    // convert from const char* via std::string
     static bool convert(ToType* output, const char* input)
     {
-        return conversion::ConverterSS<ToType, std::string, 0>::convert(output, input);
+        return ConverterExplicit<ToType, std::string>::convert(output, input);
     }
 };
@@ -499 +498 @@
     static bool convert(std::string* output, const char input)
     {
-        *output = std::string(input, 1);
+        *output = std::string(1, input);
         return true;
     }
@@ -507 +506 @@
     static bool convert(std::string* output, const unsigned char input)
     {
-        *output = std::string(input, 1);
+        *output = std::string(1, input);
         return true;
     }

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

@@ -27 +27 @@
  */
 
+#include "Math.h"
+
 #include <OgrePlane.h>
-
-#include "Math.h"
 #include "Convert.h"
 

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

@@ -55 +55 @@
 }
 
-_UtilExport std::ostream& operator<<(std::ostream& out, const orxonox::Radian& radian);
+_UtilExport std::ostream& operator<<(std::ostream& out, const Ogre::Radian& radian);
 _UtilExport std::istream& operator>>(std::istream& in, orxonox::Radian& radian);
 _UtilExport std::ostream& operator<<(std::ostream& out, const orxonox::Degree& degree);
@@ -128 +128 @@
     return false;
 }
+
+//// ColourValue to std::string
+//inline bool explicitConversion(std::string* output, const orxonox::ColourValue& input)
+//{
+//    std::ostringstream ostream;
+//    if (ostream << input.r << "," << input.g << "," << input.b << "," << input.a)
+//    {
+//        (*output) = ostream.str();
+//        return true;
+//    }
+//    return false;
+//}
 
 // std::string to Vector2

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

@@ -201 +201 @@
     }
 }
+//template<class T>
+//orxonox::OutputHandler& operator<<(orxonox::OutputHandler& out, const T& output)
+//{
+//    if (orxonox::OutputHandler::getSoftDebugLevel(orxonox::OutputHandler::LD_Console) >= out.getOutputLevel())
+//        std::cout << output;
+//
+//    if (orxonox::OutputHandler::getSoftDebugLevel(orxonox::OutputHandler::LD_Logfile) >= out.getOutputLevel())
+//    {
+//        out.getLogfile() << output;
+//        out.getLogfile().flush();
+//    }
+//
+//    if (orxonox::OutputHandler::getSoftDebugLevel(orxonox::OutputHandler::LD_Shell) >= out.getOutputLevel())
+//        (*out.getOutputBuffer()) << output;
+//
+//    return out;
+//}
 
 #endif /* _OutputHandler_H__ */