Changeset 848 for code/branches/core/src/util/MultiTypePrimitive.cc

Timestamp:

Mar 5, 2008, 1:29:47 AM (16 years ago)

Author:

landauf

Message:

several changes:

• XMLPort is now theoretically able to load something (but still buggy)
• Expanded Convert with several partial template specializations
• Expanded all MultiTypes with new functions, mostly to convert values
• Expanded SubString with a new functionality: chars inside parentheses aren't split

It's not yet working as it should (at least not in all cases - loading the objects name works)

File:

• code/branches/core/src/util/MultiTypePrimitive.cc (modified) (2 diffs)

code/branches/core/src/util/MultiTypePrimitive.cc

@@ -28 +28 @@
 
 #include "MultiTypePrimitive.h"
+#include "Convert.h"
 
 MultiTypePrimitive::MultiTypePrimitive(MultiType type)
@@ -140 +141 @@
 }
 
+MultiTypePrimitive::operator int() const
+{
+    return (this->type_ == MT_int) ? this->value_.int_ : ConvertValueAndReturn<MultiTypePrimitive, int>(*this);
+}
+
+MultiTypePrimitive::operator unsigned int() const
+{
+    return (this->type_ == MT_uint) ? this->value_.uint_ : ConvertValueAndReturn<MultiTypePrimitive, unsigned int>(*this);
+}
+
+MultiTypePrimitive::operator char() const
+{
+    return (this->type_ == MT_char) ? this->value_.char_ : ConvertValueAndReturn<MultiTypePrimitive, char>(*this);
+}
+
+MultiTypePrimitive::operator unsigned char() const
+{
+    return (this->type_ == MT_uchar) ? this->value_.uchar_ : ConvertValueAndReturn<MultiTypePrimitive, unsigned char>(*this);
+}
+
+MultiTypePrimitive::operator short() const
+{
+    return (this->type_ == MT_short) ? this->value_.short_ : ConvertValueAndReturn<MultiTypePrimitive, short>(*this);
+}
+
+MultiTypePrimitive::operator unsigned short() const
+{
+    return (this->type_ == MT_ushort) ? this->value_.ushort_ : ConvertValueAndReturn<MultiTypePrimitive, unsigned short>(*this);
+}
+
+MultiTypePrimitive::operator long() const
+{
+    return (this->type_ == MT_long) ? this->value_.long_ : ConvertValueAndReturn<MultiTypePrimitive, long>(*this);
+}
+
+MultiTypePrimitive::operator unsigned long() const
+{
+    return (this->type_ == MT_ulong) ? this->value_.ulong_ : ConvertValueAndReturn<MultiTypePrimitive, unsigned long>(*this);
+}
+
+MultiTypePrimitive::operator float() const
+{
+    return (this->type_ == MT_float) ? this->value_.float_ : ConvertValueAndReturn<MultiTypePrimitive, float>(*this);
+}
+
+MultiTypePrimitive::operator double() const
+{
+    return (this->type_ == MT_double) ? this->value_.double_ : ConvertValueAndReturn<MultiTypePrimitive, double>(*this);
+}
+
+MultiTypePrimitive::operator long double() const
+{
+    return (this->type_ == MT_longdouble) ? this->value_.longdouble_ : ConvertValueAndReturn<MultiTypePrimitive, long double>(*this);
+}
+
+MultiTypePrimitive::operator bool() const
+{
+    return (this->type_ == MT_bool) ? this->value_.bool_ : ConvertValueAndReturn<MultiTypePrimitive, bool>(*this);
+}
+
 void MultiTypePrimitive::setValue(const MultiTypePrimitive& mtp)
 {
     this->type_ = mtp.type_;
     this->value_ = mtp.value_;
+}
+
+std::string MultiTypePrimitive::toString() const
+{
+    std::string output;
+
+    if (this->type_ == MT_int)
+        ConvertValue(&output, this->value_.int_);
+    else if (this->type_ == MT_uint)
+        ConvertValue(&output, this->value_.uint_);
+    else if (this->type_ == MT_char)
+        ConvertValue(&output, this->value_.char_);
+    else if (this->type_ == MT_uchar)
+        ConvertValue(&output, this->value_.uchar_);
+    else if (this->type_ == MT_short)
+        ConvertValue(&output, this->value_.short_);
+    else if (this->type_ == MT_ushort)
+        ConvertValue(&output, this->value_.ushort_);
+    else if (this->type_ == MT_long)
+        ConvertValue(&output, this->value_.long_);
+    else if (this->type_ == MT_ulong)
+        ConvertValue(&output, this->value_.ulong_);
+    else if (this->type_ == MT_float)
+        ConvertValue(&output, this->value_.float_);
+    else if (this->type_ == MT_double)
+        ConvertValue(&output, this->value_.double_);
+    else if (this->type_ == MT_longdouble)
+        ConvertValue(&output, this->value_.longdouble_);
+    else if (this->type_ == MT_bool)
+        ConvertValue(&output, this->value_.bool_);
+
+    return output;
+}
+
+bool MultiTypePrimitive::fromString(const std::string value)
+{
+    if (this->type_ == MT_int)
+        return ConvertValue(&this->value_.int_, value, (int)0);
+    else if (this->type_ == MT_uint)
+        return ConvertValue(&this->value_.uint_, value, (unsigned int)0);
+    else if (this->type_ == MT_char)
+        return ConvertValue(&this->value_.char_, value, (char)0);
+    else if (this->type_ == MT_uchar)
+        return ConvertValue(&this->value_.uchar_, value, (unsigned char)0);
+    else if (this->type_ == MT_short)
+        return ConvertValue(&this->value_.short_, value, (short)0);
+    else if (this->type_ == MT_ushort)
+        return ConvertValue(&this->value_.ushort_, value, (unsigned short)0);
+    else if (this->type_ == MT_long)
+        return ConvertValue(&this->value_.long_, value, (long)0);
+    else if (this->type_ == MT_ulong)
+        return ConvertValue(&this->value_.ulong_, value, (unsigned long)0);
+    else if (this->type_ == MT_float)
+        return ConvertValue(&this->value_.float_, value, (float)0.0);
+    else if (this->type_ == MT_double)
+        return ConvertValue(&this->value_.double_, value, (double)0.0);
+    else if (this->type_ == MT_longdouble)
+        return ConvertValue(&this->value_.longdouble_, value, (long double)0.0);
+    else if (this->type_ == MT_bool)
+        return ConvertValue(&this->value_.bool_, value, false);
+    else
+        return false;
 }