Changeset 2111 for code/branches/objecthierarchy/src/util

Timestamp:

Nov 2, 2008, 12:38:26 PM (16 years ago)

Author:

rgrieder

Message:

Moved all util classes and functions to orxonox namespace.
Converted all code to 4 spaces/tab in util.

Location:

code/branches/objecthierarchy/src/util

Files:

• CRC32.cc (modified) (1 diff)
• CRC32.h (modified) (1 diff)
• Clipboard.cc (modified) (3 diffs)
• Clipboard.h (modified) (1 diff)
• Convert.h (modified) (6 diffs)
• Debug.h (modified) (15 diffs)
• Exception.cc (modified) (1 diff)
• Exception.h (modified) (2 diffs)
• ExprParser.cc (modified) (1 diff)
• ExprParser.h (modified) (1 diff)
• Math.cc (modified) (1 diff)
• Math.h (modified) (2 diffs)
• MathConvert.h (modified) (1 diff)
• MultiType.cc (modified) (1 diff)
• MultiType.h (modified) (1 diff)
• MultiTypeValue.h (modified) (1 diff)
• OutputBuffer.h (modified) (1 diff)
• SignalHandler.cc (modified) (2 diffs)
• SignalHandler.h (modified) (1 diff)
• Sleep.h (modified) (2 diffs)
• String.cc (modified) (1 diff)
• String.h (modified) (1 diff)
• SubString.cc (modified) (1 diff)
• SubString.h (modified) (1 diff)
• UtilPrereqs.h (modified) (1 diff)

code/branches/objecthierarchy/src/util/CRC32.cc

@@ -29 +29 @@
 #include "CRC32.h"
 
+namespace orxonox
+{
+    void calcCRCBit(uint32_t &crc32, int bit)
+    {
+        int hbit = (crc32 & 0x80000000) ? 1 : 0;
+        if (hbit != bit)
+            crc32 = (crc32 << 1) ^ UTIL_CRC32POLY;
+        else
+            crc32 = crc32 << 1;
+      }
 
-void calcCRCBit(uint32_t &crc32, int bit){
-    int hbit;
+    uint32_t calcCRC(unsigned char *data, unsigned int dataLength)
+    {
+        uint32_t crc32 = 0;
+        for(unsigned int i = 0; i < dataLength; i++)
+        {
+            calcCRCBit(crc32, (data[i] & 0x1) >> 0); // 1st bit
+            calcCRCBit(crc32, (data[i] & 0x2) >> 1); // 2nd bit
+            calcCRCBit(crc32, (data[i] & 0x3) >> 2); // 3rd bit
+            calcCRCBit(crc32, (data[i] & 0x4) >> 3); // 4th bit
+            calcCRCBit(crc32, (data[i] & 0x5) >> 4); // 5th bit
+            calcCRCBit(crc32, (data[i] & 0x6) >> 5); // 6th bit
+            calcCRCBit(crc32, (data[i] & 0x7) >> 6); // 7th bit
+            calcCRCBit(crc32, (data[i] & 0x8) >> 7); // 8th bit
+        }
+        return crc32;
+    }
+}
 
-    hbit=(crc32 & 0x80000000) ? 1 : 0;
-    if (hbit != bit)
-      crc32=(crc32<<1) ^ UTIL_CRC32POLY;
-    else
-      crc32=crc32<<1;
-  }
-
-  uint32_t calcCRC(unsigned char *data, unsigned int dataLength){
-    uint32_t crc32=0;
-    for(unsigned int i=0; i<dataLength; i++){
-      calcCRCBit(crc32, (data[i]&0x1)>>0); // 1st bit
-      calcCRCBit(crc32, (data[i]&0x2)>>1); // 2nd bit
-      calcCRCBit(crc32, (data[i]&0x3)>>2); // 3rd bit
-      calcCRCBit(crc32, (data[i]&0x4)>>3); // 4th bit
-      calcCRCBit(crc32, (data[i]&0x5)>>4); // 5th bit
-      calcCRCBit(crc32, (data[i]&0x6)>>5); // 6th bit
-      calcCRCBit(crc32, (data[i]&0x7)>>6); // 7th bit
-      calcCRCBit(crc32, (data[i]&0x8)>>7); // 8th bit
-    }
-    return crc32;
-  }
-

code/branches/objecthierarchy/src/util/CRC32.h

@@ -34 +34 @@
 #include "Integers.h"
 
-const unsigned int UTIL_CRC32POLY = 0x04C11DB7; /* CRC-32 Polynom */
+namespace orxonox
+{
+    const unsigned int UTIL_CRC32POLY = 0x04C11DB7; /* CRC-32 Polynom */
 
-_UtilExport void calcCRCBit(uint32_t &crc32, int bit);
+    _UtilExport void calcCRCBit(uint32_t &crc32, int bit);
 
-_UtilExport uint32_t calcCRC(unsigned char *data, unsigned int dataLength);
-
+    _UtilExport uint32_t calcCRC(unsigned char *data, unsigned int dataLength);
+}
 
 #endif /* _Util_CRC_H__ */

code/branches/objecthierarchy/src/util/Clipboard.cc

@@ -37 +37 @@
 
 #if ORXONOX_PLATFORM == ORXONOX_PLATFORM_WIN32
-    /////////////
-    // Windows //
-    /////////////
-    #include <windows.h>
-    #include "Debug.h"
+
+/////////////
+// Windows //
+/////////////
+
+#include <windows.h>
+#include "Debug.h"
+
+namespace orxonox
+{
 
     /**
@@ -97 +102 @@
         return "";
     }
-#else
-    /////////////
-    // Default //
-    /////////////
+}
 
+#else /* ORXONOX_PLATFORM == ORXONOX_PLATFORM_WIN32 */
+
+/////////////
+// Default //
+/////////////
+
+namespace orxonox
+{
     std::string clipboard = ""; //!< Keeps the text of our internal clipboard
 
@@ -123 +133 @@
         return clipboard;
     }
-#endif
+}
+
+#endif /* ORXONOX_PLATFORM == ORXONOX_PLATFORM_WIN32 */

code/branches/objecthierarchy/src/util/Clipboard.h

@@ -46 +46 @@
 #include <string>
 
-
-_UtilExport bool toClipboard(const std::string& text);
-_UtilExport std::string fromClipboard();
-
+namespace orxonox
+{
+    _UtilExport bool toClipboard(const std::string& text);
+    _UtilExport std::string fromClipboard();
+}
 
 #endif /* _Clipboard_H__ */

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

@@ -68 +68 @@
 #endif
 
-template <class FromType, class ToType>
-class ImplicitConversion
-{
-private:
-    ImplicitConversion(); ImplicitConversion(const ImplicitConversion&); ~ImplicitConversion();
-    // Gets chosen only if there is an implicit conversion from FromType to ToType.
-    static char test(ToType);
-    // Accepts any argument. Why do we not use a template? The reason is that with templates,
-    // the function above is only taken iff it is an exact type match. But since we want to
-    // check for implicit conversion, we have to use the ellipsis.
-    static long long test(...);
-    static FromType object; // helper object to handle private c'tor and d'tor
-public:
-    // test(object) only has 'long long' return type iff the compiler doesn't choose test(...)
-    enum { exists = (sizeof(test(object)) == sizeof(char)) };
-};
+namespace orxonox
+{
+    template <class FromType, class ToType>
+    class ImplicitConversion
+    {
+    private:
+        ImplicitConversion(); ImplicitConversion(const ImplicitConversion&); ~ImplicitConversion();
+        // Gets chosen only if there is an implicit conversion from FromType to ToType.
+        static char test(ToType);
+        // Accepts any argument. Why do we not use a template? The reason is that with templates,
+        // the function above is only taken iff it is an exact type match. But since we want to
+        // check for implicit conversion, we have to use the ellipsis.
+        static long long test(...);
+        static FromType object; // helper object to handle private c'tor and d'tor
+    public:
+        // test(object) only has 'long long' return type iff the compiler doesn't choose test(...)
+        enum { exists = (sizeof(test(object)) == sizeof(char)) };
+    };
+}
 
 #if ORXONOX_COMPILER == ORXONOX_COMPILER_MSVC
@@ -118 +121 @@
 */
 
-namespace
-{
-    //! Little template that maps integers to entire types (Alexandrescu 2001)
-    template <int I>
-    struct Int2Type { };
+namespace orxonox
+{
+    namespace
+    {
+        //! Little template that maps integers to entire types (Alexandrescu 2001)
+        template <int I>
+        struct Int2Type { };
+    }
+
+
+    ///////////////////
+    // No Conversion //
+    ///////////////////
+
+    // Default template. No conversion available at all.
+    template <class FromType, class ToType>
+    struct ConverterFallback
+    {
+        static bool convert(ToType* output, const FromType& input)
+        {
+            COUT(2) << "Could not convert value of type " << typeid(FromType).name()
+                    << " to type " << typeid(ToType).name() << std::endl;
+            return false;
+        }
+    };
+
+    // If all else fails, try a dynamic_cast for pointer types.
+    template <class FromType, class ToType>
+    struct ConverterFallback<FromType*, ToType*>
+    {
+        static bool convert(ToType** output, FromType* const input)
+        {
+            ToType* temp = dynamic_cast<ToType*>(input);
+            if (temp)
+            {
+                *output = temp;
+                return true;
+            }
+            else
+                return false;
+        }
+    };
 }
-
-
-///////////////////
-// No Conversion //
-///////////////////
-
-// Default template. No conversion available at all.
-template <class FromType, class ToType>
-struct ConverterFallback
-{
-    static bool convert(ToType* output, const FromType& input)
-    {
-        COUT(2) << "Could not convert value of type " << typeid(FromType).name()
-                << " to type " << typeid(ToType).name() << std::endl;
-        return false;
-    }
-};
-
-// If all else fails, try a dynamic_cast for pointer types.
-template <class FromType, class ToType>
-struct ConverterFallback<FromType*, ToType*>
-{
-    static bool convert(ToType** output, FromType* const input)
-    {
-        ToType* temp = dynamic_cast<ToType*>(input);
-        if (temp)
-        {
-            *output = temp;
-            return true;
-        }
-        else
-            return false;
-    }
-};
 
 
@@ -170 +176 @@
     static bool convert(ToType* output, const FromType& input)
     {
-        return ConverterFallback<FromType, ToType>::convert(output, input);
+        return orxonox::ConverterFallback<FromType, ToType>::convert(output, input);
     }
 };
@@ -185 +191 @@
     {
         std::string temp;
-        if (ConverterFallback<FromType, std::string>::convert(&temp, input))
+        if (orxonox::ConverterFallback<FromType, std::string>::convert(&temp, input))
         {
             std::operator <<(outstream, temp);
@@ -224 +230 @@
     inline bool operator >>(std::istream& instream, ToType& output)
     {
-        return ConverterFallback<std::string, ToType>
+        return orxonox::ConverterFallback<std::string, ToType>
             ::convert(&output, static_cast<std::istringstream&>(instream).str());
     }
@@ -247 +253 @@
 };
 
-
-///////////////////
-// Implicit Cast //
-///////////////////
-
-// implicit cast not possible, try stringstream conversion next
-template <class FromType, class ToType>
-inline bool convertImplicitely(ToType* output, const FromType& input, ::Int2Type<false>)
-{
-    return ConverterStringStream<FromType, ToType>::convert(output, input);
+namespace orxonox
+{
+
+    ///////////////////
+    // Implicit Cast //
+    ///////////////////
+
+    // implicit cast not possible, try stringstream conversion next
+    template <class FromType, class ToType>
+    inline bool convertImplicitely(ToType* output, const FromType& input, orxonox::Int2Type<false>)
+    {
+        return ConverterStringStream<FromType, ToType>::convert(output, input);
+    }
+
+    // We can cast implicitely
+    template <class FromType, class ToType>
+    inline bool convertImplicitely(ToType* output, const FromType& input, orxonox::Int2Type<true>)
+    {
+        (*output) = static_cast<ToType>(input);
+        return true;
+    }
+
+
+    ////////////////////////////////
+    // ConverterExplicit Fallback //
+    ////////////////////////////////
+
+    // Default template if no specialisation is available
+    template <class FromType, class ToType>
+    struct ConverterExplicit
+    {
+        static bool convert(ToType* output, const FromType& input)
+        {
+            // Try implict cast and probe first. If a simple cast is not possible, it will not compile
+            // We therefore have to out source it into another template function
+            const bool probe = ImplicitConversion<FromType, ToType>::exists;
+            return convertImplicitely(output, input, orxonox::Int2Type<probe>());
+        }
+    };
+
+
+    //////////////////////
+    // Public Functions //
+    //////////////////////
+
+    /**
+    @brief
+        Converts any value to any other as long as there exists a conversion.
+        Otherwise, the conversion will generate a runtime warning and return false.
+        For information about the different conversion methods (user defined too), see the section
+        'Actual conversion sequence' in this file above.
+    */
+    template <class FromType, class ToType>
+    inline bool convertValue(ToType* output, const FromType& input)
+    {
+        return ConverterExplicit<FromType, ToType>::convert(output, input);
+    }
+
+    // For compatibility reasons. The same, but with capital ConvertValue
+    template<class FromType, class ToType>
+    inline bool ConvertValue(ToType* output, const FromType& input)
+    {
+        return convertValue(output, input);
+    }
+
+    // Calls convertValue and returns true if the conversion was successful.
+    // Otherwise the fallback is used.
+    /**
+    @brief
+        Converts any value to any other as long as there exists a conversion.
+        Otherwise, the conversion will generate a runtime warning and return false.
+        For information about the different conversion methods (user defined too), see the section
+        'Actual conversion sequence' in this file above.
+        If the conversion doesn't succeed, 'fallback' is written to '*output'.
+    @param fallback
+        A default value that gets written to '*output' if there is no conversion.
+    */
+    template<class FromType, class ToType>
+    inline bool convertValue(ToType* output, const FromType& input, const ToType& fallback)
+    {
+        if (convertValue(output, input))
+            return true;
+        else
+        {
+            (*output) = fallback;
+            return false;
+        }
+    }
+
+    // for compatibility reason. (capital 'c' in ConvertValue)
+    template<class FromType, class ToType>
+    inline bool ConvertValue(ToType* output, const FromType& input, const ToType& fallback)
+    {
+        return convertValue(output, input, fallback);
+    }
+
+    // Directly returns the converted value, even if the conversion was not successful.
+    template<class FromType, class ToType>
+    inline ToType getConvertedValue(const FromType& input)
+    {
+        ToType output;
+        convertValue(&output, input);
+        return output;
+    }
+
+    // Directly returns the converted value, but uses the fallback on failure.
+    template<class FromType, class ToType>
+    inline ToType getConvertedValue(const FromType& input, const ToType& fallback)
+    {
+        ToType output;
+        convertValue(&output, input, fallback);
+        return output;
+    }
+
+    // Like getConvertedValue, but the template argument order is in reverse.
+    // That means you can call it exactly like static_cast<ToType>(fromTypeValue).
+    template<class ToType, class FromType>
+    inline ToType omni_cast(const FromType& input)
+    {
+        ToType output;
+        convertValue(&output, input);
+        return output;
+    }
+
+    // convert to string Shortcut
+    template <class FromType>
+    inline std::string convertToString(FromType value)
+    {
+      return getConvertedValue<FromType, std::string>(value);
+    }
+
+    // convert from string Shortcut
+    template <class ToType>
+    inline ToType convertFromString(std::string str)
+    {
+      return getConvertedValue<std::string, ToType>(str);
+    }
+
+    ////////////////////////////////
+    // Special string conversions //
+    ////////////////////////////////
+
+    // Delegate conversion from const char* to std::string
+    template <class ToType>
+    struct ConverterExplicit<const char*, ToType>
+    {
+        static bool convert(ToType* output, const char* input)
+        {
+            return convertValue<std::string, ToType>(output, input);
+        }
+    };
+
+    // These conversions would exhibit ambiguous << or >> operators when using stringstream
+    template <>
+    struct ConverterExplicit<char, std::string>
+    {
+        static bool convert(std::string* output, const char input)
+        {
+            *output = std::string(1, input);
+            return true;
+        }
+    };
+    template <>
+    struct ConverterExplicit<unsigned char, std::string>
+    {
+        static bool convert(std::string* output, const unsigned char input)
+        {
+            *output = std::string(1, input);
+            return true;
+        }
+    };
+    template <>
+    struct ConverterExplicit<std::string, char>
+    {
+        static bool convert(char* output, const std::string input)
+        {
+            if (input != "")
+                *output = input[0];
+            else
+                *output = '\0';
+            return true;
+        }
+    };
+    template <>
+    struct ConverterExplicit<std::string, unsigned char>
+    {
+        static bool convert(unsigned char* output, const std::string input)
+        {
+            if (input != "")
+                *output = input[0];
+            else
+                *output = '\0';
+            return true;
+        }
+    };
+
+
+    // bool to std::string
+    template <>
+    struct ConverterExplicit<bool, std::string>
+    {
+        static bool convert(std::string* output, const bool& input)
+        {
+            if (input)
+              *output = "true";
+            else
+              *output = "false";
+            return false;
+        }
+    };
+
+    // std::string to bool
+    template <>
+    struct ConverterExplicit<std::string, bool>
+    {
+        static bool convert(bool* output, const std::string& input)
+        {
+            std::string stripped = getLowercase(removeTrailingWhitespaces(input));
+            if (stripped == "true" || stripped == "on" || stripped == "yes")
+            {
+              *output = true;
+              return true;
+            }
+            else if (stripped == "false" || stripped == "off" || stripped == "no")
+            {
+              *output = false;
+              return true;
+            }
+
+            std::istringstream iss(input);
+            if (iss >> (*output))
+                return true;
+            else
+                return false;
+        }
+    };
 }
 
-// We can cast implicitely
-template <class FromType, class ToType>
-inline bool convertImplicitely(ToType* output, const FromType& input, ::Int2Type<true>)
-{
-    (*output) = static_cast<ToType>(input);
-    return true;
-}
-
-
-////////////////////////////////
-// ConverterExplicit Fallback //
-////////////////////////////////
-
-// Default template if no specialisation is available
-template <class FromType, class ToType>
-struct ConverterExplicit
-{
-    static bool convert(ToType* output, const FromType& input)
-    {
-        // Try implict cast and probe first. If a simple cast is not possible, it will not compile
-        // We therefore have to out source it into another template function
-        const bool probe = ImplicitConversion<FromType, ToType>::exists;
-        return convertImplicitely(output, input, ::Int2Type<probe>());
-    }
-};
-
-
-//////////////////////
-// Public Functions //
-//////////////////////
-
-/**
-@brief
-    Converts any value to any other as long as there exists a conversion.
-    Otherwise, the conversion will generate a runtime warning and return false.
-    For information about the different conversion methods (user defined too), see the section
-    'Actual conversion sequence' in this file above.
-*/
-template <class FromType, class ToType>
-inline bool convertValue(ToType* output, const FromType& input)
-{
-    return ConverterExplicit<FromType, ToType>::convert(output, input);
-}
-
-// For compatibility reasons. The same, but with capital ConvertValue
-template<class FromType, class ToType>
-inline bool ConvertValue(ToType* output, const FromType& input)
-{
-    return convertValue(output, input);
-}
-
-// Calls convertValue and returns true if the conversion was successful.
-// Otherwise the fallback is used.
-/**
-@brief
-    Converts any value to any other as long as there exists a conversion.
-    Otherwise, the conversion will generate a runtime warning and return false.
-    For information about the different conversion methods (user defined too), see the section
-    'Actual conversion sequence' in this file above.
-    If the conversion doesn't succeed, 'fallback' is written to '*output'.
-@param fallback
-    A default value that gets written to '*output' if there is no conversion.
-*/
-template<class FromType, class ToType>
-inline bool convertValue(ToType* output, const FromType& input, const ToType& fallback)
-{
-    if (convertValue(output, input))
-        return true;
-    else
-    {
-        (*output) = fallback;
-        return false;
-    }
-}
-
-// for compatibility reason. (capital 'c' in ConvertValue)
-template<class FromType, class ToType>
-inline bool ConvertValue(ToType* output, const FromType& input, const ToType& fallback)
-{
-    return convertValue(output, input, fallback);
-}
-
-// Directly returns the converted value, even if the conversion was not successful.
-template<class FromType, class ToType>
-inline ToType getConvertedValue(const FromType& input)
-{
-    ToType output;
-    convertValue(&output, input);
-    return output;
-}
-
-// Directly returns the converted value, but uses the fallback on failure.
-template<class FromType, class ToType>
-inline ToType getConvertedValue(const FromType& input, const ToType& fallback)
-{
-    ToType output;
-    convertValue(&output, input, fallback);
-    return output;
-}
-
-// Like getConvertedValue, but the template argument order is in reverse.
-// That means you can call it exactly like static_cast<ToType>(fromTypeValue).
-template<class ToType, class FromType>
-inline ToType omni_cast(const FromType& input)
-{
-    ToType output;
-    convertValue(&output, input);
-    return output;
-}
-
-// convert to string Shortcut
-template <class FromType>
-inline std::string convertToString(FromType value)
-{
-  return getConvertedValue<FromType, std::string>(value);
-}
-
-// convert from string Shortcut
-template <class ToType>
-inline ToType convertFromString(std::string str)
-{
-  return getConvertedValue<std::string, ToType>(str);
-}
-
-////////////////////////////////
-// Special string conversions //
-////////////////////////////////
-
-// Delegate conversion from const char* to std::string
-template <class ToType>
-struct ConverterExplicit<const char*, ToType>
-{
-    static bool convert(ToType* output, const char* input)
-    {
-        return convertValue<std::string, ToType>(output, input);
-    }
-};
-
-// These conversions would exhibit ambiguous << or >> operators when using stringstream
-template <>
-struct ConverterExplicit<char, std::string>
-{
-    static bool convert(std::string* output, const char input)
-    {
-        *output = std::string(1, input);
-        return true;
-    }
-};
-template <>
-struct ConverterExplicit<unsigned char, std::string>
-{
-    static bool convert(std::string* output, const unsigned char input)
-    {
-        *output = std::string(1, input);
-        return true;
-    }
-};
-template <>
-struct ConverterExplicit<std::string, char>
-{
-    static bool convert(char* output, const std::string input)
-    {
-        if (input != "")
-            *output = input[0];
-        else
-            *output = '\0';
-        return true;
-    }
-};
-template <>
-struct ConverterExplicit<std::string, unsigned char>
-{
-    static bool convert(unsigned char* output, const std::string input)
-    {
-        if (input != "")
-            *output = input[0];
-        else
-            *output = '\0';
-        return true;
-    }
-};
-
-
-// bool to std::string
-template <>
-struct ConverterExplicit<bool, std::string>
-{
-    static bool convert(std::string* output, const bool& input)
-    {
-        if (input)
-          *output = "true";
-        else
-          *output = "false";
-        return false;
-    }
-};
-
-// std::string to bool
-template <>
-struct ConverterExplicit<std::string, bool>
-{
-    static bool convert(bool* output, const std::string& input)
-    {
-        std::string stripped = getLowercase(removeTrailingWhitespaces(input));
-        if (stripped == "true" || stripped == "on" || stripped == "yes")
-        {
-          *output = true;
-          return true;
-        }
-        else if (stripped == "false" || stripped == "off" || stripped == "no")
-        {
-          *output = false;
-          return true;
-        }
-
-        std::istringstream iss(input);
-        if (iss >> (*output))
-            return true;
-        else
-            return false;
-    }
-};
-
 #endif /* _Convert_H__ */

code/branches/objecthierarchy/src/util/Debug.h

@@ -67 +67 @@
 #include "OutputHandler.h"
 
-
-/**
-    @brief Returns the soft debug level, stored in the only existing instance of the OutputHandler class, configured in the config-file.
-    @return The soft debug level
-*/
-static inline int getSoftDebugLevel()
-{
-    return orxonox::OutputHandler::getSoftDebugLevel();
-}
-
 namespace orxonox
 {
+    /**
+        @brief Returns the soft debug level, stored in the only existing instance of the OutputHandler class, configured in the config-file.
+        @return The soft debug level
+    */
+    static inline int getSoftDebugLevel()
+    {
+        return OutputHandler::getSoftDebugLevel();
+    }
+
     using std::endl;
 }
@@ -115 +114 @@
   #if ORX_HARD_DEBUG_LEVEL >= ORX_NONE
    #define COUT0 \
-    (getSoftDebugLevel() < ORX_NONE) ? COUT_EXEC(0) : COUT_EXEC(0)
+   (orxonox::getSoftDebugLevel() < ORX_NONE) ? COUT_EXEC(0) : COUT_EXEC(0)
   #else
    #define COUT0 \
@@ -123 +122 @@
   #if ORX_HARD_DEBUG_LEVEL >= ORX_ERROR
    #define COUT1 \
-    (getSoftDebugLevel() < ORX_ERROR) ? COUT_EXEC(1) : COUT_EXEC(1)
+    (orxonox::getSoftDebugLevel() < ORX_ERROR) ? COUT_EXEC(1) : COUT_EXEC(1)
   #else
    #define COUT1 \
@@ -131 +130 @@
   #if ORX_HARD_DEBUG_LEVEL >= ORX_WARNING
    #define COUT2 \
-    (getSoftDebugLevel() < ORX_WARNING) ? COUT_EXEC(2) : COUT_EXEC(2)
+    (orxonox::getSoftDebugLevel() < ORX_WARNING) ? COUT_EXEC(2) : COUT_EXEC(2)
   #else
    #define COUT2 \
@@ -139 +138 @@
   #if ORX_HARD_DEBUG_LEVEL >= ORX_INFO
    #define COUT3 \
-    (getSoftDebugLevel() < ORX_INFO) ? COUT_EXEC(3) : COUT_EXEC(3)
+    (orxonox::getSoftDebugLevel() < ORX_INFO) ? COUT_EXEC(3) : COUT_EXEC(3)
   #else
    #define COUT3 \
@@ -147 +146 @@
   #if ORX_HARD_DEBUG_LEVEL >= ORX_DEBUG
    #define COUT4 \
-    (getSoftDebugLevel() < ORX_DEBUG) ? COUT_EXEC(4) : COUT_EXEC(4)
+    (orxonox::getSoftDebugLevel() < ORX_DEBUG) ? COUT_EXEC(4) : COUT_EXEC(4)
   #else
    #define COUT4 \
@@ -155 +154 @@
   #if ORX_HARD_DEBUG_LEVEL >= ORX_VERBOSE
    #define COUT5 \
-    (getSoftDebugLevel() < ORX_VERBOSE) ? COUT_EXEC(5) : COUT_EXEC(5)
+    (orxonox::getSoftDebugLevel() < ORX_VERBOSE) ? COUT_EXEC(5) : COUT_EXEC(5)
   #else
    #define COUT5 \
@@ -163 +162 @@
   #if ORX_HARD_DEBUG_LEVEL >= ORX_ULTRA
    #define COUT6 \
-    (getSoftDebugLevel() < ORX_ULTRA) ? COUT_EXEC(6) : COUT_EXEC(6)
+    (orxonox::getSoftDebugLevel() < ORX_ULTRA) ? COUT_EXEC(6) : COUT_EXEC(6)
   #else
    #define COUT6 \
@@ -199 +198 @@
   #if ORX_HARD_DEBUG_LEVEL >= ORX_NONE
    #define CCOUT0 \
-    (getSoftDebugLevel() < ORX_NONE) ? COUT_EXEC(0) : CCOUT_EXEC(0)
+    (orxonox::getSoftDebugLevel() < ORX_NONE) ? COUT_EXEC(0) : CCOUT_EXEC(0)
   #else
    #define CCOUT0 \
@@ -207 +206 @@
   #if ORX_HARD_DEBUG_LEVEL >= ORX_ERROR
    #define CCOUT1 \
-    (getSoftDebugLevel() < ORX_ERROR) ? COUT_EXEC(1) : CCOUT_EXEC(1)
+    (orxonox::getSoftDebugLevel() < ORX_ERROR) ? COUT_EXEC(1) : CCOUT_EXEC(1)
   #else
    #define CCOUT1 \
@@ -215 +214 @@
   #if ORX_HARD_DEBUG_LEVEL >= ORX_WARNING
    #define CCOUT2 \
-    (getSoftDebugLevel() < ORX_WARNING) ? COUT_EXEC(2) : CCOUT_EXEC(2)
+    (orxonox::getSoftDebugLevel() < ORX_WARNING) ? COUT_EXEC(2) : CCOUT_EXEC(2)
   #else
    #define CCOUT2 \
@@ -223 +222 @@
   #if ORX_HARD_DEBUG_LEVEL >= ORX_INFO
    #define CCOUT3 \
-    (getSoftDebugLevel() < ORX_INFO) ? COUT_EXEC(3) : CCOUT_EXEC(3)
+    (orxonox::getSoftDebugLevel() < ORX_INFO) ? COUT_EXEC(3) : CCOUT_EXEC(3)
   #else
    #define CCOUT3 \
@@ -231 +230 @@
   #if ORX_HARD_DEBUG_LEVEL >= ORX_DEBUG
    #define CCOUT4 \
-    (getSoftDebugLevel() < ORX_DEBUG) ? COUT_EXEC(4) : CCOUT_EXEC(4)
+    (orxonox::getSoftDebugLevel() < ORX_DEBUG) ? COUT_EXEC(4) : CCOUT_EXEC(4)
   #else
    #define CCOUT4 \
@@ -239 +238 @@
   #if ORX_HARD_DEBUG_LEVEL >= ORX_VERBOSE
    #define CCOUT5 \
-    (getSoftDebugLevel() < ORX_VERBOSE) ? COUT_EXEC(5) : CCOUT_EXEC(5)
+    (orxonox::getSoftDebugLevel() < ORX_VERBOSE) ? COUT_EXEC(5) : CCOUT_EXEC(5)
   #else
    #define CCOUT5 \
@@ -247 +246 @@
   #if ORX_HARD_DEBUG_LEVEL >= ORX_ULTRA
    #define CCOUT6 \
-    (getSoftDebugLevel() < ORX_ULTRA) ? COUT_EXEC(6) : CCOUT_EXEC(6)
+    (orxonox::getSoftDebugLevel() < ORX_ULTRA) ? COUT_EXEC(6) : CCOUT_EXEC(6)
   #else
    #define CCOUT6 \

code/branches/objecthierarchy/src/util/Exception.cc

@@ -81 +81 @@
         return fullDescription_;
     }
-
-
 }

code/branches/objecthierarchy/src/util/Exception.h

@@ -141 +141 @@
     CREATE_ORXONOX_EXCEPTION(NotImplemented);
     CREATE_ORXONOX_EXCEPTION(GameState);
+}
 
 #define ThrowException(type, description) \
@@ -154 +155 @@
 #endif
 
-}
-
 #endif /* _Exception_H__ */

code/branches/objecthierarchy/src/util/ExprParser.cc

@@ -45 +45 @@
 #define PARSE_BLANKS while (*reading_stream == ' ') ++reading_stream
 
-ExprParser::ExprParser(const std::string& str)
+namespace orxonox
 {
-    this->failed_ = false;
-    this->reading_stream = str.c_str();
-    if (str.size() == 0 || *reading_stream == '\0')
-    {
-        this->failed_ = true;
-        this->result_ = 0.0;
-    }
-    else
-    {
-        this->result_ = parse_expr_8();
-        this->remains_ = reading_stream;
+    ExprParser::ExprParser(const std::string& str)
+    {
+        this->failed_ = false;
+        this->reading_stream = str.c_str();
+        if (str.size() == 0 || *reading_stream == '\0')
+        {
+            this->failed_ = true;
+            this->result_ = 0.0;
+        }
+        else
+        {
+            this->result_ = parse_expr_8();
+            this->remains_ = reading_stream;
+        }
+    }
+
+    //Private functions:
+    /******************/
+    double ExprParser::parse_argument()
+    {
+        double value = parse_expr_8();
+        if (*reading_stream == ',')
+        {
+            ++reading_stream;
+            return value;
+        }
+        else
+        {
+            this->failed_ = true;
+            return 0;
+        }
+    }
+
+    double ExprParser::parse_last_argument()
+    {
+        double value = parse_expr_8();
+        if (*reading_stream == ')')
+        {
+            ++reading_stream;
+            return value;
+        }
+        else
+        {
+            this->failed_ = true;
+            return 0;
+        }
+    }
+
+    double ExprParser::parse_expr_8()
+    {
+        double value = parse_expr_7();
+        for(;;)
+        {
+            switch (op)
+            {
+            case oder:
+                value = parse_expr_7() || value;
+                break;
+            default: return value;
+            }
+        };
+    }
+
+
+    double ExprParser::parse_expr_7()
+    {
+        double value = parse_expr_6();
+        for(;;)
+        {
+            switch (op)
+            {
+            case und:
+                value = value && parse_expr_6();
+                break;
+            default: return value;
+            }
+        };
+    }
+
+    double ExprParser::parse_expr_6()
+    {
+        double value = parse_expr_5();
+        for(;;)
+        {
+            switch (op)
+            {
+            case gleich:
+                value = (value == parse_expr_5());
+                break;
+            case ungleich:
+                value = (value != parse_expr_5());
+                break;
+            default:
+                return value;
+            }
+        };
+    }
+
+    double ExprParser::parse_expr_5()
+    {
+        double value = parse_expr_4();
+        for(;;)
+        {
+            switch (op)
+            {
+            case kleiner:
+                value = (value < parse_expr_4());
+                break;
+            case kleinergleich:
+                value = (value <= parse_expr_4());
+                break;
+            case groesser:
+                value = (value > parse_expr_4());
+                break;
+            case groessergleich:
+                value = (value >= parse_expr_4());
+                break;
+            default:
+                return value;
+            }
+        };
+    }
+
+    double ExprParser::parse_expr_4()
+    {
+        double value = parse_expr_3();
+        for(;;)
+        {
+            switch (op)
+            {
+            case b_plus:
+                value += parse_expr_3();
+                break;
+            case b_minus:
+                value -= parse_expr_3();
+                break;
+            default:
+                return value;
+            }
+        };
+    }
+
+    double ExprParser::parse_expr_3()
+    {
+        double value = parse_expr_2();
+        for(;;)
+        {
+            switch (op)
+            {
+            case mal:
+                value *= parse_expr_2();
+                break;
+            case durch:
+                value /= parse_expr_2();
+                break;
+            case modulo:
+                {
+                    double temp = parse_expr_2();
+                    value = value - floor(value/temp)*temp;
+                    break;
+                }
+            default:
+                return value;
+            }
+        };
+    }
+
+    double ExprParser::parse_expr_2()
+    {
+        double value = parse_expr_1();
+        while (*reading_stream != '\0')
+        {
+            op = parse_binary_operator();
+            switch (op)
+            {
+            case hoch:
+                value = pow(value,parse_expr_1());
+                break;
+            default:
+                return value;
+            }
+        };
+        op = undef;
+        return value;
+    }
+
+    double ExprParser::parse_expr_1()
+    {
+        PARSE_BLANKS;
+        double value;
+
+        unary_operator op = parse_unary_operator();
+        PARSE_BLANKS;
+
+        if (*reading_stream == '\0')
+        {
+            // end of string
+            this->failed_ = true;
+            return 0;
+        }
+        else if (*reading_stream > 47 && *reading_stream < 59 || *reading_stream == 46)
+        {  // number
+            value = strtod(reading_stream, const_cast<char**>(&reading_stream));
+        }
+        else if (*reading_stream > 64 && *reading_stream < 91 || *reading_stream > 96 && *reading_stream < 123 || *reading_stream == 46)
+        {  // variable or function
+            char* word = new char[256];
+            parse_word(word);
+            PARSE_BLANKS;
+            if (*reading_stream == '(')
+            {
+                ++reading_stream;
+#define SWITCH word
+                CASE_1("sin")
+                    value = sin(parse_last_argument());
+                CASE("asin")
+                    value = asin(parse_last_argument());
+                CASE("sinh")
+                    value = sinh(parse_last_argument());
+                CASE("asinh")
+                {
+                    value = parse_last_argument();
+                    value = log(sqrt(pow(value, 2) + 1) + value);
+                }
+                CASE("cos")
+                    value = cos(parse_last_argument());
+                CASE("acos")
+                    value = acos(parse_last_argument());
+                CASE("cosh")
+                    value = cosh(parse_last_argument());
+                CASE("acosh")
+                {
+                    value = parse_last_argument();
+                    value = log(sqrt(pow(value, 2) - 1) + value);
+                }
+                CASE("tan")
+                    value = tan(parse_last_argument());
+                CASE("atan")
+                    value = atan(parse_last_argument());
+                CASE("atan2")
+                    value = atan2(parse_argument(),parse_last_argument());
+                CASE("tanh")
+                    value = tanh(parse_last_argument());
+                CASE("atanh")
+                {
+                    value = parse_last_argument();
+                    value = 0.5*log((value + 1)/(value - 1));
+                }
+                CASE("int")
+                    value = floor(parse_last_argument());
+                CASE("floor")
+                    value = floor(parse_last_argument());
+                CASE("ceil")
+                    value = ceil(parse_last_argument());
+                CASE("abs")
+                    value = fabs(parse_last_argument());
+                CASE("exp")
+                    value = exp(parse_last_argument());
+                CASE("log")
+                    value = log10(parse_last_argument());
+                CASE("ln")
+                    value = log(parse_last_argument());
+                CASE("sign")
+                {
+                    value = parse_last_argument();
+                    value = (value>0 ? 1 : (value<0 ? -1 : 0));
+                }
+                CASE("sqrt")
+                    value = sqrt(parse_last_argument());
+                CASE("degrees")
+                    value = parse_last_argument()*180/3.1415926535897932;
+                CASE("radians")
+                    value = parse_last_argument()*3.1415926535897932/180;
+                CASE("mod")
+                {
+                    value = parse_argument();
+                    double value2 = parse_last_argument();
+                    value = value - floor(value/value2)*value2;
+                }
+                CASE("pow")
+                    value = pow(parse_argument(),parse_last_argument());
+                CASE("div")
+                    value = floor(parse_argument()/parse_last_argument());
+                CASE("max")
+                    value = std::max(parse_argument(),parse_last_argument());
+                CASE("min")
+                    value = std::min(parse_argument(),parse_last_argument());
+                CASE_ELSE
+                {
+                    this->failed_ = true;
+                    delete[] word;
+                    return 0;
+                }
+            }
+            else
+            {
+#define SWITCH word
+                CASE_1("pi")
+                    value = 3.1415926535897932;
+                CASE("e")
+                    value = 2.7182818284590452;
+                CASE_ELSE
+                {
+                    this->failed_ = true;
+                    delete[] word;
+                    return 0;
+                }
+            }
+            delete[] word;
+        }
+        else if (*reading_stream == 40)
+        {  // expresion in paranthesis
+            ++reading_stream;
+            value = parse_last_argument();
+        }
+        else
+        {
+            this->failed_ = true;
+            return 0;
+        }
+
+        PARSE_BLANKS;
+        switch (op)
+        {
+        case u_nicht: return !value;
+        case u_plus:  return  value;
+        case u_minus: return -value;
+        default:
+            this->failed_ = true;
+            return 0;
+        }
+    }
+
+    char* ExprParser::parse_word(char* str)
+    {
+        char* word = str;
+        int counter = 0;
+        while (*reading_stream > 47 && *reading_stream < 58 || *reading_stream > 64 && *reading_stream < 91 || *reading_stream > 96 && *reading_stream < 123 || *reading_stream == 46)
+        {
+            *word++ = *reading_stream++;
+            counter++;
+            if (counter > 255)
+            {
+                this->failed_ = true;
+                return '\0';
+            }
+        };
+        *word = '\0';
+        return str;
+    }
+
+    ExprParser::binary_operator ExprParser::parse_binary_operator()
+    {
+        binary_operator op;
+        switch (*reading_stream)
+        {
+        case '+': op = b_plus; break;
+        case '-': op = b_minus; break;
+        case '*': op = mal; break;
+        case '/': op = durch; break;
+        case '^': op = hoch; break;
+        case '%': op = modulo; break;
+        case '&': op = und; break;
+        case '|': op = oder; break;
+        case '=': op = gleich; break;
+        case '!': op = b_nicht; break;
+        case '<': op = kleiner; break;
+        case '>': op = groesser; break;
+        default: return undef;
+        }
+        if (*++reading_stream == '=')
+        {
+            if (op > 9)
+            {
+                ++reading_stream;
+                return (binary_operator)(op + 3);
+            }
+            else
+            {
+                --reading_stream;
+                return undef;
+            }
+        }
+        else
+            return op;
+    }
+
+    ExprParser::unary_operator ExprParser::parse_unary_operator()
+    {
+        switch (*reading_stream)
+        {
+        case '!':
+            ++reading_stream;
+            return u_nicht;
+        case '+':
+            ++reading_stream;
+            return u_plus;
+        case '-':
+            ++reading_stream;
+            return u_minus;
+        default :
+            return u_plus;
+        }
     }
 }
-
-//Private functions:
-/******************/
-double ExprParser::parse_argument()
-{
-    double value = parse_expr_8();
-    if (*reading_stream == ',')
-    {
-        ++reading_stream;
-        return value;
-    }
-    else
-    {
-        this->failed_ = true;
-        return 0;
-    }
-}
-
-double ExprParser::parse_last_argument()
-{
-    double value = parse_expr_8();
-    if (*reading_stream == ')')
-    {
-        ++reading_stream;
-        return value;
-    }
-    else
-    {
-        this->failed_ = true;
-        return 0;
-    }
-}
-
-double ExprParser::parse_expr_8()
-{
-    double value = parse_expr_7();
-    for(;;)
-    {
-        switch (op)
-        {
-        case oder:
-            value = parse_expr_7() || value;
-            break;
-        default: return value;
-        }
-    };
-}
-
-
-double ExprParser::parse_expr_7()
-{
-    double value = parse_expr_6();
-    for(;;)
-    {
-        switch (op)
-        {
-        case und:
-            value = value && parse_expr_6();
-            break;
-        default: return value;
-        }
-    };
-}
-
-double ExprParser::parse_expr_6()
-{
-    double value = parse_expr_5();
-    for(;;)
-    {
-        switch (op)
-        {
-        case gleich:
-            value = (value == parse_expr_5());
-            break;
-        case ungleich:
-            value = (value != parse_expr_5());
-            break;
-        default:
-            return value;
-        }
-    };
-}
-
-double ExprParser::parse_expr_5()
-{
-    double value = parse_expr_4();
-    for(;;)
-    {
-        switch (op)
-        {
-        case kleiner:
-            value = (value < parse_expr_4());
-            break;
-        case kleinergleich:
-            value = (value <= parse_expr_4());
-            break;
-        case groesser:
-            value = (value > parse_expr_4());
-            break;
-        case groessergleich:
-            value = (value >= parse_expr_4());
-            break;
-        default:
-            return value;
-        }
-    };
-}
-
-double ExprParser::parse_expr_4()
-{
-    double value = parse_expr_3();
-    for(;;)
-    {
-        switch (op)
-        {
-        case b_plus:
-            value += parse_expr_3();
-            break;
-        case b_minus:
-            value -= parse_expr_3();
-            break;
-        default:
-            return value;
-        }
-    };
-}
-
-double ExprParser::parse_expr_3()
-{
-    double value = parse_expr_2();
-    for(;;)
-    {
-        switch (op)
-        {
-        case mal:
-            value *= parse_expr_2();
-            break;
-        case durch:
-            value /= parse_expr_2();
-            break;
-        case modulo:
-            {
-                double temp = parse_expr_2();
-                value = value - floor(value/temp)*temp;
-                break;
-            }
-        default:
-            return value;
-        }
-    };
-}
-
-double ExprParser::parse_expr_2()
-{
-    double value = parse_expr_1();
-    while (*reading_stream != '\0')
-    {
-        op = parse_binary_operator();
-        switch (op)
-        {
-        case hoch:
-            value = pow(value,parse_expr_1());
-            break;
-        default:
-            return value;
-        }
-    };
-    op = undef;
-    return value;
-}
-
-double ExprParser::parse_expr_1()
-{
-    PARSE_BLANKS;
-    double value;
-
-    unary_operator op = parse_unary_operator();
-    PARSE_BLANKS;
-
-    if (*reading_stream == '\0')
-    {
-        // end of string
-        this->failed_ = true;
-        return 0;
-    }
-    else if (*reading_stream > 47 && *reading_stream < 59 || *reading_stream == 46)
-    {  // number
-        value = strtod(reading_stream, const_cast<char**>(&reading_stream));
-    }
-    else if (*reading_stream > 64 && *reading_stream < 91 || *reading_stream > 96 && *reading_stream < 123 || *reading_stream == 46)
-    {  // variable or function
-        char* word = new char[256];
-        parse_word(word);
-        PARSE_BLANKS;
-        if (*reading_stream == '(')
-        {
-            ++reading_stream;
-#define SWITCH word
-            CASE_1("sin")
-                value = sin(parse_last_argument());
-            CASE("asin")
-                value = asin(parse_last_argument());
-            CASE("sinh")
-                value = sinh(parse_last_argument());
-            CASE("asinh")
-            {
-                value = parse_last_argument();
-                value = log(sqrt(pow(value, 2) + 1) + value);
-            }
-            CASE("cos")
-                value = cos(parse_last_argument());
-            CASE("acos")
-                value = acos(parse_last_argument());
-            CASE("cosh")
-                value = cosh(parse_last_argument());
-            CASE("acosh")
-            {
-                value = parse_last_argument();
-                value = log(sqrt(pow(value, 2) - 1) + value);
-            }
-            CASE("tan")
-                value = tan(parse_last_argument());
-            CASE("atan")
-                value = atan(parse_last_argument());
-            CASE("atan2")
-                value = atan2(parse_argument(),parse_last_argument());
-            CASE("tanh")
-                value = tanh(parse_last_argument());
-            CASE("atanh")
-            {
-                value = parse_last_argument();
-                value = 0.5*log((value + 1)/(value - 1));
-            }
-            CASE("int")
-                value = floor(parse_last_argument());
-            CASE("floor")
-                value = floor(parse_last_argument());
-            CASE("ceil")
-                value = ceil(parse_last_argument());
-            CASE("abs")
-                value = fabs(parse_last_argument());
-            CASE("exp")
-                value = exp(parse_last_argument());
-            CASE("log")
-                value = log10(parse_last_argument());
-            CASE("ln")
-                value = log(parse_last_argument());
-            CASE("sign")
-            {
-                value = parse_last_argument();
-                value = (value>0 ? 1 : (value<0 ? -1 : 0));
-            }
-            CASE("sqrt")
-                value = sqrt(parse_last_argument());
-            CASE("degrees")
-                value = parse_last_argument()*180/3.1415926535897932;
-            CASE("radians")
-                value = parse_last_argument()*3.1415926535897932/180;
-            CASE("mod")
-            {
-                value = parse_argument();
-                double value2 = parse_last_argument();
-                value = value - floor(value/value2)*value2;
-            }
-            CASE("pow")
-                value = pow(parse_argument(),parse_last_argument());
-            CASE("div")
-                value = floor(parse_argument()/parse_last_argument());
-            CASE("max")
-                value = std::max(parse_argument(),parse_last_argument());
-            CASE("min")
-                value = std::min(parse_argument(),parse_last_argument());
-            CASE_ELSE
-            {
-                this->failed_ = true;
-                delete[] word;
-                return 0;
-            }
-        }
-        else
-        {
-#define SWITCH word
-            CASE_1("pi")
-                value = 3.1415926535897932;
-            CASE("e")
-                value = 2.7182818284590452;
-            CASE_ELSE
-            {
-                this->failed_ = true;
-                delete[] word;
-                return 0;
-            }
-        }
-        delete[] word;
-    }
-    else if (*reading_stream == 40)
-    {  // expresion in paranthesis
-        ++reading_stream;
-        value = parse_last_argument();
-    }
-    else
-    {
-        this->failed_ = true;
-        return 0;
-    }
-
-    PARSE_BLANKS;
-    switch (op)
-    {
-    case u_nicht: return !value;
-    case u_plus:  return  value;
-    case u_minus: return -value;
-    default:
-        this->failed_ = true;
-        return 0;
-    }
-}
-
-char* ExprParser::parse_word(char* str)
-{
-    char* word = str;
-    int counter = 0;
-    while (*reading_stream > 47 && *reading_stream < 58 || *reading_stream > 64 && *reading_stream < 91 || *reading_stream > 96 && *reading_stream < 123 || *reading_stream == 46)
-    {
-        *word++ = *reading_stream++;
-        counter++;
-        if (counter > 255)
-        {
-            this->failed_ = true;
-            return '\0';
-        }
-    };
-    *word = '\0';
-    return str;
-}
-
-ExprParser::binary_operator ExprParser::parse_binary_operator()
-{
-    binary_operator op;
-    switch (*reading_stream)
-    {
-    case '+': op = b_plus; break;
-    case '-': op = b_minus; break;
-    case '*': op = mal; break;
-    case '/': op = durch; break;
-    case '^': op = hoch; break;
-    case '%': op = modulo; break;
-    case '&': op = und; break;
-    case '|': op = oder; break;
-    case '=': op = gleich; break;
-    case '!': op = b_nicht; break;
-    case '<': op = kleiner; break;
-    case '>': op = groesser; break;
-    default: return undef;
-    }
-    if (*++reading_stream == '=')
-    {
-        if (op > 9)
-        {
-            ++reading_stream;
-            return (binary_operator)(op + 3);
-        }
-        else
-        {
-            --reading_stream;
-            return undef;
-        }
-    }
-    else
-        return op;
-}
-
-ExprParser::unary_operator ExprParser::parse_unary_operator()
-{
-    switch (*reading_stream)
-    {
-    case '!':
-        ++reading_stream;
-        return u_nicht;
-    case '+':
-        ++reading_stream;
-        return u_plus;
-    case '-':
-        ++reading_stream;
-        return u_minus;
-    default :
-        return u_plus;
-    }
-}

code/branches/objecthierarchy/src/util/ExprParser.h

@@ -38 +38 @@
 #include <string>
 
-class _UtilExport ExprParser
+namespace orxonox
 {
-public:
-    enum binary_operator
+    class _UtilExport ExprParser
     {
-        b_plus,
-        b_minus,
-        mal,
-        durch,
-        modulo,
-        hoch,
-        undef,
-        oder,
-        und,
-        gleich,
-        b_nicht,
-        kleiner,
-        groesser,
-        ungleich,
-        kleinergleich,
-        groessergleich
+    public:
+        enum binary_operator
+        {
+            b_plus,
+            b_minus,
+            mal,
+            durch,
+            modulo,
+            hoch,
+            undef,
+            oder,
+            und,
+            gleich,
+            b_nicht,
+            kleiner,
+            groesser,
+            ungleich,
+            kleinergleich,
+            groessergleich
+        };
+
+        enum unary_operator
+        {
+            u_plus,
+            u_minus,
+            u_nicht
+        };
+
+
+        ExprParser(const std::string& str);
+        std::string& getRemains() { return  this->remains_; }
+        double       getResult()  { return  this->result_; }
+        bool         getSuccess() { return !this->failed_; }
+
+    private:
+        double parse_expr_1();
+        double parse_expr_2();
+        double parse_expr_3();
+        double parse_expr_4();
+        double parse_expr_5();
+        double parse_expr_6();
+        double parse_expr_7();
+        double parse_expr_8();
+        char* parse_word(char* str);
+        binary_operator parse_binary_operator();
+        unary_operator parse_unary_operator();
+
+        double parse_argument();
+        double parse_last_argument();
+
+        binary_operator op;
+        const char* reading_stream;
+        bool failed_;
+        double result_;
+        std::string remains_;
+
     };
 
-    enum unary_operator
-    {
-        u_plus,
-        u_minus,
-        u_nicht
-    };
-
-
-    ExprParser(const std::string& str);
-    std::string& getRemains() { return  this->remains_; }
-    double       getResult()  { return  this->result_; }
-    bool         getSuccess() { return !this->failed_; }
-
-private:
-    double parse_expr_1();
-    double parse_expr_2();
-    double parse_expr_3();
-    double parse_expr_4();
-    double parse_expr_5();
-    double parse_expr_6();
-    double parse_expr_7();
-    double parse_expr_8();
-    char* parse_word(char* str);
-    binary_operator parse_binary_operator();
-    unary_operator parse_unary_operator();
-
-    double parse_argument();
-    double parse_last_argument();
-
-    binary_operator op;
-    const char* reading_stream;
-    bool failed_;
-    double result_;
-    std::string remains_;
-
-};
-
-//Endzeichen für float expression: ')', '}', ']', ',', ';'
-_UtilExport bool parse_float(char* const, char**, double*);
-//Endzeichen angegeben
-_UtilExport bool parse_float(char* const, char**, char, double*);
-//Letzter Teil-float eines Vektors parsen (keine Vergleichs- und Logikoperationen)
-_UtilExport bool parse_vector_float(char* const, char**, bool, double*);
+    //Endzeichen für float expression: ')', '}', ']', ',', ';'
+    _UtilExport bool parse_float(char* const, char**, double*);
+    //Endzeichen angegeben
+    _UtilExport bool parse_float(char* const, char**, char, double*);
+    //Letzter Teil-float eines Vektors parsen (keine Vergleichs- und Logikoperationen)
+    _UtilExport bool parse_vector_float(char* const, char**, bool, double*);
+}
 
 #endif /* _FloatParser_H__ */

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

@@ -38 +38 @@
 #include "SubString.h"
 
-/**
-    @brief Function for writing a Radian to a stream.
-*/
-std::ostream& operator<<(std::ostream& out, const orxonox::Radian& radian)
+namespace orxonox
 {
-    out << radian.valueRadians();
-    return out;
+    /**
+        @brief Function for writing a Radian to a stream.
+    */
+    std::ostream& operator<<(std::ostream& out, const orxonox::Radian& radian)
+    {
+        out << radian.valueRadians();
+        return out;
+    }
+
+    /**
+        @brief Function for reading a Radian from a stream.
+    */
+    std::istream& operator>>(std::istream& in, orxonox::Radian& radian)
+    {
+        float temp;
+        in >> temp;
+        radian = temp;
+        return in;
+    }
+
+    /**
+        @brief Function for writing a Degree to a stream.
+    */
+    std::ostream& operator<<(std::ostream& out, const orxonox::Degree& degree)
+    {
+        out << degree.valueDegrees();
+        return out;
+    }
+
+    /**
+        @brief Function for reading a Degree from a stream.
+    */
+    std::istream& operator>>(std::istream& in, orxonox::Degree& degree)
+    {
+        float temp;
+        in >> temp;
+        degree = temp;
+        return in;
+    }
+
+
+    /**
+        @brief Gets the angle between my viewing direction and the direction to the position of the other object.
+        @param myposition My position
+        @param mydirection My viewing direction
+        @param otherposition The position of the other object
+        @return The angle
+
+        @example
+        If the other object is exactly in front of me, the function returns 0.
+        If the other object is exactly behind me, the function returns pi.
+        If the other object is exactly right/left to me (or above/below), the function returns pi/2.
+    */
+    float getAngle(const orxonox::Vector3& myposition, const orxonox::Vector3& mydirection, const orxonox::Vector3& otherposition)
+    {
+        orxonox::Vector3 distance = otherposition - myposition;
+        float distancelength = distance.length();
+        if (distancelength == 0)
+            return 0;
+        else
+            return acos(clamp<float>(mydirection.dotProduct(distance) / distancelength, -1, 1));
+    }
+
+    /**
+        @brief Gets the 2D viewing direction (up/down, left/right) to the position of the other object.
+        @param myposition My position
+        @param mydirection My viewing direction
+        @param myorthonormal My orthonormalvector (pointing upwards through my head)
+        @param otherposition The position of the other object
+        @return The viewing direction
+
+        @example
+        If the other object is exactly in front of me, the function returns Vector2(0, 0).
+        If the other object is exactly at my left, the function returns Vector2(-1, 0).
+        If the other object is exactly at my right, the function returns Vector2(1, 0).
+        If the other object is only a bit at my right, the function still returns Vector2(1, 0).
+        If the other object is exactly above me, the function returns Vector2(0, 1).
+    */
+    orxonox::Vector2 get2DViewdirection(const orxonox::Vector3& myposition, const orxonox::Vector3& mydirection, const orxonox::Vector3& myorthonormal, const orxonox::Vector3& otherposition)
+    {
+        orxonox::Vector3 distance = otherposition - myposition;
+
+        // project difference vector on our plane
+        orxonox::Vector3 projection = Ogre::Plane(mydirection, myposition).projectVector(distance);
+
+        float projectionlength = projection.length();
+        if (projectionlength == 0) return orxonox::Vector2(0, 0);
+        float angle = acos(clamp<float>(myorthonormal.dotProduct(projection) / projectionlength, -1, 1));
+
+        if ((mydirection.crossProduct(myorthonormal)).dotProduct(distance) > 0)
+            return orxonox::Vector2(sin(angle), cos(angle));
+        else
+            return orxonox::Vector2(-sin(angle), cos(angle));
+    }
+
+    /**
+        @brief Gets the 2D viewing direction (up/down, left/right) to the position of the other object, multiplied with the viewing distance to the object (0° = 0, 180° = 1).
+        @param myposition My position
+        @param mydirection My viewing direction
+        @param myorthonormal My orthonormalvector (pointing upwards through my head)
+        @param otherposition The position of the other object
+        @return The viewing direction
+
+        @example
+        If the other object is exactly in front of me, the function returns Vector2(0, 0).
+        If the other object is exactly at my left, the function returns Vector2(-0.5, 0).
+        If the other object is exactly at my right, the function returns Vector2(0.5, 0).
+        If the other object is only a bit at my right, the function still returns Vector2(0.01, 0).
+        If the other object is exactly above me, the function returns Vector2(0, 0.5).
+    */
+    orxonox::Vector2 get2DViewcoordinates(const orxonox::Vector3& myposition, const orxonox::Vector3& mydirection, const orxonox::Vector3& myorthonormal, const orxonox::Vector3& otherposition)
+    {
+        orxonox::Vector3 distance = otherposition - myposition;
+
+        // project difference vector on our plane
+        orxonox::Vector3 projection = Ogre::Plane(mydirection, myposition).projectVector(distance);
+
+        float projectionlength = projection.length();
+        if (projectionlength == 0) return orxonox::Vector2(0, 0);
+        float angle = acos(clamp<float>(myorthonormal.dotProduct(projection) / projectionlength, -1, 1));
+
+        float distancelength = distance.length();
+        if (distancelength == 0) return orxonox::Vector2(0, 0);
+        float radius = acos(clamp<float>(mydirection.dotProduct(distance) / distancelength, -1, 1)) / Ogre::Math::PI;
+
+        if ((mydirection.crossProduct(myorthonormal)).dotProduct(distance) > 0)
+            return orxonox::Vector2(sin(angle) * radius, cos(angle) * radius);
+        else
+            return orxonox::Vector2(-sin(angle) * radius, cos(angle) * radius);
+    }
+
+    /**
+        @brief Returns the predicted position I have to aim at, if I want to hit a moving target with a moving projectile.
+        @param myposition My position
+        @param projectilespeed The speed of my projectile
+        @param targetposition The position of my target
+        @param targetvelocity The velocity of my target
+        @return The predicted position
+
+        The function predicts the position based on a linear velocity of the target. If the target changes speed or direction, the projectile will miss.
+    */
+    orxonox::Vector3 getPredictedPosition(const orxonox::Vector3& myposition, float projectilespeed, const orxonox::Vector3& targetposition, const orxonox::Vector3& targetvelocity)
+    {
+        float squaredProjectilespeed = projectilespeed * projectilespeed;
+        orxonox::Vector3 distance = targetposition - myposition;
+        float a = distance.squaredLength();
+        float b = 2 * (distance.x + distance.y + distance.z) * (targetvelocity.x + targetvelocity.y + targetvelocity.z);
+        float c = targetvelocity.squaredLength();
+
+        float temp = 4*squaredProjectilespeed*c + a*a - 4*b*c;
+        if (temp < 0)
+            return orxonox::Vector3::ZERO;
+
+        temp = sqrt(temp);
+        float time = (temp + a) / (2 * (squaredProjectilespeed - b));
+        return (targetposition + targetvelocity * time);
+    }
+
+    unsigned long getUniqueNumber()
+    {
+        static unsigned long aNumber = 135;
+        return aNumber++;
+    }
+
+
+    //////////////////////////
+    // Conversion functions //
+    //////////////////////////
+
+    // std::string to Vector2
+    bool ConverterFallback<std::string, orxonox::Vector2>::convert(orxonox::Vector2* output, const std::string& input)
+    {
+        size_t opening_parenthesis, closing_parenthesis = input.find(')');
+        if ((opening_parenthesis = input.find('(')) == std::string::npos)
+            opening_parenthesis = 0;
+        else
+            opening_parenthesis++;
+
+        SubString tokens(input.substr(opening_parenthesis, closing_parenthesis - opening_parenthesis),
+                         ",", SubString::WhiteSpaces, false, '\\', true, '"', true, '\0', '\0', true, '\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
+    bool ConverterFallback<std::string, orxonox::Vector3>::convert(orxonox::Vector3* output, const std::string& input)
+    {
+        size_t opening_parenthesis, closing_parenthesis = input.find(')');
+        if ((opening_parenthesis = input.find('(')) == std::string::npos)
+            opening_parenthesis = 0;
+        else
+            opening_parenthesis++;
+
+        SubString tokens(input.substr(opening_parenthesis, closing_parenthesis - opening_parenthesis),
+                         ",", SubString::WhiteSpaces, false, '\\', true, '"', true, '\0', '\0', true, '\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
+    bool ConverterFallback<std::string, orxonox::Vector4>::convert(orxonox::Vector4* output, const std::string& input)
+    {
+        size_t opening_parenthesis, closing_parenthesis = input.find(')');
+        if ((opening_parenthesis = input.find('(')) == std::string::npos)
+            opening_parenthesis = 0;
+        else
+            opening_parenthesis++;
+
+        SubString tokens(input.substr(opening_parenthesis, closing_parenthesis - opening_parenthesis),
+                         ",", SubString::WhiteSpaces, false, '\\', true, '"', true, '\0', '\0', true, '\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
+    bool ConverterFallback<std::string, orxonox::Quaternion>::convert(orxonox::Quaternion* output, const std::string& input)
+    {
+        size_t opening_parenthesis, closing_parenthesis = input.find(')');
+        if ((opening_parenthesis = input.find('(')) == std::string::npos) { opening_parenthesis = 0; } else { opening_parenthesis++; }
+
+        SubString tokens(input.substr(opening_parenthesis, closing_parenthesis - opening_parenthesis), ",", SubString::WhiteSpaces, false, '\\', true, '"', true, '\0', '\0', true, '\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
+    bool ConverterFallback<std::string, orxonox::ColourValue>::convert(orxonox::ColourValue* output, const std::string& input)
+    {
+        size_t opening_parenthesis, closing_parenthesis = input.find(')');
+        if ((opening_parenthesis = input.find('(')) == std::string::npos) { opening_parenthesis = 0; } else { opening_parenthesis++; }
+
+        SubString tokens(input.substr(opening_parenthesis, closing_parenthesis - opening_parenthesis), ",", SubString::WhiteSpaces, false, '\\', true, '"', true, '\0', '\0', true, '\0');
+        if (tokens.size() >= 3)
+        {
+            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 (tokens.size() >= 4)
+            {
+                if (!ConvertValue(&(output->a), tokens[3]))
+                    return false;
+            }
+            else
+                output->a = 1.0;
+
+            return true;
+        }
+        return false;
+    }
 }
-
-/**
-    @brief Function for reading a Radian from a stream.
-*/
-std::istream& operator>>(std::istream& in, orxonox::Radian& radian)
-{
-    float temp;
-    in >> temp;
-    radian = temp;
-    return in;
-}
-
-/**
-    @brief Function for writing a Degree to a stream.
-*/
-std::ostream& operator<<(std::ostream& out, const orxonox::Degree& degree)
-{
-    out << degree.valueDegrees();
-    return out;
-}
-
-/**
-    @brief Function for reading a Degree from a stream.
-*/
-std::istream& operator>>(std::istream& in, orxonox::Degree& degree)
-{
-    float temp;
-    in >> temp;
-    degree = temp;
-    return in;
-}
-
-
-/**
-    @brief Gets the angle between my viewing direction and the direction to the position of the other object.
-    @param myposition My position
-    @param mydirection My viewing direction
-    @param otherposition The position of the other object
-    @return The angle
-
-    @example
-    If the other object is exactly in front of me, the function returns 0.
-    If the other object is exactly behind me, the function returns pi.
-    If the other object is exactly right/left to me (or above/below), the function returns pi/2.
-*/
-float getAngle(const orxonox::Vector3& myposition, const orxonox::Vector3& mydirection, const orxonox::Vector3& otherposition)
-{
-    orxonox::Vector3 distance = otherposition - myposition;
-    float distancelength = distance.length();
-    if (distancelength == 0)
-        return 0;
-    else
-        return acos(clamp<float>(mydirection.dotProduct(distance) / distancelength, -1, 1));
-}
-
-/**
-    @brief Gets the 2D viewing direction (up/down, left/right) to the position of the other object.
-    @param myposition My position
-    @param mydirection My viewing direction
-    @param myorthonormal My orthonormalvector (pointing upwards through my head)
-    @param otherposition The position of the other object
-    @return The viewing direction
-
-    @example
-    If the other object is exactly in front of me, the function returns Vector2(0, 0).
-    If the other object is exactly at my left, the function returns Vector2(-1, 0).
-    If the other object is exactly at my right, the function returns Vector2(1, 0).
-    If the other object is only a bit at my right, the function still returns Vector2(1, 0).
-    If the other object is exactly above me, the function returns Vector2(0, 1).
-*/
-orxonox::Vector2 get2DViewdirection(const orxonox::Vector3& myposition, const orxonox::Vector3& mydirection, const orxonox::Vector3& myorthonormal, const orxonox::Vector3& otherposition)
-{
-    orxonox::Vector3 distance = otherposition - myposition;
-
-    // project difference vector on our plane
-    orxonox::Vector3 projection = Ogre::Plane(mydirection, myposition).projectVector(distance);
-
-    float projectionlength = projection.length();
-    if (projectionlength == 0) return orxonox::Vector2(0, 0);
-    float angle = acos(clamp<float>(myorthonormal.dotProduct(projection) / projectionlength, -1, 1));
-
-    if ((mydirection.crossProduct(myorthonormal)).dotProduct(distance) > 0)
-        return orxonox::Vector2(sin(angle), cos(angle));
-    else
-        return orxonox::Vector2(-sin(angle), cos(angle));
-}
-
-/**
-    @brief Gets the 2D viewing direction (up/down, left/right) to the position of the other object, multiplied with the viewing distance to the object (0° = 0, 180° = 1).
-    @param myposition My position
-    @param mydirection My viewing direction
-    @param myorthonormal My orthonormalvector (pointing upwards through my head)
-    @param otherposition The position of the other object
-    @return The viewing direction
-
-    @example
-    If the other object is exactly in front of me, the function returns Vector2(0, 0).
-    If the other object is exactly at my left, the function returns Vector2(-0.5, 0).
-    If the other object is exactly at my right, the function returns Vector2(0.5, 0).
-    If the other object is only a bit at my right, the function still returns Vector2(0.01, 0).
-    If the other object is exactly above me, the function returns Vector2(0, 0.5).
-*/
-orxonox::Vector2 get2DViewcoordinates(const orxonox::Vector3& myposition, const orxonox::Vector3& mydirection, const orxonox::Vector3& myorthonormal, const orxonox::Vector3& otherposition)
-{
-    orxonox::Vector3 distance = otherposition - myposition;
-
-    // project difference vector on our plane
-    orxonox::Vector3 projection = Ogre::Plane(mydirection, myposition).projectVector(distance);
-
-    float projectionlength = projection.length();
-    if (projectionlength == 0) return orxonox::Vector2(0, 0);
-    float angle = acos(clamp<float>(myorthonormal.dotProduct(projection) / projectionlength, -1, 1));
-
-    float distancelength = distance.length();
-    if (distancelength == 0) return orxonox::Vector2(0, 0);
-    float radius = acos(clamp<float>(mydirection.dotProduct(distance) / distancelength, -1, 1)) / Ogre::Math::PI;
-
-    if ((mydirection.crossProduct(myorthonormal)).dotProduct(distance) > 0)
-        return orxonox::Vector2(sin(angle) * radius, cos(angle) * radius);
-    else
-        return orxonox::Vector2(-sin(angle) * radius, cos(angle) * radius);
-}
-
-/**
-    @brief Returns the predicted position I have to aim at, if I want to hit a moving target with a moving projectile.
-    @param myposition My position
-    @param projectilespeed The speed of my projectile
-    @param targetposition The position of my target
-    @param targetvelocity The velocity of my target
-    @return The predicted position
-
-    The function predicts the position based on a linear velocity of the target. If the target changes speed or direction, the projectile will miss.
-*/
-orxonox::Vector3 getPredictedPosition(const orxonox::Vector3& myposition, float projectilespeed, const orxonox::Vector3& targetposition, const orxonox::Vector3& targetvelocity)
-{
-    float squaredProjectilespeed = projectilespeed * projectilespeed;
-    orxonox::Vector3 distance = targetposition - myposition;
-    float a = distance.squaredLength();
-    float b = 2 * (distance.x + distance.y + distance.z) * (targetvelocity.x + targetvelocity.y + targetvelocity.z);
-    float c = targetvelocity.squaredLength();
-
-    float temp = 4*squaredProjectilespeed*c + a*a - 4*b*c;
-    if (temp < 0)
-        return orxonox::Vector3::ZERO;
-
-    temp = sqrt(temp);
-    float time = (temp + a) / (2 * (squaredProjectilespeed - b));
-    return (targetposition + targetvelocity * time);
-}
-
-unsigned long getUniqueNumber()
-{
-    static unsigned long aNumber = 135;
-    return aNumber++;
-}
-
-
-//////////////////////////
-// Conversion functions //
-//////////////////////////
-
-// std::string to Vector2
-bool ConverterFallback<std::string, orxonox::Vector2>::convert(orxonox::Vector2* output, const std::string& input)
-{
-    size_t opening_parenthesis, closing_parenthesis = input.find(')');
-    if ((opening_parenthesis = input.find('(')) == std::string::npos)
-        opening_parenthesis = 0;
-    else
-        opening_parenthesis++;
-
-    SubString tokens(input.substr(opening_parenthesis, closing_parenthesis - opening_parenthesis),
-                     ",", SubString::WhiteSpaces, false, '\\', true, '"', true, '\0', '\0', true, '\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
-bool ConverterFallback<std::string, orxonox::Vector3>::convert(orxonox::Vector3* output, const std::string& input)
-{
-    size_t opening_parenthesis, closing_parenthesis = input.find(')');
-    if ((opening_parenthesis = input.find('(')) == std::string::npos)
-        opening_parenthesis = 0;
-    else
-        opening_parenthesis++;
-
-    SubString tokens(input.substr(opening_parenthesis, closing_parenthesis - opening_parenthesis),
-                     ",", SubString::WhiteSpaces, false, '\\', true, '"', true, '\0', '\0', true, '\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
-bool ConverterFallback<std::string, orxonox::Vector4>::convert(orxonox::Vector4* output, const std::string& input)
-{
-    size_t opening_parenthesis, closing_parenthesis = input.find(')');
-    if ((opening_parenthesis = input.find('(')) == std::string::npos)
-        opening_parenthesis = 0;
-    else
-        opening_parenthesis++;
-
-    SubString tokens(input.substr(opening_parenthesis, closing_parenthesis - opening_parenthesis),
-                     ",", SubString::WhiteSpaces, false, '\\', true, '"', true, '\0', '\0', true, '\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
-bool ConverterFallback<std::string, orxonox::Quaternion>::convert(orxonox::Quaternion* output, const std::string& input)
-{
-    size_t opening_parenthesis, closing_parenthesis = input.find(')');
-    if ((opening_parenthesis = input.find('(')) == std::string::npos) { opening_parenthesis = 0; } else { opening_parenthesis++; }
-
-    SubString tokens(input.substr(opening_parenthesis, closing_parenthesis - opening_parenthesis), ",", SubString::WhiteSpaces, false, '\\', true, '"', true, '\0', '\0', true, '\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
-bool ConverterFallback<std::string, orxonox::ColourValue>::convert(orxonox::ColourValue* output, const std::string& input)
-{
-    size_t opening_parenthesis, closing_parenthesis = input.find(')');
-    if ((opening_parenthesis = input.find('(')) == std::string::npos) { opening_parenthesis = 0; } else { opening_parenthesis++; }
-
-    SubString tokens(input.substr(opening_parenthesis, closing_parenthesis - opening_parenthesis), ",", SubString::WhiteSpaces, false, '\\', true, '"', true, '\0', '\0', true, '\0');
-    if (tokens.size() >= 3)
-    {
-        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 (tokens.size() >= 4)
-        {
-            if (!ConvertValue(&(output->a), tokens[3]))
-                return false;
-        }
-        else
-            output->a = 1.0;
-
-        return true;
-    }
-    return false;
-}

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

@@ -49 +49 @@
 #include <OgreQuaternion.h>
 #include <OgreColourValue.h>
-
-namespace orxonox
-{
-  typedef Ogre::Radian Radian;
-  typedef Ogre::Degree Degree;
-  typedef Ogre::Vector2 Vector2;
-  typedef Ogre::Vector3 Vector3;
-  typedef Ogre::Vector4 Vector4;
-  typedef Ogre::Matrix3 Matrix3;
-  typedef Ogre::Matrix4 Matrix4;
-  typedef Ogre::Quaternion Quaternion;
-  typedef Ogre::ColourValue ColourValue;
-}
-
-_UtilExport std::ostream& operator<<(std::ostream& out, const orxonox::Radian& radian);
-_UtilExport std::istream& operator>>(std::istream& in, orxonox::Radian& radian);
-_UtilExport std::ostream& operator<<(std::ostream& out, const orxonox::Degree& degree);
-_UtilExport std::istream& operator>>(std::istream& in, orxonox::Degree& degree);
-
-_UtilExport float getAngle(const orxonox::Vector3& myposition, const orxonox::Vector3& mydirection, const orxonox::Vector3& otherposition);
-_UtilExport orxonox::Vector2 get2DViewdirection(const orxonox::Vector3& myposition, const orxonox::Vector3& mydirection, const orxonox::Vector3& myorthonormal, const orxonox::Vector3& otherposition);
-_UtilExport orxonox::Vector2 get2DViewcoordinates(const orxonox::Vector3& myposition, const orxonox::Vector3& mydirection, const orxonox::Vector3& myorthonormal, const orxonox::Vector3& otherposition);
-_UtilExport orxonox::Vector3 getPredictedPosition(const orxonox::Vector3& myposition, float projectilespeed, const orxonox::Vector3& targetposition, const orxonox::Vector3& targetvelocity);
 
 //Get around Windows hackery
@@ -83 +60 @@
 #endif
 
-/**
-    @brief Returns the sign of the given value.
-    @param x The value
-    @return 1 if the value is positive or zero, -1 if the value is negative
-*/
-template <typename T>
-inline T sgn(T x)
+namespace orxonox
 {
-    return (x >= 0) ? 1 : -1;
+    typedef Ogre::Radian Radian;
+    typedef Ogre::Degree Degree;
+    typedef Ogre::Vector2 Vector2;
+    typedef Ogre::Vector3 Vector3;
+    typedef Ogre::Vector4 Vector4;
+    typedef Ogre::Matrix3 Matrix3;
+    typedef Ogre::Matrix4 Matrix4;
+    typedef Ogre::Quaternion Quaternion;
+    typedef Ogre::ColourValue ColourValue;
+
+    _UtilExport std::ostream& operator<<(std::ostream& out, const orxonox::Radian& radian);
+    _UtilExport std::istream& operator>>(std::istream& in, orxonox::Radian& radian);
+    _UtilExport std::ostream& operator<<(std::ostream& out, const orxonox::Degree& degree);
+    _UtilExport std::istream& operator>>(std::istream& in, orxonox::Degree& degree);
+
+    _UtilExport float getAngle(const orxonox::Vector3& myposition, const orxonox::Vector3& mydirection, const orxonox::Vector3& otherposition);
+    _UtilExport orxonox::Vector2 get2DViewdirection(const orxonox::Vector3& myposition, const orxonox::Vector3& mydirection, const orxonox::Vector3& myorthonormal, const orxonox::Vector3& otherposition);
+    _UtilExport orxonox::Vector2 get2DViewcoordinates(const orxonox::Vector3& myposition, const orxonox::Vector3& mydirection, const orxonox::Vector3& myorthonormal, const orxonox::Vector3& otherposition);
+    _UtilExport orxonox::Vector3 getPredictedPosition(const orxonox::Vector3& myposition, float projectilespeed, const orxonox::Vector3& targetposition, const orxonox::Vector3& targetvelocity);
+
+    /**
+        @brief Returns the sign of the given value.
+        @param x The value
+        @return 1 if the value is positive or zero, -1 if the value is negative
+    */
+    template <typename T>
+    inline T sgn(T x)
+    {
+        return (x >= 0) ? 1 : -1;
+    }
+
+    /**
+        @brief Returns the smaller of two values.
+    */
+    template <typename T>
+    inline T min(T a, T b)
+    {
+        return (a <= b) ? a : b;
+    }
+
+    /**
+        @brief Returns the greater of two values.
+    */
+    template <typename T>
+    inline T max(T a, T b)
+    {
+        return (a >= b) ? a : b;
+    }
+
+    /**
+        @brief Keeps a value between a lower and an upper limit.
+        @param x The value
+        @param min The lower limit
+        @param max The upper limit
+    */
+    template <typename T>
+    inline T clamp(T x, T min, T max)
+    {
+        if (x < min)
+            return min;
+
+        if (x > max)
+            return max;
+
+        return x;
+    }
+
+    /**
+        @brief Returns the square value (x^2).
+    */
+    template <typename T>
+    inline T square(T x)
+    {
+        return x*x;
+    }
+
+    /**
+        @brief Returns the cube value (x^3).
+    */
+    template <typename T>
+    inline T cube(T x)
+    {
+        return x*x*x;
+    }
+
+    /**
+        @brief Rounds the value down.
+    */
+    template <typename T>
+    inline int floor(T x)
+    {
+        return (int)(x);
+    }
+
+    /**
+        @brief Rounds the value up.
+    */
+    template <typename T>
+    inline int ceil(T x)
+    {
+        int temp = floor(x);
+        return (temp != x) ? (temp + 1) : temp;
+    }
+
+    /**
+        @brief Rounds the value.
+    */
+    template <typename T>
+    inline int round(T x)
+    {
+        return (int)(x + 0.5);
+    }
+
+    /**
+        @brief The modulo operation, enhanced to work properly with negative values.
+        @param x The value
+        @param max The operand
+    */
+    template <typename T>
+    inline int mod(T x, int max)
+    {
+        if (x >= 0)
+            return (x % max);
+        else
+            return ((x % max) + max);
+    }
+
+    template <typename T>
+    inline T zeroise()
+    {
+        BOOST_STATIC_ASSERT(sizeof(T) == 0);
+        return T();
+    }
+
+    template <> inline char                 zeroise<char>()                 { return 0; }
+    template <> inline unsigned char        zeroise<unsigned char>()        { return 0; }
+    template <> inline short                zeroise<short>()                { return 0; }
+    template <> inline unsigned short       zeroise<unsigned short>()       { return 0; }
+    template <> inline int                  zeroise<int>()                  { return 0; }
+    template <> inline unsigned int         zeroise<unsigned int>()         { return 0; }
+    template <> inline long                 zeroise<long>()                 { return 0; }
+    template <> inline unsigned long        zeroise<unsigned long>()        { return 0; }
+    template <> inline long long            zeroise<long long>()            { return 0; }
+    template <> inline unsigned long long   zeroise<unsigned long long>()   { return 0; }
+    template <> inline float                zeroise<float>()                { return 0; }
+    template <> inline double               zeroise<double>()               { return 0; }
+    template <> inline long double          zeroise<long double>()          { return 0; }
+    template <> inline bool                 zeroise<bool>()                 { return 0; }
+    template <> inline void*                zeroise<void*>()                { return 0; }
+    template <> inline std::string          zeroise<std::string>()          { return ""; }
+    template <> inline orxonox::Radian      zeroise<orxonox::Radian>()      { return orxonox::Radian(0.0f); }
+    template <> inline orxonox::Degree      zeroise<orxonox::Degree>()      { return orxonox::Degree(0.0f); }
+    template <> inline orxonox::Vector2     zeroise<orxonox::Vector2>()     { return orxonox::Vector2    (0, 0)      ; }
+    template <> inline orxonox::Vector3     zeroise<orxonox::Vector3>()     { return orxonox::Vector3    (0, 0, 0)   ; }
+    template <> inline orxonox::Vector4     zeroise<orxonox::Vector4>()     { return orxonox::Vector4    (0, 0, 0, 0); }
+    template <> inline orxonox::ColourValue zeroise<orxonox::ColourValue>() { return orxonox::ColourValue(0, 0, 0, 0); }
+    template <> inline orxonox::Quaternion  zeroise<orxonox::Quaternion>()  { return orxonox::Quaternion (0, 0, 0, 0); }
+
+    /**
+        @brief Interpolates between two values for a time between 0 and 1.
+        @param time The time is a value between 0 and 1 - the function returns start if time is 0 and end if time is 1 and interpolates if time is between 0 and 1.
+        @param start The value at time = 0
+        @param end The value at time = 1
+        @return The interpolation at a given time
+    */
+    template <typename T>
+    T interpolate(float time, const T& start, const T& end)
+    {
+        return time * (end - start) + start;
+    }
+
+    /**
+        @brief Interpolates smoothly between two values for a time between 0 and 1. The function starts slowly, increases faster and stops slowly again.
+        @param time The time is a value between 0 and 1 - the function returns start if time is 0 and end if time is 1 and interpolates if time is between 0 and 1.
+        @param start The value at time = 0
+        @param end The value at time = 1
+        @return The smoothed interpolation at a given time
+    */
+    template <typename T>
+    T interpolateSmooth(float time, const T& start, const T& end)
+    {
+        return (-2 * (end - start) * cube(time)) + (3 * (end - start) * square(time)) + start;
+    }
+
+    /**
+        @brief Returns a random number between 0 and almost 1: 0 <= rnd < 1.
+    */
+    inline float rnd()
+    {
+        return rand() / (RAND_MAX + 1.0);
+    }
+
+    /**
+        @brief Returns a random number between 0 and almost max: 0 <= rnd < max.
+        @param max The maximum
+    */
+    inline float rnd(float max)
+    {
+        return rnd() * max;
+    }
+
+    /**
+        @brief Returns a random number between min and almost max: min <= rnd < max.
+        @param min The minimum
+        @param max The maximum
+    */
+    inline float rnd(float min, float max)
+    {
+        return rnd(max - min) + min;
+    }
+
+    _UtilExport unsigned long getUniqueNumber();
+
+    class IntVector2
+    {
+    public:
+      IntVector2() : x(0), y(0) { }
+      IntVector2(int _x, int _y) : x(_x), y(_y) { }
+      int x;
+      int y;
+    };
+
+    class IntVector3
+    {
+    public:
+      IntVector3() : x(0), y(0), z(0) { }
+      IntVector3(int _x, int _y, int _z) : x(_x), y(_y), z(_z) { }
+      int x;
+      int y;
+      int z;
+    };
 }
 
-/**
-    @brief Returns the smaller of two values.
-*/
-template <typename T>
-inline T min(T a, T b)
-{
-    return (a <= b) ? a : b;
-}
-
-/**
-    @brief Returns the greater of two values.
-*/
-template <typename T>
-inline T max(T a, T b)
-{
-    return (a >= b) ? a : b;
-}
-
-/**
-    @brief Keeps a value between a lower and an upper limit.
-    @param x The value
-    @param min The lower limit
-    @param max The upper limit
-*/
-template <typename T>
-inline T clamp(T x, T min, T max)
-{
-    if (x < min)
-        return min;
-
-    if (x > max)
-        return max;
-
-    return x;
-}
-
-/**
-    @brief Returns the square value (x^2).
-*/
-template <typename T>
-inline T square(T x)
-{
-    return x*x;
-}
-
-/**
-    @brief Returns the cube value (x^3).
-*/
-template <typename T>
-inline T cube(T x)
-{
-    return x*x*x;
-}
-
-/**
-    @brief Rounds the value down.
-*/
-template <typename T>
-inline int floor(T x)
-{
-    return (int)(x);
-}
-
-/**
-    @brief Rounds the value up.
-*/
-template <typename T>
-inline int ceil(T x)
-{
-    int temp = floor(x);
-    return (temp != x) ? (temp + 1) : temp;
-}
-
-/**
-    @brief Rounds the value.
-*/
-template <typename T>
-inline int round(T x)
-{
-    return (int)(x + 0.5);
-}
-
-/**
-    @brief The modulo operation, enhanced to work properly with negative values.
-    @param x The value
-    @param max The operand
-*/
-template <typename T>
-inline int mod(T x, int max)
-{
-    if (x >= 0)
-        return (x % max);
-    else
-        return ((x % max) + max);
-}
-
-template <typename T>
-inline T zeroise()
-{
-    BOOST_STATIC_ASSERT(sizeof(T) == 0);
-    return T();
-}
-
-template <> inline char                 zeroise<char>()                 { return 0; }
-template <> inline unsigned char        zeroise<unsigned char>()        { return 0; }
-template <> inline short                zeroise<short>()                { return 0; }
-template <> inline unsigned short       zeroise<unsigned short>()       { return 0; }
-template <> inline int                  zeroise<int>()                  { return 0; }
-template <> inline unsigned int         zeroise<unsigned int>()         { return 0; }
-template <> inline long                 zeroise<long>()                 { return 0; }
-template <> inline unsigned long        zeroise<unsigned long>()        { return 0; }
-template <> inline long long            zeroise<long long>()            { return 0; }
-template <> inline unsigned long long   zeroise<unsigned long long>()   { return 0; }
-template <> inline float                zeroise<float>()                { return 0; }
-template <> inline double               zeroise<double>()               { return 0; }
-template <> inline long double          zeroise<long double>()          { return 0; }
-template <> inline bool                 zeroise<bool>()                 { return 0; }
-template <> inline void*                zeroise<void*>()                { return 0; }
-template <> inline std::string          zeroise<std::string>()          { return ""; }
-template <> inline orxonox::Radian      zeroise<orxonox::Radian>()      { return orxonox::Radian(0.0f); }
-template <> inline orxonox::Degree      zeroise<orxonox::Degree>()      { return orxonox::Degree(0.0f); }
-template <> inline orxonox::Vector2     zeroise<orxonox::Vector2>()     { return orxonox::Vector2    (0, 0)      ; }
-template <> inline orxonox::Vector3     zeroise<orxonox::Vector3>()     { return orxonox::Vector3    (0, 0, 0)   ; }
-template <> inline orxonox::Vector4     zeroise<orxonox::Vector4>()     { return orxonox::Vector4    (0, 0, 0, 0); }
-template <> inline orxonox::ColourValue zeroise<orxonox::ColourValue>() { return orxonox::ColourValue(0, 0, 0, 0); }
-template <> inline orxonox::Quaternion  zeroise<orxonox::Quaternion>()  { return orxonox::Quaternion (0, 0, 0, 0); }
-
-/**
-    @brief Interpolates between two values for a time between 0 and 1.
-    @param time The time is a value between 0 and 1 - the function returns start if time is 0 and end if time is 1 and interpolates if time is between 0 and 1.
-    @param start The value at time = 0
-    @param end The value at time = 1
-    @return The interpolation at a given time
-*/
-template <typename T>
-T interpolate(float time, const T& start, const T& end)
-{
-    return time * (end - start) + start;
-}
-
-/**
-    @brief Interpolates smoothly between two values for a time between 0 and 1. The function starts slowly, increases faster and stops slowly again.
-    @param time The time is a value between 0 and 1 - the function returns start if time is 0 and end if time is 1 and interpolates if time is between 0 and 1.
-    @param start The value at time = 0
-    @param end The value at time = 1
-    @return The smoothed interpolation at a given time
-*/
-template <typename T>
-T interpolateSmooth(float time, const T& start, const T& end)
-{
-    return (-2 * (end - start) * cube(time)) + (3 * (end - start) * square(time)) + start;
-}
-
-/**
-    @brief Returns a random number between 0 and almost 1: 0 <= rnd < 1.
-*/
-inline _UtilExport float rnd()
-{
-    return rand() / (RAND_MAX + 1.0);
-}
-
-/**
-    @brief Returns a random number between 0 and almost max: 0 <= rnd < max.
-    @param max The maximum
-*/
-inline _UtilExport float rnd(float max)
-{
-    return rnd() * max;
-}
-
-/**
-    @brief Returns a random number between min and almost max: min <= rnd < max.
-    @param min The minimum
-    @param max The maximum
-*/
-inline _UtilExport float rnd(float min, float max)
-{
-    return rnd(max - min) + min;
-}
-
-_UtilExport unsigned long getUniqueNumber();
-
-class _UtilExport IntVector2
-{
-public:
-  IntVector2() : x(0), y(0) { }
-  IntVector2(int _x, int _y) : x(_x), y(_y) { }
-  int x;
-  int y;
-};
-
-class _UtilExport IntVector3
-{
-public:
-  IntVector3() : x(0), y(0), z(0) { }
-  IntVector3(int _x, int _y, int _z) : x(_x), y(_y), z(_z) { }
-  int x;
-  int y;
-  int z;
-};
-
 #endif /* _Util_Math_H__ */

code/branches/objecthierarchy/src/util/MathConvert.h

@@ -40 +40 @@
 #include "Convert.h"
 
-
-////////////////////
-// Math to string //
-////////////////////
-
-// Vector2 to std::string
-template <>
-struct ConverterExplicit<orxonox::Vector2, std::string>
+namespace orxonox
 {
-    static bool convert(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
-template <>
-struct ConverterExplicit<orxonox::Vector3, std::string>
-{
-    static bool convert(std::string* output, const orxonox::Vector3& input)
-    {
-        std::ostringstream ostream;
-        if (ostream << input.x << "," << input.y << "," << input.z)
-        {
-            (*output) = ostream.str();
-            return true;
-        }
-        return false;
-    }
-};
-
-// Vector4 to std::string
-template <>
-struct ConverterExplicit<orxonox::Vector4, std::string>
-{
-    static bool convert(std::string* output, const orxonox::Vector4& input)
-    {
-        std::ostringstream ostream;
-        if (ostream << input.x << "," << input.y << "," << input.z << "," << input.w)
-        {
-            (*output) = ostream.str();
-            return true;
-        }
-        return false;
-    }
-};
-
-// Quaternion to std::string
-template <>
-struct ConverterExplicit<orxonox::Quaternion, std::string>
-{
-    static bool convert(std::string* output, const orxonox::Quaternion& input)
-    {
-        std::ostringstream ostream;
-        if (ostream << input.w << "," << input.x << "," << input.y << "," << input.z)
-        {
-            (*output) = ostream.str();
-            return true;
-        }
-        return false;
-    }
-};
-
-// ColourValue to std::string
-template <>
-struct ConverterExplicit<orxonox::ColourValue, std::string>
-{
-    static bool convert(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;
-    }
-};
-
-
-////////////////////
-// string to Math //
-////////////////////
-
-// std::string to Vector2
-template <> struct _UtilExport ConverterFallback<std::string, orxonox::Vector2>
-{ static bool convert(orxonox::Vector2*     output, const std::string& input); };
-// std::string to Vector3
-template <> struct _UtilExport ConverterFallback<std::string, orxonox::Vector3>
-{ static bool convert(orxonox::Vector3*     output, const std::string& input); };
-// std::string to Vector4
-template <> struct _UtilExport ConverterFallback<std::string, orxonox::Vector4>
-{ static bool convert(orxonox::Vector4*     output, const std::string& input); };
-// std::string to Quaternion
-template <> struct _UtilExport ConverterFallback<std::string, orxonox::Quaternion>
-{ static bool convert(orxonox::Quaternion*  output, const std::string& input); };
-// std::string to ColourValue
-template <> struct _UtilExport ConverterFallback<std::string, orxonox::ColourValue>
-{ static bool convert(orxonox::ColourValue* output, const std::string& input); };
-
-
-///////////////////////////////
-// From and to Radian/Degree //
-///////////////////////////////
-
-// From Radian
-template <class ToType>
-struct ConverterFallback<orxonox::Radian, ToType>
-{
-    static bool convert(ToType* output, const orxonox::Radian& input)
-    {
-        return convertValue<Ogre::Real, ToType>(output, input.valueRadians());
-    }
-};
-
-// From Degree
-template <class ToType>
-struct ConverterFallback<orxonox::Degree, ToType>
-{
-    static bool convert(ToType* output, const orxonox::Degree& input)
-    {
-        return convertValue<Ogre::Real, ToType>(output, input.valueDegrees());
-    }
-};
-
-// To Radian
-template <class FromType>
-struct ConverterFallback<FromType, orxonox::Radian>
-{
-    static bool convert(orxonox::Radian* output, const FromType& input)
-    {
-        float temp;
-        if (convertValue(&temp, input))
-        {
-            *output = temp;
-            return true;
-        }
-        else
-            return false;
-    }
-};
-
-// To Degree
-template <class FromType>
-struct ConverterFallback<FromType, orxonox::Degree>
-{
-    static bool convert(orxonox::Degree* output, const FromType& input)
-    {
-        float temp;
-        if (convertValue(&temp, input))
-        {
-            *output = temp;
-            return true;
-        }
-        else
-            return false;
-    }
-};
+    ////////////////////
+    // Math to string //
+    ////////////////////
+
+    // Vector2 to std::string
+    template <>
+    struct ConverterExplicit<orxonox::Vector2, std::string>
+    {
+        static bool convert(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
+    template <>
+    struct ConverterExplicit<orxonox::Vector3, std::string>
+    {
+        static bool convert(std::string* output, const orxonox::Vector3& input)
+        {
+            std::ostringstream ostream;
+            if (ostream << input.x << "," << input.y << "," << input.z)
+            {
+                (*output) = ostream.str();
+                return true;
+            }
+            return false;
+        }
+    };
+
+    // Vector4 to std::string
+    template <>
+    struct ConverterExplicit<orxonox::Vector4, std::string>
+    {
+        static bool convert(std::string* output, const orxonox::Vector4& input)
+        {
+            std::ostringstream ostream;
+            if (ostream << input.x << "," << input.y << "," << input.z << "," << input.w)
+            {
+                (*output) = ostream.str();
+                return true;
+            }
+            return false;
+        }
+    };
+
+    // Quaternion to std::string
+    template <>
+    struct ConverterExplicit<orxonox::Quaternion, std::string>
+    {
+        static bool convert(std::string* output, const orxonox::Quaternion& input)
+        {
+            std::ostringstream ostream;
+            if (ostream << input.w << "," << input.x << "," << input.y << "," << input.z)
+            {
+                (*output) = ostream.str();
+                return true;
+            }
+            return false;
+        }
+    };
+
+    // ColourValue to std::string
+    template <>
+    struct ConverterExplicit<orxonox::ColourValue, std::string>
+    {
+        static bool convert(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;
+        }
+    };
+
+
+    ////////////////////
+    // string to Math //
+    ////////////////////
+
+    // std::string to Vector2
+    template <> struct _UtilExport ConverterFallback<std::string, orxonox::Vector2>
+    { static bool convert(orxonox::Vector2*     output, const std::string& input); };
+    // std::string to Vector3
+    template <> struct _UtilExport ConverterFallback<std::string, orxonox::Vector3>
+    { static bool convert(orxonox::Vector3*     output, const std::string& input); };
+    // std::string to Vector4
+    template <> struct _UtilExport ConverterFallback<std::string, orxonox::Vector4>
+    { static bool convert(orxonox::Vector4*     output, const std::string& input); };
+    // std::string to Quaternion
+    template <> struct _UtilExport ConverterFallback<std::string, orxonox::Quaternion>
+    { static bool convert(orxonox::Quaternion*  output, const std::string& input); };
+    // std::string to ColourValue
+    template <> struct _UtilExport ConverterFallback<std::string, orxonox::ColourValue>
+    { static bool convert(orxonox::ColourValue* output, const std::string& input); };
+
+
+    ///////////////////////////////
+    // From and to Radian/Degree //
+    ///////////////////////////////
+
+    // From Radian
+    template <class ToType>
+    struct ConverterFallback<orxonox::Radian, ToType>
+    {
+        static bool convert(ToType* output, const orxonox::Radian& input)
+        {
+            return convertValue<Ogre::Real, ToType>(output, input.valueRadians());
+        }
+    };
+
+    // From Degree
+    template <class ToType>
+    struct ConverterFallback<orxonox::Degree, ToType>
+    {
+        static bool convert(ToType* output, const orxonox::Degree& input)
+        {
+            return convertValue<Ogre::Real, ToType>(output, input.valueDegrees());
+        }
+    };
+
+    // To Radian
+    template <class FromType>
+    struct ConverterFallback<FromType, orxonox::Radian>
+    {
+        static bool convert(orxonox::Radian* output, const FromType& input)
+        {
+            float temp;
+            if (convertValue(&temp, input))
+            {
+                *output = temp;
+                return true;
+            }
+            else
+                return false;
+        }
+    };
+
+    // To Degree
+    template <class FromType>
+    struct ConverterFallback<FromType, orxonox::Degree>
+    {
+        static bool convert(orxonox::Degree* output, const FromType& input)
+        {
+            float temp;
+            if (convertValue(&temp, input))
+            {
+                *output = temp;
+                return true;
+            }
+            else
+                return false;
+        }
+    };
+}
 
 #endif /* _MathConvert_H__ */

code/branches/objecthierarchy/src/util/MultiType.cc

@@ -35 +35 @@
 #include "MultiTypeValue.h"
 
-/**
-    @brief Converts the current value of the MultiType to a new type.
-    @param type The type
-*/
-bool MultiType::convert(MT_Type type)
+namespace orxonox
 {
-    switch (type)
+    /**
+        @brief Converts the current value of the MultiType to a new type.
+        @param type The type
+    */
+    bool MultiType::convert(MT_Type type)
     {
-        case MT_char:
-            return this->convert<char>(); break;
-        case MT_uchar:
-            return this->convert<unsigned char>(); break;
-        case MT_short:
-            return this->convert<short>(); break;
-        case MT_ushort:
-            return this->convert<unsigned short>(); break;
-        case MT_int:
-            return this->convert<int>(); break;
-        case MT_uint:
-            return this->convert<unsigned int>(); break;
-        case MT_long:
-            return this->convert<long>(); break;
-        case MT_ulong:
-            return this->convert<unsigned long>(); break;
-        case MT_longlong:
-            return this->convert<long long>(); break;
-        case MT_ulonglong:
-            return this->convert<unsigned long long>(); break;
-        case MT_float:
-            return this->convert<float>(); break;
-        case MT_double:
-            return this->convert<double>(); break;
-        case MT_longdouble:
-            return this->convert<long double>(); break;
-        case MT_bool:
-            return this->convert<bool>(); break;
-        case MT_void:
-            return this->convert<void*>(); break;
-        case MT_string:
-            return this->convert<std::string>(); break;
-        case MT_vector2:
-            return this->convert<orxonox::Vector2>(); break;
-        case MT_vector3:
-            return this->convert<orxonox::Vector3>(); break;
-        case MT_vector4:
-            return this->convert<orxonox::Vector4>(); break;
-        case MT_colourvalue:
-            return this->convert<orxonox::ColourValue>(); break;
-        case MT_quaternion:
-            return this->convert<orxonox::Quaternion>(); break;
-        case MT_radian:
-            return this->convert<orxonox::Radian>(); break;
-        case MT_degree:
-            return this->convert<orxonox::Degree>(); break;
-        default:
-            this->reset(); return false; break;
-    };
+        switch (type)
+        {
+            case MT_char:
+                return this->convert<char>(); break;
+            case MT_uchar:
+                return this->convert<unsigned char>(); break;
+            case MT_short:
+                return this->convert<short>(); break;
+            case MT_ushort:
+                return this->convert<unsigned short>(); break;
+            case MT_int:
+                return this->convert<int>(); break;
+            case MT_uint:
+                return this->convert<unsigned int>(); break;
+            case MT_long:
+                return this->convert<long>(); break;
+            case MT_ulong:
+                return this->convert<unsigned long>(); break;
+            case MT_longlong:
+                return this->convert<long long>(); break;
+            case MT_ulonglong:
+                return this->convert<unsigned long long>(); break;
+            case MT_float:
+                return this->convert<float>(); break;
+            case MT_double:
+                return this->convert<double>(); break;
+            case MT_longdouble:
+                return this->convert<long double>(); break;
+            case MT_bool:
+                return this->convert<bool>(); break;
+            case MT_void:
+                return this->convert<void*>(); break;
+            case MT_string:
+                return this->convert<std::string>(); break;
+            case MT_vector2:
+                return this->convert<orxonox::Vector2>(); break;
+            case MT_vector3:
+                return this->convert<orxonox::Vector3>(); break;
+            case MT_vector4:
+                return this->convert<orxonox::Vector4>(); break;
+            case MT_colourvalue:
+                return this->convert<orxonox::ColourValue>(); break;
+            case MT_quaternion:
+                return this->convert<orxonox::Quaternion>(); break;
+            case MT_radian:
+                return this->convert<orxonox::Radian>(); break;
+            case MT_degree:
+                return this->convert<orxonox::Degree>(); break;
+            default:
+                this->reset(); return false; break;
+        };
+    }
+
+    /**
+        @brief Returns the name of the current type.
+        @return The name
+    */
+    std::string MultiType::getTypename() const
+    {
+        MT_Type type = (this->value_) ? this->value_->type_ : MT_null;
+
+        switch (type)
+        {
+            case MT_char:
+                return "char"; break;
+            case MT_uchar:
+                return "unsigned char"; break;
+            case MT_short:
+                return "short"; break;
+            case MT_ushort:
+                return "unsigned short"; break;
+            case MT_int:
+                return "int"; break;
+            case MT_uint:
+                return "unsigned int"; break;
+            case MT_long:
+                return "long"; break;
+            case MT_ulong:
+                return "unsigned long"; break;
+            case MT_longlong:
+                return "long long"; break;
+            case MT_ulonglong:
+                return "unsigned long long"; break;
+            case MT_float:
+                return "float"; break;
+            case MT_double:
+                return "double"; break;
+            case MT_longdouble:
+                return "long double"; break;
+            case MT_bool:
+                return "bool"; break;
+            case MT_void:
+                return "void*"; break;
+            case MT_string:
+                return "std::string"; break;
+            case MT_vector2:
+                return "orxonox::Vector2"; break;
+            case MT_vector3:
+                return "orxonox::Vector3"; break;
+            case MT_vector4:
+                return "orxonox::Vector4"; break;
+            case MT_colourvalue:
+                return "orxonox::ColourValue"; break;
+            case MT_quaternion:
+                return "orxonox::Quaternion"; break;
+            case MT_radian:
+                return "orxonox::Radian"; break;
+            case MT_degree:
+                return "orxonox::Degree"; break;
+            default:
+                return "unknown"; break;
+        };
+    }
+
+    MultiType::operator char()                 const { return (this->value_) ? ((this->value_->type_ == MT_char       ) ? ((MT_Value<char>                *)this->value_)->value_ : (*this->value_)) : 0;                      } /** @brief Returns the current value, converted to the requested type. */
+    MultiType::operator unsigned char()        const { return (this->value_) ? ((this->value_->type_ == MT_uchar      ) ? ((MT_Value<unsigned char>       *)this->value_)->value_ : (*this->value_)) : 0;                      } /** @brief Returns the current value, converted to the requested type. */
+    MultiType::operator short()                const { return (this->value_) ? ((this->value_->type_ == MT_short      ) ? ((MT_Value<short>               *)this->value_)->value_ : (*this->value_)) : 0;                      } /** @brief Returns the current value, converted to the requested type. */
+    MultiType::operator unsigned short()       const { return (this->value_) ? ((this->value_->type_ == MT_ushort     ) ? ((MT_Value<unsigned short>      *)this->value_)->value_ : (*this->value_)) : 0;                      } /** @brief Returns the current value, converted to the requested type. */
+    MultiType::operator int()                  const { return (this->value_) ? ((this->value_->type_ == MT_int        ) ? ((MT_Value<int>                 *)this->value_)->value_ : (*this->value_)) : 0;                      } /** @brief Returns the current value, converted to the requested type. */
+    MultiType::operator unsigned int()         const { return (this->value_) ? ((this->value_->type_ == MT_uint       ) ? ((MT_Value<unsigned int>        *)this->value_)->value_ : (*this->value_)) : 0;                      } /** @brief Returns the current value, converted to the requested type. */
+    MultiType::operator long()                 const { return (this->value_) ? ((this->value_->type_ == MT_long       ) ? ((MT_Value<long>                *)this->value_)->value_ : (*this->value_)) : 0;                      } /** @brief Returns the current value, converted to the requested type. */
+    MultiType::operator unsigned long()        const { return (this->value_) ? ((this->value_->type_ == MT_ulong      ) ? ((MT_Value<unsigned long>       *)this->value_)->value_ : (*this->value_)) : 0;                      } /** @brief Returns the current value, converted to the requested type. */
+    MultiType::operator long long()            const { return (this->value_) ? ((this->value_->type_ == MT_longlong   ) ? ((MT_Value<long long>           *)this->value_)->value_ : (*this->value_)) : 0;                      } /** @brief Returns the current value, converted to the requested type. */
+    MultiType::operator unsigned long long()   const { return (this->value_) ? ((this->value_->type_ == MT_ulonglong  ) ? ((MT_Value<unsigned long long>  *)this->value_)->value_ : (*this->value_)) : 0;                      } /** @brief Returns the current value, converted to the requested type. */
+    MultiType::operator float()                const { return (this->value_) ? ((this->value_->type_ == MT_float      ) ? ((MT_Value<float>               *)this->value_)->value_ : (*this->value_)) : 0;                      } /** @brief Returns the current value, converted to the requested type. */
+    MultiType::operator double()               const { return (this->value_) ? ((this->value_->type_ == MT_double     ) ? ((MT_Value<double>              *)this->value_)->value_ : (*this->value_)) : 0;                      } /** @brief Returns the current value, converted to the requested type. */
+    MultiType::operator long double()          const { return (this->value_) ? ((this->value_->type_ == MT_longdouble ) ? ((MT_Value<long double>         *)this->value_)->value_ : (*this->value_)) : 0;                      } /** @brief Returns the current value, converted to the requested type. */
+    MultiType::operator bool()                 const { return (this->value_) ? ((this->value_->type_ == MT_bool       ) ? ((MT_Value<bool>                *)this->value_)->value_ : (*this->value_)) : 0;                      } /** @brief Returns the current value, converted to the requested type. */
+    MultiType::operator void*()                const { return (this->value_) ? ((this->value_->type_ == MT_void       ) ? ((MT_Value<void*>               *)this->value_)->value_ : (*this->value_)) : 0;                      } /** @brief Returns the current value, converted to the requested type. */
+    MultiType::operator std::string()          const { return (this->value_) ? ((this->value_->type_ == MT_string     ) ? ((MT_Value<std::string>         *)this->value_)->value_ : (*this->value_)) : zeroise<std::string>();          } /** @brief Returns the current value, converted to the requested type. */
+    MultiType::operator orxonox::Vector2()     const { return (this->value_) ? ((this->value_->type_ == MT_vector2    ) ? ((MT_Value<orxonox::Vector2>    *)this->value_)->value_ : (*this->value_)) : zeroise<orxonox::Vector2>();     } /** @brief Returns the current value, converted to the requested type. */
+    MultiType::operator orxonox::Vector3()     const { return (this->value_) ? ((this->value_->type_ == MT_vector3    ) ? ((MT_Value<orxonox::Vector3>    *)this->value_)->value_ : (*this->value_)) : zeroise<orxonox::Vector3>();     } /** @brief Returns the current value, converted to the requested type. */
+    MultiType::operator orxonox::Vector4()     const { return (this->value_) ? ((this->value_->type_ == MT_vector4    ) ? ((MT_Value<orxonox::Vector4>    *)this->value_)->value_ : (*this->value_)) : zeroise<orxonox::Vector4>();     } /** @brief Returns the current value, converted to the requested type. */
+    MultiType::operator orxonox::ColourValue() const { return (this->value_) ? ((this->value_->type_ == MT_colourvalue) ? ((MT_Value<orxonox::ColourValue>*)this->value_)->value_ : (*this->value_)) : zeroise<orxonox::ColourValue>(); } /** @brief Returns the current value, converted to the requested type. */
+    MultiType::operator orxonox::Quaternion()  const { return (this->value_) ? ((this->value_->type_ == MT_quaternion ) ? ((MT_Value<orxonox::Quaternion> *)this->value_)->value_ : (*this->value_)) : zeroise<orxonox::Quaternion>();  } /** @brief Returns the current value, converted to the requested type. */
+    MultiType::operator orxonox::Radian()      const { return (this->value_) ? ((this->value_->type_ == MT_radian     ) ? ((MT_Value<orxonox::Radian>     *)this->value_)->value_ : (*this->value_)) : zeroise<orxonox::Radian>();      } /** @brief Returns the current value, converted to the requested type. */
+    MultiType::operator orxonox::Degree()      const { return (this->value_) ? ((this->value_->type_ == MT_degree     ) ? ((MT_Value<orxonox::Degree>     *)this->value_)->value_ : (*this->value_)) : zeroise<orxonox::Degree>();      } /** @brief Returns the current value, converted to the requested type. */
+
+    template <> void MultiType::createNewValueContainer(const char& value)                 { this->value_ = new MT_Value<char>                (value, MT_char       ); } /** @brief Creates a new value container for the given type. */
+    template <> void MultiType::createNewValueContainer(const unsigned char& value)        { this->value_ = new MT_Value<unsigned char>       (value, MT_uchar      ); } /** @brief Creates a new value container for the given type. */
+    template <> void MultiType::createNewValueContainer(const short& value)                { this->value_ = new MT_Value<short>               (value, MT_short      ); } /** @brief Creates a new value container for the given type. */
+    template <> void MultiType::createNewValueContainer(const unsigned short& value)       { this->value_ = new MT_Value<unsigned short>      (value, MT_ushort     ); } /** @brief Creates a new value container for the given type. */
+    template <> void MultiType::createNewValueContainer(const int& value)                  { this->value_ = new MT_Value<int>                 (value, MT_int        ); } /** @brief Creates a new value container for the given type. */
+    template <> void MultiType::createNewValueContainer(const unsigned int& value)         { this->value_ = new MT_Value<unsigned int>        (value, MT_uint       ); } /** @brief Creates a new value container for the given type. */
+    template <> void MultiType::createNewValueContainer(const long& value)                 { this->value_ = new MT_Value<long>                (value, MT_long       ); } /** @brief Creates a new value container for the given type. */
+    template <> void MultiType::createNewValueContainer(const unsigned long& value)        { this->value_ = new MT_Value<unsigned long>       (value, MT_ulong      ); } /** @brief Creates a new value container for the given type. */
+    template <> void MultiType::createNewValueContainer(const long long& value)            { this->value_ = new MT_Value<long long>           (value, MT_longlong   ); } /** @brief Creates a new value container for the given type. */
+    template <> void MultiType::createNewValueContainer(const unsigned long long& value)   { this->value_ = new MT_Value<unsigned long long>  (value, MT_ulonglong  ); } /** @brief Creates a new value container for the given type. */
+    template <> void MultiType::createNewValueContainer(const float& value)                { this->value_ = new MT_Value<float>               (value, MT_float      ); } /** @brief Creates a new value container for the given type. */
+    template <> void MultiType::createNewValueContainer(const double& value)               { this->value_ = new MT_Value<double>              (value, MT_double     ); } /** @brief Creates a new value container for the given type. */
+    template <> void MultiType::createNewValueContainer(const long double& value)          { this->value_ = new MT_Value<long double>         (value, MT_longdouble ); } /** @brief Creates a new value container for the given type. */
+    template <> void MultiType::createNewValueContainer(const bool& value)                 { this->value_ = new MT_Value<bool>                (value, MT_bool       ); } /** @brief Creates a new value container for the given type. */
+    template <> void MultiType::createNewValueContainer(      void* const& value)          { this->value_ = new MT_Value<void*>               (value, MT_void       ); } /** @brief Creates a new value container for the given type. */
+    template <> void MultiType::createNewValueContainer(const std::string& value)          { this->value_ = new MT_Value<std::string>         (value, MT_string     ); } /** @brief Creates a new value container for the given type. */
+    template <> void MultiType::createNewValueContainer(const orxonox::Vector2& value)     { this->value_ = new MT_Value<orxonox::Vector2>    (value, MT_vector2    ); } /** @brief Creates a new value container for the given type. */
+    template <> void MultiType::createNewValueContainer(const orxonox::Vector3& value)     { this->value_ = new MT_Value<orxonox::Vector3>    (value, MT_vector3    ); } /** @brief Creates a new value container for the given type. */
+    template <> void MultiType::createNewValueContainer(const orxonox::Vector4& value)     { this->value_ = new MT_Value<orxonox::Vector4>    (value, MT_vector4    ); } /** @brief Creates a new value container for the given type. */
+    template <> void MultiType::createNewValueContainer(const orxonox::ColourValue& value) { this->value_ = new MT_Value<orxonox::ColourValue>(value, MT_colourvalue); } /** @brief Creates a new value container for the given type. */
+    template <> void MultiType::createNewValueContainer(const orxonox::Quaternion& value)  { this->value_ = new MT_Value<orxonox::Quaternion> (value, MT_quaternion ); } /** @brief Creates a new value container for the given type. */
+    template <> void MultiType::createNewValueContainer(const orxonox::Radian& value)      { this->value_ = new MT_Value<orxonox::Radian>     (value, MT_radian     ); } /** @brief Creates a new value container for the given type. */
+    template <> void MultiType::createNewValueContainer(const orxonox::Degree& value)      { this->value_ = new MT_Value<orxonox::Degree>     (value, MT_degree     ); } /** @brief Creates a new value container for the given type. */
 }
-
-/**
-    @brief Returns the name of the current type.
-    @return The name
-*/
-std::string MultiType::getTypename() const
-{
-    MT_Type type = (this->value_) ? this->value_->type_ : MT_null;
-
-    switch (type)
-    {
-        case MT_char:
-            return "char"; break;
-        case MT_uchar:
-            return "unsigned char"; break;
-        case MT_short:
-            return "short"; break;
-        case MT_ushort:
-            return "unsigned short"; break;
-        case MT_int:
-            return "int"; break;
-        case MT_uint:
-            return "unsigned int"; break;
-        case MT_long:
-            return "long"; break;
-        case MT_ulong:
-            return "unsigned long"; break;
-        case MT_longlong:
-            return "long long"; break;
-        case MT_ulonglong:
-            return "unsigned long long"; break;
-        case MT_float:
-            return "float"; break;
-        case MT_double:
-            return "double"; break;
-        case MT_longdouble:
-            return "long double"; break;
-        case MT_bool:
-            return "bool"; break;
-        case MT_void:
-            return "void*"; break;
-        case MT_string:
-            return "std::string"; break;
-        case MT_vector2:
-            return "orxonox::Vector2"; break;
-        case MT_vector3:
-            return "orxonox::Vector3"; break;
-        case MT_vector4:
-            return "orxonox::Vector4"; break;
-        case MT_colourvalue:
-            return "orxonox::ColourValue"; break;
-        case MT_quaternion:
-            return "orxonox::Quaternion"; break;
-        case MT_radian:
-            return "orxonox::Radian"; break;
-        case MT_degree:
-            return "orxonox::Degree"; break;
-        default:
-            return "unknown"; break;
-    };
-}
-
-MultiType::operator char()                 const { return (this->value_) ? ((this->value_->type_ == MT_char       ) ? ((MT_Value<char>                *)this->value_)->value_ : (*this->value_)) : 0;                      } /** @brief Returns the current value, converted to the requested type. */
-MultiType::operator unsigned char()        const { return (this->value_) ? ((this->value_->type_ == MT_uchar      ) ? ((MT_Value<unsigned char>       *)this->value_)->value_ : (*this->value_)) : 0;                      } /** @brief Returns the current value, converted to the requested type. */
-MultiType::operator short()                const { return (this->value_) ? ((this->value_->type_ == MT_short      ) ? ((MT_Value<short>               *)this->value_)->value_ : (*this->value_)) : 0;                      } /** @brief Returns the current value, converted to the requested type. */
-MultiType::operator unsigned short()       const { return (this->value_) ? ((this->value_->type_ == MT_ushort     ) ? ((MT_Value<unsigned short>      *)this->value_)->value_ : (*this->value_)) : 0;                      } /** @brief Returns the current value, converted to the requested type. */
-MultiType::operator int()                  const { return (this->value_) ? ((this->value_->type_ == MT_int        ) ? ((MT_Value<int>                 *)this->value_)->value_ : (*this->value_)) : 0;                      } /** @brief Returns the current value, converted to the requested type. */
-MultiType::operator unsigned int()         const { return (this->value_) ? ((this->value_->type_ == MT_uint       ) ? ((MT_Value<unsigned int>        *)this->value_)->value_ : (*this->value_)) : 0;                      } /** @brief Returns the current value, converted to the requested type. */
-MultiType::operator long()                 const { return (this->value_) ? ((this->value_->type_ == MT_long       ) ? ((MT_Value<long>                *)this->value_)->value_ : (*this->value_)) : 0;                      } /** @brief Returns the current value, converted to the requested type. */
-MultiType::operator unsigned long()        const { return (this->value_) ? ((this->value_->type_ == MT_ulong      ) ? ((MT_Value<unsigned long>       *)this->value_)->value_ : (*this->value_)) : 0;                      } /** @brief Returns the current value, converted to the requested type. */
-MultiType::operator long long()            const { return (this->value_) ? ((this->value_->type_ == MT_longlong   ) ? ((MT_Value<long long>           *)this->value_)->value_ : (*this->value_)) : 0;                      } /** @brief Returns the current value, converted to the requested type. */
-MultiType::operator unsigned long long()   const { return (this->value_) ? ((this->value_->type_ == MT_ulonglong  ) ? ((MT_Value<unsigned long long>  *)this->value_)->value_ : (*this->value_)) : 0;                      } /** @brief Returns the current value, converted to the requested type. */
-MultiType::operator float()                const { return (this->value_) ? ((this->value_->type_ == MT_float      ) ? ((MT_Value<float>               *)this->value_)->value_ : (*this->value_)) : 0;                      } /** @brief Returns the current value, converted to the requested type. */
-MultiType::operator double()               const { return (this->value_) ? ((this->value_->type_ == MT_double     ) ? ((MT_Value<double>              *)this->value_)->value_ : (*this->value_)) : 0;                      } /** @brief Returns the current value, converted to the requested type. */
-MultiType::operator long double()          const { return (this->value_) ? ((this->value_->type_ == MT_longdouble ) ? ((MT_Value<long double>         *)this->value_)->value_ : (*this->value_)) : 0;                      } /** @brief Returns the current value, converted to the requested type. */
-MultiType::operator bool()                 const { return (this->value_) ? ((this->value_->type_ == MT_bool       ) ? ((MT_Value<bool>                *)this->value_)->value_ : (*this->value_)) : 0;                      } /** @brief Returns the current value, converted to the requested type. */
-MultiType::operator void*()                const { return (this->value_) ? ((this->value_->type_ == MT_void       ) ? ((MT_Value<void*>               *)this->value_)->value_ : (*this->value_)) : 0;                      } /** @brief Returns the current value, converted to the requested type. */
-MultiType::operator std::string()          const { return (this->value_) ? ((this->value_->type_ == MT_string     ) ? ((MT_Value<std::string>         *)this->value_)->value_ : (*this->value_)) : zeroise<std::string>();          } /** @brief Returns the current value, converted to the requested type. */
-MultiType::operator orxonox::Vector2()     const { return (this->value_) ? ((this->value_->type_ == MT_vector2    ) ? ((MT_Value<orxonox::Vector2>    *)this->value_)->value_ : (*this->value_)) : zeroise<orxonox::Vector2>();     } /** @brief Returns the current value, converted to the requested type. */
-MultiType::operator orxonox::Vector3()     const { return (this->value_) ? ((this->value_->type_ == MT_vector3    ) ? ((MT_Value<orxonox::Vector3>    *)this->value_)->value_ : (*this->value_)) : zeroise<orxonox::Vector3>();     } /** @brief Returns the current value, converted to the requested type. */
-MultiType::operator orxonox::Vector4()     const { return (this->value_) ? ((this->value_->type_ == MT_vector4    ) ? ((MT_Value<orxonox::Vector4>    *)this->value_)->value_ : (*this->value_)) : zeroise<orxonox::Vector4>();     } /** @brief Returns the current value, converted to the requested type. */
-MultiType::operator orxonox::ColourValue() const { return (this->value_) ? ((this->value_->type_ == MT_colourvalue) ? ((MT_Value<orxonox::ColourValue>*)this->value_)->value_ : (*this->value_)) : zeroise<orxonox::ColourValue>(); } /** @brief Returns the current value, converted to the requested type. */
-MultiType::operator orxonox::Quaternion()  const { return (this->value_) ? ((this->value_->type_ == MT_quaternion ) ? ((MT_Value<orxonox::Quaternion> *)this->value_)->value_ : (*this->value_)) : zeroise<orxonox::Quaternion>();  } /** @brief Returns the current value, converted to the requested type. */
-MultiType::operator orxonox::Radian()      const { return (this->value_) ? ((this->value_->type_ == MT_radian     ) ? ((MT_Value<orxonox::Radian>     *)this->value_)->value_ : (*this->value_)) : zeroise<orxonox::Radian>();      } /** @brief Returns the current value, converted to the requested type. */
-MultiType::operator orxonox::Degree()      const { return (this->value_) ? ((this->value_->type_ == MT_degree     ) ? ((MT_Value<orxonox::Degree>     *)this->value_)->value_ : (*this->value_)) : zeroise<orxonox::Degree>();      } /** @brief Returns the current value, converted to the requested type. */
-
-template <> void MultiType::createNewValueContainer(const char& value)                 { this->value_ = new MT_Value<char>                (value, MT_char       ); } /** @brief Creates a new value container for the given type. */
-template <> void MultiType::createNewValueContainer(const unsigned char& value)        { this->value_ = new MT_Value<unsigned char>       (value, MT_uchar      ); } /** @brief Creates a new value container for the given type. */
-template <> void MultiType::createNewValueContainer(const short& value)                { this->value_ = new MT_Value<short>               (value, MT_short      ); } /** @brief Creates a new value container for the given type. */
-template <> void MultiType::createNewValueContainer(const unsigned short& value)       { this->value_ = new MT_Value<unsigned short>      (value, MT_ushort     ); } /** @brief Creates a new value container for the given type. */
-template <> void MultiType::createNewValueContainer(const int& value)                  { this->value_ = new MT_Value<int>                 (value, MT_int        ); } /** @brief Creates a new value container for the given type. */
-template <> void MultiType::createNewValueContainer(const unsigned int& value)         { this->value_ = new MT_Value<unsigned int>        (value, MT_uint       ); } /** @brief Creates a new value container for the given type. */
-template <> void MultiType::createNewValueContainer(const long& value)                 { this->value_ = new MT_Value<long>                (value, MT_long       ); } /** @brief Creates a new value container for the given type. */
-template <> void MultiType::createNewValueContainer(const unsigned long& value)        { this->value_ = new MT_Value<unsigned long>       (value, MT_ulong      ); } /** @brief Creates a new value container for the given type. */
-template <> void MultiType::createNewValueContainer(const long long& value)            { this->value_ = new MT_Value<long long>           (value, MT_longlong   ); } /** @brief Creates a new value container for the given type. */
-template <> void MultiType::createNewValueContainer(const unsigned long long& value)   { this->value_ = new MT_Value<unsigned long long>  (value, MT_ulonglong  ); } /** @brief Creates a new value container for the given type. */
-template <> void MultiType::createNewValueContainer(const float& value)                { this->value_ = new MT_Value<float>               (value, MT_float      ); } /** @brief Creates a new value container for the given type. */
-template <> void MultiType::createNewValueContainer(const double& value)               { this->value_ = new MT_Value<double>              (value, MT_double     ); } /** @brief Creates a new value container for the given type. */
-template <> void MultiType::createNewValueContainer(const long double& value)          { this->value_ = new MT_Value<long double>         (value, MT_longdouble ); } /** @brief Creates a new value container for the given type. */
-template <> void MultiType::createNewValueContainer(const bool& value)                 { this->value_ = new MT_Value<bool>                (value, MT_bool       ); } /** @brief Creates a new value container for the given type. */
-template <> void MultiType::createNewValueContainer(      void* const& value)          { this->value_ = new MT_Value<void*>               (value, MT_void       ); } /** @brief Creates a new value container for the given type. */
-template <> void MultiType::createNewValueContainer(const std::string& value)          { this->value_ = new MT_Value<std::string>         (value, MT_string     ); } /** @brief Creates a new value container for the given type. */
-template <> void MultiType::createNewValueContainer(const orxonox::Vector2& value)     { this->value_ = new MT_Value<orxonox::Vector2>    (value, MT_vector2    ); } /** @brief Creates a new value container for the given type. */
-template <> void MultiType::createNewValueContainer(const orxonox::Vector3& value)     { this->value_ = new MT_Value<orxonox::Vector3>    (value, MT_vector3    ); } /** @brief Creates a new value container for the given type. */
-template <> void MultiType::createNewValueContainer(const orxonox::Vector4& value)     { this->value_ = new MT_Value<orxonox::Vector4>    (value, MT_vector4    ); } /** @brief Creates a new value container for the given type. */
-template <> void MultiType::createNewValueContainer(const orxonox::ColourValue& value) { this->value_ = new MT_Value<orxonox::ColourValue>(value, MT_colourvalue); } /** @brief Creates a new value container for the given type. */
-template <> void MultiType::createNewValueContainer(const orxonox::Quaternion& value)  { this->value_ = new MT_Value<orxonox::Quaternion> (value, MT_quaternion ); } /** @brief Creates a new value container for the given type. */
-template <> void MultiType::createNewValueContainer(const orxonox::Radian& value)      { this->value_ = new MT_Value<orxonox::Radian>     (value, MT_radian     ); } /** @brief Creates a new value container for the given type. */
-template <> void MultiType::createNewValueContainer(const orxonox::Degree& value)      { this->value_ = new MT_Value<orxonox::Degree>     (value, MT_degree     ); } /** @brief Creates a new value container for the given type. */

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

@@ -73 +73 @@
 #include "Math.h"
 
-/**
-    @brief Enum of all possible types of a MultiType.
-*/
-enum MT_Type
+namespace orxonox
 {
-    MT_null,
-    MT_char,
-    MT_uchar,
-    MT_short,
-    MT_ushort,
-    MT_int,
-    MT_uint,
-    MT_long,
-    MT_ulong,
-    MT_longlong,
-    MT_ulonglong,
-    MT_float,
-    MT_double,
-    MT_longdouble,
-    MT_bool,
-    MT_void,
-    MT_string,
-    MT_vector2,
-    MT_vector3,
-    MT_vector4,
-    MT_colourvalue,
-    MT_quaternion,
-    MT_radian,
-    MT_degree
-};
-
-/**
-    @brief The MultiType can hold a value of many possible types and convert them to other types.
-
-    The following types are supported by the MultiType:
-     - all primitves
-     - all pointers
-     - string
-     - Vector2, Vector3, Vector4
-     - Quaternion
-     - ColourValue
-     - Radian, Degree
-
-    The internal type of a MultiType is determined by the first assigned value, but can be
-    changed by using setType<T>(), convert<T>() or setValue<T>(value). If a value gets assigned
-    the normal way (operator=, setValue(value)), the value gets converted to the current internal
-    type of the MultiType.
-*/
-class _UtilExport MultiType
-{
-    _UtilExport friend std::ostream& operator<<(std::ostream& outstream, const MultiType& mt);
-    template <typename T> friend struct MT_Value;
-
     /**
-        @brief MT_ValueBase is an almost pure virtual baseclass of MT_Value<T>, which holds the value of the MultiType.
-        This class is only used within the MultiType.
+        @brief Enum of all possible types of a MultiType.
     */
-    struct _UtilExport MT_ValueBase
+    enum MT_Type
     {
-        MT_ValueBase(MT_Type type) : type_(type), bHasDefaultValue_(false) {}
-        virtual ~MT_ValueBase() {}
-
-        virtual MT_ValueBase* clone() const = 0;
-
-        virtual void reset() = 0;
-        virtual bool assimilate(const MultiType& other) = 0;
-
-        /** @brief Returns the type of the current value. */
-        const MT_Type& getType() const { return this->type_; }
-
-        /** @brief Checks whether the value is a default one. */
-        bool hasDefaultValue()   const { return this->bHasDefaultValue_; }
-
-        virtual bool setValue(const char& value)                 = 0;
-        virtual bool setValue(const unsigned char& value)        = 0;
-        virtual bool setValue(const short& value)                = 0;
-        virtual bool setValue(const unsigned short& value)       = 0;
-        virtual bool setValue(const int& value)                  = 0;
-        virtual bool setValue(const unsigned int& value)         = 0;
-        virtual bool setValue(const long& value)                 = 0;
-        virtual bool setValue(const unsigned long& value)        = 0;
-        virtual bool setValue(const long long& value)            = 0;
-        virtual bool setValue(const unsigned long long& value)   = 0;
-        virtual bool setValue(const float& value)                = 0;
-        virtual bool setValue(const double& value)               = 0;
-        virtual bool setValue(const long double& value)          = 0;
-        virtual bool setValue(const bool& value)                 = 0;
-        virtual bool setValue(      void* const& value)          = 0;
-        virtual bool setValue(const std::string& value)          = 0;
-        virtual bool setValue(const orxonox::Vector2& value)     = 0;
-        virtual bool setValue(const orxonox::Vector3& value)     = 0;
-        virtual bool setValue(const orxonox::Vector4& value)     = 0;
-        virtual bool setValue(const orxonox::ColourValue& value) = 0;
-        virtual bool setValue(const orxonox::Quaternion& value)  = 0;
-        virtual bool setValue(const orxonox::Radian& value)      = 0;
-        virtual bool setValue(const orxonox::Degree& value)      = 0;
-
-        virtual bool getValue(char*                 value) const = 0;
-        virtual bool getValue(unsigned char*        value) const = 0;
-        virtual bool getValue(short*                value) const = 0;
-        virtual bool getValue(unsigned short*       value) const = 0;
-        virtual bool getValue(int*                  value) const = 0;
-        virtual bool getValue(unsigned int*         value) const = 0;
-        virtual bool getValue(long*                 value) const = 0;
-        virtual bool getValue(unsigned long*        value) const = 0;
-        virtual bool getValue(long long*            value) const = 0;
-        virtual bool getValue(unsigned long long*   value) const = 0;
-        virtual bool getValue(float*                value) const = 0;
-        virtual bool getValue(double*               value) const = 0;
-        virtual bool getValue(long double*          value) const = 0;
-        virtual bool getValue(bool*                 value) const = 0;
-        virtual bool getValue(void**                value) const = 0;
-        virtual bool getValue(std::string*          value) const = 0;
-        virtual bool getValue(orxonox::Vector2*     value) const = 0;
-        virtual bool getValue(orxonox::Vector3*     value) const = 0;
-        virtual bool getValue(orxonox::Vector4*     value) const = 0;
-        virtual bool getValue(orxonox::ColourValue* value) const = 0;
-        virtual bool getValue(orxonox::Quaternion*  value) const = 0;
-        virtual bool getValue(orxonox::Radian*      value) const = 0;
-        virtual bool getValue(orxonox::Degree*      value) const = 0;
-
-        virtual operator char()                 const = 0;
-        virtual operator unsigned char()        const = 0;
-        virtual operator short()                const = 0;
-        virtual operator unsigned short()       const = 0;
-        virtual operator int()                  const = 0;
-        virtual operator unsigned int()         const = 0;
-        virtual operator long()                 const = 0;
-        virtual operator unsigned long()        const = 0;
-        virtual operator long long()            const = 0;
-        virtual operator unsigned long long()   const = 0;
-        virtual operator float()                const = 0;
-        virtual operator double()               const = 0;
-        virtual operator long double()          const = 0;
-        virtual operator bool()                 const = 0;
-        virtual operator void*()                const = 0;
-        virtual operator std::string()          const = 0;
-        virtual operator orxonox::Vector2()     const = 0;
-        virtual operator orxonox::Vector3()     const = 0;
-        virtual operator orxonox::Vector4()     const = 0;
-        virtual operator orxonox::ColourValue() const = 0;
-        virtual operator orxonox::Quaternion()  const = 0;
-        virtual operator orxonox::Radian()      const = 0;
-        virtual operator orxonox::Degree()      const = 0;
-
-        virtual void toString(std::ostream& outstream) const = 0;
-
-        MT_Type type_;          //!< The type of the current value
-        bool bHasDefaultValue_; //!< True if the last conversion wasn't successful
+        MT_null,
+        MT_char,
+        MT_uchar,
+        MT_short,
+        MT_ushort,
+        MT_int,
+        MT_uint,
+        MT_long,
+        MT_ulong,
+        MT_longlong,
+        MT_ulonglong,
+        MT_float,
+        MT_double,
+        MT_longdouble,
+        MT_bool,
+        MT_void,
+        MT_string,
+        MT_vector2,
+        MT_vector3,
+        MT_vector4,
+        MT_colourvalue,
+        MT_quaternion,
+        MT_radian,
+        MT_degree
     };
 
+    /**
+        @brief The MultiType can hold a value of many possible types and convert them to other types.
+
+        The following types are supported by the MultiType:
+         - all primitves
+         - all pointers
+         - string
+         - Vector2, Vector3, Vector4
+         - Quaternion
+         - ColourValue
+         - Radian, Degree
+
+        The internal type of a MultiType is determined by the first assigned value, but can be
+        changed by using setType<T>(), convert<T>() or setValue<T>(value). If a value gets assigned
+        the normal way (operator=, setValue(value)), the value gets converted to the current internal
+        type of the MultiType.
+    */
+    class _UtilExport MultiType
+    {
+        _UtilExport friend std::ostream& operator<<(std::ostream& outstream, const MultiType& mt);
+        template <typename T> friend class MT_Value;
+
     public:
-        inline MultiType()                                  : value_(0) {}                                      /** @brief Default constructor: Assigns no value and no type. The type will be determined by the first assignment of a value. */
-        inline MultiType(const char& value)                 : value_(0) { this->assignValue(value); }           /** @brief Constructor: Assigns the given value and sets the type. */
-        inline MultiType(const unsigned char& value)        : value_(0) { this->assignValue(value); }           /** @brief Constructor: Assigns the given value and sets the type. */
-        inline MultiType(const short& value)                : value_(0) { this->assignValue(value); }           /** @brief Constructor: Assigns the given value and sets the type. */
-        inline MultiType(const unsigned short& value)       : value_(0) { this->assignValue(value); }           /** @brief Constructor: Assigns the given value and sets the type. */
-        inline MultiType(const int& value)                  : value_(0) { this->assignValue(value); }           /** @brief Constructor: Assigns the given value and sets the type. */
-        inline MultiType(const unsigned int& value)         : value_(0) { this->assignValue(value); }           /** @brief Constructor: Assigns the given value and sets the type. */
-        inline MultiType(const long& value)                 : value_(0) { this->assignValue(value); }           /** @brief Constructor: Assigns the given value and sets the type. */
-        inline MultiType(const unsigned long& value)        : value_(0) { this->assignValue(value); }           /** @brief Constructor: Assigns the given value and sets the type. */
-        inline MultiType(const long long& value)            : value_(0) { this->assignValue(value); }           /** @brief Constructor: Assigns the given value and sets the type. */
-        inline MultiType(const unsigned long long& value)   : value_(0) { this->assignValue(value); }           /** @brief Constructor: Assigns the given value and sets the type. */
-        inline MultiType(const float& value)                : value_(0) { this->assignValue(value); }           /** @brief Constructor: Assigns the given value and sets the type. */
-        inline MultiType(const double& value)               : value_(0) { this->assignValue(value); }           /** @brief Constructor: Assigns the given value and sets the type. */
-        inline MultiType(const long double& value)          : value_(0) { this->assignValue(value); }           /** @brief Constructor: Assigns the given value and sets the type. */
-        inline MultiType(const bool& value)                 : value_(0) { this->assignValue(value); }           /** @brief Constructor: Assigns the given value and sets the type. */
-        inline MultiType(      void* const& value)          : value_(0) { this->assignValue(value); }           /** @brief Constructor: Assigns the given value and sets the type. */
-        inline MultiType(const std::string& value)          : value_(0) { this->assignValue(value); }           /** @brief Constructor: Assigns the given value and sets the type. */
-        inline MultiType(const orxonox::Vector2& value)     : value_(0) { this->assignValue(value); }           /** @brief Constructor: Assigns the given value and sets the type. */
-        inline MultiType(const orxonox::Vector3& value)     : value_(0) { this->assignValue(value); }           /** @brief Constructor: Assigns the given value and sets the type. */
-        inline MultiType(const orxonox::Vector4& value)     : value_(0) { this->assignValue(value); }           /** @brief Constructor: Assigns the given value and sets the type. */
-        inline MultiType(const orxonox::ColourValue& value) : value_(0) { this->assignValue(value); }           /** @brief Constructor: Assigns the given value and sets the type. */
-        inline MultiType(const orxonox::Quaternion& value)  : value_(0) { this->assignValue(value); }           /** @brief Constructor: Assigns the given value and sets the type. */
-        inline MultiType(const orxonox::Radian& value)      : value_(0) { this->assignValue(value); }           /** @brief Constructor: Assigns the given value and sets the type. */
-        inline MultiType(const orxonox::Degree& value)      : value_(0) { this->assignValue(value); }           /** @brief Constructor: Assigns the given value and sets the type. */
-        inline MultiType(const char* value)                 : value_(0) { this->setValue(std::string(value)); } /** @brief Constructor: Converts the char array to a std::string, assigns the value and sets the type. */
-        inline MultiType(const MultiType& other)            : value_(0) { this->setValue(other); }              /** @brief Copyconstructor: Assigns value and type of the other MultiType. */
-        inline MultiType(MT_Type type)                      : value_(0) { this->setType(type); }                /** @brief Constructor: Sets the type, the next assignment will determine the value. */
-
-        /** @brief Destructor: Deletes the MT_Value. */
-        inline ~MultiType() { if (this->value_) { delete this->value_; } }
-
-        template <typename V> inline const MultiType& operator=(const V& value)         { this->setValue(value); return (*this); } /** @brief Assigns a new value. The value will be converted to the current type of the MultiType. */
-        template <typename V> inline const MultiType& operator=(V* value)               { this->setValue(value); return (*this); } /** @brief Assigns a pointer. */
-        inline                       const MultiType& operator=(const MultiType& other) { this->setValue(other); return (*this); } /** @brief Assigns the value of the other MultiType and converts it to the current type of the MultiType. */
-        inline                       const MultiType& operator=(MT_Type type)           { this->setType(type);   return (*this); } /** @brief Resets the value and changes the type. */
-
-        inline bool                                   setValue(const char& value);
-        inline bool                                   setValue(const unsigned char& value);
-        inline bool                                   setValue(const short& value);
-        inline bool                                   setValue(const unsigned short& value);
-        inline bool                                   setValue(const int& value);
-        inline bool                                   setValue(const unsigned int& value);
-        inline bool                                   setValue(const long& value);
-        inline bool                                   setValue(const unsigned long& value);
-        inline bool                                   setValue(const long long& value);
-        inline bool                                   setValue(const unsigned long long& value);
-        inline bool                                   setValue(const float& value);
-        inline bool                                   setValue(const double& value);
-        inline bool                                   setValue(const long double& value);
-        inline bool                                   setValue(const bool& value);
-        inline bool                                   setValue(      void* const& value);
-        inline bool                                   setValue(const std::string& value);
-        inline bool                                   setValue(const orxonox::Vector2& value);
-        inline bool                                   setValue(const orxonox::Vector3& value);
-        inline bool                                   setValue(const orxonox::Vector4& value);
-        inline bool                                   setValue(const orxonox::ColourValue& value);
-        inline bool                                   setValue(const orxonox::Quaternion& value);
-        inline bool                                   setValue(const orxonox::Radian& value);
-        inline bool                                   setValue(const orxonox::Degree& value);
-        inline bool                                   setValue(const char* value);
-        /** @brief Assigns a pointer. */
-        template <typename V> inline bool             setValue(V* value)               { if (this->value_) { return this->value_->setValue((void*)value); } else { return this->assignValue((void*)value); } }
-        /** @brief Assigns the value of the other MultiType and converts it to the current type. */
-        bool                                          setValue(const MultiType& other) { if (this->value_) { return this->value_->assimilate(other); } else { if (other.value_) { this->value_ = other.value_->clone(); } return true; } }
-        /** @brief Changes the type to T and assigns the new value (which might be of another type than T - it gets converted). */
-        template <typename T, typename V> inline bool setValue(const V& value) { this->setType<T>(); return this->setValue(value); }
-
-
-        /** @brief Copies the other MultiType by assigning value and type. */
-        inline void                       copy(const MultiType& other)    { if (this == &other) { return; } if (this->value_) { delete this->value_; } this->value_ = (other.value_) ? other.value_->clone() : 0; }
-
-        template <typename T> inline bool convert()                       { return this->setValue<T>((T)(*this));  } /** @brief Converts the current value to type T. */
-        inline bool                       convert(const MultiType& other) { return this->convert(other.getType()); } /** @brief Converts the current value to the type of the other MultiType. */
-        bool                              convert(MT_Type type);
-
-        /** @brief Current content gets deleted. New type is MT_null */
-        inline void                       reset()                         { if (this->value_) this->value_->reset(); }
-
-        template <typename T> inline void setType()                       { this->assignValue(T());                            } /** @brief Resets the value and changes the internal type to T. */
-        inline void                       setType(const MultiType& other) { this->setType(other.getType());                    } /** @brief Resets the value and changes the internal type to the type of the other MultiType. */
-        inline void                       setType(MT_Type type)           { this->reset(); this->convert(type); this->reset(); } /** @brief Resets the value and changes the internal type to the given type. */
-
-        /** @brief Returns the current type. */
-        inline MT_Type                    getType()                 const { return (this->value_) ? this->value_->type_ : MT_null; }
-        /** @brief Returns true if the current type equals the given type. */
-        inline bool                       isType(MT_Type type)      const { return (this->value_) ? (this->value_->type_ == type) : (type == MT_null); }
-        /** @brief Returns true if the current type is T. */
-        template <typename T> inline bool isType()                  const { return false; } // Only works for specialized values - see below
-        std::string                       getTypename()             const;
-
-        /** @brief Checks whether the value is a default one. */
-        bool                              hasDefaultValue()         const { return this->value_->hasDefaultValue(); }
-
-        operator char()                  const;
-        operator unsigned char()         const;
-        operator short()                 const;
-        operator unsigned short()        const;
-        operator int()                   const;
-        operator unsigned int()          const;
-        operator long()                  const;
-        operator unsigned long()         const;
-        operator long long()             const;
-        operator unsigned long long()    const;
-        operator float()                 const;
-        operator double()                const;
-        operator long double()           const;
-        operator bool()                  const;
-        operator void*()                 const;
-        operator std::string()           const;
-        operator orxonox::Vector2()      const;
-        operator orxonox::Vector3()      const;
-        operator orxonox::Vector4()      const;
-        operator orxonox::ColourValue()  const;
-        operator orxonox::Quaternion()   const;
-        operator orxonox::Radian()       const;
-        operator orxonox::Degree()       const;
-        /** @brief Returns the current value, converted to a T* pointer. */
-        template <class T> operator T*() const { return ((T*)this->operator void*()); }
-
-        inline bool getValue(char*                 value) const { if (this->value_) { return this->value_->getValue(value); } return false; } /** @brief Assigns the value to the given pointer. The value gets converted if the types don't match. */
-        inline bool getValue(unsigned char*        value) const { if (this->value_) { return this->value_->getValue(value); } return false; } /** @brief Assigns the value to the given pointer. The value gets converted if the types don't match. */
-        inline bool getValue(short*                value) const { if (this->value_) { return this->value_->getValue(value); } return false; } /** @brief Assigns the value to the given pointer. The value gets converted if the types don't match. */
-        inline bool getValue(unsigned short*       value) const { if (this->value_) { return this->value_->getValue(value); } return false; } /** @brief Assigns the value to the given pointer. The value gets converted if the types don't match. */
-        inline bool getValue(int*                  value) const { if (this->value_) { return this->value_->getValue(value); } return false; } /** @brief Assigns the value to the given pointer. The value gets converted if the types don't match. */
-        inline bool getValue(unsigned int*         value) const { if (this->value_) { return this->value_->getValue(value); } return false; } /** @brief Assigns the value to the given pointer. The value gets converted if the types don't match. */
-        inline bool getValue(long*                 value) const { if (this->value_) { return this->value_->getValue(value); } return false; } /** @brief Assigns the value to the given pointer. The value gets converted if the types don't match. */
-        inline bool getValue(unsigned long*        value) const { if (this->value_) { return this->value_->getValue(value); } return false; } /** @brief Assigns the value to the given pointer. The value gets converted if the types don't match. */
-        inline bool getValue(long long*            value) const { if (this->value_) { return this->value_->getValue(value); } return false; } /** @brief Assigns the value to the given pointer. The value gets converted if the types don't match. */
-        inline bool getValue(unsigned long long*   value) const { if (this->value_) { return this->value_->getValue(value); } return false; } /** @brief Assigns the value to the given pointer. The value gets converted if the types don't match. */
-        inline bool getValue(float*                value) const { if (this->value_) { return this->value_->getValue(value); } return false; } /** @brief Assigns the value to the given pointer. The value gets converted if the types don't match. */
-        inline bool getValue(double*               value) const { if (this->value_) { return this->value_->getValue(value); } return false; } /** @brief Assigns the value to the given pointer. The value gets converted if the types don't match. */
-        inline bool getValue(long double*          value) const { if (this->value_) { return this->value_->getValue(value); } return false; } /** @brief Assigns the value to the given pointer. The value gets converted if the types don't match. */
-        inline bool getValue(bool*                 value) const { if (this->value_) { return this->value_->getValue(value); } return false; } /** @brief Assigns the value to the given pointer. The value gets converted if the types don't match. */
-        inline bool getValue(void**                value) const { if (this->value_) { return this->value_->getValue(value); } return false; } /** @brief Assigns the value to the given pointer. The value gets converted if the types don't match. */
-        inline bool getValue(std::string*          value) const { if (this->value_) { return this->value_->getValue(value); } return false; } /** @brief Assigns the value to the given pointer. The value gets converted if the types don't match. */
-        inline bool getValue(orxonox::Vector2*     value) const { if (this->value_) { return this->value_->getValue(value); } return false; } /** @brief Assigns the value to the given pointer. The value gets converted if the types don't match. */
-        inline bool getValue(orxonox::Vector3*     value) const { if (this->value_) { return this->value_->getValue(value); } return false; } /** @brief Assigns the value to the given pointer. The value gets converted if the types don't match. */
-        inline bool getValue(orxonox::Vector4*     value) const { if (this->value_) { return this->value_->getValue(value); } return false; } /** @brief Assigns the value to the given pointer. The value gets converted if the types don't match. */
-        inline bool getValue(orxonox::ColourValue* value) const { if (this->value_) { return this->value_->getValue(value); } return false; } /** @brief Assigns the value to the given pointer. The value gets converted if the types don't match. */
-        inline bool getValue(orxonox::Quaternion*  value) const { if (this->value_) { return this->value_->getValue(value); } return false; } /** @brief Assigns the value to the given pointer. The value gets converted if the types don't match. */
-        inline bool getValue(orxonox::Radian*      value) const { if (this->value_) { return this->value_->getValue(value); } return false; } /** @brief Assigns the value to the given pointer. The value gets converted if the types don't match. */
-        inline bool getValue(orxonox::Degree*      value) const { if (this->value_) { return this->value_->getValue(value); } return false; } /** @brief Assigns the value to the given pointer. The value gets converted if the types don't match. */
-
-        inline char                     getChar()             const { return this->operator char();                 } /** @brief Returns the current value, converted to the requested type. */
-        inline unsigned char            getUnsignedChar()     const { return this->operator unsigned char();        } /** @brief Returns the current value, converted to the requested type. */
-        inline short                    getShort()            const { return this->operator short();                } /** @brief Returns the current value, converted to the requested type. */
-        inline unsigned short           getUnsignedShort()    const { return this->operator unsigned short();       } /** @brief Returns the current value, converted to the requested type. */
-        inline int                      getInt()              const { return this->operator int();                  } /** @brief Returns the current value, converted to the requested type. */
-        inline unsigned int             getUnsignedInt()      const { return this->operator unsigned int();         } /** @brief Returns the current value, converted to the requested type. */
-        inline long                     getLong()             const { return this->operator long();                 } /** @brief Returns the current value, converted to the requested type. */
-        inline unsigned long            getUnsignedLong()     const { return this->operator unsigned long();        } /** @brief Returns the current value, converted to the requested type. */
-        inline long long                getLongLong()         const { return this->operator long long();            } /** @brief Returns the current value, converted to the requested type. */
-        inline unsigned long long       getUnsignedLongLong() const { return this->operator unsigned long long();   } /** @brief Returns the current value, converted to the requested type. */
-        inline float                    getFloat()            const { return this->operator float();                } /** @brief Returns the current value, converted to the requested type. */
-        inline double                   getDouble()           const { return this->operator double();               } /** @brief Returns the current value, converted to the requested type. */
-        inline long double              getLongDouble()       const { return this->operator long double();          } /** @brief Returns the current value, converted to the requested type. */
-        inline bool                     getBool()             const { return this->operator bool();                 } /** @brief Returns the current value, converted to the requested type. */
-        inline void*                    getVoid()             const { return this->operator void*();                } /** @brief Returns the current value, converted to the requested type. */
-        inline std::string              getString()           const { return this->operator std::string();          } /** @brief Returns the current value, converted to the requested type. */
-        inline orxonox::Vector2         getVector2()          const { return this->operator orxonox::Vector2();     } /** @brief Returns the current value, converted to the requested type. */
-        inline orxonox::Vector3         getVector3()          const { return this->operator orxonox::Vector3();     } /** @brief Returns the current value, converted to the requested type. */
-        inline orxonox::Vector4         getVector4()          const { return this->operator orxonox::Vector4();     } /** @brief Returns the current value, converted to the requested type. */
-        inline orxonox::ColourValue     getColourValue()      const { return this->operator orxonox::ColourValue(); } /** @brief Returns the current value, converted to the requested type. */
-        inline orxonox::Quaternion      getQuaternion()       const { return this->operator orxonox::Quaternion();  } /** @brief Returns the current value, converted to the requested type. */
-        inline orxonox::Radian          getRadian()           const { return this->operator orxonox::Radian();      } /** @brief Returns the current value, converted to the requested type. */
-        inline orxonox::Degree          getDegree()           const { return this->operator orxonox::Degree();      } /** @brief Returns the current value, converted to the requested type. */
-        template <typename T> inline T* getPointer()          const { return ((T*)this->getVoid());                 } /** @brief Returns the current value, converted to a T* pointer. */
-
-    private:
-        inline bool assignValue(const char& value)                 { if (this->value_ && this->value_->type_ == MT_char)        { return this->value_->setValue(value); } else { this->changeValueContainer<char>(value);                 return true; } } /** @brief Assigns a new value by changing type and creating a new container. */
-        inline bool assignValue(const unsigned char& value)        { if (this->value_ && this->value_->type_ == MT_uchar)       { return this->value_->setValue(value); } else { this->changeValueContainer<unsigned char>(value);        return true; } } /** @brief Assigns a new value by changing type and creating a new container. */
-        inline bool assignValue(const short& value)                { if (this->value_ && this->value_->type_ == MT_short)       { return this->value_->setValue(value); } else { this->changeValueContainer<short>(value);                return true; } } /** @brief Assigns a new value by changing type and creating a new container. */
-        inline bool assignValue(const unsigned short& value)       { if (this->value_ && this->value_->type_ == MT_ushort)      { return this->value_->setValue(value); } else { this->changeValueContainer<unsigned short>(value);       return true; } } /** @brief Assigns a new value by changing type and creating a new container. */
-        inline bool assignValue(const int& value)                  { if (this->value_ && this->value_->type_ == MT_int)         { return this->value_->setValue(value); } else { this->changeValueContainer<int>(value);                  return true; } } /** @brief Assigns a new value by changing type and creating a new container. */
-        inline bool assignValue(const unsigned int& value)         { if (this->value_ && this->value_->type_ == MT_uint)        { return this->value_->setValue(value); } else { this->changeValueContainer<unsigned int>(value);         return true; } } /** @brief Assigns a new value by changing type and creating a new container. */
-        inline bool assignValue(const long& value)                 { if (this->value_ && this->value_->type_ == MT_long)        { return this->value_->setValue(value); } else { this->changeValueContainer<long>(value);                 return true; } } /** @brief Assigns a new value by changing type and creating a new container. */
-        inline bool assignValue(const unsigned long& value)        { if (this->value_ && this->value_->type_ == MT_ulong)       { return this->value_->setValue(value); } else { this->changeValueContainer<unsigned long>(value);        return true; } } /** @brief Assigns a new value by changing type and creating a new container. */
-        inline bool assignValue(const long long& value)            { if (this->value_ && this->value_->type_ == MT_longlong)    { return this->value_->setValue(value); } else { this->changeValueContainer<long long>(value);            return true; } } /** @brief Assigns a new value by changing type and creating a new container. */
-        inline bool assignValue(const unsigned long long& value)   { if (this->value_ && this->value_->type_ == MT_ulonglong)   { return this->value_->setValue(value); } else { this->changeValueContainer<unsigned long long>(value);   return true; } } /** @brief Assigns a new value by changing type and creating a new container. */
-        inline bool assignValue(const float& value)                { if (this->value_ && this->value_->type_ == MT_float)       { return this->value_->setValue(value); } else { this->changeValueContainer<float>(value);                return true; } } /** @brief Assigns a new value by changing type and creating a new container. */
-        inline bool assignValue(const double& value)               { if (this->value_ && this->value_->type_ == MT_double)      { return this->value_->setValue(value); } else { this->changeValueContainer<double>(value);               return true; } } /** @brief Assigns a new value by changing type and creating a new container. */
-        inline bool assignValue(const long double& value)          { if (this->value_ && this->value_->type_ == MT_longdouble)  { return this->value_->setValue(value); } else { this->changeValueContainer<long double>(value);          return true; } } /** @brief Assigns a new value by changing type and creating a new container. */
-        inline bool assignValue(const bool& value)                 { if (this->value_ && this->value_->type_ == MT_bool)        { return this->value_->setValue(value); } else { this->changeValueContainer<bool>(value);                 return true; } } /** @brief Assigns a new value by changing type and creating a new container. */
-        inline bool assignValue(      void* const& value)          { if (this->value_ && this->value_->type_ == MT_void)        { return this->value_->setValue(value); } else { this->changeValueContainer<void*>(value);                return true; } } /** @brief Assigns a new value by changing type and creating a new container. */
-        inline bool assignValue(const std::string& value)          { if (this->value_ && this->value_->type_ == MT_string)      { return this->value_->setValue(value); } else { this->changeValueContainer<std::string>(value);          return true; } } /** @brief Assigns a new value by changing type and creating a new container. */
-        inline bool assignValue(const orxonox::Vector2& value)     { if (this->value_ && this->value_->type_ == MT_vector2)     { return this->value_->setValue(value); } else { this->changeValueContainer<orxonox::Vector2>(value);     return true; } } /** @brief Assigns a new value by changing type and creating a new container. */
-        inline bool assignValue(const orxonox::Vector3& value)     { if (this->value_ && this->value_->type_ == MT_vector3)     { return this->value_->setValue(value); } else { this->changeValueContainer<orxonox::Vector3>(value);     return true; } } /** @brief Assigns a new value by changing type and creating a new container. */
-        inline bool assignValue(const orxonox::Vector4& value)     { if (this->value_ && this->value_->type_ == MT_vector4)     { return this->value_->setValue(value); } else { this->changeValueContainer<orxonox::Vector4>(value);     return true; } } /** @brief Assigns a new value by changing type and creating a new container. */
-        inline bool assignValue(const orxonox::ColourValue& value) { if (this->value_ && this->value_->type_ == MT_colourvalue) { return this->value_->setValue(value); } else { this->changeValueContainer<orxonox::ColourValue>(value); return true; } } /** @brief Assigns a new value by changing type and creating a new container. */
-        inline bool assignValue(const orxonox::Quaternion& value)  { if (this->value_ && this->value_->type_ == MT_quaternion)  { return this->value_->setValue(value); } else { this->changeValueContainer<orxonox::Quaternion>(value);  return true; } } /** @brief Assigns a new value by changing type and creating a new container. */
-        inline bool assignValue(const orxonox::Radian& value)      { if (this->value_ && this->value_->type_ == MT_radian)      { return this->value_->setValue(value); } else { this->changeValueContainer<orxonox::Radian>(value);      return true; } } /** @brief Assigns a new value by changing type and creating a new container. */
-        inline bool assignValue(const orxonox::Degree& value)      { if (this->value_ && this->value_->type_ == MT_degree)      { return this->value_->setValue(value); } else { this->changeValueContainer<orxonox::Degree>(value);      return true; } } /** @brief Assigns a new value by changing type and creating a new container. */
-
-        /** @brief Changes the value container. */
-        template <typename T> inline void changeValueContainer(const T& value) { if (this->value_) { delete this->value_; } this->createNewValueContainer<T>(value); }
-        /** @brief Creates a new value container (works only with specialized types). */
-        template <typename T>        void createNewValueContainer(const T& value) { BOOST_STATIC_ASSERT(sizeof(T) == 0); return false; }
-
-        MT_ValueBase* value_; //!< A pointer to the value container
-};
-
-/** @brief Puts the MultiType on a stream by using the native << operator of the current type. */
-_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);        } /** @brief Returns true if the current type equals the given type. */
-template <> inline bool MultiType::isType<unsigned char>()        const { return (this->value_ && this->value_->type_ == MT_uchar);       } /** @brief Returns true if the current type equals the given type. */
-template <> inline bool MultiType::isType<short>()                const { return (this->value_ && this->value_->type_ == MT_short);       } /** @brief Returns true if the current type equals the given type. */
-template <> inline bool MultiType::isType<unsigned short>()       const { return (this->value_ && this->value_->type_ == MT_ushort);      } /** @brief Returns true if the current type equals the given type. */
-template <> inline bool MultiType::isType<int>()                  const { return (this->value_ && this->value_->type_ == MT_int);         } /** @brief Returns true if the current type equals the given type. */
-template <> inline bool MultiType::isType<unsigned int>()         const { return (this->value_ && this->value_->type_ == MT_uint);        } /** @brief Returns true if the current type equals the given type. */
-template <> inline bool MultiType::isType<long>()                 const { return (this->value_ && this->value_->type_ == MT_long);        } /** @brief Returns true if the current type equals the given type. */
-template <> inline bool MultiType::isType<unsigned long>()        const { return (this->value_ && this->value_->type_ == MT_ulong);       } /** @brief Returns true if the current type equals the given type. */
-template <> inline bool MultiType::isType<long long>()            const { return (this->value_ && this->value_->type_ == MT_longlong);    } /** @brief Returns true if the current type equals the given type. */
-template <> inline bool MultiType::isType<unsigned long long>()   const { return (this->value_ && this->value_->type_ == MT_ulonglong);   } /** @brief Returns true if the current type equals the given type. */
-template <> inline bool MultiType::isType<float>()                const { return (this->value_ && this->value_->type_ == MT_float);       } /** @brief Returns true if the current type equals the given type. */
-template <> inline bool MultiType::isType<double>()               const { return (this->value_ && this->value_->type_ == MT_double);      } /** @brief Returns true if the current type equals the given type. */
-template <> inline bool MultiType::isType<long double>()          const { return (this->value_ && this->value_->type_ == MT_longdouble);  } /** @brief Returns true if the current type equals the given type. */
-template <> inline bool MultiType::isType<bool>()                 const { return (this->value_ && this->value_->type_ == MT_bool);        } /** @brief Returns true if the current type equals the given type. */
-template <> inline bool MultiType::isType<void*>()                const { return (this->value_ && this->value_->type_ == MT_void);        } /** @brief Returns true if the current type equals the given type. */
-template <> inline bool MultiType::isType<std::string>()          const { return (this->value_ && this->value_->type_ == MT_string);      } /** @brief Returns true if the current type equals the given type. */
-template <> inline bool MultiType::isType<orxonox::Vector2>()     const { return (this->value_ && this->value_->type_ == MT_vector2);     } /** @brief Returns true if the current type equals the given type. */
-template <> inline bool MultiType::isType<orxonox::Vector3>()     const { return (this->value_ && this->value_->type_ == MT_vector3);     } /** @brief Returns true if the current type equals the given type. */
-template <> inline bool MultiType::isType<orxonox::Vector4>()     const { return (this->value_ && this->value_->type_ == MT_vector4);     } /** @brief Returns true if the current type equals the given type. */
-template <> inline bool MultiType::isType<orxonox::ColourValue>() const { return (this->value_ && this->value_->type_ == MT_colourvalue); } /** @brief Returns true if the current type equals the given type. */
-template <> inline bool MultiType::isType<orxonox::Quaternion>()  const { return (this->value_ && this->value_->type_ == MT_quaternion);  } /** @brief Returns true if the current type equals the given type. */
-template <> inline bool MultiType::isType<orxonox::Radian>()      const { return (this->value_ && this->value_->type_ == MT_radian);      } /** @brief Returns true if the current type equals the given type. */
-template <> inline bool MultiType::isType<orxonox::Degree>()      const { return (this->value_ && this->value_->type_ == MT_degree);      } /** @brief Returns true if the current type equals the given type. */
-
-// Specialization to avoid ambiguities with the conversion operator
-template <> inline bool MultiType::convert<std::string>()          { return this->setValue<std::string>         (this->operator std::string());          } /** @brief Converts the current value to the given type. */
-template <> inline bool MultiType::convert<orxonox::Vector2>()     { return this->setValue<orxonox::Vector2>    (this->operator orxonox::Vector2());     } /** @brief Converts the current value to the given type. */
-template <> inline bool MultiType::convert<orxonox::Vector3>()     { return this->setValue<orxonox::Vector3>    (this->operator orxonox::Vector3());     } /** @brief Converts the current value to the given type. */
-template <> inline bool MultiType::convert<orxonox::Vector4>()     { return this->setValue<orxonox::Vector4>    (this->operator orxonox::Vector4());     } /** @brief Converts the current value to the given type. */
-template <> inline bool MultiType::convert<orxonox::ColourValue>() { return this->setValue<orxonox::ColourValue>(this->operator orxonox::ColourValue()); } /** @brief Converts the current value to the given type. */
-template <> inline bool MultiType::convert<orxonox::Quaternion>()  { return this->setValue<orxonox::Quaternion> (this->operator orxonox::Quaternion());  } /** @brief Converts the current value to the given type. */
-template <> inline bool MultiType::convert<orxonox::Radian>()      { return this->setValue<orxonox::Radian>     (this->operator orxonox::Radian());      } /** @brief Converts the current value to the given type. */
-template <> inline bool MultiType::convert<orxonox::Degree>()      { return this->setValue<orxonox::Degree>     (this->operator orxonox::Degree());      } /** @brief Converts the current value to the given type. */
-
-// Specialization to avoid ambiguities with the conversion operator
-template <> inline bool MultiType::convert<const std::string&>()          { return this->convert<std::string>();          } /** @brief Converts the current value to the given type. */
-template <> inline bool MultiType::convert<const orxonox::Vector2&>()     { return this->convert<orxonox::Vector2>();     } /** @brief Converts the current value to the given type. */
-template <> inline bool MultiType::convert<const orxonox::Vector3&>()     { return this->convert<orxonox::Vector3>();     } /** @brief Converts the current value to the given type. */
-template <> inline bool MultiType::convert<const orxonox::Vector4&>()     { return this->convert<orxonox::Vector4>();     } /** @brief Converts the current value to the given type. */
-template <> inline bool MultiType::convert<const orxonox::ColourValue&>() { return this->convert<orxonox::ColourValue>(); } /** @brief Converts the current value to the given type. */
-template <> inline bool MultiType::convert<const orxonox::Quaternion&>()  { return this->convert<orxonox::Quaternion>();  } /** @brief Converts the current value to the given type. */
-template <> inline bool MultiType::convert<const orxonox::Radian&>()      { return this->convert<orxonox::Radian>();      } /** @brief Converts the current value to the given type. */
-template <> inline bool MultiType::convert<const orxonox::Degree&>()      { return this->convert<orxonox::Degree>();      } /** @brief Converts the current value to the given type. */
-
-template <> void MultiType::createNewValueContainer(const char& value);
-template <> void MultiType::createNewValueContainer(const unsigned char& value);
-template <> void MultiType::createNewValueContainer(const short& value);
-template <> void MultiType::createNewValueContainer(const unsigned short& value);
-template <> void MultiType::createNewValueContainer(const int& value);
-template <> void MultiType::createNewValueContainer(const unsigned int& value);
-template <> void MultiType::createNewValueContainer(const long& value);
-template <> void MultiType::createNewValueContainer(const unsigned long& value);
-template <> void MultiType::createNewValueContainer(const long long& value);
-template <> void MultiType::createNewValueContainer(const unsigned long long& value);
-template <> void MultiType::createNewValueContainer(const float& value);
-template <> void MultiType::createNewValueContainer(const double& value);
-template <> void MultiType::createNewValueContainer(const bool& value);
-template <> void MultiType::createNewValueContainer(const long double& value);
-template <> void MultiType::createNewValueContainer(      void* const& value);
-template <> void MultiType::createNewValueContainer(const std::string& value);
-template <> void MultiType::createNewValueContainer(const orxonox::Vector2& value);
-template <> void MultiType::createNewValueContainer(const orxonox::Vector3& value);
-template <> void MultiType::createNewValueContainer(const orxonox::Vector4& value);
-template <> void MultiType::createNewValueContainer(const orxonox::ColourValue& value);
-template <> void MultiType::createNewValueContainer(const orxonox::Quaternion& value);
-template <> void MultiType::createNewValueContainer(const orxonox::Radian& value);
-template <> void MultiType::createNewValueContainer(const orxonox::Degree& value);
-
-inline bool MultiType::setValue(const char& value)                  { if (this->value_) { return this->value_->setValue(value); } else { return this->assignValue(value); } } /** @brief Assigns the given value and converts it to the current type. */
-inline bool MultiType::setValue(const unsigned char& value)         { if (this->value_) { return this->value_->setValue(value); } else { return this->assignValue(value); } } /** @brief Assigns the given value and converts it to the current type. */
-inline bool MultiType::setValue(const short& value)                 { if (this->value_) { return this->value_->setValue(value); } else { return this->assignValue(value); } } /** @brief Assigns the given value and converts it to the current type. */
-inline bool MultiType::setValue(const unsigned short& value)        { if (this->value_) { return this->value_->setValue(value); } else { return this->assignValue(value); } } /** @brief Assigns the given value and converts it to the current type. */
-inline bool MultiType::setValue(const int& value)                   { if (this->value_) { return this->value_->setValue(value); } else { return this->assignValue(value); } } /** @brief Assigns the given value and converts it to the current type. */
-inline bool MultiType::setValue(const unsigned int& value)          { if (this->value_) { return this->value_->setValue(value); } else { return this->assignValue(value); } } /** @brief Assigns the given value and converts it to the current type. */
-inline bool MultiType::setValue(const long& value)                  { if (this->value_) { return this->value_->setValue(value); } else { return this->assignValue(value); } } /** @brief Assigns the given value and converts it to the current type. */
-inline bool MultiType::setValue(const unsigned long& value)         { if (this->value_) { return this->value_->setValue(value); } else { return this->assignValue(value); } } /** @brief Assigns the given value and converts it to the current type. */
-inline bool MultiType::setValue(const long long& value)             { if (this->value_) { return this->value_->setValue(value); } else { return this->assignValue(value); } } /** @brief Assigns the given value and converts it to the current type. */
-inline bool MultiType::setValue(const unsigned long long& value)    { if (this->value_) { return this->value_->setValue(value); } else { return this->assignValue(value); } } /** @brief Assigns the given value and converts it to the current type. */
-inline bool MultiType::setValue(const float& value)                 { if (this->value_) { return this->value_->setValue(value); } else { return this->assignValue(value); } } /** @brief Assigns the given value and converts it to the current type. */
-inline bool MultiType::setValue(const double& value)                { if (this->value_) { return this->value_->setValue(value); } else { return this->assignValue(value); } } /** @brief Assigns the given value and converts it to the current type. */
-inline bool MultiType::setValue(const long double& value)           { if (this->value_) { return this->value_->setValue(value); } else { return this->assignValue(value); } } /** @brief Assigns the given value and converts it to the current type. */
-inline bool MultiType::setValue(const bool& value)                  { if (this->value_) { return this->value_->setValue(value); } else { return this->assignValue(value); } } /** @brief Assigns the given value and converts it to the current type. */
-inline bool MultiType::setValue(      void* const& value)           { if (this->value_) { return this->value_->setValue(value); } else { return this->assignValue(value); } } /** @brief Assigns the given value and converts it to the current type. */
-inline bool MultiType::setValue(const std::string& value)           { if (this->value_) { return this->value_->setValue(value); } else { return this->assignValue(value); } } /** @brief Assigns the given value and converts it to the current type. */
-inline bool MultiType::setValue(const orxonox::Vector2& value)      { if (this->value_) { return this->value_->setValue(value); } else { return this->assignValue(value); } } /** @brief Assigns the given value and converts it to the current type. */
-inline bool MultiType::setValue(const orxonox::Vector3& value)      { if (this->value_) { return this->value_->setValue(value); } else { return this->assignValue(value); } } /** @brief Assigns the given value and converts it to the current type. */
-inline bool MultiType::setValue(const orxonox::Vector4& value)      { if (this->value_) { return this->value_->setValue(value); } else { return this->assignValue(value); } } /** @brief Assigns the given value and converts it to the current type. */
-inline bool MultiType::setValue(const orxonox::ColourValue& value)  { if (this->value_) { return this->value_->setValue(value); } else { return this->assignValue(value); } } /** @brief Assigns the given value and converts it to the current type. */
-inline bool MultiType::setValue(const orxonox::Quaternion& value)   { if (this->value_) { return this->value_->setValue(value); } else { return this->assignValue(value); } } /** @brief Assigns the given value and converts it to the current type. */
-inline bool MultiType::setValue(const orxonox::Radian& value)       { if (this->value_) { return this->value_->setValue(value); } else { return this->assignValue(value); } } /** @brief Assigns the given value and converts it to the current type. */
-inline bool MultiType::setValue(const orxonox::Degree& value)       { if (this->value_) { return this->value_->setValue(value); } else { return this->assignValue(value); } } /** @brief Assigns the given value and converts it to the current type. */
-
-inline bool MultiType::setValue(const char* value)                  { if (this->value_) { return this->value_->setValue(std::string(value)); } else { return this->assignValue(std::string(value)); } }  /** @brief Assigns the given value and converts it to the current type. */
+        /**
+            @brief MT_ValueBase is an almost pure virtual baseclass of MT_Value<T>, which holds the value of the MultiType.
+            This class is only used within the MultiType.
+        */
+        class _UtilExport MT_ValueBase
+        {
+        public:
+            MT_ValueBase(MT_Type type) : type_(type), bHasDefaultValue_(false) {}
+            virtual ~MT_ValueBase() {}
+
+            virtual MT_ValueBase* clone() const = 0;
+
+            virtual void reset() = 0;
+            virtual bool assimilate(const MultiType& other) = 0;
+
+            /** @brief Returns the type of the current value. */
+            const MT_Type& getType() const { return this->type_; }
+
+            /** @brief Checks whether the value is a default one. */
+            bool hasDefaultValue()   const { return this->bHasDefaultValue_; }
+
+            virtual bool setValue(const char& value)                 = 0;
+            virtual bool setValue(const unsigned char& value)        = 0;
+            virtual bool setValue(const short& value)                = 0;
+            virtual bool setValue(const unsigned short& value)       = 0;
+            virtual bool setValue(const int& value)                  = 0;
+            virtual bool setValue(const unsigned int& value)         = 0;
+            virtual bool setValue(const long& value)                 = 0;
+            virtual bool setValue(const unsigned long& value)        = 0;
+            virtual bool setValue(const long long& value)            = 0;
+            virtual bool setValue(const unsigned long long& value)   = 0;
+            virtual bool setValue(const float& value)                = 0;
+            virtual bool setValue(const double& value)               = 0;
+            virtual bool setValue(const long double& value)          = 0;
+            virtual bool setValue(const bool& value)                 = 0;
+            virtual bool setValue(      void* const& value)          = 0;
+            virtual bool setValue(const std::string& value)          = 0;
+            virtual bool setValue(const orxonox::Vector2& value)     = 0;
+            virtual bool setValue(const orxonox::Vector3& value)     = 0;
+            virtual bool setValue(const orxonox::Vector4& value)     = 0;
+            virtual bool setValue(const orxonox::ColourValue& value) = 0;
+            virtual bool setValue(const orxonox::Quaternion& value)  = 0;
+            virtual bool setValue(const orxonox::Radian& value)      = 0;
+            virtual bool setValue(const orxonox::Degree& value)      = 0;
+
+            virtual bool getValue(char*                 value) const = 0;
+            virtual bool getValue(unsigned char*        value) const = 0;
+            virtual bool getValue(short*                value) const = 0;
+            virtual bool getValue(unsigned short*       value) const = 0;
+            virtual bool getValue(int*                  value) const = 0;
+            virtual bool getValue(unsigned int*         value) const = 0;
+            virtual bool getValue(long*                 value) const = 0;
+            virtual bool getValue(unsigned long*        value) const = 0;
+            virtual bool getValue(long long*            value) const = 0;
+            virtual bool getValue(unsigned long long*   value) const = 0;
+            virtual bool getValue(float*                value) const = 0;
+            virtual bool getValue(double*               value) const = 0;
+            virtual bool getValue(long double*          value) const = 0;
+            virtual bool getValue(bool*                 value) const = 0;
+            virtual bool getValue(void**                value) const = 0;
+            virtual bool getValue(std::string*          value) const = 0;
+            virtual bool getValue(orxonox::Vector2*     value) const = 0;
+            virtual bool getValue(orxonox::Vector3*     value) const = 0;
+            virtual bool getValue(orxonox::Vector4*     value) const = 0;
+            virtual bool getValue(orxonox::ColourValue* value) const = 0;
+            virtual bool getValue(orxonox::Quaternion*  value) const = 0;
+            virtual bool getValue(orxonox::Radian*      value) const = 0;
+            virtual bool getValue(orxonox::Degree*      value) const = 0;
+
+            virtual operator char()                 const = 0;
+            virtual operator unsigned char()        const = 0;
+            virtual operator short()                const = 0;
+            virtual operator unsigned short()       const = 0;
+            virtual operator int()                  const = 0;
+            virtual operator unsigned int()         const = 0;
+            virtual operator long()                 const = 0;
+            virtual operator unsigned long()        const = 0;
+            virtual operator long long()            const = 0;
+            virtual operator unsigned long long()   const = 0;
+            virtual operator float()                const = 0;
+            virtual operator double()               const = 0;
+            virtual operator long double()          const = 0;
+            virtual operator bool()                 const = 0;
+            virtual operator void*()                const = 0;
+            virtual operator std::string()          const = 0;
+            virtual operator orxonox::Vector2()     const = 0;
+            virtual operator orxonox::Vector3()     const = 0;
+            virtual operator orxonox::Vector4()     const = 0;
+            virtual operator orxonox::ColourValue() const = 0;
+            virtual operator orxonox::Quaternion()  const = 0;
+            virtual operator orxonox::Radian()      const = 0;
+            virtual operator orxonox::Degree()      const = 0;
+
+            virtual void toString(std::ostream& outstream) const = 0;
+
+            MT_Type type_;          //!< The type of the current value
+            bool bHasDefaultValue_; //!< True if the last conversion wasn't successful
+        };
+
+        public:
+            inline MultiType()                                  : value_(0) {}                                      /** @brief Default constructor: Assigns no value and no type. The type will be determined by the first assignment of a value. */
+            inline MultiType(const char& value)                 : value_(0) { this->assignValue(value); }           /** @brief Constructor: Assigns the given value and sets the type. */
+            inline MultiType(const unsigned char& value)        : value_(0) { this->assignValue(value); }           /** @brief Constructor: Assigns the given value and sets the type. */
+            inline MultiType(const short& value)                : value_(0) { this->assignValue(value); }           /** @brief Constructor: Assigns the given value and sets the type. */
+            inline MultiType(const unsigned short& value)       : value_(0) { this->assignValue(value); }           /** @brief Constructor: Assigns the given value and sets the type. */
+            inline MultiType(const int& value)                  : value_(0) { this->assignValue(value); }           /** @brief Constructor: Assigns the given value and sets the type. */
+            inline MultiType(const unsigned int& value)         : value_(0) { this->assignValue(value); }           /** @brief Constructor: Assigns the given value and sets the type. */
+            inline MultiType(const long& value)                 : value_(0) { this->assignValue(value); }           /** @brief Constructor: Assigns the given value and sets the type. */
+            inline MultiType(const unsigned long& value)        : value_(0) { this->assignValue(value); }           /** @brief Constructor: Assigns the given value and sets the type. */
+            inline MultiType(const long long& value)            : value_(0) { this->assignValue(value); }           /** @brief Constructor: Assigns the given value and sets the type. */
+            inline MultiType(const unsigned long long& value)   : value_(0) { this->assignValue(value); }           /** @brief Constructor: Assigns the given value and sets the type. */
+            inline MultiType(const float& value)                : value_(0) { this->assignValue(value); }           /** @brief Constructor: Assigns the given value and sets the type. */
+            inline MultiType(const double& value)               : value_(0) { this->assignValue(value); }           /** @brief Constructor: Assigns the given value and sets the type. */
+            inline MultiType(const long double& value)          : value_(0) { this->assignValue(value); }           /** @brief Constructor: Assigns the given value and sets the type. */
+            inline MultiType(const bool& value)                 : value_(0) { this->assignValue(value); }           /** @brief Constructor: Assigns the given value and sets the type. */
+            inline MultiType(      void* const& value)          : value_(0) { this->assignValue(value); }           /** @brief Constructor: Assigns the given value and sets the type. */
+            inline MultiType(const std::string& value)          : value_(0) { this->assignValue(value); }           /** @brief Constructor: Assigns the given value and sets the type. */
+            inline MultiType(const orxonox::Vector2& value)     : value_(0) { this->assignValue(value); }           /** @brief Constructor: Assigns the given value and sets the type. */
+            inline MultiType(const orxonox::Vector3& value)     : value_(0) { this->assignValue(value); }           /** @brief Constructor: Assigns the given value and sets the type. */
+            inline MultiType(const orxonox::Vector4& value)     : value_(0) { this->assignValue(value); }           /** @brief Constructor: Assigns the given value and sets the type. */
+            inline MultiType(const orxonox::ColourValue& value) : value_(0) { this->assignValue(value); }           /** @brief Constructor: Assigns the given value and sets the type. */
+            inline MultiType(const orxonox::Quaternion& value)  : value_(0) { this->assignValue(value); }           /** @brief Constructor: Assigns the given value and sets the type. */
+            inline MultiType(const orxonox::Radian& value)      : value_(0) { this->assignValue(value); }           /** @brief Constructor: Assigns the given value and sets the type. */
+            inline MultiType(const orxonox::Degree& value)      : value_(0) { this->assignValue(value); }           /** @brief Constructor: Assigns the given value and sets the type. */
+            inline MultiType(const char* value)                 : value_(0) { this->setValue(std::string(value)); } /** @brief Constructor: Converts the char array to a std::string, assigns the value and sets the type. */
+            inline MultiType(const MultiType& other)            : value_(0) { this->setValue(other); }              /** @brief Copyconstructor: Assigns value and type of the other MultiType. */
+            inline MultiType(MT_Type type)                      : value_(0) { this->setType(type); }                /** @brief Constructor: Sets the type, the next assignment will determine the value. */
+
+            /** @brief Destructor: Deletes the MT_Value. */
+            inline ~MultiType() { if (this->value_) { delete this->value_; } }
+
+            template <typename V> inline const MultiType& operator=(const V& value)         { this->setValue(value); return (*this); } /** @brief Assigns a new value. The value will be converted to the current type of the MultiType. */
+            template <typename V> inline const MultiType& operator=(V* value)               { this->setValue(value); return (*this); } /** @brief Assigns a pointer. */
+            inline                       const MultiType& operator=(const MultiType& other) { this->setValue(other); return (*this); } /** @brief Assigns the value of the other MultiType and converts it to the current type of the MultiType. */
+            inline                       const MultiType& operator=(MT_Type type)           { this->setType(type);   return (*this); } /** @brief Resets the value and changes the type. */
+
+            inline bool                                   setValue(const char& value);
+            inline bool                                   setValue(const unsigned char& value);
+            inline bool                                   setValue(const short& value);
+            inline bool                                   setValue(const unsigned short& value);
+            inline bool                                   setValue(const int& value);
+            inline bool                                   setValue(const unsigned int& value);
+            inline bool                                   setValue(const long& value);
+            inline bool                                   setValue(const unsigned long& value);
+            inline bool                                   setValue(const long long& value);
+            inline bool                                   setValue(const unsigned long long& value);
+            inline bool                                   setValue(const float& value);
+            inline bool                                   setValue(const double& value);
+            inline bool                                   setValue(const long double& value);
+            inline bool                                   setValue(const bool& value);
+            inline bool                                   setValue(      void* const& value);
+            inline bool                                   setValue(const std::string& value);
+            inline bool                                   setValue(const orxonox::Vector2& value);
+            inline bool                                   setValue(const orxonox::Vector3& value);
+            inline bool                                   setValue(const orxonox::Vector4& value);
+            inline bool                                   setValue(const orxonox::ColourValue& value);
+            inline bool                                   setValue(const orxonox::Quaternion& value);
+            inline bool                                   setValue(const orxonox::Radian& value);
+            inline bool                                   setValue(const orxonox::Degree& value);
+            inline bool                                   setValue(const char* value);
+            /** @brief Assigns a pointer. */
+            template <typename V> inline bool             setValue(V* value)               { if (this->value_) { return this->value_->setValue((void*)value); } else { return this->assignValue((void*)value); } }
+            /** @brief Assigns the value of the other MultiType and converts it to the current type. */
+            bool                                          setValue(const MultiType& other) { if (this->value_) { return this->value_->assimilate(other); } else { if (other.value_) { this->value_ = other.value_->clone(); } return true; } }
+            /** @brief Changes the type to T and assigns the new value (which might be of another type than T - it gets converted). */
+            template <typename T, typename V> inline bool setValue(const V& value) { this->setType<T>(); return this->setValue(value); }
+
+
+            /** @brief Copies the other MultiType by assigning value and type. */
+            inline void                       copy(const MultiType& other)    { if (this == &other) { return; } if (this->value_) { delete this->value_; } this->value_ = (other.value_) ? other.value_->clone() : 0; }
+
+            template <typename T> inline bool convert()                       { return this->setValue<T>((T)(*this));  } /** @brief Converts the current value to type T. */
+            inline bool                       convert(const MultiType& other) { return this->convert(other.getType()); } /** @brief Converts the current value to the type of the other MultiType. */
+            bool                              convert(MT_Type type);
+
+            /** @brief Current content gets deleted. New type is MT_null */
+            inline void                       reset()                         { if (this->value_) this->value_->reset(); }
+
+            template <typename T> inline void setType()                       { this->assignValue(T());                            } /** @brief Resets the value and changes the internal type to T. */
+            inline void                       setType(const MultiType& other) { this->setType(other.getType());                    } /** @brief Resets the value and changes the internal type to the type of the other MultiType. */
+            inline void                       setType(MT_Type type)           { this->reset(); this->convert(type); this->reset(); } /** @brief Resets the value and changes the internal type to the given type. */
+
+            /** @brief Returns the current type. */
+            inline MT_Type                    getType()                 const { return (this->value_) ? this->value_->type_ : MT_null; }
+            /** @brief Returns true if the current type equals the given type. */
+            inline bool                       isType(MT_Type type)      const { return (this->value_) ? (this->value_->type_ == type) : (type == MT_null); }
+            /** @brief Returns true if the current type is T. */
+            template <typename T> inline bool isType()                  const { return false; } // Only works for specialized values - see below
+            std::string                       getTypename()             const;
+
+            /** @brief Checks whether the value is a default one. */
+            bool                              hasDefaultValue()         const { return this->value_->hasDefaultValue(); }
+
+            operator char()                  const;
+            operator unsigned char()         const;
+            operator short()                 const;
+            operator unsigned short()        const;
+            operator int()                   const;
+            operator unsigned int()          const;
+            operator long()                  const;
+            operator unsigned long()         const;
+            operator long long()             const;
+            operator unsigned long long()    const;
+            operator float()                 const;
+            operator double()                const;
+            operator long double()           const;
+            operator bool()                  const;
+            operator void*()                 const;
+            operator std::string()           const;
+            operator orxonox::Vector2()      const;
+            operator orxonox::Vector3()      const;
+            operator orxonox::Vector4()      const;
+            operator orxonox::ColourValue()  const;
+            operator orxonox::Quaternion()   const;
+            operator orxonox::Radian()       const;
+            operator orxonox::Degree()       const;
+            /** @brief Returns the current value, converted to a T* pointer. */
+            template <class T> operator T*() const { return ((T*)this->operator void*()); }
+
+            inline bool getValue(char*                 value) const { if (this->value_) { return this->value_->getValue(value); } return false; } /** @brief Assigns the value to the given pointer. The value gets converted if the types don't match. */
+            inline bool getValue(unsigned char*        value) const { if (this->value_) { return this->value_->getValue(value); } return false; } /** @brief Assigns the value to the given pointer. The value gets converted if the types don't match. */
+            inline bool getValue(short*                value) const { if (this->value_) { return this->value_->getValue(value); } return false; } /** @brief Assigns the value to the given pointer. The value gets converted if the types don't match. */
+            inline bool getValue(unsigned short*       value) const { if (this->value_) { return this->value_->getValue(value); } return false; } /** @brief Assigns the value to the given pointer. The value gets converted if the types don't match. */
+            inline bool getValue(int*                  value) const { if (this->value_) { return this->value_->getValue(value); } return false; } /** @brief Assigns the value to the given pointer. The value gets converted if the types don't match. */
+            inline bool getValue(unsigned int*         value) const { if (this->value_) { return this->value_->getValue(value); } return false; } /** @brief Assigns the value to the given pointer. The value gets converted if the types don't match. */
+            inline bool getValue(long*                 value) const { if (this->value_) { return this->value_->getValue(value); } return false; } /** @brief Assigns the value to the given pointer. The value gets converted if the types don't match. */
+            inline bool getValue(unsigned long*        value) const { if (this->value_) { return this->value_->getValue(value); } return false; } /** @brief Assigns the value to the given pointer. The value gets converted if the types don't match. */
+            inline bool getValue(long long*            value) const { if (this->value_) { return this->value_->getValue(value); } return false; } /** @brief Assigns the value to the given pointer. The value gets converted if the types don't match. */
+            inline bool getValue(unsigned long long*   value) const { if (this->value_) { return this->value_->getValue(value); } return false; } /** @brief Assigns the value to the given pointer. The value gets converted if the types don't match. */
+            inline bool getValue(float*                value) const { if (this->value_) { return this->value_->getValue(value); } return false; } /** @brief Assigns the value to the given pointer. The value gets converted if the types don't match. */
+            inline bool getValue(double*               value) const { if (this->value_) { return this->value_->getValue(value); } return false; } /** @brief Assigns the value to the given pointer. The value gets converted if the types don't match. */
+            inline bool getValue(long double*          value) const { if (this->value_) { return this->value_->getValue(value); } return false; } /** @brief Assigns the value to the given pointer. The value gets converted if the types don't match. */
+            inline bool getValue(bool*                 value) const { if (this->value_) { return this->value_->getValue(value); } return false; } /** @brief Assigns the value to the given pointer. The value gets converted if the types don't match. */
+            inline bool getValue(void**                value) const { if (this->value_) { return this->value_->getValue(value); } return false; } /** @brief Assigns the value to the given pointer. The value gets converted if the types don't match. */
+            inline bool getValue(std::string*          value) const { if (this->value_) { return this->value_->getValue(value); } return false; } /** @brief Assigns the value to the given pointer. The value gets converted if the types don't match. */
+            inline bool getValue(orxonox::Vector2*     value) const { if (this->value_) { return this->value_->getValue(value); } return false; } /** @brief Assigns the value to the given pointer. The value gets converted if the types don't match. */
+            inline bool getValue(orxonox::Vector3*     value) const { if (this->value_) { return this->value_->getValue(value); } return false; } /** @brief Assigns the value to the given pointer. The value gets converted if the types don't match. */
+            inline bool getValue(orxonox::Vector4*     value) const { if (this->value_) { return this->value_->getValue(value); } return false; } /** @brief Assigns the value to the given pointer. The value gets converted if the types don't match. */
+            inline bool getValue(orxonox::ColourValue* value) const { if (this->value_) { return this->value_->getValue(value); } return false; } /** @brief Assigns the value to the given pointer. The value gets converted if the types don't match. */
+            inline bool getValue(orxonox::Quaternion*  value) const { if (this->value_) { return this->value_->getValue(value); } return false; } /** @brief Assigns the value to the given pointer. The value gets converted if the types don't match. */
+            inline bool getValue(orxonox::Radian*      value) const { if (this->value_) { return this->value_->getValue(value); } return false; } /** @brief Assigns the value to the given pointer. The value gets converted if the types don't match. */
+            inline bool getValue(orxonox::Degree*      value) const { if (this->value_) { return this->value_->getValue(value); } return false; } /** @brief Assigns the value to the given pointer. The value gets converted if the types don't match. */
+
+            inline char                     getChar()             const { return this->operator char();                 } /** @brief Returns the current value, converted to the requested type. */
+            inline unsigned char            getUnsignedChar()     const { return this->operator unsigned char();        } /** @brief Returns the current value, converted to the requested type. */
+            inline short                    getShort()            const { return this->operator short();                } /** @brief Returns the current value, converted to the requested type. */
+            inline unsigned short           getUnsignedShort()    const { return this->operator unsigned short();       } /** @brief Returns the current value, converted to the requested type. */
+            inline int                      getInt()              const { return this->operator int();                  } /** @brief Returns the current value, converted to the requested type. */
+            inline unsigned int             getUnsignedInt()      const { return this->operator unsigned int();         } /** @brief Returns the current value, converted to the requested type. */
+            inline long                     getLong()             const { return this->operator long();                 } /** @brief Returns the current value, converted to the requested type. */
+            inline unsigned long            getUnsignedLong()     const { return this->operator unsigned long();        } /** @brief Returns the current value, converted to the requested type. */
+            inline long long                getLongLong()         const { return this->operator long long();            } /** @brief Returns the current value, converted to the requested type. */
+            inline unsigned long long       getUnsignedLongLong() const { return this->operator unsigned long long();   } /** @brief Returns the current value, converted to the requested type. */
+            inline float                    getFloat()            const { return this->operator float();                } /** @brief Returns the current value, converted to the requested type. */
+            inline double                   getDouble()           const { return this->operator double();               } /** @brief Returns the current value, converted to the requested type. */
+            inline long double              getLongDouble()       const { return this->operator long double();          } /** @brief Returns the current value, converted to the requested type. */
+            inline bool                     getBool()             const { return this->operator bool();                 } /** @brief Returns the current value, converted to the requested type. */
+            inline void*                    getVoid()             const { return this->operator void*();                } /** @brief Returns the current value, converted to the requested type. */
+            inline std::string              getString()           const { return this->operator std::string();          } /** @brief Returns the current value, converted to the requested type. */
+            inline orxonox::Vector2         getVector2()          const { return this->operator orxonox::Vector2();     } /** @brief Returns the current value, converted to the requested type. */
+            inline orxonox::Vector3         getVector3()          const { return this->operator orxonox::Vector3();     } /** @brief Returns the current value, converted to the requested type. */
+            inline orxonox::Vector4         getVector4()          const { return this->operator orxonox::Vector4();     } /** @brief Returns the current value, converted to the requested type. */
+            inline orxonox::ColourValue     getColourValue()      const { return this->operator orxonox::ColourValue(); } /** @brief Returns the current value, converted to the requested type. */
+            inline orxonox::Quaternion      getQuaternion()       const { return this->operator orxonox::Quaternion();  } /** @brief Returns the current value, converted to the requested type. */
+            inline orxonox::Radian          getRadian()           const { return this->operator orxonox::Radian();      } /** @brief Returns the current value, converted to the requested type. */
+            inline orxonox::Degree          getDegree()           const { return this->operator orxonox::Degree();      } /** @brief Returns the current value, converted to the requested type. */
+            template <typename T> inline T* getPointer()          const { return ((T*)this->getVoid());                 } /** @brief Returns the current value, converted to a T* pointer. */
+
+        private:
+            inline bool assignValue(const char& value)                 { if (this->value_ && this->value_->type_ == MT_char)        { return this->value_->setValue(value); } else { this->changeValueContainer<char>(value);                 return true; } } /** @brief Assigns a new value by changing type and creating a new container. */
+            inline bool assignValue(const unsigned char& value)        { if (this->value_ && this->value_->type_ == MT_uchar)       { return this->value_->setValue(value); } else { this->changeValueContainer<unsigned char>(value);        return true; } } /** @brief Assigns a new value by changing type and creating a new container. */
+            inline bool assignValue(const short& value)                { if (this->value_ && this->value_->type_ == MT_short)       { return this->value_->setValue(value); } else { this->changeValueContainer<short>(value);                return true; } } /** @brief Assigns a new value by changing type and creating a new container. */
+            inline bool assignValue(const unsigned short& value)       { if (this->value_ && this->value_->type_ == MT_ushort)      { return this->value_->setValue(value); } else { this->changeValueContainer<unsigned short>(value);       return true; } } /** @brief Assigns a new value by changing type and creating a new container. */
+            inline bool assignValue(const int& value)                  { if (this->value_ && this->value_->type_ == MT_int)         { return this->value_->setValue(value); } else { this->changeValueContainer<int>(value);                  return true; } } /** @brief Assigns a new value by changing type and creating a new container. */
+            inline bool assignValue(const unsigned int& value)         { if (this->value_ && this->value_->type_ == MT_uint)        { return this->value_->setValue(value); } else { this->changeValueContainer<unsigned int>(value);         return true; } } /** @brief Assigns a new value by changing type and creating a new container. */
+            inline bool assignValue(const long& value)                 { if (this->value_ && this->value_->type_ == MT_long)        { return this->value_->setValue(value); } else { this->changeValueContainer<long>(value);                 return true; } } /** @brief Assigns a new value by changing type and creating a new container. */
+            inline bool assignValue(const unsigned long& value)        { if (this->value_ && this->value_->type_ == MT_ulong)       { return this->value_->setValue(value); } else { this->changeValueContainer<unsigned long>(value);        return true; } } /** @brief Assigns a new value by changing type and creating a new container. */
+            inline bool assignValue(const long long& value)            { if (this->value_ && this->value_->type_ == MT_longlong)    { return this->value_->setValue(value); } else { this->changeValueContainer<long long>(value);            return true; } } /** @brief Assigns a new value by changing type and creating a new container. */
+            inline bool assignValue(const unsigned long long& value)   { if (this->value_ && this->value_->type_ == MT_ulonglong)   { return this->value_->setValue(value); } else { this->changeValueContainer<unsigned long long>(value);   return true; } } /** @brief Assigns a new value by changing type and creating a new container. */
+            inline bool assignValue(const float& value)                { if (this->value_ && this->value_->type_ == MT_float)       { return this->value_->setValue(value); } else { this->changeValueContainer<float>(value);                return true; } } /** @brief Assigns a new value by changing type and creating a new container. */
+            inline bool assignValue(const double& value)               { if (this->value_ && this->value_->type_ == MT_double)      { return this->value_->setValue(value); } else { this->changeValueContainer<double>(value);               return true; } } /** @brief Assigns a new value by changing type and creating a new container. */
+            inline bool assignValue(const long double& value)          { if (this->value_ && this->value_->type_ == MT_longdouble)  { return this->value_->setValue(value); } else { this->changeValueContainer<long double>(value);          return true; } } /** @brief Assigns a new value by changing type and creating a new container. */
+            inline bool assignValue(const bool& value)                 { if (this->value_ && this->value_->type_ == MT_bool)        { return this->value_->setValue(value); } else { this->changeValueContainer<bool>(value);                 return true; } } /** @brief Assigns a new value by changing type and creating a new container. */
+            inline bool assignValue(      void* const& value)          { if (this->value_ && this->value_->type_ == MT_void)        { return this->value_->setValue(value); } else { this->changeValueContainer<void*>(value);                return true; } } /** @brief Assigns a new value by changing type and creating a new container. */
+            inline bool assignValue(const std::string& value)          { if (this->value_ && this->value_->type_ == MT_string)      { return this->value_->setValue(value); } else { this->changeValueContainer<std::string>(value);          return true; } } /** @brief Assigns a new value by changing type and creating a new container. */
+            inline bool assignValue(const orxonox::Vector2& value)     { if (this->value_ && this->value_->type_ == MT_vector2)     { return this->value_->setValue(value); } else { this->changeValueContainer<orxonox::Vector2>(value);     return true; } } /** @brief Assigns a new value by changing type and creating a new container. */
+            inline bool assignValue(const orxonox::Vector3& value)     { if (this->value_ && this->value_->type_ == MT_vector3)     { return this->value_->setValue(value); } else { this->changeValueContainer<orxonox::Vector3>(value);     return true; } } /** @brief Assigns a new value by changing type and creating a new container. */
+            inline bool assignValue(const orxonox::Vector4& value)     { if (this->value_ && this->value_->type_ == MT_vector4)     { return this->value_->setValue(value); } else { this->changeValueContainer<orxonox::Vector4>(value);     return true; } } /** @brief Assigns a new value by changing type and creating a new container. */
+            inline bool assignValue(const orxonox::ColourValue& value) { if (this->value_ && this->value_->type_ == MT_colourvalue) { return this->value_->setValue(value); } else { this->changeValueContainer<orxonox::ColourValue>(value); return true; } } /** @brief Assigns a new value by changing type and creating a new container. */
+            inline bool assignValue(const orxonox::Quaternion& value)  { if (this->value_ && this->value_->type_ == MT_quaternion)  { return this->value_->setValue(value); } else { this->changeValueContainer<orxonox::Quaternion>(value);  return true; } } /** @brief Assigns a new value by changing type and creating a new container. */
+            inline bool assignValue(const orxonox::Radian& value)      { if (this->value_ && this->value_->type_ == MT_radian)      { return this->value_->setValue(value); } else { this->changeValueContainer<orxonox::Radian>(value);      return true; } } /** @brief Assigns a new value by changing type and creating a new container. */
+            inline bool assignValue(const orxonox::Degree& value)      { if (this->value_ && this->value_->type_ == MT_degree)      { return this->value_->setValue(value); } else { this->changeValueContainer<orxonox::Degree>(value);      return true; } } /** @brief Assigns a new value by changing type and creating a new container. */
+
+            /** @brief Changes the value container. */
+            template <typename T> inline void changeValueContainer(const T& value) { if (this->value_) { delete this->value_; } this->createNewValueContainer<T>(value); }
+            /** @brief Creates a new value container (works only with specialized types). */
+            template <typename T>        void createNewValueContainer(const T& value) { BOOST_STATIC_ASSERT(sizeof(T) == 0); return false; }
+
+            MT_ValueBase* value_; //!< A pointer to the value container
+    };
+
+    /** @brief Puts the MultiType on a stream by using the native << operator of the current type. */
+    _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);        } /** @brief Returns true if the current type equals the given type. */
+    template <> inline bool MultiType::isType<unsigned char>()        const { return (this->value_ && this->value_->type_ == MT_uchar);       } /** @brief Returns true if the current type equals the given type. */
+    template <> inline bool MultiType::isType<short>()                const { return (this->value_ && this->value_->type_ == MT_short);       } /** @brief Returns true if the current type equals the given type. */
+    template <> inline bool MultiType::isType<unsigned short>()       const { return (this->value_ && this->value_->type_ == MT_ushort);      } /** @brief Returns true if the current type equals the given type. */
+    template <> inline bool MultiType::isType<int>()                  const { return (this->value_ && this->value_->type_ == MT_int);         } /** @brief Returns true if the current type equals the given type. */
+    template <> inline bool MultiType::isType<unsigned int>()         const { return (this->value_ && this->value_->type_ == MT_uint);        } /** @brief Returns true if the current type equals the given type. */
+    template <> inline bool MultiType::isType<long>()                 const { return (this->value_ && this->value_->type_ == MT_long);        } /** @brief Returns true if the current type equals the given type. */
+    template <> inline bool MultiType::isType<unsigned long>()        const { return (this->value_ && this->value_->type_ == MT_ulong);       } /** @brief Returns true if the current type equals the given type. */
+    template <> inline bool MultiType::isType<long long>()            const { return (this->value_ && this->value_->type_ == MT_longlong);    } /** @brief Returns true if the current type equals the given type. */
+    template <> inline bool MultiType::isType<unsigned long long>()   const { return (this->value_ && this->value_->type_ == MT_ulonglong);   } /** @brief Returns true if the current type equals the given type. */
+    template <> inline bool MultiType::isType<float>()                const { return (this->value_ && this->value_->type_ == MT_float);       } /** @brief Returns true if the current type equals the given type. */
+    template <> inline bool MultiType::isType<double>()               const { return (this->value_ && this->value_->type_ == MT_double);      } /** @brief Returns true if the current type equals the given type. */
+    template <> inline bool MultiType::isType<long double>()          const { return (this->value_ && this->value_->type_ == MT_longdouble);  } /** @brief Returns true if the current type equals the given type. */
+    template <> inline bool MultiType::isType<bool>()                 const { return (this->value_ && this->value_->type_ == MT_bool);        } /** @brief Returns true if the current type equals the given type. */
+    template <> inline bool MultiType::isType<void*>()                const { return (this->value_ && this->value_->type_ == MT_void);        } /** @brief Returns true if the current type equals the given type. */
+    template <> inline bool MultiType::isType<std::string>()          const { return (this->value_ && this->value_->type_ == MT_string);      } /** @brief Returns true if the current type equals the given type. */
+    template <> inline bool MultiType::isType<orxonox::Vector2>()     const { return (this->value_ && this->value_->type_ == MT_vector2);     } /** @brief Returns true if the current type equals the given type. */
+    template <> inline bool MultiType::isType<orxonox::Vector3>()     const { return (this->value_ && this->value_->type_ == MT_vector3);     } /** @brief Returns true if the current type equals the given type. */
+    template <> inline bool MultiType::isType<orxonox::Vector4>()     const { return (this->value_ && this->value_->type_ == MT_vector4);     } /** @brief Returns true if the current type equals the given type. */
+    template <> inline bool MultiType::isType<orxonox::ColourValue>() const { return (this->value_ && this->value_->type_ == MT_colourvalue); } /** @brief Returns true if the current type equals the given type. */
+    template <> inline bool MultiType::isType<orxonox::Quaternion>()  const { return (this->value_ && this->value_->type_ == MT_quaternion);  } /** @brief Returns true if the current type equals the given type. */
+    template <> inline bool MultiType::isType<orxonox::Radian>()      const { return (this->value_ && this->value_->type_ == MT_radian);      } /** @brief Returns true if the current type equals the given type. */
+    template <> inline bool MultiType::isType<orxonox::Degree>()      const { return (this->value_ && this->value_->type_ == MT_degree);      } /** @brief Returns true if the current type equals the given type. */
+
+    // Specialization to avoid ambiguities with the conversion operator
+    template <> inline bool MultiType::convert<std::string>()          { return this->setValue<std::string>         (this->operator std::string());          } /** @brief Converts the current value to the given type. */
+    template <> inline bool MultiType::convert<orxonox::Vector2>()     { return this->setValue<orxonox::Vector2>    (this->operator orxonox::Vector2());     } /** @brief Converts the current value to the given type. */
+    template <> inline bool MultiType::convert<orxonox::Vector3>()     { return this->setValue<orxonox::Vector3>    (this->operator orxonox::Vector3());     } /** @brief Converts the current value to the given type. */
+    template <> inline bool MultiType::convert<orxonox::Vector4>()     { return this->setValue<orxonox::Vector4>    (this->operator orxonox::Vector4());     } /** @brief Converts the current value to the given type. */
+    template <> inline bool MultiType::convert<orxonox::ColourValue>() { return this->setValue<orxonox::ColourValue>(this->operator orxonox::ColourValue()); } /** @brief Converts the current value to the given type. */
+    template <> inline bool MultiType::convert<orxonox::Quaternion>()  { return this->setValue<orxonox::Quaternion> (this->operator orxonox::Quaternion());  } /** @brief Converts the current value to the given type. */
+    template <> inline bool MultiType::convert<orxonox::Radian>()      { return this->setValue<orxonox::Radian>     (this->operator orxonox::Radian());      } /** @brief Converts the current value to the given type. */
+    template <> inline bool MultiType::convert<orxonox::Degree>()      { return this->setValue<orxonox::Degree>     (this->operator orxonox::Degree());      } /** @brief Converts the current value to the given type. */
+
+    // Specialization to avoid ambiguities with the conversion operator
+    template <> inline bool MultiType::convert<const std::string&>()          { return this->convert<std::string>();          } /** @brief Converts the current value to the given type. */
+    template <> inline bool MultiType::convert<const orxonox::Vector2&>()     { return this->convert<orxonox::Vector2>();     } /** @brief Converts the current value to the given type. */
+    template <> inline bool MultiType::convert<const orxonox::Vector3&>()     { return this->convert<orxonox::Vector3>();     } /** @brief Converts the current value to the given type. */
+    template <> inline bool MultiType::convert<const orxonox::Vector4&>()     { return this->convert<orxonox::Vector4>();     } /** @brief Converts the current value to the given type. */
+    template <> inline bool MultiType::convert<const orxonox::ColourValue&>() { return this->convert<orxonox::ColourValue>(); } /** @brief Converts the current value to the given type. */
+    template <> inline bool MultiType::convert<const orxonox::Quaternion&>()  { return this->convert<orxonox::Quaternion>();  } /** @brief Converts the current value to the given type. */
+    template <> inline bool MultiType::convert<const orxonox::Radian&>()      { return this->convert<orxonox::Radian>();      } /** @brief Converts the current value to the given type. */
+    template <> inline bool MultiType::convert<const orxonox::Degree&>()      { return this->convert<orxonox::Degree>();      } /** @brief Converts the current value to the given type. */
+
+    template <> void MultiType::createNewValueContainer(const char& value);
+    template <> void MultiType::createNewValueContainer(const unsigned char& value);
+    template <> void MultiType::createNewValueContainer(const short& value);
+    template <> void MultiType::createNewValueContainer(const unsigned short& value);
+    template <> void MultiType::createNewValueContainer(const int& value);
+    template <> void MultiType::createNewValueContainer(const unsigned int& value);
+    template <> void MultiType::createNewValueContainer(const long& value);
+    template <> void MultiType::createNewValueContainer(const unsigned long& value);
+    template <> void MultiType::createNewValueContainer(const long long& value);
+    template <> void MultiType::createNewValueContainer(const unsigned long long& value);
+    template <> void MultiType::createNewValueContainer(const float& value);
+    template <> void MultiType::createNewValueContainer(const double& value);
+    template <> void MultiType::createNewValueContainer(const bool& value);
+    template <> void MultiType::createNewValueContainer(const long double& value);
+    template <> void MultiType::createNewValueContainer(      void* const& value);
+    template <> void MultiType::createNewValueContainer(const std::string& value);
+    template <> void MultiType::createNewValueContainer(const orxonox::Vector2& value);
+    template <> void MultiType::createNewValueContainer(const orxonox::Vector3& value);
+    template <> void MultiType::createNewValueContainer(const orxonox::Vector4& value);
+    template <> void MultiType::createNewValueContainer(const orxonox::ColourValue& value);
+    template <> void MultiType::createNewValueContainer(const orxonox::Quaternion& value);
+    template <> void MultiType::createNewValueContainer(const orxonox::Radian& value);
+    template <> void MultiType::createNewValueContainer(const orxonox::Degree& value);
+
+    inline bool MultiType::setValue(const char& value)                  { if (this->value_) { return this->value_->setValue(value); } else { return this->assignValue(value); } } /** @brief Assigns the given value and converts it to the current type. */
+    inline bool MultiType::setValue(const unsigned char& value)         { if (this->value_) { return this->value_->setValue(value); } else { return this->assignValue(value); } } /** @brief Assigns the given value and converts it to the current type. */
+    inline bool MultiType::setValue(const short& value)                 { if (this->value_) { return this->value_->setValue(value); } else { return this->assignValue(value); } } /** @brief Assigns the given value and converts it to the current type. */
+    inline bool MultiType::setValue(const unsigned short& value)        { if (this->value_) { return this->value_->setValue(value); } else { return this->assignValue(value); } } /** @brief Assigns the given value and converts it to the current type. */
+    inline bool MultiType::setValue(const int& value)                   { if (this->value_) { return this->value_->setValue(value); } else { return this->assignValue(value); } } /** @brief Assigns the given value and converts it to the current type. */
+    inline bool MultiType::setValue(const unsigned int& value)          { if (this->value_) { return this->value_->setValue(value); } else { return this->assignValue(value); } } /** @brief Assigns the given value and converts it to the current type. */
+    inline bool MultiType::setValue(const long& value)                  { if (this->value_) { return this->value_->setValue(value); } else { return this->assignValue(value); } } /** @brief Assigns the given value and converts it to the current type. */
+    inline bool MultiType::setValue(const unsigned long& value)         { if (this->value_) { return this->value_->setValue(value); } else { return this->assignValue(value); } } /** @brief Assigns the given value and converts it to the current type. */
+    inline bool MultiType::setValue(const long long& value)             { if (this->value_) { return this->value_->setValue(value); } else { return this->assignValue(value); } } /** @brief Assigns the given value and converts it to the current type. */
+    inline bool MultiType::setValue(const unsigned long long& value)    { if (this->value_) { return this->value_->setValue(value); } else { return this->assignValue(value); } } /** @brief Assigns the given value and converts it to the current type. */
+    inline bool MultiType::setValue(const float& value)                 { if (this->value_) { return this->value_->setValue(value); } else { return this->assignValue(value); } } /** @brief Assigns the given value and converts it to the current type. */
+    inline bool MultiType::setValue(const double& value)                { if (this->value_) { return this->value_->setValue(value); } else { return this->assignValue(value); } } /** @brief Assigns the given value and converts it to the current type. */
+    inline bool MultiType::setValue(const long double& value)           { if (this->value_) { return this->value_->setValue(value); } else { return this->assignValue(value); } } /** @brief Assigns the given value and converts it to the current type. */
+    inline bool MultiType::setValue(const bool& value)                  { if (this->value_) { return this->value_->setValue(value); } else { return this->assignValue(value); } } /** @brief Assigns the given value and converts it to the current type. */
+    inline bool MultiType::setValue(      void* const& value)           { if (this->value_) { return this->value_->setValue(value); } else { return this->assignValue(value); } } /** @brief Assigns the given value and converts it to the current type. */
+    inline bool MultiType::setValue(const std::string& value)           { if (this->value_) { return this->value_->setValue(value); } else { return this->assignValue(value); } } /** @brief Assigns the given value and converts it to the current type. */
+    inline bool MultiType::setValue(const orxonox::Vector2& value)      { if (this->value_) { return this->value_->setValue(value); } else { return this->assignValue(value); } } /** @brief Assigns the given value and converts it to the current type. */
+    inline bool MultiType::setValue(const orxonox::Vector3& value)      { if (this->value_) { return this->value_->setValue(value); } else { return this->assignValue(value); } } /** @brief Assigns the given value and converts it to the current type. */
+    inline bool MultiType::setValue(const orxonox::Vector4& value)      { if (this->value_) { return this->value_->setValue(value); } else { return this->assignValue(value); } } /** @brief Assigns the given value and converts it to the current type. */
+    inline bool MultiType::setValue(const orxonox::ColourValue& value)  { if (this->value_) { return this->value_->setValue(value); } else { return this->assignValue(value); } } /** @brief Assigns the given value and converts it to the current type. */
+    inline bool MultiType::setValue(const orxonox::Quaternion& value)   { if (this->value_) { return this->value_->setValue(value); } else { return this->assignValue(value); } } /** @brief Assigns the given value and converts it to the current type. */
+    inline bool MultiType::setValue(const orxonox::Radian& value)       { if (this->value_) { return this->value_->setValue(value); } else { return this->assignValue(value); } } /** @brief Assigns the given value and converts it to the current type. */
+    inline bool MultiType::setValue(const orxonox::Degree& value)       { if (this->value_) { return this->value_->setValue(value); } else { return this->assignValue(value); } } /** @brief Assigns the given value and converts it to the current type. */
+
+    inline bool MultiType::setValue(const char* value)                  { if (this->value_) { return this->value_->setValue(std::string(value)); } else { return this->assignValue(std::string(value)); } }  /** @brief Assigns the given value and converts it to the current type. */
+}
 
 #endif /* _MultiType_H__ */

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

@@ -41 +41 @@
 #include "MultiType.h"
 
-/**
-    @brief The MT_Value<T> class is used to hold a value of type T within a MultiType.
-*/
-template <typename T>
-struct MT_Value : public MultiType::MT_ValueBase
+namespace orxonox
 {
-    /** @brief Constructor: Assigns the value and the type identifier. */
-    MT_Value(const T& value, MT_Type type) : MT_ValueBase(type), value_(value) {}
+    /**
+        @brief The MT_Value<T> class is used to hold a value of type T within a MultiType.
+    */
+    template <typename T>
+    class MT_Value : public MultiType::MT_ValueBase
+    {
+    public:
+        /** @brief Constructor: Assigns the value and the type identifier. */
+        MT_Value(const T& value, MT_Type type) : MT_ValueBase(type), value_(value) {}
 
-    /** @brief Creates a copy of itself. */
-    inline MT_ValueBase* clone() const { return new MT_Value<T>(this->value_, this->type_); }
+        /** @brief Creates a copy of itself. */
+        inline MT_ValueBase* clone() const { return new MT_Value<T>(this->value_, this->type_); }
 
-    /** @brief Resets the current value to the default. */
-    inline void reset() { this->value_ = zeroise<T>(); bHasDefaultValue_ = true; }
+        /** @brief Resets the current value to the default. */
+        inline void reset() { this->value_ = zeroise<T>(); bHasDefaultValue_ = true; }
 
-    /** @brief Assigns the value of the other MultiType, converted to T. @param other The other MultiType */
-    inline bool assimilate(const MultiType& other)
-    {
-        if (other.value_)
+        /** @brief Assigns the value of the other MultiType, converted to T. @param other The other MultiType */
+        inline bool assimilate(const MultiType& other)
         {
-            return !(bHasDefaultValue_ = !other.value_->getValue(&value_));
+            if (other.value_)
+            {
+                return !(bHasDefaultValue_ = !other.value_->getValue(&value_));
+            }
+            else
+            {
+                this->value_ = zeroise<T>();
+                return !(bHasDefaultValue_ = true);
+            }
         }
-        else
-        {
-            this->value_ = zeroise<T>();
-            return !(bHasDefaultValue_ = true);
-        }
-    }
 
-    inline bool getValue(char*                 value) const { return ConvertValue<T, char                >(value, value_, 0); } /** @brief Assigns the value to the given pointer. The value gets converted if the types don't match. */
-    inline bool getValue(unsigned char*        value) const { return ConvertValue<T, unsigned char       >(value, value_, 0); } /** @brief Assigns the value to the given pointer. The value gets converted if the types don't match. */
-    inline bool getValue(short*                value) const { return ConvertValue<T, short               >(value, value_, 0); } /** @brief Assigns the value to the given pointer. The value gets converted if the types don't match. */
-    inline bool getValue(unsigned short*       value) const { return ConvertValue<T, unsigned short      >(value, value_, 0); } /** @brief Assigns the value to the given pointer. The value gets converted if the types don't match. */
-    inline bool getValue(int*                  value) const { return ConvertValue<T, int                 >(value, value_, 0); } /** @brief Assigns the value to the given pointer. The value gets converted if the types don't match. */
-    inline bool getValue(unsigned int*         value) const { return ConvertValue<T, unsigned int        >(value, value_, 0); } /** @brief Assigns the value to the given pointer. The value gets converted if the types don't match. */
-    inline bool getValue(long*                 value) const { return ConvertValue<T, long                >(value, value_, 0); } /** @brief Assigns the value to the given pointer. The value gets converted if the types don't match. */
-    inline bool getValue(unsigned long*        value) const { return ConvertValue<T, unsigned long       >(value, value_, 0); } /** @brief Assigns the value to the given pointer. The value gets converted if the types don't match. */
-    inline bool getValue(long long*            value) const { return ConvertValue<T, long long           >(value, value_, 0); } /** @brief Assigns the value to the given pointer. The value gets converted if the types don't match. */
-    inline bool getValue(unsigned long long*   value) const { return ConvertValue<T, unsigned long long  >(value, value_, 0); } /** @brief Assigns the value to the given pointer. The value gets converted if the types don't match. */
-    inline bool getValue(float*                value) const { return ConvertValue<T, float               >(value, value_, 0); } /** @brief Assigns the value to the given pointer. The value gets converted if the types don't match. */
-    inline bool getValue(double*               value) const { return ConvertValue<T, double              >(value, value_, 0); } /** @brief Assigns the value to the given pointer. The value gets converted if the types don't match. */
-    inline bool getValue(long double*          value) const { return ConvertValue<T, long double         >(value, value_, 0); } /** @brief Assigns the value to the given pointer. The value gets converted if the types don't match. */
-    inline bool getValue(bool*                 value) const { return ConvertValue<T, bool                >(value, value_, 0); } /** @brief Assigns the value to the given pointer. The value gets converted if the types don't match. */
-    inline bool getValue(void**                value) const { return ConvertValue<T, void*               >(value, value_, 0); } /** @brief Assigns the value to the given pointer. The value gets converted if the types don't match. */
-    inline bool getValue(std::string*          value) const { return ConvertValue<T, std::string         >(value, value_, zeroise<std::string>         ()); } /** @brief Assigns the value to the given pointer. The value gets converted if the types don't match. */
-    inline bool getValue(orxonox::Vector2*     value) const { return ConvertValue<T, orxonox::Vector2    >(value, value_, zeroise<orxonox::Vector2>    ()); } /** @brief Assigns the value to the given pointer. The value gets converted if the types don't match. */
-    inline bool getValue(orxonox::Vector3*     value) const { return ConvertValue<T, orxonox::Vector3    >(value, value_, zeroise<orxonox::Vector3>    ()); } /** @brief Assigns the value to the given pointer. The value gets converted if the types don't match. */
-    inline bool getValue(orxonox::Vector4*     value) const { return ConvertValue<T, orxonox::Vector4    >(value, value_, zeroise<orxonox::Vector4>    ()); } /** @brief Assigns the value to the given pointer. The value gets converted if the types don't match. */
-    inline bool getValue(orxonox::ColourValue* value) const { return ConvertValue<T, orxonox::ColourValue>(value, value_, zeroise<orxonox::ColourValue>()); } /** @brief Assigns the value to the given pointer. The value gets converted if the types don't match. */
-    inline bool getValue(orxonox::Quaternion*  value) const { return ConvertValue<T, orxonox::Quaternion >(value, value_, zeroise<orxonox::Quaternion> ()); } /** @brief Assigns the value to the given pointer. The value gets converted if the types don't match. */
-    inline bool getValue(orxonox::Radian*      value) const { return ConvertValue<T, orxonox::Radian     >(value, value_, zeroise<orxonox::Radian>     ()); } /** @brief Assigns the value to the given pointer. The value gets converted if the types don't match. */
-    inline bool getValue(orxonox::Degree*      value) const { return ConvertValue<T, orxonox::Degree     >(value, value_, zeroise<orxonox::Degree>     ()); } /** @brief Assigns the value to the given pointer. The value gets converted if the types don't match. */
+        inline bool getValue(char*                 value) const { return ConvertValue<T, char                >(value, value_, 0); } /** @brief Assigns the value to the given pointer. The value gets converted if the types don't match. */
+        inline bool getValue(unsigned char*        value) const { return ConvertValue<T, unsigned char       >(value, value_, 0); } /** @brief Assigns the value to the given pointer. The value gets converted if the types don't match. */
+        inline bool getValue(short*                value) const { return ConvertValue<T, short               >(value, value_, 0); } /** @brief Assigns the value to the given pointer. The value gets converted if the types don't match. */
+        inline bool getValue(unsigned short*       value) const { return ConvertValue<T, unsigned short      >(value, value_, 0); } /** @brief Assigns the value to the given pointer. The value gets converted if the types don't match. */
+        inline bool getValue(int*                  value) const { return ConvertValue<T, int                 >(value, value_, 0); } /** @brief Assigns the value to the given pointer. The value gets converted if the types don't match. */
+        inline bool getValue(unsigned int*         value) const { return ConvertValue<T, unsigned int        >(value, value_, 0); } /** @brief Assigns the value to the given pointer. The value gets converted if the types don't match. */
+        inline bool getValue(long*                 value) const { return ConvertValue<T, long                >(value, value_, 0); } /** @brief Assigns the value to the given pointer. The value gets converted if the types don't match. */
+        inline bool getValue(unsigned long*        value) const { return ConvertValue<T, unsigned long       >(value, value_, 0); } /** @brief Assigns the value to the given pointer. The value gets converted if the types don't match. */
+        inline bool getValue(long long*            value) const { return ConvertValue<T, long long           >(value, value_, 0); } /** @brief Assigns the value to the given pointer. The value gets converted if the types don't match. */
+        inline bool getValue(unsigned long long*   value) const { return ConvertValue<T, unsigned long long  >(value, value_, 0); } /** @brief Assigns the value to the given pointer. The value gets converted if the types don't match. */
+        inline bool getValue(float*                value) const { return ConvertValue<T, float               >(value, value_, 0); } /** @brief Assigns the value to the given pointer. The value gets converted if the types don't match. */
+        inline bool getValue(double*               value) const { return ConvertValue<T, double              >(value, value_, 0); } /** @brief Assigns the value to the given pointer. The value gets converted if the types don't match. */
+        inline bool getValue(long double*          value) const { return ConvertValue<T, long double         >(value, value_, 0); } /** @brief Assigns the value to the given pointer. The value gets converted if the types don't match. */
+        inline bool getValue(bool*                 value) const { return ConvertValue<T, bool                >(value, value_, 0); } /** @brief Assigns the value to the given pointer. The value gets converted if the types don't match. */
+        inline bool getValue(void**                value) const { return ConvertValue<T, void*               >(value, value_, 0); } /** @brief Assigns the value to the given pointer. The value gets converted if the types don't match. */
+        inline bool getValue(std::string*          value) const { return ConvertValue<T, std::string         >(value, value_, zeroise<std::string>         ()); } /** @brief Assigns the value to the given pointer. The value gets converted if the types don't match. */
+        inline bool getValue(orxonox::Vector2*     value) const { return ConvertValue<T, orxonox::Vector2    >(value, value_, zeroise<orxonox::Vector2>    ()); } /** @brief Assigns the value to the given pointer. The value gets converted if the types don't match. */
+        inline bool getValue(orxonox::Vector3*     value) const { return ConvertValue<T, orxonox::Vector3    >(value, value_, zeroise<orxonox::Vector3>    ()); } /** @brief Assigns the value to the given pointer. The value gets converted if the types don't match. */
+        inline bool getValue(orxonox::Vector4*     value) const { return ConvertValue<T, orxonox::Vector4    >(value, value_, zeroise<orxonox::Vector4>    ()); } /** @brief Assigns the value to the given pointer. The value gets converted if the types don't match. */
+        inline bool getValue(orxonox::ColourValue* value) const { return ConvertValue<T, orxonox::ColourValue>(value, value_, zeroise<orxonox::ColourValue>()); } /** @brief Assigns the value to the given pointer. The value gets converted if the types don't match. */
+        inline bool getValue(orxonox::Quaternion*  value) const { return ConvertValue<T, orxonox::Quaternion >(value, value_, zeroise<orxonox::Quaternion> ()); } /** @brief Assigns the value to the given pointer. The value gets converted if the types don't match. */
+        inline bool getValue(orxonox::Radian*      value) const { return ConvertValue<T, orxonox::Radian     >(value, value_, zeroise<orxonox::Radian>     ()); } /** @brief Assigns the value to the given pointer. The value gets converted if the types don't match. */
+        inline bool getValue(orxonox::Degree*      value) const { return ConvertValue<T, orxonox::Degree     >(value, value_, zeroise<orxonox::Degree>     ()); } /** @brief Assigns the value to the given pointer. The value gets converted if the types don't match. */
 
-    inline bool setValue(const char& value)                 { return !(bHasDefaultValue_ = !ConvertValue<char                , T>(&value_, value, zeroise<T>())); } /** @brief Assigns the value by converting it to T. */
-    inline bool setValue(const unsigned char& value)        { return !(bHasDefaultValue_ = !ConvertValue<unsigned char       , T>(&value_, value, zeroise<T>())); } /** @brief Assigns the value by converting it to T. */
-    inline bool setValue(const short& value)                { return !(bHasDefaultValue_ = !ConvertValue<short               , T>(&value_, value, zeroise<T>())); } /** @brief Assigns the value by converting it to T. */
-    inline bool setValue(const unsigned short& value)       { return !(bHasDefaultValue_ = !ConvertValue<unsigned short      , T>(&value_, value, zeroise<T>())); } /** @brief Assigns the value by converting it to T. */
-    inline bool setValue(const int& value)                  { return !(bHasDefaultValue_ = !ConvertValue<int                 , T>(&value_, value, zeroise<T>())); } /** @brief Assigns the value by converting it to T. */
-    inline bool setValue(const unsigned int& value)         { return !(bHasDefaultValue_ = !ConvertValue<unsigned int        , T>(&value_, value, zeroise<T>())); } /** @brief Assigns the value by converting it to T. */
-    inline bool setValue(const long& value)                 { return !(bHasDefaultValue_ = !ConvertValue<long                , T>(&value_, value, zeroise<T>())); } /** @brief Assigns the value by converting it to T. */
-    inline bool setValue(const unsigned long& value)        { return !(bHasDefaultValue_ = !ConvertValue<unsigned long       , T>(&value_, value, zeroise<T>())); } /** @brief Assigns the value by converting it to T. */
-    inline bool setValue(const long long& value)            { return !(bHasDefaultValue_ = !ConvertValue<long long           , T>(&value_, value, zeroise<T>())); } /** @brief Assigns the value by converting it to T. */
-    inline bool setValue(const unsigned long long& value)   { return !(bHasDefaultValue_ = !ConvertValue<unsigned long long  , T>(&value_, value, zeroise<T>())); } /** @brief Assigns the value by converting it to T. */
-    inline bool setValue(const float& value)                { return !(bHasDefaultValue_ = !ConvertValue<float               , T>(&value_, value, zeroise<T>())); } /** @brief Assigns the value by converting it to T. */
-    inline bool setValue(const double& value)               { return !(bHasDefaultValue_ = !ConvertValue<double              , T>(&value_, value, zeroise<T>())); } /** @brief Assigns the value by converting it to T. */
-    inline bool setValue(const long double& value)          { return !(bHasDefaultValue_ = !ConvertValue<long double         , T>(&value_, value, zeroise<T>())); } /** @brief Assigns the value by converting it to T. */
-    inline bool setValue(const bool& value)                 { return !(bHasDefaultValue_ = !ConvertValue<bool                , T>(&value_, value, zeroise<T>())); } /** @brief Assigns the value by converting it to T. */
-    inline bool setValue(      void* const& value)          { return !(bHasDefaultValue_ = !ConvertValue<void*               , T>(&value_, value, zeroise<T>())); } /** @brief Assigns the value by converting it to T. */
-    inline bool setValue(const std::string& value)          { return !(bHasDefaultValue_ = !ConvertValue<std::string         , T>(&value_, value, zeroise<T>())); } /** @brief Assigns the value by converting it to T. */
-    inline bool setValue(const orxonox::Vector2& value)     { return !(bHasDefaultValue_ = !ConvertValue<orxonox::Vector2    , T>(&value_, value, zeroise<T>())); } /** @brief Assigns the value by converting it to T. */
-    inline bool setValue(const orxonox::Vector3& value)     { return !(bHasDefaultValue_ = !ConvertValue<orxonox::Vector3    , T>(&value_, value, zeroise<T>())); } /** @brief Assigns the value by converting it to T. */
-    inline bool setValue(const orxonox::Vector4& value)     { return !(bHasDefaultValue_ = !ConvertValue<orxonox::Vector4    , T>(&value_, value, zeroise<T>())); } /** @brief Assigns the value by converting it to T. */
-    inline bool setValue(const orxonox::ColourValue& value) { return !(bHasDefaultValue_ = !ConvertValue<orxonox::ColourValue, T>(&value_, value, zeroise<T>())); } /** @brief Assigns the value by converting it to T. */
-    inline bool setValue(const orxonox::Quaternion& value)  { return !(bHasDefaultValue_ = !ConvertValue<orxonox::Quaternion , T>(&value_, value, zeroise<T>())); } /** @brief Assigns the value by converting it to T. */
-    inline bool setValue(const orxonox::Radian& value)      { return !(bHasDefaultValue_ = !ConvertValue<orxonox::Radian     , T>(&value_, value, zeroise<T>())); } /** @brief Assigns the value by converting it to T. */
-    inline bool setValue(const orxonox::Degree& value)      { return !(bHasDefaultValue_ = !ConvertValue<orxonox::Degree     , T>(&value_, value, zeroise<T>())); } /** @brief Assigns the value by converting it to T. */
+        inline bool setValue(const char& value)                 { return !(bHasDefaultValue_ = !ConvertValue<char                , T>(&value_, value, zeroise<T>())); } /** @brief Assigns the value by converting it to T. */
+        inline bool setValue(const unsigned char& value)        { return !(bHasDefaultValue_ = !ConvertValue<unsigned char       , T>(&value_, value, zeroise<T>())); } /** @brief Assigns the value by converting it to T. */
+        inline bool setValue(const short& value)                { return !(bHasDefaultValue_ = !ConvertValue<short               , T>(&value_, value, zeroise<T>())); } /** @brief Assigns the value by converting it to T. */
+        inline bool setValue(const unsigned short& value)       { return !(bHasDefaultValue_ = !ConvertValue<unsigned short      , T>(&value_, value, zeroise<T>())); } /** @brief Assigns the value by converting it to T. */
+        inline bool setValue(const int& value)                  { return !(bHasDefaultValue_ = !ConvertValue<int                 , T>(&value_, value, zeroise<T>())); } /** @brief Assigns the value by converting it to T. */
+        inline bool setValue(const unsigned int& value)         { return !(bHasDefaultValue_ = !ConvertValue<unsigned int        , T>(&value_, value, zeroise<T>())); } /** @brief Assigns the value by converting it to T. */
+        inline bool setValue(const long& value)                 { return !(bHasDefaultValue_ = !ConvertValue<long                , T>(&value_, value, zeroise<T>())); } /** @brief Assigns the value by converting it to T. */
+        inline bool setValue(const unsigned long& value)        { return !(bHasDefaultValue_ = !ConvertValue<unsigned long       , T>(&value_, value, zeroise<T>())); } /** @brief Assigns the value by converting it to T. */
+        inline bool setValue(const long long& value)            { return !(bHasDefaultValue_ = !ConvertValue<long long           , T>(&value_, value, zeroise<T>())); } /** @brief Assigns the value by converting it to T. */
+        inline bool setValue(const unsigned long long& value)   { return !(bHasDefaultValue_ = !ConvertValue<unsigned long long  , T>(&value_, value, zeroise<T>())); } /** @brief Assigns the value by converting it to T. */
+        inline bool setValue(const float& value)                { return !(bHasDefaultValue_ = !ConvertValue<float               , T>(&value_, value, zeroise<T>())); } /** @brief Assigns the value by converting it to T. */
+        inline bool setValue(const double& value)               { return !(bHasDefaultValue_ = !ConvertValue<double              , T>(&value_, value, zeroise<T>())); } /** @brief Assigns the value by converting it to T. */
+        inline bool setValue(const long double& value)          { return !(bHasDefaultValue_ = !ConvertValue<long double         , T>(&value_, value, zeroise<T>())); } /** @brief Assigns the value by converting it to T. */
+        inline bool setValue(const bool& value)                 { return !(bHasDefaultValue_ = !ConvertValue<bool                , T>(&value_, value, zeroise<T>())); } /** @brief Assigns the value by converting it to T. */
+        inline bool setValue(      void* const& value)          { return !(bHasDefaultValue_ = !ConvertValue<void*               , T>(&value_, value, zeroise<T>())); } /** @brief Assigns the value by converting it to T. */
+        inline bool setValue(const std::string& value)          { return !(bHasDefaultValue_ = !ConvertValue<std::string         , T>(&value_, value, zeroise<T>())); } /** @brief Assigns the value by converting it to T. */
+        inline bool setValue(const orxonox::Vector2& value)     { return !(bHasDefaultValue_ = !ConvertValue<orxonox::Vector2    , T>(&value_, value, zeroise<T>())); } /** @brief Assigns the value by converting it to T. */
+        inline bool setValue(const orxonox::Vector3& value)     { return !(bHasDefaultValue_ = !ConvertValue<orxonox::Vector3    , T>(&value_, value, zeroise<T>())); } /** @brief Assigns the value by converting it to T. */
+        inline bool setValue(const orxonox::Vector4& value)     { return !(bHasDefaultValue_ = !ConvertValue<orxonox::Vector4    , T>(&value_, value, zeroise<T>())); } /** @brief Assigns the value by converting it to T. */
+        inline bool setValue(const orxonox::ColourValue& value) { return !(bHasDefaultValue_ = !ConvertValue<orxonox::ColourValue, T>(&value_, value, zeroise<T>())); } /** @brief Assigns the value by converting it to T. */
+        inline bool setValue(const orxonox::Quaternion& value)  { return !(bHasDefaultValue_ = !ConvertValue<orxonox::Quaternion , T>(&value_, value, zeroise<T>())); } /** @brief Assigns the value by converting it to T. */
+        inline bool setValue(const orxonox::Radian& value)      { return !(bHasDefaultValue_ = !ConvertValue<orxonox::Radian     , T>(&value_, value, zeroise<T>())); } /** @brief Assigns the value by converting it to T. */
+        inline bool setValue(const orxonox::Degree& value)      { return !(bHasDefaultValue_ = !ConvertValue<orxonox::Degree     , T>(&value_, value, zeroise<T>())); } /** @brief Assigns the value by converting it to T. */
 
-    inline operator char()                 const { return getConvertedValue<T, char>                (this->value_, 0); }     /** @brief Returns the current value, converted to the requested type. */
-    inline operator unsigned char()        const { return getConvertedValue<T, unsigned char>       (this->value_, 0); }     /** @brief Returns the current value, converted to the requested type. */
-    inline operator short()                const { return getConvertedValue<T, short>               (this->value_, 0); }     /** @brief Returns the current value, converted to the requested type. */
-    inline operator unsigned short()       const { return getConvertedValue<T, unsigned short>      (this->value_, 0); }     /** @brief Returns the current value, converted to the requested type. */
-    inline operator int()                  const { return getConvertedValue<T, int>                 (this->value_, 0); }     /** @brief Returns the current value, converted to the requested type. */
-    inline operator unsigned int()         const { return getConvertedValue<T, unsigned int>        (this->value_, 0); }     /** @brief Returns the current value, converted to the requested type. */
-    inline operator long()                 const { return getConvertedValue<T, long>                (this->value_, 0); }     /** @brief Returns the current value, converted to the requested type. */
-    inline operator unsigned long()        const { return getConvertedValue<T, unsigned long>       (this->value_, 0); }     /** @brief Returns the current value, converted to the requested type. */
-    inline operator long long()            const { return getConvertedValue<T, long long>           (this->value_, 0); }     /** @brief Returns the current value, converted to the requested type. */
-    inline operator unsigned long long()   const { return getConvertedValue<T, unsigned long long>  (this->value_, 0); }     /** @brief Returns the current value, converted to the requested type. */
-    inline operator float()                const { return getConvertedValue<T, float>               (this->value_, 0); }     /** @brief Returns the current value, converted to the requested type. */
-    inline operator double()               const { return getConvertedValue<T, double>              (this->value_, 0); }     /** @brief Returns the current value, converted to the requested type. */
-    inline operator long double()          const { return getConvertedValue<T, long double>         (this->value_, 0); }     /** @brief Returns the current value, converted to the requested type. */
-    inline operator bool()                 const { return getConvertedValue<T, bool>                (this->value_, 0); }     /** @brief Returns the current value, converted to the requested type. */
-    inline operator void*()                const { return getConvertedValue<T, void*>               (this->value_, 0); }     /** @brief Returns the current value, converted to the requested type. */
-    inline operator std::string()          const { return getConvertedValue<T, std::string>         (this->value_, zeroise<std::string         >()); } /** @brief Returns the current value, converted to the requested type. */
-    inline operator orxonox::Vector2()     const { return getConvertedValue<T, orxonox::Vector2>    (this->value_, zeroise<orxonox::Vector2    >()); } /** @brief Returns the current value, converted to the requested type. */
-    inline operator orxonox::Vector3()     const { return getConvertedValue<T, orxonox::Vector3>    (this->value_, zeroise<orxonox::Vector3    >()); } /** @brief Returns the current value, converted to the requested type. */
-    inline operator orxonox::Vector4()     const { return getConvertedValue<T, orxonox::Vector4>    (this->value_, zeroise<orxonox::Vector4    >()); } /** @brief Returns the current value, converted to the requested type. */
-    inline operator orxonox::ColourValue() const { return getConvertedValue<T, orxonox::ColourValue>(this->value_, zeroise<orxonox::ColourValue>()); } /** @brief Returns the current value, converted to the requested type. */
-    inline operator orxonox::Quaternion()  const { return getConvertedValue<T, orxonox::Quaternion> (this->value_, zeroise<orxonox::Quaternion >()); } /** @brief Returns the current value, converted to the requested type. */
-    inline operator orxonox::Radian()      const { return getConvertedValue<T, orxonox::Radian>     (this->value_, zeroise<orxonox::Radian     >()); } /** @brief Returns the current value, converted to the requested type. */
-    inline operator orxonox::Degree()      const { return getConvertedValue<T, orxonox::Degree>     (this->value_, zeroise<orxonox::Degree     >()); } /** @brief Returns the current value, converted to the requested type. */
+        inline operator char()                 const { return getConvertedValue<T, char>                (this->value_, 0); }     /** @brief Returns the current value, converted to the requested type. */
+        inline operator unsigned char()        const { return getConvertedValue<T, unsigned char>       (this->value_, 0); }     /** @brief Returns the current value, converted to the requested type. */
+        inline operator short()                const { return getConvertedValue<T, short>               (this->value_, 0); }     /** @brief Returns the current value, converted to the requested type. */
+        inline operator unsigned short()       const { return getConvertedValue<T, unsigned short>      (this->value_, 0); }     /** @brief Returns the current value, converted to the requested type. */
+        inline operator int()                  const { return getConvertedValue<T, int>                 (this->value_, 0); }     /** @brief Returns the current value, converted to the requested type. */
+        inline operator unsigned int()         const { return getConvertedValue<T, unsigned int>        (this->value_, 0); }     /** @brief Returns the current value, converted to the requested type. */
+        inline operator long()                 const { return getConvertedValue<T, long>                (this->value_, 0); }     /** @brief Returns the current value, converted to the requested type. */
+        inline operator unsigned long()        const { return getConvertedValue<T, unsigned long>       (this->value_, 0); }     /** @brief Returns the current value, converted to the requested type. */
+        inline operator long long()            const { return getConvertedValue<T, long long>           (this->value_, 0); }     /** @brief Returns the current value, converted to the requested type. */
+        inline operator unsigned long long()   const { return getConvertedValue<T, unsigned long long>  (this->value_, 0); }     /** @brief Returns the current value, converted to the requested type. */
+        inline operator float()                const { return getConvertedValue<T, float>               (this->value_, 0); }     /** @brief Returns the current value, converted to the requested type. */
+        inline operator double()               const { return getConvertedValue<T, double>              (this->value_, 0); }     /** @brief Returns the current value, converted to the requested type. */
+        inline operator long double()          const { return getConvertedValue<T, long double>         (this->value_, 0); }     /** @brief Returns the current value, converted to the requested type. */
+        inline operator bool()                 const { return getConvertedValue<T, bool>                (this->value_, 0); }     /** @brief Returns the current value, converted to the requested type. */
+        inline operator void*()                const { return getConvertedValue<T, void*>               (this->value_, 0); }     /** @brief Returns the current value, converted to the requested type. */
+        inline operator std::string()          const { return getConvertedValue<T, std::string>         (this->value_, zeroise<std::string         >()); } /** @brief Returns the current value, converted to the requested type. */
+        inline operator orxonox::Vector2()     const { return getConvertedValue<T, orxonox::Vector2>    (this->value_, zeroise<orxonox::Vector2    >()); } /** @brief Returns the current value, converted to the requested type. */
+        inline operator orxonox::Vector3()     const { return getConvertedValue<T, orxonox::Vector3>    (this->value_, zeroise<orxonox::Vector3    >()); } /** @brief Returns the current value, converted to the requested type. */
+        inline operator orxonox::Vector4()     const { return getConvertedValue<T, orxonox::Vector4>    (this->value_, zeroise<orxonox::Vector4    >()); } /** @brief Returns the current value, converted to the requested type. */
+        inline operator orxonox::ColourValue() const { return getConvertedValue<T, orxonox::ColourValue>(this->value_, zeroise<orxonox::ColourValue>()); } /** @brief Returns the current value, converted to the requested type. */
+        inline operator orxonox::Quaternion()  const { return getConvertedValue<T, orxonox::Quaternion> (this->value_, zeroise<orxonox::Quaternion >()); } /** @brief Returns the current value, converted to the requested type. */
+        inline operator orxonox::Radian()      const { return getConvertedValue<T, orxonox::Radian>     (this->value_, zeroise<orxonox::Radian     >()); } /** @brief Returns the current value, converted to the requested type. */
+        inline operator orxonox::Degree()      const { return getConvertedValue<T, orxonox::Degree>     (this->value_, zeroise<orxonox::Degree     >()); } /** @brief Returns the current value, converted to the requested type. */
 
-    /** @brief Puts the current value on the stream */
-    inline void toString(std::ostream& outstream) const { outstream << this->value_; }
+        /** @brief Puts the current value on the stream */
+        inline void toString(std::ostream& outstream) const { outstream << this->value_; }
 
-    T value_; //!< The stored value
-};
+        T value_; //!< The stored value
+    };
+}
 
 #endif /* _MultiTypeValue_H__ */

code/branches/objecthierarchy/src/util/OutputBuffer.h

@@ -58 +58 @@
         an OutputBuffer and this buffer changes.
     */
-    class _UtilExport OutputBufferListener
+    class OutputBufferListener
     {
         friend class OutputBuffer;

code/branches/objecthierarchy/src/util/SignalHandler.cc

@@ -40 +40 @@
 #include <cstring>
 
-SignalHandler * SignalHandler::singletonRef = NULL;
+namespace orxonox
+{
+    SignalHandler * SignalHandler::singletonRef = NULL;
+}
 
 #if ORXONOX_PLATFORM != ORXONOX_PLATFORM_WIN32
@@ -49 +52 @@
 #include <X11/keysym.h>
 
-bool SignalHandler::bXAutoKeyRepeatOn_ = false;
-
-SignalHandler::SignalHandler()
+namespace orxonox
 {
+    bool SignalHandler::bXAutoKeyRepeatOn_ = false;
+
+    SignalHandler::SignalHandler()
+    {
+    }
+
+    /**
+     * register signal handlers for SIGSEGV and SIGABRT
+     * @param appName path to executable eg argv[0]
+     * @param filename filename to append backtrace to
+     */
+    void SignalHandler::doCatch( const std::string & appName, const std::string & filename )
+    {
+      this->appName = appName;
+      this->filename = filename;
+
+      // prepare for restoring XAutoKeyRepeat
+      Display* display;
+      if ((display = XOpenDisplay(0)))
+      {
+        XKeyboardState oldState;
+        XGetKeyboardControl(display, &oldState);
+        if (oldState.global_auto_repeat == AutoRepeatModeOn)
+          bXAutoKeyRepeatOn_ = true;
+        else
+          bXAutoKeyRepeatOn_ = false;
+        XCloseDisplay(display);
+      }
+      else
+      {
+        std::cout << "Warning: couldn't open X display to restore XAutoKeyRepeat." << std::endl;
+        bXAutoKeyRepeatOn_ = false;
+      }
+
+
+      // make sure doCatch is only called once without calling dontCatch
+      assert( sigRecList.size() == 0 );
+
+      catchSignal( SIGSEGV );
+      catchSignal( SIGABRT );
+      catchSignal( SIGILL );
+    }
+
+    /**
+     * restore previous signal handlers
+     */
+    void SignalHandler::dontCatch()
+    {
+      for ( SignalRecList::iterator it = sigRecList.begin(); it != sigRecList.end(); it++ )
+      {
+        signal( it->signal, it->handler );
+      }
+
+      sigRecList.clear();
+    }
+
+    /**
+     * catch signal sig
+     * @param sig signal to catch
+     */
+    void SignalHandler::catchSignal( int sig )
+    {
+      sig_t handler = signal( sig, SignalHandler::sigHandler );
+
+      assert( handler != SIG_ERR );
+
+      SignalRec rec;
+      rec.signal = sig;
+      rec.handler = handler;
+
+      sigRecList.push_front( rec );
+    }
+
+    /**
+     * sigHandler is called when receiving signals
+     * @param sig
+     */
+    void SignalHandler::sigHandler( int sig )
+    {
+      for ( SignalCallbackList::iterator it = SignalHandler::getInstance()->callbackList.begin(); it != SignalHandler::getInstance()->callbackList.end(); it++  )
+      {
+        (*(it->cb))( it->someData );
+      }
+
+      std::string sigName = "UNKNOWN";
+
+      switch ( sig )
+      {
+        case SIGSEGV:
+          sigName = "SIGSEGV";
+          break;
+        case SIGABRT:
+          sigName = "SIGABRT";
+          break;
+        case SIGILL:
+          sigName = "SIGILL";
+          break;
+      }
+
+      if (bXAutoKeyRepeatOn_)
+      {
+        std::cout << "Trying to restore XAutoKeyRepeat" << std::endl;
+        Display* display;
+        if ((display = XOpenDisplay(0)))
+        {
+          XAutoRepeatOn(display);
+          XCloseDisplay(display);
+        }
+      }
+
+      COUT(0) << "recieved signal " << sigName.c_str() << std::endl << "try to write backtrace to file orxonox.log" << std::endl;
+
+      int sigPipe[2];
+      if ( pipe(sigPipe) == -1 )
+      {
+        perror("pipe failed!\n");
+        exit(EXIT_FAILURE);
+      }
+
+      int sigPid = fork();
+
+      if ( sigPid == -1 )
+      {
+        perror("fork failed!\n");
+        exit(EXIT_FAILURE);
+      }
+
+      // gdb will be attached to this process
+      if ( sigPid == 0 )
+      {
+        getInstance()->dontCatch();
+        // wait for message from parent when it has attached gdb
+        int someData;
+
+        read( sigPipe[0], &someData, sizeof(someData) );
+
+        if ( someData != 0x12345678 )
+        {
+          COUT(0) << "something went wrong :(" << std::endl;
+        }
+
+        return;
+      }
+
+      int gdbIn[2];
+      int gdbOut[2];
+      int gdbErr[2];
+
+      if ( pipe(gdbIn) == -1 || pipe(gdbOut) == -1 || pipe(gdbErr) == -1 )
+      {
+        perror("pipe failed!\n");
+        kill( sigPid, SIGTERM );
+        waitpid( sigPid, NULL, 0 );
+        exit(EXIT_FAILURE);
+      }
+
+      int gdbPid = fork();
+      // this process will run gdb
+
+      if ( gdbPid == -1 )
+      {
+        perror("fork failed\n");
+        kill( sigPid, SIGTERM );
+        waitpid( sigPid, NULL, 0 );
+        exit(EXIT_FAILURE);
+      }
+
+      if ( gdbPid == 0 )
+      {
+        // start gdb
+
+        close(gdbIn[1]);
+        close(gdbOut[0]);
+        close(gdbErr[0]);
+
+        dup2( gdbIn[0], STDIN_FILENO );
+        dup2( gdbOut[1], STDOUT_FILENO );
+        dup2( gdbErr[1], STDERR_FILENO );
+
+        execlp( "sh", "sh", "-c", "gdb", (void*)NULL);
+      }
+
+      char cmd[256];
+      snprintf( cmd, 256, "file %s\nattach %d\nc\n", getInstance()->appName.c_str(), sigPid );
+      write( gdbIn[1], cmd, strlen(cmd) );
+
+      int charsFound = 0;
+      int promptFound = 0;
+      char byte;
+      while ( read( gdbOut[0], &byte, 1 ) == 1 )
+      {
+        if (
+          charsFound == 0 && byte == '(' ||
+          charsFound == 1 && byte == 'g' ||
+          charsFound == 2 && byte == 'd' ||
+          charsFound == 3 && byte == 'b' ||
+          charsFound == 4 && byte == ')' ||
+          charsFound == 5 && byte == ' '
+            )
+              charsFound++;
+        else
+          charsFound = 0;
+
+        if ( charsFound == 6 )
+        {
+          promptFound++;
+          charsFound = 0;
+        }
+
+        if ( promptFound == 3 )
+        {
+          break;
+        }
+      }
+
+      int someData = 0x12345678;
+      write( sigPipe[1], &someData, sizeof(someData) );
+
+      write( gdbIn[1], "bt\nk\nq\n", 7 );
+
+
+      charsFound = 0;
+      promptFound = 0;
+      std::string bt;
+      while ( read( gdbOut[0], &byte, 1 ) == 1 )
+      {
+        bt += std::string( &byte, 1 );
+
+        if (
+          charsFound == 0 && byte == '(' ||
+          charsFound == 1 && byte == 'g' ||
+          charsFound == 2 && byte == 'd' ||
+          charsFound == 3 && byte == 'b' ||
+          charsFound == 4 && byte == ')' ||
+          charsFound == 5 && byte == ' '
+            )
+              charsFound++;
+        else
+          charsFound = 0;
+
+        if ( charsFound == 6 )
+        {
+          promptFound++;
+          charsFound = 0;
+          bt += "\n";
+        }
+
+        if ( promptFound == 3 )
+        {
+          break;
+        }
+      }
+
+
+      waitpid( sigPid, NULL, 0 );
+      waitpid( gdbPid, NULL, 0 );
+
+      int wsRemoved = 0;
+
+      while ( wsRemoved < 2 && bt.length() > 0 )
+      {
+        if ( bt[1] == '\n' )
+          wsRemoved++;
+        bt.erase(0, 1);
+      }
+
+      if ( bt.length() > 0 )
+        bt.erase(0, 1);
+
+      time_t now = time(NULL);
+
+      std::string timeString = "\n\n\n\n"
+                         "=======================================================\n"
+                         "= time: " + std::string(ctime(&now)) +
+             "=======================================================\n";
+      bt.insert(0, timeString);
+
+      FILE * f = fopen( getInstance()->filename.c_str(), "a" );
+
+      if ( !f )
+      {
+        perror( ( std::string( "could not append to " ) + getInstance()->filename ).c_str() );
+        exit(EXIT_FAILURE);
+      }
+
+      if ( fwrite( bt.c_str(), 1, bt.length(), f ) != bt.length() )
+      {
+        COUT(0) << "could not write " << bt.length() << " byte to " << getInstance()->filename << std::endl;
+        exit(EXIT_FAILURE);
+      }
+
+      exit(EXIT_FAILURE);
+    }
+
+    void SignalHandler::registerCallback( SignalCallback cb, void * someData )
+    {
+      SignalCallbackRec rec;
+      rec.cb = cb;
+      rec.someData = someData;
+
+      callbackList.push_back(rec);
+    }
 }
 
-/**
- * register signal handlers for SIGSEGV and SIGABRT
- * @param appName path to executable eg argv[0]
- * @param filename filename to append backtrace to
- */
-void SignalHandler::doCatch( const std::string & appName, const std::string & filename )
-{
-  this->appName = appName;
-  this->filename = filename;
-
-  // prepare for restoring XAutoKeyRepeat
-  Display* display;
-  if ((display = XOpenDisplay(0)))
-  {
-    XKeyboardState oldState;
-    XGetKeyboardControl(display, &oldState);
-    if (oldState.global_auto_repeat == AutoRepeatModeOn)
-      bXAutoKeyRepeatOn_ = true;
-    else
-      bXAutoKeyRepeatOn_ = false;
-    XCloseDisplay(display);
-  }
-  else
-  {
-    std::cout << "Warning: couldn't open X display to restore XAutoKeyRepeat." << std::endl;
-    bXAutoKeyRepeatOn_ = false;
-  }
-
-
-  // make sure doCatch is only called once without calling dontCatch
-  assert( sigRecList.size() == 0 );
-
-  catchSignal( SIGSEGV );
-  catchSignal( SIGABRT );
-  catchSignal( SIGILL );
-}
-
-/**
- * restore previous signal handlers
- */
-void SignalHandler::dontCatch()
-{
-  for ( SignalRecList::iterator it = sigRecList.begin(); it != sigRecList.end(); it++ )
-  {
-    signal( it->signal, it->handler );
-  }
-
-  sigRecList.clear();
-}
-
-/**
- * catch signal sig
- * @param sig signal to catch
- */
-void SignalHandler::catchSignal( int sig )
-{
-  sig_t handler = signal( sig, SignalHandler::sigHandler );
-
-  assert( handler != SIG_ERR );
-
-  SignalRec rec;
-  rec.signal = sig;
-  rec.handler = handler;
-
-  sigRecList.push_front( rec );
-}
-
-/**
- * sigHandler is called when receiving signals
- * @param sig
- */
-void SignalHandler::sigHandler( int sig )
-{
-  for ( SignalCallbackList::iterator it = SignalHandler::getInstance()->callbackList.begin(); it != SignalHandler::getInstance()->callbackList.end(); it++  )
-  {
-    (*(it->cb))( it->someData );
-  }
-
-  std::string sigName = "UNKNOWN";
-
-  switch ( sig )
-  {
-    case SIGSEGV:
-      sigName = "SIGSEGV";
-      break;
-    case SIGABRT:
-      sigName = "SIGABRT";
-      break;
-    case SIGILL:
-      sigName = "SIGILL";
-      break;
-  }
-
-  if (bXAutoKeyRepeatOn_)
-  {
-    std::cout << "Trying to restore XAutoKeyRepeat" << std::endl;
-    Display* display;
-    if ((display = XOpenDisplay(0)))
-    {
-      XAutoRepeatOn(display);
-      XCloseDisplay(display);
-    }
-  }
-
-  COUT(0) << "recieved signal " << sigName.c_str() << std::endl << "try to write backtrace to file orxonox.log" << std::endl;
-
-  int sigPipe[2];
-  if ( pipe(sigPipe) == -1 )
-  {
-    perror("pipe failed!\n");
-    exit(EXIT_FAILURE);
-  }
-
-  int sigPid = fork();
-
-  if ( sigPid == -1 )
-  {
-    perror("fork failed!\n");
-    exit(EXIT_FAILURE);
-  }
-
-  // gdb will be attached to this process
-  if ( sigPid == 0 )
-  {
-    getInstance()->dontCatch();
-    // wait for message from parent when it has attached gdb
-    int someData;
-
-    read( sigPipe[0], &someData, sizeof(someData) );
-
-    if ( someData != 0x12345678 )
-    {
-      COUT(0) << "something went wrong :(" << std::endl;
-    }
-
-    return;
-  }
-
-  int gdbIn[2];
-  int gdbOut[2];
-  int gdbErr[2];
-
-  if ( pipe(gdbIn) == -1 || pipe(gdbOut) == -1 || pipe(gdbErr) == -1 )
-  {
-    perror("pipe failed!\n");
-    kill( sigPid, SIGTERM );
-    waitpid( sigPid, NULL, 0 );
-    exit(EXIT_FAILURE);
-  }
-
-  int gdbPid = fork();
-  // this process will run gdb
-
-  if ( gdbPid == -1 )
-  {
-    perror("fork failed\n");
-    kill( sigPid, SIGTERM );
-    waitpid( sigPid, NULL, 0 );
-    exit(EXIT_FAILURE);
-  }
-
-  if ( gdbPid == 0 )
-  {
-    // start gdb
-
-    close(gdbIn[1]);
-    close(gdbOut[0]);
-    close(gdbErr[0]);
-
-    dup2( gdbIn[0], STDIN_FILENO );
-    dup2( gdbOut[1], STDOUT_FILENO );
-    dup2( gdbErr[1], STDERR_FILENO );
-
-    execlp( "sh", "sh", "-c", "gdb", (void*)NULL);
-  }
-
-  char cmd[256];
-  snprintf( cmd, 256, "file %s\nattach %d\nc\n", getInstance()->appName.c_str(), sigPid );
-  write( gdbIn[1], cmd, strlen(cmd) );
-
-  int charsFound = 0;
-  int promptFound = 0;
-  char byte;
-  while ( read( gdbOut[0], &byte, 1 ) == 1 )
-  {
-    if (
-      charsFound == 0 && byte == '(' ||
-      charsFound == 1 && byte == 'g' ||
-      charsFound == 2 && byte == 'd' ||
-      charsFound == 3 && byte == 'b' ||
-      charsFound == 4 && byte == ')' ||
-      charsFound == 5 && byte == ' '
-        )
-          charsFound++;
-    else
-      charsFound = 0;
-
-    if ( charsFound == 6 )
-    {
-      promptFound++;
-      charsFound = 0;
-    }
-
-    if ( promptFound == 3 )
-    {
-      break;
-    }
-  }
-
-  int someData = 0x12345678;
-  write( sigPipe[1], &someData, sizeof(someData) );
-
-  write( gdbIn[1], "bt\nk\nq\n", 7 );
-
-
-  charsFound = 0;
-  promptFound = 0;
-  std::string bt;
-  while ( read( gdbOut[0], &byte, 1 ) == 1 )
-  {
-    bt += std::string( &byte, 1 );
-
-    if (
-      charsFound == 0 && byte == '(' ||
-      charsFound == 1 && byte == 'g' ||
-      charsFound == 2 && byte == 'd' ||
-      charsFound == 3 && byte == 'b' ||
-      charsFound == 4 && byte == ')' ||
-      charsFound == 5 && byte == ' '
-        )
-          charsFound++;
-    else
-      charsFound = 0;
-
-    if ( charsFound == 6 )
-    {
-      promptFound++;
-      charsFound = 0;
-      bt += "\n";
-    }
-
-    if ( promptFound == 3 )
-    {
-      break;
-    }
-  }
-
-
-  waitpid( sigPid, NULL, 0 );
-  waitpid( gdbPid, NULL, 0 );
-
-  int wsRemoved = 0;
-
-  while ( wsRemoved < 2 && bt.length() > 0 )
-  {
-    if ( bt[1] == '\n' )
-      wsRemoved++;
-    bt.erase(0, 1);
-  }
-
-  if ( bt.length() > 0 )
-    bt.erase(0, 1);
-
-  time_t now = time(NULL);
-
-  std::string timeString = "\n\n\n\n"
-                     "=======================================================\n"
-                     "= time: " + std::string(ctime(&now)) +
-         "=======================================================\n";
-  bt.insert(0, timeString);
-
-  FILE * f = fopen( getInstance()->filename.c_str(), "a" );
-
-  if ( !f )
-  {
-    perror( ( std::string( "could not append to " ) + getInstance()->filename ).c_str() );
-    exit(EXIT_FAILURE);
-  }
-
-  if ( fwrite( bt.c_str(), 1, bt.length(), f ) != bt.length() )
-  {
-    COUT(0) << "could not write " << bt.length() << " byte to " << getInstance()->filename << std::endl;
-    exit(EXIT_FAILURE);
-  }
-
-  exit(EXIT_FAILURE);
-}
-
-void SignalHandler::registerCallback( SignalCallback cb, void * someData )
-{
-  SignalCallbackRec rec;
-  rec.cb = cb;
-  rec.someData = someData;
-
-  callbackList.push_back(rec);
-}
-
 #endif /* ORXONOX_PLATFORM == ORXONOX_PLATFORM_WIN32 */

code/branches/objecthierarchy/src/util/SignalHandler.h

@@ -40 +40 @@
 #include <string>
 
-typedef int (*SignalCallback)( void * someData );
+namespace orxonox
+{
+    typedef int (*SignalCallback)( void * someData );
+}
 
 #if ORXONOX_PLATFORM != ORXONOX_PLATFORM_WIN32
 #include <signal.h>
 
-struct SignalRec
+namespace orxonox
 {
-  int signal;
-  sig_t handler;
-};
+    struct SignalRec
+    {
+        int signal;
+        sig_t handler;
+    };
 
-struct SignalCallbackRec
-{
-  SignalCallback cb;
-  void * someData;
-};
+    struct SignalCallbackRec
+    {
+        SignalCallback cb;
+        void * someData;
+    };
 
 
-typedef std::list<SignalRec> SignalRecList;
-typedef std::list<SignalCallbackRec> SignalCallbackList;
+    typedef std::list<SignalRec> SignalRecList;
+    typedef std::list<SignalCallbackRec> SignalCallbackList;
 
-class SignalHandler
-{
-  private:
-    SignalHandler();
-  public:
-    inline static SignalHandler* getInstance() { if (!SignalHandler::singletonRef) SignalHandler::singletonRef = new SignalHandler(); return SignalHandler::singletonRef; }
-    ~SignalHandler(){ SignalHandler::singletonRef = NULL; }
+    class SignalHandler
+    {
+    private:
+        SignalHandler();
+    public:
+        inline static SignalHandler* getInstance() { if (!SignalHandler::singletonRef) SignalHandler::singletonRef = new SignalHandler(); return SignalHandler::singletonRef; }
+        ~SignalHandler(){ SignalHandler::singletonRef = NULL; }
 
-    void registerCallback( SignalCallback cb, void * someData );
+        void registerCallback( SignalCallback cb, void * someData );
 
-    void doCatch( const std::string & appName, const std::string & filename );
-    void dontCatch();
+        void doCatch( const std::string & appName, const std::string & filename );
+        void dontCatch();
 
-  private:
-    static void sigHandler( int sig );
+    private:
+        static void sigHandler( int sig );
 
-    void catchSignal( int sig );
-    SignalRecList sigRecList;
+        void catchSignal( int sig );
+        SignalRecList sigRecList;
 
-    SignalCallbackList callbackList;
+        SignalCallbackList callbackList;
 
-    static SignalHandler * singletonRef;
+        static SignalHandler * singletonRef;
 
-    std::string appName;
-    std::string filename;
+        std::string appName;
+        std::string filename;
 
-    // used to turn on KeyAutoRepeat if OIS crashes
-    static bool bXAutoKeyRepeatOn_;
-};
+        // used to turn on KeyAutoRepeat if OIS crashes
+        static bool bXAutoKeyRepeatOn_;
+    };
+}
 
 #else /* ORXONOX_PLATFORM == ORXONOX_PLATFORM_WIN32 */
 
-class _UtilExport SignalHandler
+namespace orxonox
 {
-  public:
-    inline static SignalHandler* getInstance() { if (!SignalHandler::singletonRef) SignalHandler::singletonRef = new SignalHandler(); return SignalHandler::singletonRef; };
-    void doCatch( const std::string & appName, const std::string & filename ) {};
-    void dontCatch() {};
-    void registerCallback( SignalCallback cb, void * someData ) {};
+    class _UtilExport SignalHandler
+    {
+    public:
+        inline static SignalHandler* getInstance() { if (!SignalHandler::singletonRef) SignalHandler::singletonRef = new SignalHandler(); return SignalHandler::singletonRef; };
+        void doCatch( const std::string & appName, const std::string & filename ) {};
+        void dontCatch() {};
+        void registerCallback( SignalCallback cb, void * someData ) {};
 
-  private:
-    static SignalHandler * singletonRef;
-};
+    private:
+        static SignalHandler * singletonRef;
+    };
+}
 
 #endif /* ORXONOX_PLATFORM == ORXONOX_PLATFORM_WIN32 */

code/branches/objecthierarchy/src/util/Sleep.h

@@ -41 +41 @@
 #include <winbase.h>
 
-inline void usleep(DWORD dwMicroseconds)
+namespace orxonox
 {
-  Sleep(dwMicroseconds / 1000);
-}
+    inline void usleep(DWORD dwMicroseconds)
+    {
+        Sleep(dwMicroseconds / 1000);
+    }
 
-inline void msleep(DWORD dwMilliseconds)
-{
-  Sleep(dwMilliseconds);
-}
+    inline void msleep(DWORD dwMilliseconds)
+    {
+        Sleep(dwMilliseconds);
+    }
 
-inline void sleep(DWORD dwSeconds)
-{
-  Sleep(dwSeconds * 1000);
+    inline void sleep(DWORD dwSeconds)
+    {
+        Sleep(dwSeconds * 1000);
+    }
 }
 
@@ -60 +63 @@
 #include <unistd.h>
 
-inline void msleep(unsigned long msec)
+namespace orxonox
 {
-  usleep(msec * 1000);
+    inline void usleep(unsigned long usec)
+    {
+        usleep(usec);
+    }
+    inline void msleep(unsigned long msec)
+    {
+        usleep(msec * 1000);
+    }
+    inline void sleep(unsigned long sec)
+    {
+        usleep(sec * 1000000);
+    }
 }
 

code/branches/objecthierarchy/src/util/String.cc

@@ -40 +40 @@
 #include "Math.h"
 
-std::string BLANKSTRING("");
-
-std::string getUniqueNumberString()
+namespace orxonox
 {
-    return convertToString(getUniqueNumber());
+    std::string BLANKSTRING("");
+
+    std::string getUniqueNumberString()
+    {
+        return convertToString(getUniqueNumber());
+    }
+
+    /**
+        @brief Removes all whitespaces from a string.
+        @param str The string to strip
+    */
+    void strip(std::string* str)
+    {
+        size_t pos;
+        while ((pos = (*str).find(" ")) < (*str).length())
+            (*str).erase(pos, 1);
+        while ((pos = (*str).find("\t")) < (*str).length())
+            (*str).erase(pos, 1);
+        while ((pos = (*str).find("\n")) < (*str).length())
+            (*str).erase(pos, 1);
+    }
+
+    /**
+        @brief Returns a copy of a string without whitespaces.
+        @param str The string to strip
+        @return The stripped line
+    */
+    std::string getStripped(const std::string& str)
+    {
+        std::string output = std::string(str);
+        strip(&output);
+        return output;
+    }
+
+    /**
+        @brief Returns a copy of a string without trailing whitespaces.
+        @param str The string
+        @return The modified copy
+    */
+    std::string removeTrailingWhitespaces(const std::string& str)
+    {
+        size_t pos1 = 0;
+        int pos2 = str.size() - 1;
+        for (; pos1 < str.size() && (str[pos1] == ' ' || str[pos1] == '\t' || str[pos1] == '\n'); pos1++);
+        for (; pos2 > 0         && (str[pos2] == ' ' || str[pos2] == '\t' || str[pos2] == '\n'); pos2--);
+        return str.substr(pos1, pos2 - pos1 + 1);
+    }
+
+    /**
+        @brief Returns the position of the next quote in the string, starting with start.
+        @param str The string
+        @param start The startposition
+        @return The position of the next quote (std::string::npos if there is no next quote)
+    */
+    size_t getNextQuote(const std::string& str, size_t start)
+    {
+        size_t quote = start - 1;
+
+        while ((quote = str.find('\"', quote + 1)) != std::string::npos)
+        {
+            size_t backslash = quote;
+            size_t numbackslashes = 0;
+            for (; backslash > 0; backslash--, numbackslashes++)
+                if (str[backslash - 1] != '\\')
+                    break;
+
+            if (numbackslashes % 2 == 0)
+                break;
+        }
+
+        return quote;
+    }
+
+    /**
+        @brief Returns true if pos is between two quotes.
+        @param str The string
+        @param pos The position to check
+        @return True if pos is between two quotes
+    */
+    bool isBetweenQuotes(const std::string& str, size_t pos)
+    {
+        if (pos == std::string::npos)
+            return false;
+
+        size_t quotecount = 0;
+        size_t quote = (size_t)-1;
+        while ((quote = getNextQuote(str, quote + 1)) < pos)
+        {
+            if (quote == pos)
+                return false;
+            quotecount++;
+        }
+
+        if (quote == std::string::npos)
+            return false;
+
+        return ((quotecount % 2) == 1);
+    }
+
+    /**
+        @brief Returns true if the string contains something like '..."between quotes"...'.
+        @param The string
+        @return True if there is something between quotes
+    */
+    bool hasStringBetweenQuotes(const std::string& str)
+    {
+        size_t pos1 = getNextQuote(str, 0);
+        size_t pos2 = getNextQuote(str, pos1 + 1);
+        return (pos1 != std::string::npos && pos2 != std::string::npos && pos2 > pos1 + 1);
+    }
+
+    /**
+        @brief If the string contains something like '..."between quotes"...' then 'between quotes' gets returned (without quotes).
+        @param The string
+        @param The string between the quotes
+    */
+    std::string getStringBetweenQuotes(const std::string& str)
+    {
+        size_t pos1 = getNextQuote(str, 0);
+        size_t pos2 = getNextQuote(str, pos1 + 1);
+        if (pos1 != std::string::npos && pos2 != std::string::npos)
+            return str.substr(pos1, pos2 - pos1 + 1);
+        else
+            return "";
+    }
+
+    /**
+        @brief Removes enclosing quotes if available (including whitespaces at the outside of the quotes).
+        @brief str The string to strip
+        @return The string with removed quotes
+    */
+    std::string stripEnclosingQuotes(const std::string& str)
+    {
+        size_t start = std::string::npos;
+        size_t end = 0;
+
+        for (size_t pos = 0; (pos < str.size()) && (pos < std::string::npos); pos++)
+        {
+            if (str[pos] == '"')
+            {
+                start = pos;
+                break;
+            }
+
+            if ((str[pos] != ' ') && (str[pos] != '\t') && (str[pos] != '\n'))
+                return str;
+        }
+
+        for (size_t pos = str.size() - 1; pos < std::string::npos; pos--)
+        {
+            if (str[pos] == '"')
+            {
+                end = pos;
+                break;
+            }
+
+            if ((str[pos] != ' ') && (str[pos] != '\t') && (str[pos] != '\n'))
+                return str;
+        }
+
+        if ((start != std::string::npos) && (end != 0))
+            return str.substr(start + 1, end - start - 1);
+        else
+            return str;
+    }
+
+    /**
+        @brief Removes enclosing {braces} (braces must be exactly on the beginning and the end of the string).
+        @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;
+    }
+
+    /**
+        @brief Determines if a string is a comment (starts with a comment-symbol).
+        @param str The string to check
+        @return True = it's a comment
+
+        A comment is defined by a leading '#', '%', ';' or '//'.
+    */
+    bool isComment(const std::string& str)
+    {
+        // Strip the line, whitespaces are disturbing
+        std::string teststring = getStripped(str);
+
+        // There are four possible comment-symbols:
+        //  1) #comment in script-language style
+        //  2) %comment in matlab style
+        //  3) ;comment in unreal tournament config-file style
+        //  4) //comment in code style
+        if (teststring.size() >= 2)
+        {
+            if (teststring[0] == '#' || teststring[0] == '%' || teststring[0] == ';' || (teststring[0] == '/' && teststring[1] == '/'))
+                return true;
+        }
+        else if (teststring.size() == 1)
+        {
+            if (teststring[0] == '#' || teststring[0] == '%' || teststring[0] == ';')
+                return true;
+        }
+
+        return false;
+    }
+
+    /**
+        @brief Determines if a string is empty (contains only whitespaces).
+        @param str The string to check
+        @return True = it's empty
+    */
+    bool isEmpty(const std::string& str)
+    {
+        std::string temp = getStripped(str);
+        return ((temp == "") || (temp.size() == 0));
+    }
+
+    /**
+        @brief Determines if a string contains only numbers and maximal one '.'.
+        @param str The string to check
+        @return True = it's a number
+    */
+    bool isNumeric(const std::string& str)
+    {
+        bool foundPoint = false;
+
+        for (std::string::const_iterator it = str.begin(); it != str.end(); ++it)
+        {
+            if (((*it) < '0' || (*it) > '9'))
+            {
+                if ((*it) != '.' && !foundPoint)
+                    foundPoint = true;
+                else
+                    return false;
+            }
+        }
+
+        return true;
+    }
+
+    /**
+        @brief Adds backslashes to the given string which makes special chars visible. Existing slashes will be doubled.
+        @param str The string to manipulate
+        @return The string with added slashes
+    */
+    std::string addSlashes(const std::string& str)
+    {
+        std::string output = str;
+
+        for (size_t pos = 0; (pos = output.find('\\', pos)) < std::string::npos; pos += 2) { output.replace(pos, 1, "\\\\"); }
+        for (size_t pos = 0; (pos = output.find('\n', pos)) < std::string::npos; pos += 2) { output.replace(pos, 1, "\\n"); }
+        for (size_t pos = 0; (pos = output.find('\t', pos)) < std::string::npos; pos += 2) { output.replace(pos, 1, "\\t"); }
+        for (size_t pos = 0; (pos = output.find('\v', pos)) < std::string::npos; pos += 2) { output.replace(pos, 1, "\\v"); }
+        for (size_t pos = 0; (pos = output.find('\b', pos)) < std::string::npos; pos += 2) { output.replace(pos, 1, "\\b"); }
+        for (size_t pos = 0; (pos = output.find('\r', pos)) < std::string::npos; pos += 2) { output.replace(pos, 1, "\\r"); }
+        for (size_t pos = 0; (pos = output.find('\f', pos)) < std::string::npos; pos += 2) { output.replace(pos, 1, "\\f"); }
+        for (size_t pos = 0; (pos = output.find('\a', pos)) < std::string::npos; pos += 2) { output.replace(pos, 1, "\\a"); }
+        for (size_t pos = 0; (pos = output.find('"', pos)) < std::string::npos; pos += 2) { output.replace(pos, 1, "\\\""); }
+        for (size_t pos = 0; (pos = output.find('\0', pos)) < std::string::npos; pos += 2) { output.replace(pos, 1, "\\0"); }
+
+        return output;
+    }
+
+    /**
+        @brief Removes backslashes from the given string. Double backslashes are interpreted as one backslash.
+        @param str The string to manipulate
+        @return The string with removed slashes
+    */
+    std::string removeSlashes(const std::string& str)
+    {
+        if (str.size() <= 1)
+            return str;
+
+        std::string output = "";
+        for (size_t pos = 0; pos < str.size() - 1; )
+        {
+            if (str[pos] == '\\')
+            {
+                if (str[pos + 1] == '\\') { output += '\\'; pos += 2; continue; }
+                else if (str[pos + 1] == 'n') { output += '\n'; pos += 2; continue; }
+                else if (str[pos + 1] == 't') { output += '\t'; pos += 2; continue; }
+                else if (str[pos + 1] == 'v') { output += '\v'; pos += 2; continue; }
+                else if (str[pos + 1] == 'b') { output += '\b'; pos += 2; continue; }
+                else if (str[pos + 1] == 'r') { output += '\r'; pos += 2; continue; }
+                else if (str[pos + 1] == 'f') { output += '\f'; pos += 2; continue; }
+                else if (str[pos + 1] == 'a') { output += '\a'; pos += 2; continue; }
+                else if (str[pos + 1] == '"') { output += '"'; pos += 2; continue; }
+                else if (str[pos + 1] == '0') { output += '\0'; pos += 2; continue; }
+            }
+            output += str[pos];
+            pos++;
+            if (pos == str.size() - 1)
+                output += str[pos];
+        }
+
+        return output;
+    }
+
+    /**
+        @brief Replaces each char between A and Z with its lowercase equivalent.
+        @param str The string to convert
+    */
+    void lowercase(std::string* str)
+    {
+        for (size_t i = 0; i < str->size(); ++i)
+        {
+            (*str)[i] = (char)tolower((*str)[i]);
+        }
+    }
+
+    /**
+        @brief Returns a copy of the given string without uppercase chars.
+        @param str The string
+        @return The copy
+    */
+    std::string getLowercase(const std::string& str)
+    {
+        std::string output = std::string(str);
+        lowercase(&output);
+        return output;
+    }
+
+    /**
+        @brief Replaces each char between a and z with its uppercase equivalent.
+        @param str The string to convert
+    */
+    void uppercase(std::string* str)
+    {
+        for (size_t i = 0; i < str->size(); ++i)
+        {
+            (*str)[i] = (char)toupper((*str)[i]);
+        }
+    }
+
+    /**
+        @brief Returns a copy of the given string without lowercase chars.
+        @param str The string
+        @return The copy
+    */
+    std::string getUppercase(const std::string& str)
+    {
+        std::string output = std::string(str);
+        uppercase(&output);
+        return output;
+    }
+
+    /**
+        @brief Compares two strings ignoring different casing.
+        @param s1 First string
+        @param s2 Second string
+    */
+    int nocaseCmp(const std::string& s1, const std::string& s2)
+    {
+        std::string::const_iterator it1=s1.begin();
+        std::string::const_iterator it2=s2.begin();
+
+        //stop when either string's end has been reached
+        while ( (it1!=s1.end()) && (it2!=s2.end()) )
+        {
+            if(::toupper(*it1) != ::toupper(*it2)) //letters differ?
+                // return -1 to indicate smaller than, 1 otherwise
+                return (::toupper(*it1)  < ::toupper(*it2)) ? -1 : 1;
+            //proceed to the next character in each string
+            ++it1;
+            ++it2;
+        }
+        size_t size1=s1.size(), size2=s2.size();// cache lengths
+        //return -1,0 or 1 according to strings' lengths
+        if (size1==size2)
+            return 0;
+        return (size1<size2) ? -1 : 1;
+    }
+
+
+    /**
+        @brief Compares the first 'len' chars of two strings ignoring different casing.
+        @param s1 First string
+        @param s2 Second string
+        @param len Maximal number of chars to compare
+    */
+    int nocaseCmp(const std::string& s1, const std::string& s2, size_t len)
+    {
+        if (len == 0)
+            return 0;
+        std::string::const_iterator it1=s1.begin();
+        std::string::const_iterator it2=s2.begin();
+
+        //stop when either string's end has been reached
+        while ( (it1!=s1.end()) && (it2!=s2.end()) && len-- > 0)
+        {
+            if(::toupper(*it1) != ::toupper(*it2)) //letters differ?
+                // return -1 to indicate smaller than, 1 otherwise
+                return (::toupper(*it1)  < ::toupper(*it2)) ? -1 : 1;
+            //proceed to the next character in each string
+            ++it1;
+            ++it2;
+        }
+        return 0;
+    }
+
+    /**
+        @brief Returns true if the string contains a comment, introduced by #, %, ; or //.
+        @param str The string
+        @return True if the string contains a comment
+    */
+    bool hasComment(const std::string& str)
+    {
+        return (getCommentPosition(str) != std::string::npos);
+    }
+
+    /**
+        @brief If the string contains a comment, the comment gets returned (including the comment symbol), an empty string otherwise.
+        @param str The string
+        @return The comment
+    */
+    std::string getComment(const std::string& str)
+    {
+        return str.substr(getCommentPosition(str));
+    }
+
+    /**
+        @brief If the string contains a comment, the position of the comment-symbol gets returned, std::string::npos otherwise.
+        @param str The string
+        @return The position
+    */
+    size_t getCommentPosition(const std::string& str)
+    {
+        return getNextCommentPosition(str, 0);
+    }
+
+    /**
+        @brief Returns the position of the next comment-symbol, starting with start.
+        @param str The string
+        @param start The startposition
+        @return The position
+    */
+    size_t getNextCommentPosition(const std::string& str, size_t start)
+    {
+        for (size_t i = start; i < str.size(); i++)
+            if (isComment(str.substr(i)))
+                return i;
+
+        return std::string::npos;
+    }
 }
-
-/**
-    @brief Removes all whitespaces from a string.
-    @param str The string to strip
-*/
-void strip(std::string* str)
-{
-    size_t pos;
-    while ((pos = (*str).find(" ")) < (*str).length())
-        (*str).erase(pos, 1);
-    while ((pos = (*str).find("\t")) < (*str).length())
-        (*str).erase(pos, 1);
-    while ((pos = (*str).find("\n")) < (*str).length())
-        (*str).erase(pos, 1);
-}
-
-/**
-    @brief Returns a copy of a string without whitespaces.
-    @param str The string to strip
-    @return The stripped line
-*/
-std::string getStripped(const std::string& str)
-{
-    std::string output = std::string(str);
-    strip(&output);
-    return output;
-}
-
-/**
-    @brief Returns a copy of a string without trailing whitespaces.
-    @param str The string
-    @return The modified copy
-*/
-std::string removeTrailingWhitespaces(const std::string& str)
-{
-    size_t pos1 = 0;
-    int pos2 = str.size() - 1;
-    for (; pos1 < str.size() && (str[pos1] == ' ' || str[pos1] == '\t' || str[pos1] == '\n'); pos1++);
-    for (; pos2 > 0         && (str[pos2] == ' ' || str[pos2] == '\t' || str[pos2] == '\n'); pos2--);
-    return str.substr(pos1, pos2 - pos1 + 1);
-}
-
-/**
-    @brief Returns the position of the next quote in the string, starting with start.
-    @param str The string
-    @param start The startposition
-    @return The position of the next quote (std::string::npos if there is no next quote)
-*/
-size_t getNextQuote(const std::string& str, size_t start)
-{
-    size_t quote = start - 1;
-
-    while ((quote = str.find('\"', quote + 1)) != std::string::npos)
-    {
-        size_t backslash = quote;
-        size_t numbackslashes = 0;
-        for (; backslash > 0; backslash--, numbackslashes++)
-            if (str[backslash - 1] != '\\')
-                break;
-
-        if (numbackslashes % 2 == 0)
-            break;
-    }
-
-    return quote;
-}
-
-/**
-    @brief Returns true if pos is between two quotes.
-    @param str The string
-    @param pos The position to check
-    @return True if pos is between two quotes
-*/
-bool isBetweenQuotes(const std::string& str, size_t pos)
-{
-    if (pos == std::string::npos)
-        return false;
-
-    size_t quotecount = 0;
-    size_t quote = (size_t)-1;
-    while ((quote = getNextQuote(str, quote + 1)) < pos)
-    {
-        if (quote == pos)
-            return false;
-        quotecount++;
-    }
-
-    if (quote == std::string::npos)
-        return false;
-
-    return ((quotecount % 2) == 1);
-}
-
-/**
-    @brief Returns true if the string contains something like '..."between quotes"...'.
-    @param The string
-    @return True if there is something between quotes
-*/
-bool hasStringBetweenQuotes(const std::string& str)
-{
-    size_t pos1 = getNextQuote(str, 0);
-    size_t pos2 = getNextQuote(str, pos1 + 1);
-    return (pos1 != std::string::npos && pos2 != std::string::npos && pos2 > pos1 + 1);
-}
-
-/**
-    @brief If the string contains something like '..."between quotes"...' then 'between quotes' gets returned (without quotes).
-    @param The string
-    @param The string between the quotes
-*/
-std::string getStringBetweenQuotes(const std::string& str)
-{
-    size_t pos1 = getNextQuote(str, 0);
-    size_t pos2 = getNextQuote(str, pos1 + 1);
-    if (pos1 != std::string::npos && pos2 != std::string::npos)
-        return str.substr(pos1, pos2 - pos1 + 1);
-    else
-        return "";
-}
-
-/**
-    @brief Removes enclosing quotes if available (including whitespaces at the outside of the quotes).
-    @brief str The string to strip
-    @return The string with removed quotes
-*/
-std::string stripEnclosingQuotes(const std::string& str)
-{
-    size_t start = std::string::npos;
-    size_t end = 0;
-
-    for (size_t pos = 0; (pos < str.size()) && (pos < std::string::npos); pos++)
-    {
-        if (str[pos] == '"')
-        {
-            start = pos;
-            break;
-        }
-
-        if ((str[pos] != ' ') && (str[pos] != '\t') && (str[pos] != '\n'))
-            return str;
-    }
-
-    for (size_t pos = str.size() - 1; pos < std::string::npos; pos--)
-    {
-        if (str[pos] == '"')
-        {
-            end = pos;
-            break;
-        }
-
-        if ((str[pos] != ' ') && (str[pos] != '\t') && (str[pos] != '\n'))
-            return str;
-    }
-
-    if ((start != std::string::npos) && (end != 0))
-        return str.substr(start + 1, end - start - 1);
-    else
-        return str;
-}
-
-/**
-    @brief Removes enclosing {braces} (braces must be exactly on the beginning and the end of the string).
-    @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;
-}
-
-/**
-    @brief Determines if a string is a comment (starts with a comment-symbol).
-    @param str The string to check
-    @return True = it's a comment
-
-    A comment is defined by a leading '#', '%', ';' or '//'.
-*/
-bool isComment(const std::string& str)
-{
-    // Strip the line, whitespaces are disturbing
-    std::string teststring = getStripped(str);
-
-    // There are four possible comment-symbols:
-    //  1) #comment in script-language style
-    //  2) %comment in matlab style
-    //  3) ;comment in unreal tournament config-file style
-    //  4) //comment in code style
-    if (teststring.size() >= 2)
-    {
-        if (teststring[0] == '#' || teststring[0] == '%' || teststring[0] == ';' || (teststring[0] == '/' && teststring[1] == '/'))
-            return true;
-    }
-    else if (teststring.size() == 1)
-    {
-        if (teststring[0] == '#' || teststring[0] == '%' || teststring[0] == ';')
-            return true;
-    }
-
-    return false;
-}
-
-/**
-    @brief Determines if a string is empty (contains only whitespaces).
-    @param str The string to check
-    @return True = it's empty
-*/
-bool isEmpty(const std::string& str)
-{
-    std::string temp = getStripped(str);
-    return ((temp == "") || (temp.size() == 0));
-}
-
-/**
-    @brief Determines if a string contains only numbers and maximal one '.'.
-    @param str The string to check
-    @return True = it's a number
-*/
-bool isNumeric(const std::string& str)
-{
-    bool foundPoint = false;
-
-    for (std::string::const_iterator it = str.begin(); it != str.end(); ++it)
-    {
-        if (((*it) < '0' || (*it) > '9'))
-        {
-            if ((*it) != '.' && !foundPoint)
-                foundPoint = true;
-            else
-                return false;
-        }
-    }
-
-    return true;
-}
-
-/**
-    @brief Adds backslashes to the given string which makes special chars visible. Existing slashes will be doubled.
-    @param str The string to manipulate
-    @return The string with added slashes
-*/
-std::string addSlashes(const std::string& str)
-{
-    std::string output = str;
-
-    for (size_t pos = 0; (pos = output.find('\\', pos)) < std::string::npos; pos += 2) { output.replace(pos, 1, "\\\\"); }
-    for (size_t pos = 0; (pos = output.find('\n', pos)) < std::string::npos; pos += 2) { output.replace(pos, 1, "\\n"); }
-    for (size_t pos = 0; (pos = output.find('\t', pos)) < std::string::npos; pos += 2) { output.replace(pos, 1, "\\t"); }
-    for (size_t pos = 0; (pos = output.find('\v', pos)) < std::string::npos; pos += 2) { output.replace(pos, 1, "\\v"); }
-    for (size_t pos = 0; (pos = output.find('\b', pos)) < std::string::npos; pos += 2) { output.replace(pos, 1, "\\b"); }
-    for (size_t pos = 0; (pos = output.find('\r', pos)) < std::string::npos; pos += 2) { output.replace(pos, 1, "\\r"); }
-    for (size_t pos = 0; (pos = output.find('\f', pos)) < std::string::npos; pos += 2) { output.replace(pos, 1, "\\f"); }
-    for (size_t pos = 0; (pos = output.find('\a', pos)) < std::string::npos; pos += 2) { output.replace(pos, 1, "\\a"); }
-    for (size_t pos = 0; (pos = output.find('"', pos)) < std::string::npos; pos += 2) { output.replace(pos, 1, "\\\""); }
-    for (size_t pos = 0; (pos = output.find('\0', pos)) < std::string::npos; pos += 2) { output.replace(pos, 1, "\\0"); }
-
-    return output;
-}
-
-/**
-    @brief Removes backslashes from the given string. Double backslashes are interpreted as one backslash.
-    @param str The string to manipulate
-    @return The string with removed slashes
-*/
-std::string removeSlashes(const std::string& str)
-{
-    if (str.size() <= 1)
-        return str;
-
-    std::string output = "";
-    for (size_t pos = 0; pos < str.size() - 1; )
-    {
-        if (str[pos] == '\\')
-        {
-            if (str[pos + 1] == '\\') { output += '\\'; pos += 2; continue; }
-            else if (str[pos + 1] == 'n') { output += '\n'; pos += 2; continue; }
-            else if (str[pos + 1] == 't') { output += '\t'; pos += 2; continue; }
-            else if (str[pos + 1] == 'v') { output += '\v'; pos += 2; continue; }
-            else if (str[pos + 1] == 'b') { output += '\b'; pos += 2; continue; }
-            else if (str[pos + 1] == 'r') { output += '\r'; pos += 2; continue; }
-            else if (str[pos + 1] == 'f') { output += '\f'; pos += 2; continue; }
-            else if (str[pos + 1] == 'a') { output += '\a'; pos += 2; continue; }
-            else if (str[pos + 1] == '"') { output += '"'; pos += 2; continue; }
-            else if (str[pos + 1] == '0') { output += '\0'; pos += 2; continue; }
-        }
-        output += str[pos];
-        pos++;
-        if (pos == str.size() - 1)
-            output += str[pos];
-    }
-
-    return output;
-}
-
-/**
-    @brief Replaces each char between A and Z with its lowercase equivalent.
-    @param str The string to convert
-*/
-void lowercase(std::string* str)
-{
-    for (size_t i = 0; i < str->size(); ++i)
-    {
-        (*str)[i] = (char)tolower((*str)[i]);
-    }
-}
-
-/**
-    @brief Returns a copy of the given string without uppercase chars.
-    @param str The string
-    @return The copy
-*/
-std::string getLowercase(const std::string& str)
-{
-    std::string output = std::string(str);
-    lowercase(&output);
-    return output;
-}
-
-/**
-    @brief Replaces each char between a and z with its uppercase equivalent.
-    @param str The string to convert
-*/
-void uppercase(std::string* str)
-{
-    for (size_t i = 0; i < str->size(); ++i)
-    {
-        (*str)[i] = (char)toupper((*str)[i]);
-    }
-}
-
-/**
-    @brief Returns a copy of the given string without lowercase chars.
-    @param str The string
-    @return The copy
-*/
-std::string getUppercase(const std::string& str)
-{
-    std::string output = std::string(str);
-    uppercase(&output);
-    return output;
-}
-
-/**
-    @brief Compares two strings ignoring different casing.
-    @param s1 First string
-    @param s2 Second string
-*/
-int nocaseCmp(const std::string& s1, const std::string& s2)
-{
-    std::string::const_iterator it1=s1.begin();
-    std::string::const_iterator it2=s2.begin();
-
-    //stop when either string's end has been reached
-    while ( (it1!=s1.end()) && (it2!=s2.end()) )
-    {
-        if(::toupper(*it1) != ::toupper(*it2)) //letters differ?
-            // return -1 to indicate smaller than, 1 otherwise
-            return (::toupper(*it1)  < ::toupper(*it2)) ? -1 : 1;
-        //proceed to the next character in each string
-        ++it1;
-        ++it2;
-    }
-    size_t size1=s1.size(), size2=s2.size();// cache lengths
-    //return -1,0 or 1 according to strings' lengths
-    if (size1==size2)
-        return 0;
-    return (size1<size2) ? -1 : 1;
-}
-
-
-/**
-    @brief Compares the first 'len' chars of two strings ignoring different casing.
-    @param s1 First string
-    @param s2 Second string
-    @param len Maximal number of chars to compare
-*/
-int nocaseCmp(const std::string& s1, const std::string& s2, size_t len)
-{
-    if (len == 0)
-        return 0;
-    std::string::const_iterator it1=s1.begin();
-    std::string::const_iterator it2=s2.begin();
-
-    //stop when either string's end has been reached
-    while ( (it1!=s1.end()) && (it2!=s2.end()) && len-- > 0)
-    {
-        if(::toupper(*it1) != ::toupper(*it2)) //letters differ?
-            // return -1 to indicate smaller than, 1 otherwise
-            return (::toupper(*it1)  < ::toupper(*it2)) ? -1 : 1;
-        //proceed to the next character in each string
-        ++it1;
-        ++it2;
-    }
-    return 0;
-}
-
-/**
-    @brief Returns true if the string contains a comment, introduced by #, %, ; or //.
-    @param str The string
-    @return True if the string contains a comment
-*/
-bool hasComment(const std::string& str)
-{
-    return (getCommentPosition(str) != std::string::npos);
-}
-
-/**
-    @brief If the string contains a comment, the comment gets returned (including the comment symbol), an empty string otherwise.
-    @param str The string
-    @return The comment
-*/
-std::string getComment(const std::string& str)
-{
-    return str.substr(getCommentPosition(str));
-}
-
-/**
-    @brief If the string contains a comment, the position of the comment-symbol gets returned, std::string::npos otherwise.
-    @param str The string
-    @return The position
-*/
-size_t getCommentPosition(const std::string& str)
-{
-    return getNextCommentPosition(str, 0);
-}
-
-/**
-    @brief Returns the position of the next comment-symbol, starting with start.
-    @param str The string
-    @param start The startposition
-    @return The position
-*/
-size_t getNextCommentPosition(const std::string& str, size_t start)
-{
-    for (size_t i = start; i < str.size(); i++)
-        if (isComment(str.substr(i)))
-            return i;
-
-    return std::string::npos;
-}

code/branches/objecthierarchy/src/util/String.h

@@ -40 +40 @@
 #include <sstream>
 
-extern _UtilExport std::string BLANKSTRING;
-_UtilExport std::string getUniqueNumberString();
+namespace orxonox
+{
+    extern _UtilExport std::string BLANKSTRING;
+    _UtilExport std::string getUniqueNumberString();
 
-_UtilExport void        strip(std::string* str);
-_UtilExport std::string getStripped(const std::string& str);
+    _UtilExport void        strip(std::string* str);
+    _UtilExport std::string getStripped(const std::string& str);
 
-_UtilExport std::string removeTrailingWhitespaces(const std::string& str);
+    _UtilExport std::string removeTrailingWhitespaces(const std::string& str);
 
-_UtilExport size_t      getNextQuote(const std::string& str, size_t start);
-_UtilExport bool        isBetweenQuotes(const std::string& str, size_t pos);
+    _UtilExport size_t      getNextQuote(const std::string& str, size_t start);
+    _UtilExport bool        isBetweenQuotes(const std::string& str, size_t pos);
 
-_UtilExport bool        hasStringBetweenQuotes(const std::string& str);
-_UtilExport std::string getStringBetweenQuotes(const std::string& str);
+    _UtilExport bool        hasStringBetweenQuotes(const std::string& str);
+    _UtilExport std::string getStringBetweenQuotes(const std::string& str);
 
-_UtilExport std::string stripEnclosingQuotes(const std::string& str);
-_UtilExport std::string stripEnclosingBraces(const std::string& str);
+    _UtilExport std::string stripEnclosingQuotes(const std::string& str);
+    _UtilExport std::string stripEnclosingBraces(const std::string& str);
 
-_UtilExport bool        isEmpty(const std::string& str);
-_UtilExport bool        isComment(const std::string& str);
-_UtilExport bool        isNumeric(const std::string& str);
+    _UtilExport bool        isEmpty(const std::string& str);
+    _UtilExport bool        isComment(const std::string& str);
+    _UtilExport bool        isNumeric(const std::string& str);
 
-_UtilExport std::string addSlashes(const std::string& str);
-_UtilExport std::string removeSlashes(const std::string& str);
+    _UtilExport std::string addSlashes(const std::string& str);
+    _UtilExport std::string removeSlashes(const std::string& str);
 
-_UtilExport void        lowercase(std::string* str);
-_UtilExport std::string getLowercase(const std::string& str);
+    _UtilExport void        lowercase(std::string* str);
+    _UtilExport std::string getLowercase(const std::string& str);
 
-_UtilExport void        uppercase(std::string* str);
-_UtilExport std::string getUppercase(const std::string& str);
+    _UtilExport void        uppercase(std::string* str);
+    _UtilExport std::string getUppercase(const std::string& str);
 
-_UtilExport int         nocaseCmp(const std::string& s1, const std::string& s2);
-_UtilExport int         nocaseCmp(const std::string& s1, const std::string& s2, size_t len);
+    _UtilExport int         nocaseCmp(const std::string& s1, const std::string& s2);
+    _UtilExport int         nocaseCmp(const std::string& s1, const std::string& s2, size_t len);
 
-_UtilExport bool        hasComment(const std::string& str);
-_UtilExport std::string getComment(const std::string& str);
-_UtilExport size_t      getCommentPosition(const std::string& str);
-_UtilExport size_t      getNextCommentPosition(const std::string& str, size_t start = 0);
+    _UtilExport bool        hasComment(const std::string& str);
+    _UtilExport std::string getComment(const std::string& str);
+    _UtilExport size_t      getCommentPosition(const std::string& str);
+    _UtilExport size_t      getNextCommentPosition(const std::string& str, size_t start = 0);
+}
 
 #endif /* _Util_String_H__ */

code/branches/objecthierarchy/src/util/SubString.cc

@@ -40 +40 @@
 #include "SubString.h"
 
-/**
- * @brief default constructor
- */
-SubString::SubString()
-{}
-
-
-/**
- * @brief create a SubString from
- * @param string the String to Split
- * @param delimiter the Character at which to split string (delimiter)
- */
-SubString::SubString(const std::string& string, char delimiter)
+namespace orxonox
 {
-  this->split(string, delimiter);
-}
-
-
-/**
- * @brief Splits a String into multiple splitters.
- * @param string the String to split
- * @param delimiters multiple set of characters at what to split. (delimiters)
- * @param delimiterNeighbours neighbours of the delimiters, that will be erased only when near a delimiter.
- * @param emptyEntries If empty entries should be allewed or removed.
- * @param escapeChar The Escape Character that overrides splitters commends and so on...
- * @param safemode_char within these characters splitting won't happen
- * @param comment_char the Comment character.
- */
-SubString::SubString(const std::string& string,
-                     const std::string& delimiters, const std::string& delimiterNeighbours, bool emptyEntries,
-                     char escapeChar, bool removeEscapeChar, char safemode_char, bool removeSafemodeChar,
-                     char openparenthesis_char, char closeparenthesis_char, bool removeParenthesisChars, char comment_char)
-{
-  SubString::splitLine(this->strings, this->bInSafemode, string, delimiters, delimiterNeighbours, emptyEntries, escapeChar, removeEscapeChar, safemode_char, removeSafemodeChar, openparenthesis_char, closeparenthesis_char, removeParenthesisChars, comment_char);
-}
-
-/**
- * @brief creates a SubSet of a SubString.
- * @param subString the SubString to take a set from.
- * @param subSetBegin the beginning to the end
- */
-SubString::SubString(const SubString& subString, unsigned int subSetBegin)
-{
-  for (unsigned int i = subSetBegin; i < subString.size(); i++)
-  {
-    this->strings.push_back(subString[i]);
-    this->bInSafemode.push_back(subString.isInSafemode(i));
-  }
-}
-
-
-/**
- * @brief creates a SubSet of a SubString.
- * @param subString the SubString to take a Set from
- * @param subSetBegin the beginning to the end
- * @param subSetEnd the end of the SubSet (max subString.size() will be checked internaly)
- */
-SubString::SubString(const SubString& subString, unsigned int subSetBegin, unsigned int subSetEnd)
-{
-  for (unsigned int i = subSetBegin; i < subString.size() && i < subSetEnd; i++)
-  {
-    this->strings.push_back(subString[i]);
-    this->bInSafemode.push_back(subString.isInSafemode(i));
-  }
-}
-
-/**
- * @brief creates a Substring from a count and values set.
- * @param argc: the Arguments Count.
- * @param argv: Argument Values.
- */
-SubString::SubString(unsigned int argc, const char** argv)
-{
-  for(unsigned int i = 0; i < argc; ++i)
-  {
-    this->strings.push_back(std::string(argv[i]));
-    this->bInSafemode.push_back(false);
-  }
-}
-
-/**
- * @brief removes the object from memory
- */
-SubString::~SubString()
-{ }
-
-/** @brief An empty String */
-// const std::string SubString::emptyString = "";
-/** @brief Helper that gets you a String consisting of all White Spaces */
-const std::string SubString::WhiteSpaces = " \n\t";
-/** @brief Helper that gets you a String consisting of all WhiteSpaces and the Comma */
-const std::string SubString::WhiteSpacesWithComma = " \n\t,";
-/** An Empty SubString */
-const SubString SubString::NullSubString = SubString();
-
-/**
- * @brief stores the Value of subString in this SubString
- * @param subString will be copied into this String.
- * @returns this SubString.
- */
-SubString& SubString::operator=(const SubString& subString)
-{
-  this->strings = subString.strings;
-  this->bInSafemode = subString.bInSafemode;
-  return *this;
-}
-
-
-/**
- * @brief comparator.
- * @param subString the SubString to compare against this one.
- * @returns true if the Stored Strings match
- */
-bool SubString::operator==(const SubString& subString) const
-{
-  return ((this->strings == subString.strings) && (this->bInSafemode == subString.bInSafemode));
-}
-
-/**
- * @brief comparator.
- * @param subString the SubString to compare against this one.
- * @returns true if the Stored Strings match
- */
-bool SubString::compare(const SubString& subString) const
-{
-  return (*this == subString);
-}
-
-/**
- * @brief comparator.
- * @param subString the SubString to compare against this one.
- * @param length how many entries to compare. (from 0 to length)
- * @returns true if the Stored Strings match
- */
-bool SubString::compare(const SubString& subString, unsigned int length) const
-{
-  if (length > this->size() || length > subString.size())
-    return false;
-
-  for (unsigned int i = 0; i < length; i++)
-    if ((this->strings[i] != subString.strings[i]) || (this->bInSafemode[i] != subString.bInSafemode[i]))
-      return false;
-  return true;
-}
-
-
-/**
- * @brief append operator
- * @param subString the String to append.
- * @returns a SubString where this and subString are appended.
- */
-SubString SubString::operator+(const SubString& subString) const
-{
-  return SubString(*this) += subString;
-}
-
-
-/**
- * @brief append operator.
- * @param subString append subString to this SubString.
- * @returns this substring appended with subString
- */
-SubString& SubString::operator+=(const SubString& subString)
-{
-  for (unsigned int i = 0; i < subString.size(); i++)
-  {
-    this->strings.push_back(subString[i]);
-    this->bInSafemode.push_back(subString.isInSafemode(i));
-  }
-  return *this;
-}
-
-
-/**
- * @brief Split the String at
- * @param string where to split
- * @param splitter delimiter.
- */
-unsigned int SubString::split(const std::string& string, char splitter)
-{
-  this->strings.clear();
-  this->bInSafemode.clear();
-  char split[2];
-  split[0] = splitter;
-  split[1] = '\0';
-  SubString::splitLine(this->strings, this->bInSafemode, string, split);
-  return strings.size();
-}
-
-
-/**
- * @brief Splits a String into multiple splitters.
- * @param string the String to split
- * @param delimiters multiple set of characters at what to split. (delimiters)
- * @param delimiterNeighbours: Neighbours to the Delimiters that will be erased too.
- * @param emptyEntries: If empty entries are added to the List of SubStrings
- * @param escapeChar The Escape Character that overrides splitters commends and so on...
- * @param safemode_char within these characters splitting won't happen
- * @param comment_char the Comment character.
- */
-unsigned int SubString::split(const std::string& string,
-                              const std::string& delimiters, const std::string& delimiterNeighbours, bool emptyEntries,
-                              char escapeChar, bool removeExcapeChar, char safemode_char, bool removeSafemodeChar,
-                              char openparenthesis_char, char closeparenthesis_char, bool removeParenthesisChars, char comment_char)
-{
-  this->strings.clear();
-  this->bInSafemode.clear();
-  SubString::splitLine(this->strings, this->bInSafemode, string, delimiters, delimiterNeighbours, emptyEntries, escapeChar, removeExcapeChar, safemode_char, removeSafemodeChar, openparenthesis_char, closeparenthesis_char, removeParenthesisChars, comment_char);
-  return this->strings.size();
-}
-
-
-/**
- * @brief joins together all Strings of this Substring.
- * @param delimiter the String between the subStrings.
- * @returns the joined String.
- */
-std::string SubString::join(const std::string& delimiter) const
-{
-  if (!this->strings.empty())
-  {
-    std::string retVal = this->strings[0];
-    for (unsigned int i = 1; i < this->strings.size(); i++)
-      retVal += delimiter + this->strings[i];
-    return retVal;
-  }
-  else
-  {
-    static std::string empty;
-    return empty;
-  }
-}
-
-
-/**
- * @brief creates a SubSet of a SubString.
- * @param subSetBegin the beginning to the end
- * @returns the SubSet
- *
- * This function is added for your convenience, and does the same as
- * SubString::SubString(const SubString& subString, unsigned int subSetBegin)
- */
-SubString SubString::subSet(unsigned int subSetBegin) const
-{
-  return SubString(*this, subSetBegin);
-}
-
-
-/**
- * @brief creates a SubSet of a SubString.
- * @param subSetBegin the beginning to
- * @param subSetEnd the end of the SubSet to select (if bigger than subString.size() it will be downset.)
- * @returns the SubSet
- *
- * This function is added for your convenience, and does the same as
- * SubString::SubString(const SubString& subString, unsigned int subSetBegin)
- */
-SubString SubString::subSet(unsigned int subSetBegin, unsigned int subSetEnd) const
-{
-  return SubString(*this, subSetBegin, subSetEnd);
-}
-
-
-/**
- * @brief splits line into tokens and stores them in ret.
- * @param ret the Array, where the Splitted strings will be stored in
- * to the beginning of the current token is stored
- * @param line the inputLine to split
- * @param delimiters a String of Delimiters (here the input will be splitted)
- * @param delimiterNeighbours Naighbours to the Delimitter, that will be removed if they are to the left or the right of a Delimiter.
- * @param emptyEntries: if empty Strings are added to the List of Strings.
- * @param escape_char: Escape carater (escapes splitters)
- * @param safemode_char: the beginning of the safemode is marked with this
- * @param removeSafemodeChar removes the safemode_char from the beginning and the ending of a token
- * @param openparenthesis_char the beginning of a safemode is marked with this
- * @param closeparenthesis_char the ending of a safemode is marked with this
- * @param removeParenthesisChars removes the parenthesis from the beginning and the ending of a token
- * @param comment_char: the beginning of a comment is marked with this: (until the end of a Line)
- * @param start_state: the Initial state on how to parse the String.
- * @return SPLIT_LINE_STATE the parser was in when returning
- *
- * This is the Actual Splitting Algorithm from Clemens Wacha
- * Supports delimiters, escape characters,
- * ignores special  characters between safemode_char and between comment_char and linend '\n'.
- */
-SubString::SPLIT_LINE_STATE
-SubString::splitLine(std::vector<std::string>& ret,
-                     std::vector<bool>& bInSafemode,
-                     const std::string& line,
-                     const std::string& delimiters,
-                     const std::string& delimiterNeighbours,
-                     bool emptyEntries,
-                     char escape_char,
-                     bool removeExcapeChar,
-                     char safemode_char,
-                     bool removeSafemodeChar,
-                     char openparenthesis_char,
-                     char closeparenthesis_char,
-                     bool removeParenthesisChars,
-                     char comment_char,
-                     SPLIT_LINE_STATE start_state)
-{
-  SPLIT_LINE_STATE state = start_state;
-  unsigned int i = 0;
-  unsigned int fallBackNeighbours = 0;
-
-  std::string token;
-  bool inSafemode = false;
-
-  if(start_state != SL_NORMAL && ret.size() > 0)
-  {
-    token = ret[ret.size()-1];
-    ret.pop_back();
-  }
-  if(start_state != SL_NORMAL && bInSafemode.size() > 0)
-  {
-    inSafemode = bInSafemode[bInSafemode.size()-1];
-    bInSafemode.pop_back();
-  }
-
-  while(i < line.size())
-  {
-    switch(state)
-    {
-      case SL_NORMAL:
-        if(line[i] == escape_char)
-        {
-          state = SL_ESCAPE;
-          if (!removeExcapeChar)
-            token += line[i];
-        }
-        else if(line[i] == safemode_char)
-        {
-          state = SL_SAFEMODE;
-          inSafemode = true;
-          if (!removeSafemodeChar)
-            token += line[i];
-        }
-        else if(line[i] == openparenthesis_char)
-        {
-          state = SL_PARENTHESES;
-          inSafemode = true;
-          if (!removeParenthesisChars)
-            token += line[i];
-        }
-        else if(line[i] == comment_char)
-        {
-          if (fallBackNeighbours > 0)
+    /**
+     * @brief default constructor
+     */
+    SubString::SubString()
+    {}
+
+
+    /**
+     * @brief create a SubString from
+     * @param string the String to Split
+     * @param delimiter the Character at which to split string (delimiter)
+     */
+    SubString::SubString(const std::string& string, char delimiter)
+    {
+        this->split(string, delimiter);
+    }
+
+
+    /**
+     * @brief Splits a String into multiple splitters.
+     * @param string the String to split
+     * @param delimiters multiple set of characters at what to split. (delimiters)
+     * @param delimiterNeighbours neighbours of the delimiters, that will be erased only when near a delimiter.
+     * @param emptyEntries If empty entries should be allewed or removed.
+     * @param escapeChar The Escape Character that overrides splitters commends and so on...
+     * @param safemode_char within these characters splitting won't happen
+     * @param comment_char the Comment character.
+     */
+    SubString::SubString(const std::string& string,
+                         const std::string& delimiters, const std::string& delimiterNeighbours, bool emptyEntries,
+                         char escapeChar, bool removeEscapeChar, char safemode_char, bool removeSafemodeChar,
+                         char openparenthesis_char, char closeparenthesis_char, bool removeParenthesisChars, char comment_char)
+    {
+        SubString::splitLine(this->strings, this->bInSafemode, string, delimiters, delimiterNeighbours, emptyEntries, escapeChar, removeEscapeChar, safemode_char, removeSafemodeChar, openparenthesis_char, closeparenthesis_char, removeParenthesisChars, comment_char);
+    }
+
+    /**
+     * @brief creates a SubSet of a SubString.
+     * @param subString the SubString to take a set from.
+     * @param subSetBegin the beginning to the end
+     */
+    SubString::SubString(const SubString& subString, unsigned int subSetBegin)
+    {
+        for (unsigned int i = subSetBegin; i < subString.size(); i++)
+        {
+            this->strings.push_back(subString[i]);
+            this->bInSafemode.push_back(subString.isInSafemode(i));
+        }
+    }
+
+
+    /**
+     * @brief creates a SubSet of a SubString.
+     * @param subString the SubString to take a Set from
+     * @param subSetBegin the beginning to the end
+     * @param subSetEnd the end of the SubSet (max subString.size() will be checked internaly)
+     */
+    SubString::SubString(const SubString& subString, unsigned int subSetBegin, unsigned int subSetEnd)
+    {
+        for (unsigned int i = subSetBegin; i < subString.size() && i < subSetEnd; i++)
+        {
+            this->strings.push_back(subString[i]);
+            this->bInSafemode.push_back(subString.isInSafemode(i));
+        }
+    }
+
+    /**
+     * @brief creates a Substring from a count and values set.
+     * @param argc: the Arguments Count.
+     * @param argv: Argument Values.
+     */
+    SubString::SubString(unsigned int argc, const char** argv)
+    {
+        for(unsigned int i = 0; i < argc; ++i)
+        {
+            this->strings.push_back(std::string(argv[i]));
+            this->bInSafemode.push_back(false);
+        }
+    }
+
+    /**
+     * @brief removes the object from memory
+     */
+    SubString::~SubString()
+    { }
+
+    /** @brief An empty String */
+    // const std::string SubString::emptyString = "";
+    /** @brief Helper that gets you a String consisting of all White Spaces */
+    const std::string SubString::WhiteSpaces = " \n\t";
+    /** @brief Helper that gets you a String consisting of all WhiteSpaces and the Comma */
+    const std::string SubString::WhiteSpacesWithComma = " \n\t,";
+    /** An Empty SubString */
+    const SubString SubString::NullSubString = SubString();
+
+    /**
+     * @brief stores the Value of subString in this SubString
+     * @param subString will be copied into this String.
+     * @returns this SubString.
+     */
+    SubString& SubString::operator=(const SubString& subString)
+    {
+        this->strings = subString.strings;
+        this->bInSafemode = subString.bInSafemode;
+        return *this;
+    }
+
+
+    /**
+     * @brief comparator.
+     * @param subString the SubString to compare against this one.
+     * @returns true if the Stored Strings match
+     */
+    bool SubString::operator==(const SubString& subString) const
+    {
+        return ((this->strings == subString.strings) && (this->bInSafemode == subString.bInSafemode));
+    }
+
+    /**
+     * @brief comparator.
+     * @param subString the SubString to compare against this one.
+     * @returns true if the Stored Strings match
+     */
+    bool SubString::compare(const SubString& subString) const
+    {
+        return (*this == subString);
+    }
+
+    /**
+     * @brief comparator.
+     * @param subString the SubString to compare against this one.
+     * @param length how many entries to compare. (from 0 to length)
+     * @returns true if the Stored Strings match
+     */
+    bool SubString::compare(const SubString& subString, unsigned int length) const
+    {
+        if (length > this->size() || length > subString.size())
+            return false;
+
+        for (unsigned int i = 0; i < length; i++)
+            if ((this->strings[i] != subString.strings[i]) || (this->bInSafemode[i] != subString.bInSafemode[i]))
+                return false;
+        return true;
+    }
+
+
+    /**
+     * @brief append operator
+     * @param subString the String to append.
+     * @returns a SubString where this and subString are appended.
+     */
+    SubString SubString::operator+(const SubString& subString) const
+    {
+        return SubString(*this) += subString;
+    }
+
+
+    /**
+     * @brief append operator.
+     * @param subString append subString to this SubString.
+     * @returns this substring appended with subString
+     */
+    SubString& SubString::operator+=(const SubString& subString)
+    {
+        for (unsigned int i = 0; i < subString.size(); i++)
+        {
+            this->strings.push_back(subString[i]);
+            this->bInSafemode.push_back(subString.isInSafemode(i));
+        }
+        return *this;
+    }
+
+
+    /**
+     * @brief Split the String at
+     * @param string where to split
+     * @param splitter delimiter.
+     */
+    unsigned int SubString::split(const std::string& string, char splitter)
+    {
+        this->strings.clear();
+        this->bInSafemode.clear();
+        char split[2];
+        split[0] = splitter;
+        split[1] = '\0';
+        SubString::splitLine(this->strings, this->bInSafemode, string, split);
+        return strings.size();
+    }
+
+
+    /**
+     * @brief Splits a String into multiple splitters.
+     * @param string the String to split
+     * @param delimiters multiple set of characters at what to split. (delimiters)
+     * @param delimiterNeighbours: Neighbours to the Delimiters that will be erased too.
+     * @param emptyEntries: If empty entries are added to the List of SubStrings
+     * @param escapeChar The Escape Character that overrides splitters commends and so on...
+     * @param safemode_char within these characters splitting won't happen
+     * @param comment_char the Comment character.
+     */
+    unsigned int SubString::split(const std::string& string,
+                                  const std::string& delimiters, const std::string& delimiterNeighbours, bool emptyEntries,
+                                  char escapeChar, bool removeExcapeChar, char safemode_char, bool removeSafemodeChar,
+                                  char openparenthesis_char, char closeparenthesis_char, bool removeParenthesisChars, char comment_char)
+    {
+        this->strings.clear();
+        this->bInSafemode.clear();
+        SubString::splitLine(this->strings, this->bInSafemode, string, delimiters, delimiterNeighbours, emptyEntries, escapeChar, removeExcapeChar, safemode_char, removeSafemodeChar, openparenthesis_char, closeparenthesis_char, removeParenthesisChars, comment_char);
+        return this->strings.size();
+    }
+
+
+    /**
+     * @brief joins together all Strings of this Substring.
+     * @param delimiter the String between the subStrings.
+     * @returns the joined String.
+     */
+    std::string SubString::join(const std::string& delimiter) const
+    {
+        if (!this->strings.empty())
+        {
+            std::string retVal = this->strings[0];
+            for (unsigned int i = 1; i < this->strings.size(); i++)
+                retVal += delimiter + this->strings[i];
+            return retVal;
+        }
+        else
+        {
+            static std::string empty;
+            return empty;
+        }
+    }
+
+
+    /**
+     * @brief creates a SubSet of a SubString.
+     * @param subSetBegin the beginning to the end
+     * @returns the SubSet
+     *
+     * This function is added for your convenience, and does the same as
+     * SubString::SubString(const SubString& subString, unsigned int subSetBegin)
+     */
+    SubString SubString::subSet(unsigned int subSetBegin) const
+    {
+        return SubString(*this, subSetBegin);
+    }
+
+
+    /**
+     * @brief creates a SubSet of a SubString.
+     * @param subSetBegin the beginning to
+     * @param subSetEnd the end of the SubSet to select (if bigger than subString.size() it will be downset.)
+     * @returns the SubSet
+     *
+     * This function is added for your convenience, and does the same as
+     * SubString::SubString(const SubString& subString, unsigned int subSetBegin)
+     */
+    SubString SubString::subSet(unsigned int subSetBegin, unsigned int subSetEnd) const
+    {
+        return SubString(*this, subSetBegin, subSetEnd);
+    }
+
+
+    /**
+     * @brief splits line into tokens and stores them in ret.
+     * @param ret the Array, where the Splitted strings will be stored in
+     * to the beginning of the current token is stored
+     * @param line the inputLine to split
+     * @param delimiters a String of Delimiters (here the input will be splitted)
+     * @param delimiterNeighbours Naighbours to the Delimitter, that will be removed if they are to the left or the right of a Delimiter.
+     * @param emptyEntries: if empty Strings are added to the List of Strings.
+     * @param escape_char: Escape carater (escapes splitters)
+     * @param safemode_char: the beginning of the safemode is marked with this
+     * @param removeSafemodeChar removes the safemode_char from the beginning and the ending of a token
+     * @param openparenthesis_char the beginning of a safemode is marked with this
+     * @param closeparenthesis_char the ending of a safemode is marked with this
+     * @param removeParenthesisChars removes the parenthesis from the beginning and the ending of a token
+     * @param comment_char: the beginning of a comment is marked with this: (until the end of a Line)
+     * @param start_state: the Initial state on how to parse the String.
+     * @return SPLIT_LINE_STATE the parser was in when returning
+     *
+     * This is the Actual Splitting Algorithm from Clemens Wacha
+     * Supports delimiters, escape characters,
+     * ignores special  characters between safemode_char and between comment_char and linend '\n'.
+     */
+    SubString::SPLIT_LINE_STATE
+    SubString::splitLine(std::vector<std::string>& ret,
+                         std::vector<bool>& bInSafemode,
+                         const std::string& line,
+                         const std::string& delimiters,
+                         const std::string& delimiterNeighbours,
+                         bool emptyEntries,
+                         char escape_char,
+                         bool removeExcapeChar,
+                         char safemode_char,
+                         bool removeSafemodeChar,
+                         char openparenthesis_char,
+                         char closeparenthesis_char,
+                         bool removeParenthesisChars,
+                         char comment_char,
+                         SPLIT_LINE_STATE start_state)
+    {
+        SPLIT_LINE_STATE state = start_state;
+        unsigned int i = 0;
+        unsigned int fallBackNeighbours = 0;
+
+        std::string token;
+        bool inSafemode = false;
+
+        if(start_state != SL_NORMAL && ret.size() > 0)
+        {
+            token = ret[ret.size()-1];
+            ret.pop_back();
+        }
+        if(start_state != SL_NORMAL && bInSafemode.size() > 0)
+        {
+            inSafemode = bInSafemode[bInSafemode.size()-1];
+            bInSafemode.pop_back();
+        }
+
+        while(i < line.size())
+        {
+            switch(state)
+            {
+            case SL_NORMAL:
+                if(line[i] == escape_char)
+                {
+                    state = SL_ESCAPE;
+                    if (!removeExcapeChar)
+                        token += line[i];
+                }
+                else if(line[i] == safemode_char)
+                {
+                    state = SL_SAFEMODE;
+                    inSafemode = true;
+                    if (!removeSafemodeChar)
+                        token += line[i];
+                }
+                else if(line[i] == openparenthesis_char)
+                {
+                    state = SL_PARENTHESES;
+                    inSafemode = true;
+                    if (!removeParenthesisChars)
+                        token += line[i];
+                }
+                else if(line[i] == comment_char)
+                {
+                    if (fallBackNeighbours > 0)
+                        token = token.substr(0, token.size() - fallBackNeighbours);
+                    /// FINISH
+                    if(emptyEntries || token.size() > 0)
+                    {
+                        ret.push_back(token);
+                        token.clear();
+                        bInSafemode.push_back(inSafemode);
+                        inSafemode = false;
+                    }
+                    token += line[i];       // EAT
+                    state = SL_COMMENT;
+                }
+                else if(delimiters.find(line[i]) != std::string::npos)
+                {
+                    // line[i] is a delimiter
+                    if (fallBackNeighbours > 0)
+                        token = token.substr(0, token.size() - fallBackNeighbours);
+                    /// FINISH
+                    if(emptyEntries || token.size() > 0)
+                    {
+                        ret.push_back(token);
+                        token.clear();
+                        bInSafemode.push_back(inSafemode);
+                        inSafemode = false;
+                    }
+                    state = SL_NORMAL;
+                }
+                else
+                {
+                    if (delimiterNeighbours.find(line[i]) != std::string::npos)
+                    {
+                        if (token.size() > 0)
+                            ++fallBackNeighbours;
+                        else
+                        {
+                            i++;
+                            continue;
+                        }
+                    }
+                    else
+                        fallBackNeighbours = 0;
+                    token += line[i];       // EAT
+                }
+                break;
+            case SL_ESCAPE:
+                if (!removeSafemodeChar)
+                    token += line[i];
+                else
+                {
+                    if(line[i] == 'n') token += '\n';
+                    else if(line[i] == 't') token += '\t';
+                    else if(line[i] == 'v') token += '\v';
+                    else if(line[i] == 'b') token += '\b';
+                    else if(line[i] == 'r') token += '\r';
+                    else if(line[i] == 'f') token += '\f';
+                    else if(line[i] == 'a') token += '\a';
+                    else if(line[i] == '?') token += '\?';
+                    else token += line[i];  // EAT
+                }
+                state = SL_NORMAL;
+                break;
+            case SL_SAFEMODE:
+                if(line[i] == safemode_char)
+                {
+                    state = SL_NORMAL;
+                    if (!removeSafemodeChar)
+                        token += line[i];
+                }
+                else if(line[i] == escape_char)
+                {
+                    state = SL_SAFEESCAPE;
+                }
+                else
+                {
+                    token += line[i];       // EAT
+                }
+                break;
+
+            case SL_SAFEESCAPE:
+                if(line[i] == 'n') token += '\n';
+                else if(line[i] == 't') token += '\t';
+                else if(line[i] == 'v') token += '\v';
+                else if(line[i] == 'b') token += '\b';
+                else if(line[i] == 'r') token += '\r';
+                else if(line[i] == 'f') token += '\f';
+                else if(line[i] == 'a') token += '\a';
+                else if(line[i] == '?') token += '\?';
+                else token += line[i];  // EAT
+                state = SL_SAFEMODE;
+                break;
+
+            case SL_PARENTHESES:
+                if(line[i] == closeparenthesis_char)
+                {
+                    state = SL_NORMAL;
+                    if (!removeParenthesisChars)
+                        token += line[i];
+                }
+                else if(line[i] == escape_char)
+                {
+                    state = SL_PARENTHESESESCAPE;
+                }
+                else
+                {
+                    token += line[i];       // EAT
+                }
+                break;
+
+            case SL_PARENTHESESESCAPE:
+                if(line[i] == 'n') token += '\n';
+                else if(line[i] == 't') token += '\t';
+                else if(line[i] == 'v') token += '\v';
+                else if(line[i] == 'b') token += '\b';
+                else if(line[i] == 'r') token += '\r';
+                else if(line[i] == 'f') token += '\f';
+                else if(line[i] == 'a') token += '\a';
+                else if(line[i] == '?') token += '\?';
+                else token += line[i];  // EAT
+                state = SL_PARENTHESES;
+                break;
+
+            case SL_COMMENT:
+                if(line[i] == '\n')
+                {
+                    /// FINISH
+                    if(token.size() > 0)
+                    {
+                        ret.push_back(token);
+                        token.clear();
+                        bInSafemode.push_back(inSafemode);
+                        inSafemode = false;
+                    }
+                    state = SL_NORMAL;
+                }
+                else
+                {
+                    token += line[i];       // EAT
+                }
+                break;
+
+            default:
+                // nothing
+                break;
+            }
+            i++;
+        }
+
+        /// FINISH
+        if (fallBackNeighbours > 0)
             token = token.substr(0, token.size() - fallBackNeighbours);
-          /// FINISH
-          if(emptyEntries || token.size() > 0)
-          {
+        if(emptyEntries || token.size() > 0)
+        {
             ret.push_back(token);
             token.clear();
             bInSafemode.push_back(inSafemode);
             inSafemode = false;
-          }
-          token += line[i];       // EAT
-          state = SL_COMMENT;
-        }
-        else if(delimiters.find(line[i]) != std::string::npos)
-        {
-          // line[i] is a delimiter
-          if (fallBackNeighbours > 0)
-            token = token.substr(0, token.size() - fallBackNeighbours);
-          /// FINISH
-          if(emptyEntries || token.size() > 0)
-          {
-            ret.push_back(token);
-            token.clear();
-            bInSafemode.push_back(inSafemode);
-            inSafemode = false;
-          }
-          state = SL_NORMAL;
-        }
-        else
-        {
-          if (delimiterNeighbours.find(line[i]) != std::string::npos)
-          {
-            if (token.size() > 0)
-              ++fallBackNeighbours;
-            else
-            {
-              i++;
-              continue;
-            }
-          }
-          else
-            fallBackNeighbours = 0;
-          token += line[i];       // EAT
-        }
-        break;
-      case SL_ESCAPE:
-        if (!removeSafemodeChar)
-          token += line[i];
-        else
-        {
-          if(line[i] == 'n') token += '\n';
-          else if(line[i] == 't') token += '\t';
-          else if(line[i] == 'v') token += '\v';
-          else if(line[i] == 'b') token += '\b';
-          else if(line[i] == 'r') token += '\r';
-          else if(line[i] == 'f') token += '\f';
-          else if(line[i] == 'a') token += '\a';
-          else if(line[i] == '?') token += '\?';
-          else token += line[i];  // EAT
-        }
-        state = SL_NORMAL;
-        break;
-      case SL_SAFEMODE:
-        if(line[i] == safemode_char)
-        {
-          state = SL_NORMAL;
-          if (!removeSafemodeChar)
-            token += line[i];
-        }
-        else if(line[i] == escape_char)
-        {
-          state = SL_SAFEESCAPE;
-        }
-        else
-        {
-          token += line[i];       // EAT
-        }
-        break;
-
-      case SL_SAFEESCAPE:
-        if(line[i] == 'n') token += '\n';
-        else if(line[i] == 't') token += '\t';
-        else if(line[i] == 'v') token += '\v';
-        else if(line[i] == 'b') token += '\b';
-        else if(line[i] == 'r') token += '\r';
-        else if(line[i] == 'f') token += '\f';
-        else if(line[i] == 'a') token += '\a';
-        else if(line[i] == '?') token += '\?';
-        else token += line[i];  // EAT
-        state = SL_SAFEMODE;
-        break;
-
-      case SL_PARENTHESES:
-        if(line[i] == closeparenthesis_char)
-        {
-          state = SL_NORMAL;
-          if (!removeParenthesisChars)
-            token += line[i];
-        }
-        else if(line[i] == escape_char)
-        {
-          state = SL_PARENTHESESESCAPE;
-        }
-        else
-        {
-          token += line[i];       // EAT
-        }
-        break;
-
-      case SL_PARENTHESESESCAPE:
-        if(line[i] == 'n') token += '\n';
-        else if(line[i] == 't') token += '\t';
-        else if(line[i] == 'v') token += '\v';
-        else if(line[i] == 'b') token += '\b';
-        else if(line[i] == 'r') token += '\r';
-        else if(line[i] == 'f') token += '\f';
-        else if(line[i] == 'a') token += '\a';
-        else if(line[i] == '?') token += '\?';
-        else token += line[i];  // EAT
-        state = SL_PARENTHESES;
-        break;
-
-      case SL_COMMENT:
-        if(line[i] == '\n')
-        {
-          /// FINISH
-          if(token.size() > 0)
-          {
-            ret.push_back(token);
-            token.clear();
-            bInSafemode.push_back(inSafemode);
-            inSafemode = false;
-          }
-          state = SL_NORMAL;
-        }
-        else
-        {
-          token += line[i];       // EAT
-        }
-        break;
-
-      default:
-        // nothing
-        break;
-    }
-    i++;
-  }
-
-  /// FINISH
-  if (fallBackNeighbours > 0)
-    token = token.substr(0, token.size() - fallBackNeighbours);
-  if(emptyEntries || token.size() > 0)
-  {
-    ret.push_back(token);
-    token.clear();
-    bInSafemode.push_back(inSafemode);
-    inSafemode = false;
-  }
-  return(state);
+        }
+        return(state);
+    }
+
+
+    /**
+     * @brief Some nice debug information about this SubString
+     */
+    void SubString::debug() const
+    {
+        printf("Substring-information::count=%d ::", this->strings.size());
+        for (unsigned int i = 0; i < this->strings.size(); i++)
+            printf("s%d='%s'::", i, this->strings[i].c_str());
+        printf("\n");
+    }
 }
-
-
-/**
- * @brief Some nice debug information about this SubString
- */
-void SubString::debug() const
-{
-  printf("Substring-information::count=%d ::", this->strings.size());
-  for (unsigned int i = 0; i < this->strings.size(); i++)
-    printf("s%d='%s'::", i, this->strings[i].c_str());
-  printf("\n");
-}

code/branches/objecthierarchy/src/util/SubString.h

@@ -64 +64 @@
 #include <string>
 
-//! A class that can load one string and split it in multipe ones
-/**
- * SubString is a very Powerfull way to create a SubSet from a String
- * It can be used, to Split strings append them and join them again.
- */
-class _UtilExport SubString
+namespace orxonox
 {
-public:
-  //! An enumerator for the State the Parser is in
-  typedef enum {
-    SL_NORMAL,            //!< Normal state
-    SL_ESCAPE,            //!< After an escape character
-    SL_SAFEMODE,          //!< In safe mode (between "" mostly).
-    SL_SAFEESCAPE,        //!< In safe mode with the internal escape character, that escapes even the savemode character.
-    SL_COMMENT,           //!< In Comment mode.
-    SL_PARENTHESES,       //!< Between parentheses (usually '(' and ')')
-    SL_PARENTHESESESCAPE, //!< Between parentheses with the internal escape character, that escapes even the closing paranthesis character.
-  } SPLIT_LINE_STATE;
+    //! A class that can load one string and split it in multipe ones
+    /**
+     * SubString is a very Powerfull way to create a SubSet from a String
+     * It can be used, to Split strings append them and join them again.
+     */
+    class _UtilExport SubString
+    {
+    public:
+        //! An enumerator for the State the Parser is in
+        typedef enum {
+            SL_NORMAL,            //!< Normal state
+            SL_ESCAPE,            //!< After an escape character
+            SL_SAFEMODE,          //!< In safe mode (between "" mostly).
+            SL_SAFEESCAPE,        //!< In safe mode with the internal escape character, that escapes even the savemode character.
+            SL_COMMENT,           //!< In Comment mode.
+            SL_PARENTHESES,       //!< Between parentheses (usually '(' and ')')
+            SL_PARENTHESESESCAPE, //!< Between parentheses with the internal escape character, that escapes even the closing paranthesis character.
+        } SPLIT_LINE_STATE;
 
 
-public:
-  SubString();
-  SubString(const std::string& string, char delimiter = ',');
-  SubString(const std::string& string,
-            const std::string& delimiters, const std::string& delimiterNeighbours = "", bool emptyEntries=false,
-            char escapeChar ='\\', bool removeEscapeChar = true, char safemode_char = '"', bool removeSafemodeChar = true,
-            char openparenthesis_char = '(', char closeparenthesis_char = ')',  bool removeParenthesisChars = true, char comment_char = '\0');
-  SubString(unsigned int argc, const char** argv);
-  /** @brief create a Substring as a copy of another one. @param subString the SubString to copy. */
-  SubString(const SubString& subString) { *this = subString; };
-  SubString(const SubString& subString, unsigned int subSetBegin);
-  SubString(const SubString& subString, unsigned int subSetBegin, unsigned int subSetEnd);
-  ~SubString();
+    public:
+        SubString();
+        SubString(const std::string& string, char delimiter = ',');
+        SubString(const std::string& string,
+                  const std::string& delimiters, const std::string& delimiterNeighbours = "", bool emptyEntries=false,
+                  char escapeChar ='\\', bool removeEscapeChar = true, char safemode_char = '"', bool removeSafemodeChar = true,
+                  char openparenthesis_char = '(', char closeparenthesis_char = ')',  bool removeParenthesisChars = true, char comment_char = '\0');
+        SubString(unsigned int argc, const char** argv);
+        /** @brief create a Substring as a copy of another one. @param subString the SubString to copy. */
+        SubString(const SubString& subString) { *this = subString; };
+        SubString(const SubString& subString, unsigned int subSetBegin);
+        SubString(const SubString& subString, unsigned int subSetBegin, unsigned int subSetEnd);
+        ~SubString();
 
-  // operate on the SubString
-  SubString& operator=(const SubString& subString);
-  bool operator==(const SubString& subString) const;
-  bool compare(const SubString& subString) const;
-  bool compare(const SubString& subString, unsigned int length) const;
-  SubString operator+(const SubString& subString) const;
-  SubString& operator+=(const SubString& subString);
-  /** @param subString the String to append @returns appended String. @brief added for convenience */
-  SubString& append(const SubString subString) { return (*this += subString); };
+        // operate on the SubString
+        SubString& operator=(const SubString& subString);
+        bool operator==(const SubString& subString) const;
+        bool compare(const SubString& subString) const;
+        bool compare(const SubString& subString, unsigned int length) const;
+        SubString operator+(const SubString& subString) const;
+        SubString& operator+=(const SubString& subString);
+        /** @param subString the String to append @returns appended String. @brief added for convenience */
+        SubString& append(const SubString subString) { return (*this += subString); };
 
-  /////////////////////////////////////////
-  // Split and Join the any String. ///////
-  unsigned int split(const std::string& string = "", char delimiter = ',');
-  unsigned int split(const std::string& string,
-                     const std::string& delimiters, const std::string& delimiterNeighbours = "", bool emptyEntries = false,
-                     char escapeChar ='\\', bool removeExcapeChar = true, char safemode_char = '"', bool removeSafemodeChar = true,
-                     char openparenthesis_char = '(', char closeparenthesis_char = ')',  bool removeParenthesisChars = true, char comment_char = '\0');
-  std::string join(const std::string& delimiter = " ") const;
-  ////////////////////////////////////////
+        /////////////////////////////////////////
+        // Split and Join the any String. ///////
+        unsigned int split(const std::string& string = "", char delimiter = ',');
+        unsigned int split(const std::string& string,
+                           const std::string& delimiters, const std::string& delimiterNeighbours = "", bool emptyEntries = false,
+                           char escapeChar ='\\', bool removeExcapeChar = true, char safemode_char = '"', bool removeSafemodeChar = true,
+                           char openparenthesis_char = '(', char closeparenthesis_char = ')',  bool removeParenthesisChars = true, char comment_char = '\0');
+        std::string join(const std::string& delimiter = " ") const;
+        ////////////////////////////////////////
 
-  // retrieve a SubSet from the String
-  SubString subSet(unsigned int subSetBegin) const;
-  SubString subSet(unsigned int subSetBegin, unsigned int subSetEnd) const;
+        // retrieve a SubSet from the String
+        SubString subSet(unsigned int subSetBegin) const;
+        SubString subSet(unsigned int subSetBegin, unsigned int subSetEnd) const;
 
-  // retrieve Information from within
-  /** @brief Returns true if the SubString is empty */
-  inline bool empty() const { return this->strings.empty(); };
-  /** @brief Returns the count of Strings stored in this substring */
-  inline unsigned int size() const { return this->strings.size(); };
-  /** @brief Returns the i'th string from the subset of Strings @param i the i'th String */
-  inline const std::string& operator[](unsigned int i) const { return this->strings[i]; };
-  /** @brief Returns the i'th string from the subset of Strings @param i the i'th String */
-  inline const std::string& getString(unsigned int i) const { return (*this)[i]; };
-  /** @brief Returns all Strings as std::vector */
-  inline const std::vector<std::string>& getAllStrings() const { return this->strings; }
-  /** @brief Returns true if the token is in safemode. @param i the i'th token */
-  inline bool isInSafemode(unsigned int i) const { return this->bInSafemode[i]; }
-  /** @brief Returns the front of the StringList. */
-  inline const std::string& front() const { return this->strings.front(); };
-  /** @brief Returns the back of the StringList. */
-  inline const std::string& back() const { return this->strings.back(); };
-  /** @brief removes the back of the strings list. */
-  inline void pop_back() { this->strings.pop_back(); this->bInSafemode.pop_back(); };
+        // retrieve Information from within
+        /** @brief Returns true if the SubString is empty */
+        inline bool empty() const { return this->strings.empty(); };
+        /** @brief Returns the count of Strings stored in this substring */
+        inline unsigned int size() const { return this->strings.size(); };
+        /** @brief Returns the i'th string from the subset of Strings @param i the i'th String */
+        inline const std::string& operator[](unsigned int i) const { return this->strings[i]; };
+        /** @brief Returns the i'th string from the subset of Strings @param i the i'th String */
+        inline const std::string& getString(unsigned int i) const { return (*this)[i]; };
+        /** @brief Returns all Strings as std::vector */
+        inline const std::vector<std::string>& getAllStrings() const { return this->strings; }
+        /** @brief Returns true if the token is in safemode. @param i the i'th token */
+        inline bool isInSafemode(unsigned int i) const { return this->bInSafemode[i]; }
+        /** @brief Returns the front of the StringList. */
+        inline const std::string& front() const { return this->strings.front(); };
+        /** @brief Returns the back of the StringList. */
+        inline const std::string& back() const { return this->strings.back(); };
+        /** @brief removes the back of the strings list. */
+        inline void pop_back() { this->strings.pop_back(); this->bInSafemode.pop_back(); };
 
-  // the almighty algorithm.
-  static SPLIT_LINE_STATE splitLine(std::vector<std::string>& ret,
-                                    std::vector<bool>& bInSafemode,
-                                    const std::string& line,
-                                    const std::string& delimiters = SubString::WhiteSpaces,
-                                    const std::string& delimiterNeighbours = "",
-                                    bool emptyEntries = false,
-                                    char escape_char = '\\',
-                                    bool removeExcapeChar = true,
-                                    char safemode_char = '"',
-                                    bool removeSafemodeChar = true,
-                                    char openparenthesis_char = '(',
-                                    char closeparenthesis_char = ')',
-                                    bool removeParenthesisChars = true,
-                                    char comment_char = '\0',
-                                    SPLIT_LINE_STATE start_state = SL_NORMAL);
-  // debugging.
-  void debug() const;
+        // the almighty algorithm.
+        static SPLIT_LINE_STATE splitLine(std::vector<std::string>& ret,
+                                          std::vector<bool>& bInSafemode,
+                                          const std::string& line,
+                                          const std::string& delimiters = SubString::WhiteSpaces,
+                                          const std::string& delimiterNeighbours = "",
+                                          bool emptyEntries = false,
+                                          char escape_char = '\\',
+                                          bool removeExcapeChar = true,
+                                          char safemode_char = '"',
+                                          bool removeSafemodeChar = true,
+                                          char openparenthesis_char = '(',
+                                          char closeparenthesis_char = ')',
+                                          bool removeParenthesisChars = true,
+                                          char comment_char = '\0',
+                                          SPLIT_LINE_STATE start_state = SL_NORMAL);
+        // debugging.
+        void debug() const;
 
-public:
-  static const std::string WhiteSpaces;
-  static const std::string WhiteSpacesWithComma;
-  static const SubString   NullSubString;
+    public:
+        static const std::string WhiteSpaces;
+        static const std::string WhiteSpacesWithComma;
+        static const SubString   NullSubString;
 
-private:
-  std::vector<std::string>  strings;                      //!< strings produced from a single string splitted in multiple strings
-  std::vector<bool>         bInSafemode;
-};
+    private:
+        std::vector<std::string>  strings;                      //!< strings produced from a single string splitted in multiple strings
+        std::vector<bool>         bInSafemode;
+    };
+}
 
 #endif /* __SubString_H__ */

code/branches/objecthierarchy/src/util/UtilPrereqs.h

@@ -60 +60 @@
 // Forward declarations
 //-----------------------------------------------------------------------
-class ArgReader;
-class Convert;
-class ExprParser;
-class MultiType;
-class SubString;
 namespace orxonox
 {
+    class Exception;
+    class ExprParser;
+    class IntVector2;
+    class IntVector3;
+    class MultiType;
     class OutputBuffer;
     class OutputBufferListener;
-    class Error;
     class OutputHandler;
+    class SignalHandler;
+    class SubString;
 }