Changeset 1001 for code/branches/core2/src/util/MultiTypeString.h

Timestamp:

Apr 8, 2008, 1:51:25 AM (16 years ago)

Author:

landauf

Message:

ok, be aware, here comes a big one. people with weak nerves should probably better look away or take some serious drugs.
this update includes partial and explicit class template specialization, partial and explicit specialized template function overloading, template meta programming and a simple typecast.
yeah right, a typecast. but let me explain the whole story from the beginning.

it all started with a simple problem: i had a double in a MultiType and wanted a float, but i always got 0. what was the problem? the conversion 'MultiType to anyting' was handled by the Converter class in util/Convert.h and the Converter was specialized for strings, multitypes, vectors and so on, but not for int, float, bool, …
so i've first wanted to implement a typecast as default, but this was a bad idea because it doesn't work for almost every generic type.
implementing an explicit specialization for every possible pair of primitives (did you ever happened to use an unsigned short? or a long double? no? ignorants ) would have been a simple but ugly solution.
but there were other problems: if there's a rule to convert a string into anything and another rule to convert anything into an int - what happens if you want to convert a string into an int? compiler error! …ambiguous partial template specialization.
so i've spent days and nights to find a solution. this is my 5th try or so and i'm still really unsure if it works, but it's the first version i want to commit to have at least a backup.
if you're interested in looking at the code you better wait until i've cleaned up the whole thing, it's a real mess. and i want to do further tests, but now i'm tired. good night

File:

• code/branches/core2/src/util/MultiTypeString.h (modified) (7 diffs)

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

@@ -33 +33 @@
 #include <iostream>
 #include "UtilPrereqs.h"
-#include "XMLIncludes.h"
-#include "tinyxml/ticpp.h"
 
 #include "MultiTypePrimitive.h"
@@ -57 +55 @@
         inline MultiTypeString(const char*           value)   { this->setValue(value); }
         inline MultiTypeString(const std::string&    value)   { this->setValue(value); }
-        inline MultiTypeString(const orxonox::Element& value) { this->setValue(value); }
         inline MultiTypeString(const MultiTypeString& mts)    { this->setValue(mts);   }
         virtual inline ~MultiTypeString() {}
@@ -64 +61 @@
         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 orxonox::Element& value)   { this->setValue(value); return *this; }
         inline MultiTypeString& operator=(const MultiTypeString& mts)      { this->setValue(mts);   return *this; }
 
@@ -70 +66 @@
         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);              }
-        inline bool operator==(const orxonox::Element& value) const { return (&this->xmlelement_ == &value);             }
         bool operator==(const MultiTypeString& mts) const;
 
@@ -76 +71 @@
         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);              }
-        inline bool operator!=(const orxonox::Element& value) const { return (&this->xmlelement_ != &value);             }
         bool operator!=(const MultiTypeString& mts) const;
 
@@ -94 +88 @@
         virtual operator std::string()          const;
         virtual operator const char*()          const;
-        virtual operator orxonox::Element()     const;
 
         using MultiTypePrimitive::setValue;
         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;              }
-        inline void setValue(const orxonox::Element& value) { this->type_ = MT_xmlelement; this->xmlelement_ = value;              }
         void setValue(const MultiTypeString& mts);
 
         inline std::string getString()          const { return this->string_;         }
         inline const char*  getConstChar()      const { return this->string_.c_str(); }
-        inline orxonox::Element getXMLElement() const { return this->xmlelement_;     }
 
         inline std::string& getString()          { return this->string_;         }
         inline const char*  getConstChar()       { return this->string_.c_str(); }
-        inline orxonox::Element& getXMLElement() { return this->xmlelement_;     }
 
         using MultiTypePrimitive::getValue;
         inline void getValue(std::string*      variable) const { (*variable) = this->string_;         }
         inline void getValue(const char**      variable) const { (*variable) = this->string_.c_str(); }
-        inline void getValue(orxonox::Element* variable) const { (*variable) = this->xmlelement_;     }
 
         virtual std::string getTypename() const;
@@ -122 +111 @@
     protected:
         std::string      string_;
-        orxonox::Element xmlelement_;
 };