Changeset 853 for code/branches/core/src/util

Timestamp:

Mar 5, 2008, 6:38:09 PM (16 years ago)

Author:

landauf

Message:

sync with notebook, there are some changes in the MultiTypes, XMLPort and the WorldEntity, but there's still a bug in some of the Converter-specializations

Location:

code/branches/core/src/util

Files:

• Convert.h (modified) (5 diffs)
• MultiTypeMath.cc (modified) (2 diffs)
• MultiTypeMath.h (modified) (3 diffs)
• MultiTypePrimitive.cc (modified) (3 diffs)
• MultiTypePrimitive.h (modified) (2 diffs)
• MultiTypeString.cc (modified) (2 diffs)
• MultiTypeString.h (modified) (3 diffs)

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

@@ -397 +397 @@
     bool operator()(orxonox::Vector2* output, const std::string& input) const
     {
-      SubString tokens(input, ",", SubString::WhiteSpaces, false, '\\', '"', '(', ')', '\0');
+      SubString tokens(input, ",", SubString::WhiteSpaces, false, '\\', '"', '\0', '\0', '\0');
 
       if (tokens.size() >= 2)
@@ -420 +420 @@
     bool operator()(orxonox::Vector3* output, const std::string& input) const
     {
-      SubString tokens(input, ",", SubString::WhiteSpaces, false, '\\', '"', '(', ')', '\0');
+      SubString tokens(input, ",", SubString::WhiteSpaces, false, '\\', '"', '\0', '\0', '\0');
 
       if (tokens.size() >= 3)
@@ -445 +445 @@
     bool operator()(orxonox::Vector4* output, const std::string& input) const
     {
-      SubString tokens(input, ",", SubString::WhiteSpaces, false, '\\', '"', '(', ')', '\0');
+      SubString tokens(input, ",", SubString::WhiteSpaces, false, '\\', '"', '\0', '\0', '\0');
 
       if (tokens.size() >= 4)
@@ -472 +472 @@
     bool operator()(orxonox::Quaternion* output, const std::string& input) const
     {
-      SubString tokens(input, ",", SubString::WhiteSpaces, false, '\\', '"', '(', ')', '\0');
+      SubString tokens(input, ",", SubString::WhiteSpaces, false, '\\', '"', '\0', '\0', '\0');
 
       if (tokens.size() >= 4)
@@ -499 +499 @@
     bool operator()(orxonox::ColourValue* output, const std::string& input) const
     {
-      SubString tokens(input, ",", SubString::WhiteSpaces, false, '\\', '"', '(', ')', '\0');
+      SubString tokens(input, ",", SubString::WhiteSpaces, false, '\\', '"', '\0', '\0', '\0');
 
       if (tokens.size() >= 4)

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

@@ -44 +44 @@
     else if (type == MT_degree)
         this->degree_ = orxonox::Degree(0);
-}
-
-MultiTypeMath::MultiTypeMath(const MultiTypeMath& mtm) : MultiTypeString(mtm)
-{
-    this->type_ = mtm.type_;
-    this->value_ = mtm.value_;
-}
-
-MultiTypeMath& MultiTypeMath::operator=(const MultiTypeMath& mtm)
-{
-    this->type_ = mtm.type_;
-    this->value_ = mtm.value_;
-    return *this;
 }
 
@@ -103 +90 @@
 MultiTypeMath::operator orxonox::Vector2() const
 {
-    return (this->type_ == MT_vector2) ? this->vector2_ : ConvertValueAndReturn<MultiTypePrimitive, orxonox::Vector2>(*this);
+    return (this->type_ == MT_vector2) ? this->vector2_ : ConvertValueAndReturn<MultiTypeMath, orxonox::Vector2>(*this);
 }
 
 MultiTypeMath::operator orxonox::Vector3() const
 {
-    return (this->type_ == MT_vector3) ? this->vector3_ : ConvertValueAndReturn<MultiTypePrimitive, orxonox::Vector3>(*this);
+std::cout << "4_2: Convert MultiTypeMath to Vector3:" << std::endl;
+std::cout << "     MultiTypeMath has type " << this->getType() << std::endl;
+std::cout << MT_vector3 << std::endl;
+std::cout << MT_string << std::endl;
+std::cout << MT_vector2 << std::endl;
+std::cout << MT_int << std::endl;
+std::cout << MT_uint << std::endl;
+std::cout << MT_null << std::endl;
+if (this->type_ == MT_vector3)
+{
+    std::cout << "     MultiTypeMath contains already a Vector3" << std::endl;
+    std::cout << "     Returnvalue is " << this->vector3_ << std::endl;
+}
+else
+{
+    std::cout << "     MultiTypeMath doesn't contain a Vector3" << std::endl;
+    std::cout << "     Returnvalue is " << ConvertValueAndReturn<MultiTypeMath, orxonox::Vector3>(*this) << std::endl;
+    std::cout << "     Returnvalue was " << ConvertValueAndReturn<MultiTypePrimitive, orxonox::Vector3>(*this) << std::endl;
+}
+    return (this->type_ == MT_vector3) ? this->vector3_ : ConvertValueAndReturn<MultiTypeMath, orxonox::Vector3>(*this);
 }
 
 MultiTypeMath::operator orxonox::Quaternion() const
 {
-    return (this->type_ == MT_quaternion) ? this->quaternion_ : ConvertValueAndReturn<MultiTypePrimitive, orxonox::Quaternion>(*this);
+    return (this->type_ == MT_quaternion) ? this->quaternion_ : ConvertValueAndReturn<MultiTypeMath, orxonox::Quaternion>(*this);
 }
 
 MultiTypeMath::operator orxonox::ColourValue() const
 {
-    return (this->type_ == MT_colourvalue) ? this->colourvalue_ : ConvertValueAndReturn<MultiTypePrimitive, orxonox::ColourValue>(*this);
+    return (this->type_ == MT_colourvalue) ? this->colourvalue_ : ConvertValueAndReturn<MultiTypeMath, orxonox::ColourValue>(*this);
 }
 
 MultiTypeMath::operator orxonox::Radian() const
 {
-    return (this->type_ == MT_radian) ? this->radian_ : ConvertValueAndReturn<MultiTypePrimitive, orxonox::Radian>(*this);
+    return (this->type_ == MT_radian) ? this->radian_ : ConvertValueAndReturn<MultiTypeMath, orxonox::Radian>(*this);
 }
 
 MultiTypeMath::operator orxonox::Degree() const
 {
-    return (this->type_ == MT_degree) ? this->degree_ : ConvertValueAndReturn<MultiTypePrimitive, orxonox::Degree>(*this);
+    return (this->type_ == MT_degree) ? this->degree_ : ConvertValueAndReturn<MultiTypeMath, orxonox::Degree>(*this);
 }
 
 void MultiTypeMath::setValue(const MultiTypeMath& mtm)
 {
-    this->type_ = mtm.type_;
-    this->value_ = mtm.value_;
+    std::cout << "4_3: setValue in MultiTypeMath with other Multitype as parameter: " << mtm << std::endl;
+
+    MultiTypeString::setValue(mtm);
+    this->vector2_ = mtm.vector2_;
+    this->vector3_ = mtm.vector3_;
+    this->quaternion_ = mtm.quaternion_;
+    this->colourvalue_ = mtm.colourvalue_;
+    this->radian_ = mtm.radian_;
+    this->degree_ = mtm.degree_;
 }
 

code/branches/core/src/util/MultiTypeMath.h

@@ -59 +59 @@
         inline MultiTypeMath(const orxonox::Radian&      value) { this->setValue(value); }
         inline MultiTypeMath(const orxonox::Degree&      value) { this->setValue(value); }
-        MultiTypeMath(const MultiTypeMath& mtm);
+        inline MultiTypeMath(const MultiTypeMath& mtm)          { this->setValue(mtm);   }
 
         using MultiTypeString::operator=;
@@ -68 +68 @@
         inline MultiTypeMath& operator=(const orxonox::Radian&      value) { this->setValue(value); return *this; }
         inline MultiTypeMath& operator=(const orxonox::Degree&      value) { this->setValue(value); return *this; }
-        MultiTypeMath& operator=(const MultiTypeMath& mtm);
+        inline MultiTypeMath& operator=(const MultiTypeMath& mtm)          { this->setValue(mtm);   return *this; }
 
         using MultiTypeString::operator==;
@@ -97 +97 @@
         using MultiTypeString::setValue;
         inline void setValue(const orxonox::Vector2&     value) { this->type_ = MT_vector2;     this->vector2_     = value; }
-        inline void setValue(const orxonox::Vector3&     value) { this->type_ = MT_vector3;     this->vector3_     = value; }
+        inline void setValue(const orxonox::Vector3&     value) { std::cout << "4_4: setValue Vector3: " << value << std::endl; this->type_ = MT_vector3;     this->vector3_     = value; }
         inline void setValue(const orxonox::ColourValue& value) { this->type_ = MT_colourvalue; this->colourvalue_ = value; }
         inline void setValue(const orxonox::Quaternion&  value) { this->type_ = MT_quaternion;  this->quaternion_  = value; }

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

@@ -32 +32 @@
 MultiTypePrimitive::MultiTypePrimitive(MultiType type)
 {
+std::cout << "4_5: Created MultiTypePrimitive with type " << type << std::endl;
     this->type_ = type;
 
@@ -60 +61 @@
     else
         this->value_.int_ = 0;
-}
-
-MultiTypePrimitive::MultiTypePrimitive(const MultiTypePrimitive& mtp)
-{
-    this->type_ = mtp.type_;
-    this->value_ = mtp.value_;
-}
-
-MultiTypePrimitive& MultiTypePrimitive::operator=(const MultiTypePrimitive& mtp)
-{
-    this->type_ = mtp.type_;
-    this->value_ = mtp.value_;
-    return *this;
 }
 
@@ -203 +191 @@
 void MultiTypePrimitive::setValue(const MultiTypePrimitive& mtp)
 {
+    std::cout << "4_3: setValue in MultiTypePrimitive with other Multitype as parameter: " << mtp << std::endl;
     this->type_ = mtp.type_;
     this->value_ = mtp.value_;

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

@@ -52 +52 @@
         inline MultiTypePrimitive(long double    value) { this->setValue(value); }
         inline MultiTypePrimitive(bool           value) { this->setValue(value); }
-        MultiTypePrimitive(const MultiTypePrimitive& mtp);
+        inline MultiTypePrimitive(const MultiTypePrimitive& mtp) { this->setValue(mtp); }
 
         inline MultiTypePrimitive& operator=(MultiType      value) { this->type_ = MT_null; return *this; }
@@ -67 +67 @@
         inline MultiTypePrimitive& operator=(long double    value) { this->setValue(value); return *this; }
         inline MultiTypePrimitive& operator=(bool           value) { this->setValue(value); return *this; }
-        MultiTypePrimitive& operator=(const MultiTypePrimitive& mtp);
+        inline MultiTypePrimitive& operator=(const MultiTypePrimitive& mtp) { this->setValue(mtp); return *this; }
 
         inline bool operator==(int            value) const { return (this->value_.int_        == value); }

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

@@ -38 +38 @@
 }
 
-MultiTypeString::MultiTypeString(const MultiTypeString& mts) : MultiTypePrimitive(mts)
-{
-    this->type_ = mts.type_;
-    this->value_ = mts.value_;
-}
-
-MultiTypeString& MultiTypeString::operator=(const MultiTypeString& mts)
-{
-    this->type_ = mts.type_;
-    this->value_ = mts.value_;
-    return *this;
-}
-
 bool MultiTypeString::operator==(const MultiTypeString& mts) const
 {
@@ -79 +66 @@
 MultiTypeString::operator std::string() const
 {
-    return (this->type_ == MT_string) ? this->string_ : ConvertValueAndReturn<MultiTypePrimitive, std::string>(*this);
+    return (this->type_ == MT_string) ? this->string_ : ConvertValueAndReturn<MultiTypeString, std::string>(*this);
 }
 
 MultiTypeString::operator const char*() const
 {
-    return (this->type_ == MT_constchar) ? this->string_.c_str() : ConvertValueAndReturn<MultiTypePrimitive, const char*>(*this);
+    return ((this->type_ == MT_constchar) ? this->string_ : ConvertValueAndReturn<MultiTypeString, std::string>(*this)).c_str();
 }
 
 void MultiTypeString::setValue(const MultiTypeString& mts)
 {
-    this->type_ = mts.type_;
-    this->value_ = mts.value_;
+    MultiTypePrimitive::setValue(mts);
+    this->string_ = mts.string_;
 }
 

code/branches/core/src/util/MultiTypeString.h

@@ -31 +31 @@
 
 #include <string>
-
+#include <iostream>
 #include "UtilPrereqs.h"
 
@@ -52 +52 @@
         inline MultiTypeString(long double    value) : MultiTypePrimitive(value) {}
         inline MultiTypeString(bool           value) : MultiTypePrimitive(value) {}
-        inline MultiTypeString(const char*        value) { this->setValue(value); }
-        inline MultiTypeString(const std::string& value) { this->setValue(value); }
-        MultiTypeString(const MultiTypeString& mtp);
+        inline MultiTypeString(const char*        value)   { this->setValue(value); }
+        inline MultiTypeString(const std::string& value)   { this->setValue(value); std::cout << "4_1: Created MultiTypeString with value " << value << " and type " << this->getType() << std::endl; }
+        inline MultiTypeString(const MultiTypeString& mts) { this->setValue(mts);   }
 
         using MultiTypePrimitive::operator=;
-        inline MultiTypeString& operator=(const char*        value) { this->setValue(value); return *this; }
-        inline MultiTypeString& operator=(const std::string& value) { this->setValue(value); return *this; }
-        MultiTypeString& operator=(const MultiTypeString& mtp);
+        inline MultiTypeString& operator=(const char*        value)   { this->setValue(value); return *this; }
+        inline MultiTypeString& operator=(const std::string& value)   { this->setValue(value); return *this; }
+        inline MultiTypeString& operator=(const MultiTypeString& mts) { this->setValue(mts);   return *this; }
 
         using MultiTypePrimitive::operator==;
         inline bool operator==(const char*        value) const { return (this->string_ == std::string(value)); }
         inline bool operator==(const std::string& value) const { return (this->string_ == value);              }
-        bool operator==(const MultiTypeString& mtp) const;
+        bool operator==(const MultiTypeString& mts) const;
 
         using MultiTypePrimitive::operator!=;
         inline bool operator!=(const char*        value) const { return (this->string_ != std::string(value)); }
         inline bool operator!=(const std::string& value) const { return (this->string_ != value);              }
-        bool operator!=(const MultiTypeString& mtp) const;
+        bool operator!=(const MultiTypeString& mts) const;
 
         operator std::string() const;
@@ -77 +77 @@
         inline void setValue(const char*        value) { this->type_ = MT_string; this->string_ = std::string(value); }
         inline void setValue(const std::string& value) { this->type_ = MT_string; this->string_ = value;              }
-        void setValue(const MultiTypeString& mtp);
+        void setValue(const MultiTypeString& mts);
 
         inline const std::string getString() const { return this->string_;         }