Changeset 1716 for code/branches/core3/src

Timestamp:

Sep 6, 2008, 4:21:56 PM (16 years ago)

Author:

landauf

Message:

Added new 'MultiType', replacing MultiTypePrimitive, MultiTypeString and MultiTypeMath. MultiType can hold all types MultiTypeMath was able to hold, namely all primitives, pointers, string and several math objects (vector2, 3 and 4, quaternion, colourvalue, radian, degree).

The new MultiType has a completely changed behaviour, I'll explain this on a wiki page somewhen.
But to say the most important things in a few words:
The MultiType has a fixed type. This type is determined by the first assigned value (by using setValue(value), operator=(value) or MultiType(value)). Every other value getting assigned later, will be converted to the first type. But you can change the type (setType<T>()), convert the value (convert<T>()) or force the type of a newly assigned value manually (setValue<T>(value)) by using template functions.

In contrast, the old MultiTypeMath changed it's internal type whenever a new type was assigned. So be aware of this important change.

At the moment I can't see any issues, but there might very well be several problems yet to discover, so further tests will be done.

Location:

code/branches/core3/src

Files:

• core/CommandEvaluation.cc (modified) (3 diffs)
• core/CommandEvaluation.h (modified) (3 diffs)
• core/ConfigValueContainer.cc (modified) (15 diffs)
• core/ConfigValueContainer.h (modified) (6 diffs)
• core/ConsoleCommand.h (modified) (1 diff)
• core/Executor.cc (modified) (5 diffs)
• core/Executor.h (modified) (8 diffs)
• core/Functor.h (modified) (11 diffs)
• core/XMLPort.h (modified) (8 diffs)
• core/input/InputManager.cc (modified) (1 diff)
• util/CMakeLists.txt (modified) (1 diff)
• util/Convert.h (modified) (3 diffs)
• util/MultiType.cc (added)
• util/MultiType.h (modified) (3 diffs)
• util/MultiTypeMath.cc (deleted)
• util/MultiTypeMath.h (deleted)
• util/MultiTypePrimitive.cc (deleted)
• util/MultiTypePrimitive.h (deleted)
• util/MultiTypeString.cc (deleted)
• util/MultiTypeString.h (deleted)
• util/MultiTypeValue.h (added)
• util/OutputBuffer.h (modified) (1 diff)
• util/UtilPrereqs.h (modified) (1 diff)

code/branches/core3/src/core/CommandEvaluation.cc

@@ -218 +218 @@
     }
 
-    void CommandEvaluation::setEvaluatedParameter(unsigned int index, MultiTypeMath param)
+    void CommandEvaluation::setEvaluatedParameter(unsigned int index, MultiType param)
     {
         if (index >= 0 && index < MAX_FUNCTOR_ARGUMENTS)
@@ -224 +224 @@
     }
 
-    MultiTypeMath CommandEvaluation::getEvaluatedParameter(unsigned int index) const
+    MultiType CommandEvaluation::getEvaluatedParameter(unsigned int index) const
     {
         if (index >= 0 && index < MAX_FUNCTOR_ARGUMENTS)
@@ -240 +240 @@
     }
 
-    MultiTypeMath CommandEvaluation::getReturnvalue() const
+    MultiType CommandEvaluation::getReturnvalue() const
     {
         if (this->function_)
             return this->function_->getReturnvalue();
 
-        return MultiTypeMath();
+        return MultiType();
     }
 

code/branches/core3/src/core/CommandEvaluation.h

@@ -37 +37 @@
 #include "ArgumentCompletionListElement.h"
 #include "util/SubString.h"
-#include "util/MultiTypeMath.h"
+#include "util/MultiType.h"
 
 namespace orxonox
@@ -81 +81 @@
                 { return (this->additionalParameter_ != "") ? (" " + this->additionalParameter_) : ""; }
 
-            void setEvaluatedParameter(unsigned int index, MultiTypeMath param);
-            MultiTypeMath getEvaluatedParameter(unsigned int index) const;
+            void setEvaluatedParameter(unsigned int index, MultiType param);
+            MultiType getEvaluatedParameter(unsigned int index) const;
 
             bool hasReturnvalue() const;
-            MultiTypeMath getReturnvalue() const;
+            MultiType getReturnvalue() const;
 
         private:
@@ -115 +115 @@
 
             bool bEvaluatedParams_;
-            MultiTypeMath param_[5];
+            MultiType param_[5];
     };
 }

code/branches/core3/src/core/ConfigValueContainer.cc

@@ -64 +64 @@
         @brief Does some special initialization for single config-values.
     */
-    void ConfigValueContainer::initValue(const MultiTypeMath& defvalue)
+    void ConfigValueContainer::initValue(const MultiType& defvalue)
     {
         this->value_ = defvalue;
@@ -82 +82 @@
         for (unsigned int i = 0; i < this->valueVector_.size(); i++)
         {
-            ConfigFileManager::getInstance()->getValue(this->type_, this->sectionname_, this->varname_, i, this->valueVector_[i].toString(), this->value_.isA(MT_string));
-            this->defvalueStringVector_.push_back(this->valueVector_[i].toString());
+            ConfigFileManager::getInstance()->getValue(this->type_, this->sectionname_, this->varname_, i, this->valueVector_[i], this->value_.isType(MT_string));
+            this->defvalueStringVector_.push_back(this->valueVector_[i]);
         }
 
@@ -103 +103 @@
         @return True if the new value was successfully assigned
     */
-    bool ConfigValueContainer::set(const MultiTypeMath& input)
-    {
-        if (this->bIsVector_)
-        {
-            return this->callFunctionWithIndex(&ConfigValueContainer::set, input.toString());
+    bool ConfigValueContainer::set(const MultiType& input)
+    {
+        if (this->bIsVector_)
+        {
+            return this->callFunctionWithIndex(&ConfigValueContainer::set, input);
         }
         else
@@ -113 +113 @@
             if (this->tset(input))
             {
-                ConfigFileManager::getInstance()->setValue(this->type_, this->sectionname_, this->varname_, input.toString(), this->value_.isA(MT_string));
+                ConfigFileManager::getInstance()->setValue(this->type_, this->sectionname_, this->varname_, input, this->value_.isType(MT_string));
                 return true;
             }
@@ -126 +126 @@
         @return True if the new value was successfully assigned
     */
-    bool ConfigValueContainer::set(unsigned int index, const MultiTypeMath& input)
+    bool ConfigValueContainer::set(unsigned int index, const MultiType& input)
     {
         if (this->bIsVector_)
@@ -132 +132 @@
             if (this->tset(index, input))
             {
-                ConfigFileManager::getInstance()->setValue(this->type_, this->sectionname_, this->varname_, index, input.toString(), this->value_.isA(MT_string));
+                ConfigFileManager::getInstance()->setValue(this->type_, this->sectionname_, this->varname_, index, input, this->value_.isType(MT_string));
                 return true;
             }
@@ -148 +148 @@
         @return True if the new value was successfully assigned
     */
-    bool ConfigValueContainer::tset(const MultiTypeMath& input)
-    {
-        if (this->bIsVector_)
-        {
-            return this->callFunctionWithIndex(&ConfigValueContainer::tset, input.toString());
-        }
-        else
-        {
-            MultiTypeMath temp = this->value_;
-            if (temp.assimilate(input))
-            {
-                this->value_ = temp;
+    bool ConfigValueContainer::tset(const MultiType& input)
+    {
+        if (this->bIsVector_)
+        {
+            return this->callFunctionWithIndex(&ConfigValueContainer::tset, input);
+        }
+        else
+        {
+//            MultiType temp = this->value_;
+//            if (temp.assimilate(input))
+//            {
+//                this->value_ = temp;
+                this->value_ = input;
                 if (this->identifier_)
                     this->identifier_->updateConfigValues();
 
                 return true;
-            }
+//            }
         }
         return false;
@@ -175 +176 @@
         @return True if the new value was successfully assigned
     */
-    bool ConfigValueContainer::tset(unsigned int index, const MultiTypeMath& input)
+    bool ConfigValueContainer::tset(unsigned int index, const MultiType& input)
     {
         if (this->bIsVector_)
@@ -189 +190 @@
                 for (unsigned int i = this->valueVector_.size(); i <= index; i++)
                 {
-                    this->valueVector_.push_back(MultiTypeMath());
+                    this->valueVector_.push_back(MultiType());
                 }
             }
 
-            MultiTypeMath temp = this->value_;
-            if (temp.assimilate(input))
-            {
-                this->valueVector_[index] = temp;
+//            MultiType temp = this->value_;
+//            if (temp.assimilate(input))
+//            {
+//                this->valueVector_[index] = temp;
+                this->valueVector_[index] = input;
 
                 if (this->identifier_)
@@ -202 +204 @@
 
                 return true;
-            }
+//            }
         }
         else
@@ -216 +218 @@
         @return True if the new entry was successfully added
     */
-    bool ConfigValueContainer::add(const MultiTypeMath& input)
+    bool ConfigValueContainer::add(const MultiType& input)
     {
         if (this->bIsVector_)
@@ -239 +241 @@
                 this->valueVector_.erase(this->valueVector_.begin() + index);
                 for (unsigned int i = index; i < this->valueVector_.size(); i++)
-                    ConfigFileManager::getInstance()->setValue(this->type_, this->sectionname_, this->varname_, i, this->valueVector_[i], this->value_.isA(MT_string));
+                    ConfigFileManager::getInstance()->setValue(this->type_, this->sectionname_, this->varname_, i, this->valueVector_[i], this->value_.isType(MT_string));
                 ConfigFileManager::getInstance()->deleteVectorEntries(this->type_, this->sectionname_, this->varname_, this->valueVector_.size());
 
@@ -275 +277 @@
     {
         if (!this->bIsVector_)
-            this->value_.fromString(ConfigFileManager::getInstance()->getValue(this->type_, this->sectionname_, this->varname_, this->defvalueString_, this->value_.isA(MT_string)));
+            this->value_ = ConfigFileManager::getInstance()->getValue(this->type_, this->sectionname_, this->varname_, this->defvalueString_, this->value_.isType(MT_string));
         else
         {
@@ -283 +285 @@
                 if (i < this->defvalueStringVector_.size())
                 {
-                    this->value_.fromString(ConfigFileManager::getInstance()->getValue(this->type_, this->sectionname_, this->varname_, i, this->defvalueStringVector_[i], this->value_.isA(MT_string)));
+                    this->value_ = ConfigFileManager::getInstance()->getValue(this->type_, this->sectionname_, this->varname_, i, this->defvalueStringVector_[i], this->value_.isType(MT_string));
                 }
                 else
                 {
-                    this->value_.fromString(ConfigFileManager::getInstance()->getValue(this->type_, this->sectionname_, this->varname_, i, MultiTypeMath(), this->value_.isA(MT_string)));
+                    this->value_ = ConfigFileManager::getInstance()->getValue(this->type_, this->sectionname_, this->varname_, i, MultiType(), this->value_.isType(MT_string));
                 }
 
@@ -301 +303 @@
         @return The returnvalue of the functioncall
     */
-    bool ConfigValueContainer::callFunctionWithIndex(bool (ConfigValueContainer::* function) (unsigned int, const MultiTypeMath&), const std::string& input)
+    bool ConfigValueContainer::callFunctionWithIndex(bool (ConfigValueContainer::* function) (unsigned int, const MultiType&), const std::string& input)
     {
         SubString token(input, " ", SubString::WhiteSpaces, true, '\\', false, '"', false, '(', ')', false, '\0');

code/branches/core3/src/core/ConfigValueContainer.h

@@ -50 +50 @@
 
 #include "util/Math.h"
-#include "util/MultiTypeMath.h"
+#include "util/MultiType.h"
 #include "ConfigFileManager.h"
 
@@ -124 +124 @@
                 this->value_ = V();
                 for (unsigned int i = 0; i < defvalue.size(); i++)
-                    this->valueVector_.push_back(MultiTypeMath(defvalue[i]));
+                    this->valueVector_.push_back(MultiType(defvalue[i]));
 
                 this->initVector();
@@ -247 +247 @@
             }
 
-            bool set(const MultiTypeMath& input);
-            bool tset(const MultiTypeMath& input);
-
-            bool set(unsigned int index, const MultiTypeMath& input);
-            bool tset(unsigned int index, const MultiTypeMath& input);
-            bool add(const MultiTypeMath& input);
+            bool set(const MultiType& input);
+            bool tset(const MultiType& input);
+
+            bool set(unsigned int index, const MultiType& input);
+            bool tset(unsigned int index, const MultiType& input);
+            bool add(const MultiType& input);
             bool remove(unsigned int index);
 
@@ -260 +260 @@
             /** @brief Converts the config-value to a string. @return The string */
             inline std::string toString() const
-                { return this->value_.toString(); }
+                { return this->value_; }
             /** @brief Returns the typename of the assigned config-value. @return The typename */
             inline std::string getTypename() const
@@ -267 +267 @@
         private:
             void init(ConfigFileType type, Identifier* identifier, const std::string& varname);
-            void initValue(const MultiTypeMath& defvalue);
+            void initValue(const MultiType& defvalue);
             void initVector();
-            bool callFunctionWithIndex(bool (ConfigValueContainer::* function) (unsigned int, const MultiTypeMath&), const std::string& input);
+            bool callFunctionWithIndex(bool (ConfigValueContainer::* function) (unsigned int, const MultiType&), const std::string& input);
 
             bool                       bIsVector_;                  //!< True if the container contains a std::vector
@@ -280 +280 @@
             std::vector<std::string>   defvalueStringVector_;       //!< A vector, containg the strings of the default-values in case we're storing a vector
 
-            MultiTypeMath              value_;                      //!< The value
-            std::vector<MultiTypeMath> valueVector_;                //!< A vector, containg the values in case we're storing a vector
+            MultiType                  value_;                      //!< The value
+            std::vector<MultiType>     valueVector_;                //!< A vector, containg the values in case we're storing a vector
 
             bool                       bAddedDescription_;          //!< True if a description was added

code/branches/core3/src/core/ConsoleCommand.h

@@ -93 +93 @@
             inline ConsoleCommand& descriptionReturnvalue(const std::string& description)
                 { this->ExecutorStatic::setDescriptionReturnvalue(description); return (*this); }
-            inline ConsoleCommand& defaultValues(const MultiTypeMath& param1)
+            inline ConsoleCommand& defaultValues(const MultiType& param1)
                 { this->ExecutorStatic::setDefaultValues(param1); return (*this); }
-            inline ConsoleCommand& defaultValues(const MultiTypeMath& param1, const MultiTypeMath& param2)
+            inline ConsoleCommand& defaultValues(const MultiType& param1, const MultiType& param2)
                 { this->ExecutorStatic::setDefaultValues(param1, param2); return (*this); }
-            inline ConsoleCommand& defaultValues(const MultiTypeMath& param1, const MultiTypeMath& param2, const MultiTypeMath& param3)
+            inline ConsoleCommand& defaultValues(const MultiType& param1, const MultiType& param2, const MultiType& param3)
                 { this->ExecutorStatic::setDefaultValues(param1, param2, param3); return (*this); }
-            inline ConsoleCommand& defaultValues(const MultiTypeMath& param1, const MultiTypeMath& param2, const MultiTypeMath& param3, const MultiTypeMath& param4)
+            inline ConsoleCommand& defaultValues(const MultiType& param1, const MultiType& param2, const MultiType& param3, const MultiType& param4)
                 { this->ExecutorStatic::setDefaultValues(param1, param2, param3, param4); return (*this); }
-            inline ConsoleCommand& defaultValues(const MultiTypeMath& param1, const MultiTypeMath& param2, const MultiTypeMath& param3, const MultiTypeMath& param4, const MultiTypeMath& param5)
+            inline ConsoleCommand& defaultValues(const MultiType& param1, const MultiType& param2, const MultiType& param3, const MultiType& param4, const MultiType& param5)
                 { this->ExecutorStatic::setDefaultValues(param1, param2, param3, param4, param5); return (*this); }
-            inline ConsoleCommand& defaultValue(unsigned int index, const MultiTypeMath& param)
+            inline ConsoleCommand& defaultValue(unsigned int index, const MultiType& param)
                 { this->ExecutorStatic::setDefaultValue(index, param); return (*this); }
 

code/branches/core3/src/core/Executor.cc

@@ -65 +65 @@
     }
 
-    bool Executor::evaluate(const std::string& params, MultiTypeMath param[5], const std::string& delimiter) const
+    bool Executor::evaluate(const std::string& params, MultiType param[5], const std::string& delimiter) const
     {
         unsigned int paramCount = this->functor_->getParamCount();
@@ -171 +171 @@
     }
 
-    Executor& Executor::setDefaultValues(const MultiTypeMath& param1)
-    {
-        this->defaultValue_[0] = param1;
-        this->bAddedDefaultValue_[0] = true;
-
-        return (*this);
-    }
-
-    Executor& Executor::setDefaultValues(const MultiTypeMath& param1, const MultiTypeMath& param2)
-    {
-        this->defaultValue_[0] = param1;
-        this->bAddedDefaultValue_[0] = true;
-        this->defaultValue_[1] = param2;
-        this->bAddedDefaultValue_[1] = true;
-
-        return (*this);
-    }
-
-    Executor& Executor::setDefaultValues(const MultiTypeMath& param1, const MultiTypeMath& param2, const MultiTypeMath& param3)
+    Executor& Executor::setDefaultValues(const MultiType& param1)
+    {
+        this->defaultValue_[0] = param1;
+        this->bAddedDefaultValue_[0] = true;
+
+        return (*this);
+    }
+
+    Executor& Executor::setDefaultValues(const MultiType& param1, const MultiType& param2)
+    {
+        this->defaultValue_[0] = param1;
+        this->bAddedDefaultValue_[0] = true;
+        this->defaultValue_[1] = param2;
+        this->bAddedDefaultValue_[1] = true;
+
+        return (*this);
+    }
+
+    Executor& Executor::setDefaultValues(const MultiType& param1, const MultiType& param2, const MultiType& param3)
     {
         this->defaultValue_[0] = param1;
@@ -201 +201 @@
     }
 
-    Executor& Executor::setDefaultValues(const MultiTypeMath& param1, const MultiTypeMath& param2, const MultiTypeMath& param3, const MultiTypeMath& param4)
+    Executor& Executor::setDefaultValues(const MultiType& param1, const MultiType& param2, const MultiType& param3, const MultiType& param4)
     {
         this->defaultValue_[0] = param1;
@@ -215 +215 @@
     }
 
-    Executor& Executor::setDefaultValues(const MultiTypeMath& param1, const MultiTypeMath& param2, const MultiTypeMath& param3, const MultiTypeMath& param4, const MultiTypeMath& param5)
+    Executor& Executor::setDefaultValues(const MultiType& param1, const MultiType& param2, const MultiType& param3, const MultiType& param4, const MultiType& param5)
     {
         this->defaultValue_[0] = param1;
@@ -231 +231 @@
     }
 
-    Executor& Executor::setDefaultValue(unsigned int index, const MultiTypeMath& param)
+    Executor& Executor::setDefaultValue(unsigned int index, const MultiType& param)
     {
         if (index >= 0 && index < MAX_FUNCTOR_ARGUMENTS)

code/branches/core3/src/core/Executor.h

@@ -64 +64 @@
         { \
             COUT(5) << "Calling Executor " << this->name_ << " through parser with one parameter, using whole string: " << params << std::endl; \
-            EXECUTOR_PARSE_FUNCTORCALL(mode)(EXECUTOR_PARSE_OBJECT(mode, 1) MultiTypeMath(params)); \
+            EXECUTOR_PARSE_FUNCTORCALL(mode)(EXECUTOR_PARSE_OBJECT(mode, 1) MultiType(params)); \
         } \
         else if (this->bAddedDefaultValue_[0]) \
@@ -90 +90 @@
         } \
         \
-        MultiTypeMath param[MAX_FUNCTOR_ARGUMENTS]; \
+        MultiType param[MAX_FUNCTOR_ARGUMENTS]; \
         COUT(5) << "Calling Executor " << this->name_ << " through parser with " << paramCount << " parameters, using " << tokens.size() << " tokens ("; \
         for (unsigned int i = 0; i < tokens.size() && i < MAX_FUNCTOR_ARGUMENTS; i++) \
@@ -145 +145 @@
             inline void operator()() const
                 { (*this->functor_)(this->defaultValue_[0], this->defaultValue_[1], this->defaultValue_[2], this->defaultValue_[3], this->defaultValue_[4]); }
-            inline void operator()(const MultiTypeMath& param1) const
+            inline void operator()(const MultiType& param1) const
                 { (*this->functor_)(param1, this->defaultValue_[1], this->defaultValue_[2], this->defaultValue_[3], this->defaultValue_[4]); }
-            inline void operator()(const MultiTypeMath& param1, const MultiTypeMath& param2) const
+            inline void operator()(const MultiType& param1, const MultiType& param2) const
                 { (*this->functor_)(param1, param2, this->defaultValue_[2], this->defaultValue_[3], this->defaultValue_[4]); }
-            inline void operator()(const MultiTypeMath& param1, const MultiTypeMath& param2, const MultiTypeMath& param3) const
+            inline void operator()(const MultiType& param1, const MultiType& param2, const MultiType& param3) const
                 { (*this->functor_)(param1, param2, param3, this->defaultValue_[3], this->defaultValue_[4]); }
-            inline void operator()(const MultiTypeMath& param1, const MultiTypeMath& param2, const MultiTypeMath& param3, const MultiTypeMath& param4) const
+            inline void operator()(const MultiType& param1, const MultiType& param2, const MultiType& param3, const MultiType& param4) const
                 { (*this->functor_)(param1, param2, param3, param4, this->defaultValue_[4]); }
-            inline void operator()(const MultiTypeMath& param1, const MultiTypeMath& param2, const MultiTypeMath& param3, const MultiTypeMath& param4, const MultiTypeMath& param5) const
+            inline void operator()(const MultiType& param1, const MultiType& param2, const MultiType& param3, const MultiType& param4, const MultiType& param5) const
                 { (*this->functor_)(param1, param2, param3, param4, param5); }
 
             bool parse(const std::string& params, const std::string& delimiter = " ") const;
 
-            bool evaluate(const std::string& params, MultiTypeMath param[5], const std::string& delimiter = " ") const;
+            bool evaluate(const std::string& params, MultiType param[5], const std::string& delimiter = " ") const;
 
             Executor& setDescription(const std::string& description);
@@ -177 +177 @@
             inline FunctionType getType() const
                 { return this->functor_->getType(); }
-            inline MultiTypeMath getReturnvalue() const
+            inline MultiType getReturnvalue() const
                 { return this->functor_->getReturnvalue(); }
             inline std::string getTypenameParam(unsigned int param) const
@@ -189 +189 @@
                 { return this->name_; }
 
-            Executor& setDefaultValues(const MultiTypeMath& param1);
-            Executor& setDefaultValues(const MultiTypeMath& param1, const MultiTypeMath& param2);
-            Executor& setDefaultValues(const MultiTypeMath& param1, const MultiTypeMath& param2, const MultiTypeMath& param3);
-            Executor& setDefaultValues(const MultiTypeMath& param1, const MultiTypeMath& param2, const MultiTypeMath& param3, const MultiTypeMath& param4);
-            Executor& setDefaultValues(const MultiTypeMath& param1, const MultiTypeMath& param2, const MultiTypeMath& param3, const MultiTypeMath& param4, const MultiTypeMath& param5);
-            Executor& setDefaultValue(unsigned int index, const MultiTypeMath& param);
-
-            inline MultiTypeMath getDefaultValue(unsigned int index) const
+            Executor& setDefaultValues(const MultiType& param1);
+            Executor& setDefaultValues(const MultiType& param1, const MultiType& param2);
+            Executor& setDefaultValues(const MultiType& param1, const MultiType& param2, const MultiType& param3);
+            Executor& setDefaultValues(const MultiType& param1, const MultiType& param2, const MultiType& param3, const MultiType& param4);
+            Executor& setDefaultValues(const MultiType& param1, const MultiType& param2, const MultiType& param3, const MultiType& param4, const MultiType& param5);
+            Executor& setDefaultValue(unsigned int index, const MultiType& param);
+
+            inline MultiType getDefaultValue(unsigned int index) const
             {
                 if (index >= 0 && index < MAX_FUNCTOR_ARGUMENTS)
@@ -216 +216 @@
             Functor* functor_;
             std::string name_;
-            MultiTypeMath defaultValue_[MAX_FUNCTOR_ARGUMENTS];
+            MultiType defaultValue_[MAX_FUNCTOR_ARGUMENTS];
             bool bAddedDefaultValue_[MAX_FUNCTOR_ARGUMENTS];
 
@@ -245 +245 @@
             inline void operator()(T* object) const
                 { (*((FunctorMember<T>*)this->functor_))(object, this->defaultValue_[0], this->defaultValue_[1], this->defaultValue_[2], this->defaultValue_[3], this->defaultValue_[4]); }
-            inline void operator()(T* object, const MultiTypeMath& param1) const
+            inline void operator()(T* object, const MultiType& param1) const
                 { (*((FunctorMember<T>*)this->functor_))(object, param1, this->defaultValue_[1], this->defaultValue_[2], this->defaultValue_[3], this->defaultValue_[4]); }
-            inline void operator()(T* object, const MultiTypeMath& param1, const MultiTypeMath& param2) const
+            inline void operator()(T* object, const MultiType& param1, const MultiType& param2) const
                 { (*((FunctorMember<T>*)this->functor_))(object, param1, param2, this->defaultValue_[2], this->defaultValue_[3], this->defaultValue_[4]); }
-            inline void operator()(T* object, const MultiTypeMath& param1, const MultiTypeMath& param2, const MultiTypeMath& param3) const
+            inline void operator()(T* object, const MultiType& param1, const MultiType& param2, const MultiType& param3) const
                 { (*((FunctorMember<T>*)this->functor_))(object, param1, param2, param3, this->defaultValue_[3], this->defaultValue_[4]); }
-            inline void operator()(T* object, const MultiTypeMath& param1, const MultiTypeMath& param2, const MultiTypeMath& param3, const MultiTypeMath& param4) const
+            inline void operator()(T* object, const MultiType& param1, const MultiType& param2, const MultiType& param3, const MultiType& param4) const
                 { (*((FunctorMember<T>*)this->functor_))(object, param1, param2, param3, param4, this->defaultValue_[4]); }
-            inline void operator()(T* object, const MultiTypeMath& param1, const MultiTypeMath& param2, const MultiTypeMath& param3, const MultiTypeMath& param4, const MultiTypeMath& param5) const
+            inline void operator()(T* object, const MultiType& param1, const MultiType& param2, const MultiType& param3, const MultiType& param4, const MultiType& param5) const
                 { (*((FunctorMember<T>*)this->functor_))(object, param1, param2, param3, param4, param5); }
 
@@ -259 +259 @@
             inline void operator()(const T* object) const
                 { (*((FunctorMember<T>*)this->functor_))(object, this->defaultValue_[0], this->defaultValue_[1], this->defaultValue_[2], this->defaultValue_[3], this->defaultValue_[4]); }
-            inline void operator()(const T* object, const MultiTypeMath& param1) const
+            inline void operator()(const T* object, const MultiType& param1) const
                 { (*((FunctorMember<T>*)this->functor_))(object, param1, this->defaultValue_[1], this->defaultValue_[2], this->defaultValue_[3], this->defaultValue_[4]); }
-            inline void operator()(const T* object, const MultiTypeMath& param1, const MultiTypeMath& param2) const
+            inline void operator()(const T* object, const MultiType& param1, const MultiType& param2) const
                 { (*((FunctorMember<T>*)this->functor_))(object, param1, param2, this->defaultValue_[2], this->defaultValue_[3], this->defaultValue_[4]); }
-            inline void operator()(const T* object, const MultiTypeMath& param1, const MultiTypeMath& param2, const MultiTypeMath& param3) const
+            inline void operator()(const T* object, const MultiType& param1, const MultiType& param2, const MultiType& param3) const
                 { (*((FunctorMember<T>*)this->functor_))(object, param1, param2, param3, this->defaultValue_[3], this->defaultValue_[4]); }
-            inline void operator()(const T* object, const MultiTypeMath& param1, const MultiTypeMath& param2, const MultiTypeMath& param3, const MultiTypeMath& param4) const
+            inline void operator()(const T* object, const MultiType& param1, const MultiType& param2, const MultiType& param3, const MultiType& param4) const
                 { (*((FunctorMember<T>*)this->functor_))(object, param1, param2, param3, param4, this->defaultValue_[4]); }
-            inline void operator()(const T* object, const MultiTypeMath& param1, const MultiTypeMath& param2, const MultiTypeMath& param3, const MultiTypeMath& param4, const MultiTypeMath& param5) const
+            inline void operator()(const T* object, const MultiType& param1, const MultiType& param2, const MultiType& param3, const MultiType& param4, const MultiType& param5) const
                 { (*((FunctorMember<T>*)this->functor_))(object, param1, param2, param3, param4, param5); }
 

code/branches/core3/src/core/Functor.h

@@ -33 +33 @@
 #include "CorePrereqs.h"
 
-#include "util/MultiTypeMath.h"
+#include "util/MultiType.h"
 #include "util/Debug.h"
 
@@ -95 +95 @@
             virtual ~Functor() {}
 
-            virtual void operator()(const MultiTypeMath& param1 = MT_null, const MultiTypeMath& param2 = MT_null, const MultiTypeMath& param3 = MT_null, const MultiTypeMath& param4 = MT_null, const MultiTypeMath& param5 = MT_null) = 0;
+            virtual void operator()(const MultiType& param1 = MT_null, const MultiType& param2 = MT_null, const MultiType& param3 = MT_null, const MultiType& param4 = MT_null, const MultiType& param5 = MT_null) = 0;
 
             inline unsigned int getParamCount() const { return this->numParams_; }
             inline bool hasReturnvalue() const { return this->hasReturnValue_; }
             inline FunctionType getType() const { return this->type_; }
-            inline MultiTypeMath getReturnvalue() const { return this->returnedValue_; }
+            inline MultiType getReturnvalue() const { return this->returnedValue_; }
 
             std::string getTypenameParam(unsigned int param) const { return (param >= 0 && param < 5) ? this->typeParam_[param] : ""; }
             std::string getTypenameReturnvalue() const { return this->typeReturnvalue_; }
 
-            virtual void evaluateParam(unsigned int index, MultiTypeMath& param) const = 0;
+            virtual void evaluateParam(unsigned int index, MultiType& param) const = 0;
 
         protected:
@@ -111 +111 @@
             bool hasReturnValue_;
             FunctionType type_;
-            MultiTypeMath returnedValue_;
+            MultiType returnedValue_;
 
             std::string typeReturnvalue_;
@@ -121 +121 @@
         public:
             virtual ~FunctorStatic() {}
-            virtual void operator()(const MultiTypeMath& param1 = MT_null, const MultiTypeMath& param2 = MT_null, const MultiTypeMath& param3 = MT_null, const MultiTypeMath& param4 = MT_null, const MultiTypeMath& param5 = MT_null) = 0;
+            virtual void operator()(const MultiType& param1 = MT_null, const MultiType& param2 = MT_null, const MultiType& param3 = MT_null, const MultiType& param4 = MT_null, const MultiType& param5 = MT_null) = 0;
     };
 
@@ -136 +136 @@
             virtual ~FunctorMember() {}
 
-            virtual void operator()(T* object, const MultiTypeMath& param1 = MT_null, const MultiTypeMath& param2 = MT_null, const MultiTypeMath& param3 = MT_null, const MultiTypeMath& param4 = MT_null, const MultiTypeMath& param5 = MT_null) = 0;
-            virtual void operator()(const T* object, const MultiTypeMath& param1 = MT_null, const MultiTypeMath& param2 = MT_null, const MultiTypeMath& param3 = MT_null, const MultiTypeMath& param4 = MT_null, const MultiTypeMath& param5 = MT_null) = 0;
-
-            virtual void operator()(const MultiTypeMath& param1 = MT_null, const MultiTypeMath& param2 = MT_null, const MultiTypeMath& param3 = MT_null, const MultiTypeMath& param4 = MT_null, const MultiTypeMath& param5 = MT_null)
+            virtual void operator()(T* object, const MultiType& param1 = MT_null, const MultiType& param2 = MT_null, const MultiType& param3 = MT_null, const MultiType& param4 = MT_null, const MultiType& param5 = MT_null) = 0;
+            virtual void operator()(const T* object, const MultiType& param1 = MT_null, const MultiType& param2 = MT_null, const MultiType& param3 = MT_null, const MultiType& param4 = MT_null, const MultiType& param5 = MT_null) = 0;
+
+            virtual void operator()(const MultiType& param1 = MT_null, const MultiType& param2 = MT_null, const MultiType& param3 = MT_null, const MultiType& param4 = MT_null, const MultiType& param5 = MT_null)
             {
                 if (this->bConstObject_)
@@ -280 +280 @@
 
 
-
+/*
 #define FUNCTOR_EVALUATE_PARAM(numparams) FUNCTOR_EVALUATE_PARAM##numparams
 #define FUNCTOR_EVALUATE_PARAM0
@@ -303 +303 @@
     else if (index == 3) { P4 temp = param; param = temp; } \
     else if (index == 4) { P5 temp = param; param = temp; }
-
+*/
+#define FUNCTOR_EVALUATE_PARAM(numparams) FUNCTOR_EVALUATE_PARAM##numparams
+#define FUNCTOR_EVALUATE_PARAM0
+#define FUNCTOR_EVALUATE_PARAM1 \
+    if (index == 0) { param.convert<P1>(); }
+#define FUNCTOR_EVALUATE_PARAM2 \
+    if (index == 0) { param.convert<P1>(); } \
+    else if (index == 1) { param.convert<P2>(); }
+#define FUNCTOR_EVALUATE_PARAM3 \
+    if (index == 0) { param.convert<P1>(); } \
+    else if (index == 1) { param.convert<P2>(); } \
+    else if (index == 2) { param.convert<P3>(); }
+#define FUNCTOR_EVALUATE_PARAM4 \
+    if (index == 0) { param.convert<P1>(); } \
+    else if (index == 1) { param.convert<P2>(); } \
+    else if (index == 2) { param.convert<P3>(); } \
+    else if (index == 3) { param.convert<P4>(); }
+#define FUNCTOR_EVALUATE_PARAM5 \
+    if (index == 0) { param.convert<P1>(); } \
+    else if (index == 1) { param.convert<P2>(); } \
+    else if (index == 2) { param.convert<P3>(); } \
+    else if (index == 3) { param.convert<P4>(); } \
+    else if (index == 4) { param.convert<P5>(); }
 
 
@@ -324 +346 @@
             } \
     \
-            void operator()(const MultiTypeMath& param1 = MT_null, const MultiTypeMath& param2 = MT_null, const MultiTypeMath& param3 = MT_null, const MultiTypeMath& param4 = MT_null, const MultiTypeMath& param5 = MT_null) \
+            void operator()(const MultiType& param1 = MT_null, const MultiType& param2 = MT_null, const MultiType& param3 = MT_null, const MultiType& param4 = MT_null, const MultiType& param5 = MT_null) \
             { \
                 FUNCTOR_STORE_RETURNVALUE(returnvalue, (*this->functionPointer_)(FUNCTOR_FUNCTION_CALL(numparams))); \
             } \
     \
-            virtual void evaluateParam(unsigned int index, MultiTypeMath& param) const \
+            virtual void evaluateParam(unsigned int index, MultiType& param) const \
             { \
                 FUNCTOR_EVALUATE_PARAM(numparams); \
@@ -362 +384 @@
             } \
     \
-            void operator()(T* object, const MultiTypeMath& param1 = MT_null, const MultiTypeMath& param2 = MT_null, const MultiTypeMath& param3 = MT_null, const MultiTypeMath& param4 = MT_null, const MultiTypeMath& param5 = MT_null) \
+            void operator()(T* object, const MultiType& param1 = MT_null, const MultiType& param2 = MT_null, const MultiType& param3 = MT_null, const MultiType& param4 = MT_null, const MultiType& param5 = MT_null) \
             { \
                 FUNCTOR_STORE_RETURNVALUE(returnvalue, (*object.*this->functionPointer_)(FUNCTOR_FUNCTION_CALL(numparams))); \
             } \
     \
-            void operator()(const T* object, const MultiTypeMath& param1 = MT_null, const MultiTypeMath& param2 = MT_null, const MultiTypeMath& param3 = MT_null, const MultiTypeMath& param4 = MT_null, const MultiTypeMath& param5 = MT_null) \
+            void operator()(const T* object, const MultiType& param1 = MT_null, const MultiType& param2 = MT_null, const MultiType& param3 = MT_null, const MultiType& param4 = MT_null, const MultiType& param5 = MT_null) \
             { \
                 COUT(1) << "An error occurred in Functor.h:" << std::endl; \
@@ -373 +395 @@
             } \
     \
-            virtual void evaluateParam(unsigned int index, MultiTypeMath& param) const \
+            virtual void evaluateParam(unsigned int index, MultiType& param) const \
             { \
                 FUNCTOR_EVALUATE_PARAM(numparams); \
@@ -395 +417 @@
             } \
     \
-            void operator()(T* object, const MultiTypeMath& param1 = MT_null, const MultiTypeMath& param2 = MT_null, const MultiTypeMath& param3 = MT_null, const MultiTypeMath& param4 = MT_null, const MultiTypeMath& param5 = MT_null) \
+            void operator()(T* object, const MultiType& param1 = MT_null, const MultiType& param2 = MT_null, const MultiType& param3 = MT_null, const MultiType& param4 = MT_null, const MultiType& param5 = MT_null) \
             { \
                 FUNCTOR_STORE_RETURNVALUE(returnvalue, (*object.*this->functionPointer_)(FUNCTOR_FUNCTION_CALL(numparams))); \
             } \
     \
-            void operator()(const T* object, const MultiTypeMath& param1 = MT_null, const MultiTypeMath& param2 = MT_null, const MultiTypeMath& param3 = MT_null, const MultiTypeMath& param4 = MT_null, const MultiTypeMath& param5 = MT_null) \
+            void operator()(const T* object, const MultiType& param1 = MT_null, const MultiType& param2 = MT_null, const MultiType& param3 = MT_null, const MultiType& param4 = MT_null, const MultiType& param5 = MT_null) \
             { \
                 FUNCTOR_STORE_RETURNVALUE(returnvalue, (*object.*this->functionPointer_)(FUNCTOR_FUNCTION_CALL(numparams))); \
             } \
     \
-            virtual void evaluateParam(unsigned int index, MultiTypeMath& param) const \
+            virtual void evaluateParam(unsigned int index, MultiType& param) const \
             { \
                 FUNCTOR_EVALUATE_PARAM(numparams); \

code/branches/core3/src/core/XMLPort.h

@@ -34 +34 @@
 #include "util/Debug.h"
 #include "util/XMLIncludes.h"
-#include "util/MultiTypeMath.h"
+#include "util/MultiType.h"
 #include "tinyxml/ticpp.h"
 #include "Executor.h"
@@ -107 +107 @@
             virtual const std::string& getDescription() = 0;
 
-            virtual XMLPortParamContainer& defaultValue(unsigned int index, const MultiTypeMath& param) = 0;
-            virtual XMLPortParamContainer& defaultValues(const MultiTypeMath& param1) = 0;
-            virtual XMLPortParamContainer& defaultValues(const MultiTypeMath& param1, const MultiTypeMath& param2) = 0;
-            virtual XMLPortParamContainer& defaultValues(const MultiTypeMath& param1, const MultiTypeMath& param2, const MultiTypeMath& param3) = 0;
-            virtual XMLPortParamContainer& defaultValues(const MultiTypeMath& param1, const MultiTypeMath& param2, const MultiTypeMath& param3, const MultiTypeMath& param4) = 0;
-            virtual XMLPortParamContainer& defaultValues(const MultiTypeMath& param1, const MultiTypeMath& param2, const MultiTypeMath& param3, const MultiTypeMath& param4, const MultiTypeMath& param5) = 0;
+            virtual XMLPortParamContainer& defaultValue(unsigned int index, const MultiType& param) = 0;
+            virtual XMLPortParamContainer& defaultValues(const MultiType& param1) = 0;
+            virtual XMLPortParamContainer& defaultValues(const MultiType& param1, const MultiType& param2) = 0;
+            virtual XMLPortParamContainer& defaultValues(const MultiType& param1, const MultiType& param2, const MultiType& param3) = 0;
+            virtual XMLPortParamContainer& defaultValues(const MultiType& param1, const MultiType& param2, const MultiType& param3, const MultiType& param4) = 0;
+            virtual XMLPortParamContainer& defaultValues(const MultiType& param1, const MultiType& param2, const MultiType& param3, const MultiType& param4, const MultiType& param5) = 0;
 
         protected:
@@ -197 +197 @@
                 { return this->loadexecutor_->getDescription(); }
 
-            virtual XMLPortParamContainer& defaultValue(unsigned int index, const MultiTypeMath& param)
+            virtual XMLPortParamContainer& defaultValue(unsigned int index, const MultiType& param)
             {
                 if (!this->loadexecutor_->defaultValueSet(index))
@@ -203 +203 @@
                 return this->portIfWaitingForDefaultValues(this->parseResult_, this->parseParams_);
             }
-            virtual XMLPortParamContainer& defaultValues(const MultiTypeMath& param1)
+            virtual XMLPortParamContainer& defaultValues(const MultiType& param1)
             {
                 if (!this->loadexecutor_->defaultValueSet(0))
@@ -209 +209 @@
                 return this->portIfWaitingForDefaultValues(this->parseResult_, this->parseParams_);
             }
-            virtual XMLPortParamContainer& defaultValues(const MultiTypeMath& param1, const MultiTypeMath& param2)
+            virtual XMLPortParamContainer& defaultValues(const MultiType& param1, const MultiType& param2)
             {
                 if ((!this->loadexecutor_->defaultValueSet(0)) || (!this->loadexecutor_->defaultValueSet(1)))
@@ -215 +215 @@
                 return this->portIfWaitingForDefaultValues(this->parseResult_, this->parseParams_);
             }
-            virtual XMLPortParamContainer& defaultValues(const MultiTypeMath& param1, const MultiTypeMath& param2, const MultiTypeMath& param3)
+            virtual XMLPortParamContainer& defaultValues(const MultiType& param1, const MultiType& param2, const MultiType& param3)
             {
                 if ((!this->loadexecutor_->defaultValueSet(0)) || (!this->loadexecutor_->defaultValueSet(1)) || (!this->loadexecutor_->defaultValueSet(2)))
@@ -221 +221 @@
                 return this->portIfWaitingForDefaultValues(this->parseResult_, this->parseParams_);
             }
-            virtual XMLPortParamContainer& defaultValues(const MultiTypeMath& param1, const MultiTypeMath& param2, const MultiTypeMath& param3, const MultiTypeMath& param4)
+            virtual XMLPortParamContainer& defaultValues(const MultiType& param1, const MultiType& param2, const MultiType& param3, const MultiType& param4)
             {
                 if ((!this->loadexecutor_->defaultValueSet(0)) || (!this->loadexecutor_->defaultValueSet(1)) || (!this->loadexecutor_->defaultValueSet(2)) || (!this->loadexecutor_->defaultValueSet(3)))
@@ -227 +227 @@
                 return this->portIfWaitingForDefaultValues(this->parseResult_, this->parseParams_);
             }
-            virtual XMLPortParamContainer& defaultValues(const MultiTypeMath& param1, const MultiTypeMath& param2, const MultiTypeMath& param3, const MultiTypeMath& param4, const MultiTypeMath& param5)
+            virtual XMLPortParamContainer& defaultValues(const MultiType& param1, const MultiType& param2, const MultiType& param3, const MultiType& param4, const MultiType& param5)
             {
                 if ((!this->loadexecutor_->defaultValueSet(0)) || (!this->loadexecutor_->defaultValueSet(1)) || (!this->loadexecutor_->defaultValueSet(2)) || (!this->loadexecutor_->defaultValueSet(3)) || (!this->loadexecutor_->defaultValueSet(4)))

code/branches/core3/src/core/input/InputManager.cc

@@ -321 +321 @@
     if (joySticksSize_)
     {
-      std::vector<MultiTypeMath> coeffPos;
-      std::vector<MultiTypeMath> coeffNeg;
-      std::vector<MultiTypeMath> zero;
+      std::vector<double> coeffPos;
+      std::vector<double> coeffNeg;
+      std::vector<int> zero;
       coeffPos.resize(24);
       coeffNeg.resize(24);

code/branches/core3/src/util/CMakeLists.txt

@@ -5 +5 @@
   ExprParser.cc
   Math.cc
-  MultiTypePrimitive.cc
-  MultiTypeString.cc
-  MultiTypeMath.cc
+  MultiType.cc
   OutputBuffer.cc
   OutputHandler.cc

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

@@ -43 +43 @@
 #include "Debug.h"
 #include "SubString.h"
-#include "MultiTypeMath.h"
+//#include "MultiTypeMath.h"
 
 // disable annoying warning about forcing value to boolean
@@ -323 +323 @@
 // MULTITYPES //
 ////////////////
-
+/*
 // convert from MultiTypePrimitive
 template <class ToType>
@@ -403 +403 @@
     }
 };
-
+*/
 
 ////////////////////

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

@@ -25 +25 @@
  *      ...
  *
- *   Inspiration: MultiType by Benjamin Grauer
  */
 
@@ -33 +32 @@
 #include "UtilPrereqs.h"
 
-enum _UtilExport MultiType
+#include <boost/static_assert.hpp>
+
+#include "Math.h"
+
+// disable annoying warning about multiple assignment operators
+#if ORXONOX_COMPILER == ORXONOX_COMPILER_MSVC
+#pragma warning(push)
+#pragma warning(disable:4522)
+#endif
+
+enum _UtilExport MT_Type
 {
     MT_null,
-    MT_void,
-    MT_int,
-    MT_uint,
     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_constchar,
+    MT_void,
     MT_string,
-    MT_xmlelement,
     MT_vector2,
     MT_vector3,
@@ -57 +66 @@
     MT_colourvalue,
     MT_quaternion,
-    MT_degree,
-    MT_radian
+    MT_radian,
+    MT_degree
 };
 
-union _UtilExport MultiTypeValue
+class _UtilExport MultiType
 {
-    void*           void_;
-    int             int_;
-    unsigned int    uint_;
-    char            char_;
-    unsigned char   uchar_;
-    short           short_;
-    unsigned short  ushort_;
-    long            long_;
-    unsigned long   ulong_;
-    float           float_;
-    double          double_;
-    long double     longdouble_;
-    bool            bool_;
+    friend std::ostream& operator<<(std::ostream& outstream, const MultiType& mt);
+
+    struct _UtilExport MT_ValueBase
+    {
+        virtual ~MT_ValueBase() {}
+
+        virtual MT_ValueBase* clone() const = 0;
+
+        virtual void setValue(const char& value)                 = 0;
+        virtual void setValue(const unsigned char& value)        = 0;
+        virtual void setValue(const short& value)                = 0;
+        virtual void setValue(const unsigned short& value)       = 0;
+        virtual void setValue(const int& value)                  = 0;
+        virtual void setValue(const unsigned int& value)         = 0;
+        virtual void setValue(const long& value)                 = 0;
+        virtual void setValue(const unsigned long& value)        = 0;
+        virtual void setValue(const long long& value)            = 0;
+        virtual void setValue(const unsigned long long& value)   = 0;
+        virtual void setValue(const float& value)                = 0;
+        virtual void setValue(const double& value)               = 0;
+        virtual void setValue(const long double& value)          = 0;
+        virtual void setValue(const bool& value)                 = 0;
+        virtual void setValue(      void* const& value)          = 0;
+        virtual void setValue(const std::string& value)          = 0;
+        virtual void setValue(const orxonox::Vector2& value)     = 0;
+        virtual void setValue(const orxonox::Vector3& value)     = 0;
+        virtual void setValue(const orxonox::Vector4& value)     = 0;
+        virtual void setValue(const orxonox::ColourValue& value) = 0;
+        virtual void setValue(const orxonox::Quaternion& value)  = 0;
+        virtual void setValue(const orxonox::Radian& value)      = 0;
+        virtual void setValue(const orxonox::Degree& value)      = 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;
+    };
+
+    public:
+        inline                       MultiType()                       : value_(0), type_(MT_null) {}
+        template <typename V> inline MultiType(const V& value)         : value_(0), type_(MT_null) { this->assignValue(value); }
+        inline                       MultiType(const MultiType& other) : value_(0), type_(MT_null) { this->setValue(other); }
+        inline                       MultiType(MT_Type type)           : value_(0), type_(MT_null) { this->setType(type); }
+        ~MultiType() { if (this->value_) { delete this->value_; } }
+
+        template <typename V>             inline MultiType& operator=(const V& value)         { this->setValue(value);          return (*this); }
+        template <typename T, typename V> inline MultiType& operator=(const V& value)         { this->assignValue((T)value);    return (*this); }
+        inline                                   MultiType& operator=(const MultiType& other) { this->setValue(other);          return (*this); }
+        inline                                   MultiType& operator=(MT_Type type)           { this->setType(type);            return (*this); }
+
+        template <typename V> inline void             setValue(const V& value)         { if (this->value_) { this->value_->setValue(value); } else { this->createNewValueContainer(value); } }
+        template <typename V> inline void             setValue(V* value)               { if (this->value_) { this->value_->setValue((void*)value); } else { this->createNewValueContainer((void*)value); } }
+        inline void                                   setValue(const char* value);
+        inline void                                   setValue(const MultiType& other) { this->type_ = other.type_; this->value_ = (other.value_) ? other.value_->clone() : 0; }
+        template <typename T, typename V> inline void setValue(const V& value)         { this->assignValue((T)value); }
+
+        template <typename T> inline void convert() { this->setValue<T>(this->operator T()); }
+
+        inline void                       reset() { if (this->value_) { delete this->value_; this->value_ = 0; } this->type_ = MT_null; }
+
+        template <typename T> inline void setType()                       { this->assignValue(T()); }
+        inline void                       setType(const MultiType& other) { this->setType(other.type_); }
+        void                              setType(MT_Type type);
+
+        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;
+        template <class T> operator T*() const { return ((T*)this->operator void*()); }
+
+        inline void getValue(char*                 value) const { if (this->value_) { (*value) = (*this->value_); } }
+        inline void getValue(unsigned char*        value) const { if (this->value_) { (*value) = (*this->value_); } }
+        inline void getValue(short*                value) const { if (this->value_) { (*value) = (*this->value_); } }
+        inline void getValue(unsigned short*       value) const { if (this->value_) { (*value) = (*this->value_); } }
+        inline void getValue(int*                  value) const { if (this->value_) { (*value) = (*this->value_); } }
+        inline void getValue(unsigned int*         value) const { if (this->value_) { (*value) = (*this->value_); } }
+        inline void getValue(long*                 value) const { if (this->value_) { (*value) = (*this->value_); } }
+        inline void getValue(unsigned long*        value) const { if (this->value_) { (*value) = (*this->value_); } }
+        inline void getValue(long long*            value) const { if (this->value_) { (*value) = (*this->value_); } }
+        inline void getValue(unsigned long long*   value) const { if (this->value_) { (*value) = (*this->value_); } }
+        inline void getValue(float*                value) const { if (this->value_) { (*value) = (*this->value_); } }
+        inline void getValue(double*               value) const { if (this->value_) { (*value) = (*this->value_); } }
+        inline void getValue(long double*          value) const { if (this->value_) { (*value) = (*this->value_); } }
+        inline void getValue(bool*                 value) const { if (this->value_) { (*value) = (*this->value_); } }
+        inline void getValue(void*                 value) const { if (this->value_) {   value  = (*this->value_); } }
+        inline void getValue(std::string*          value) const { if (this->value_) { (*value) = this->value_->operator std::string();          } }
+        inline void getValue(orxonox::Vector2*     value) const { if (this->value_) { (*value) = this->value_->operator orxonox::Vector2();     } }
+        inline void getValue(orxonox::Vector3*     value) const { if (this->value_) { (*value) = this->value_->operator orxonox::Vector3();     } }
+        inline void getValue(orxonox::Vector4*     value) const { if (this->value_) { (*value) = this->value_->operator orxonox::Vector4();     } }
+        inline void getValue(orxonox::ColourValue* value) const { if (this->value_) { (*value) = this->value_->operator orxonox::ColourValue(); } }
+        inline void getValue(orxonox::Quaternion*  value) const { if (this->value_) { (*value) = this->value_->operator orxonox::Quaternion();  } }
+        inline void getValue(orxonox::Radian*      value) const { if (this->value_) { (*value) = this->value_->operator orxonox::Radian();      } }
+        inline void getValue(orxonox::Degree*      value) const { if (this->value_) { (*value) = this->value_->operator orxonox::Degree();      } }
+
+        inline MT_Type                    getType()            const { return this->type_; }
+        inline bool                       isType(MT_Type type) const { return (this->type_ == type); }
+        template <typename T> inline bool isType()             const { return false; }
+        std::string                       getTypename()        const;
+
+        inline std::string toString() const { return this->operator std::string(); }
+
+    private:
+        inline void assignValue(const char& value)                 { if (this->value_ && this->type_ == MT_char)        { this->value_->setValue(value); } else { this->changeValueContainer<char>(value);                 this->type_ = MT_char;        } }
+        inline void assignValue(const unsigned char& value)        { if (this->value_ && this->type_ == MT_uchar)       { this->value_->setValue(value); } else { this->changeValueContainer<unsigned char>(value);        this->type_ = MT_uchar;       } }
+        inline void assignValue(const short& value)                { if (this->value_ && this->type_ == MT_short)       { this->value_->setValue(value); } else { this->changeValueContainer<short>(value);                this->type_ = MT_short;       } }
+        inline void assignValue(const unsigned short& value)       { if (this->value_ && this->type_ == MT_ushort)      { this->value_->setValue(value); } else { this->changeValueContainer<unsigned short>(value);       this->type_ = MT_ushort;      } }
+        inline void assignValue(const int& value)                  { if (this->value_ && this->type_ == MT_int)         { this->value_->setValue(value); } else { this->changeValueContainer<int>(value);                  this->type_ = MT_int;         } }
+        inline void assignValue(const unsigned int& value)         { if (this->value_ && this->type_ == MT_uint)        { this->value_->setValue(value); } else { this->changeValueContainer<unsigned int>(value);         this->type_ = MT_uint;        } }
+        inline void assignValue(const long& value)                 { if (this->value_ && this->type_ == MT_long)        { this->value_->setValue(value); } else { this->changeValueContainer<long>(value);                 this->type_ = MT_long;        } }
+        inline void assignValue(const unsigned long& value)        { if (this->value_ && this->type_ == MT_ulong)       { this->value_->setValue(value); } else { this->changeValueContainer<unsigned long>(value);        this->type_ = MT_ulong;       } }
+        inline void assignValue(const long long& value)            { if (this->value_ && this->type_ == MT_longlong)    { this->value_->setValue(value); } else { this->changeValueContainer<long long>(value);            this->type_ = MT_longlong;    } }
+        inline void assignValue(const unsigned long long& value)   { if (this->value_ && this->type_ == MT_ulonglong)   { this->value_->setValue(value); } else { this->changeValueContainer<unsigned long long>(value);   this->type_ = MT_ulonglong;   } }
+        inline void assignValue(const float& value)                { if (this->value_ && this->type_ == MT_float)       { this->value_->setValue(value); } else { this->changeValueContainer<float>(value);                this->type_ = MT_float;       } }
+        inline void assignValue(const double& value)               { if (this->value_ && this->type_ == MT_double)      { this->value_->setValue(value); } else { this->changeValueContainer<double>(value);               this->type_ = MT_double;      } }
+        inline void assignValue(const long double& value)          { if (this->value_ && this->type_ == MT_longdouble)  { this->value_->setValue(value); } else { this->changeValueContainer<long double>(value);          this->type_ = MT_longdouble;  } }
+        inline void assignValue(const bool& value)                 { if (this->value_ && this->type_ == MT_bool)        { this->value_->setValue(value); } else { this->changeValueContainer<bool>(value);                 this->type_ = MT_bool;        } }
+        inline void assignValue(      void* const& value)          { if (this->value_ && this->type_ == MT_void)        { this->value_->setValue(value); } else { this->changeValueContainer<void*>(value);                this->type_ = MT_void;        } }
+        inline void assignValue(const std::string& value)          { if (this->value_ && this->type_ == MT_string)      { this->value_->setValue(value); } else { this->changeValueContainer<std::string>(value);          this->type_ = MT_string;      } }
+        inline void assignValue(const orxonox::Vector2& value)     { if (this->value_ && this->type_ == MT_vector2)     { this->value_->setValue(value); } else { this->changeValueContainer<orxonox::Vector2>(value);     this->type_ = MT_vector2;     } }
+        inline void assignValue(const orxonox::Vector3& value)     { if (this->value_ && this->type_ == MT_vector3)     { this->value_->setValue(value); } else { this->changeValueContainer<orxonox::Vector3>(value);     this->type_ = MT_vector3;     } }
+        inline void assignValue(const orxonox::Vector4& value)     { if (this->value_ && this->type_ == MT_vector4)     { this->value_->setValue(value); } else { this->changeValueContainer<orxonox::Vector4>(value);     this->type_ = MT_vector4;     } }
+        inline void assignValue(const orxonox::ColourValue& value) { if (this->value_ && this->type_ == MT_colourvalue) { this->value_->setValue(value); } else { this->changeValueContainer<orxonox::ColourValue>(value); this->type_ = MT_colourvalue; } }
+        inline void assignValue(const orxonox::Quaternion& value)  { if (this->value_ && this->type_ == MT_quaternion)  { this->value_->setValue(value); } else { this->changeValueContainer<orxonox::Quaternion>(value);  this->type_ = MT_quaternion;  } }
+        inline void assignValue(const orxonox::Radian& value)      { if (this->value_ && this->type_ == MT_radian)      { this->value_->setValue(value); } else { this->changeValueContainer<orxonox::Radian>(value);      this->type_ = MT_radian;      } }
+        inline void assignValue(const orxonox::Degree& value)      { if (this->value_ && this->type_ == MT_degree)      { this->value_->setValue(value); } else { this->changeValueContainer<orxonox::Degree>(value);      this->type_ = MT_degree;      } }
+        template <typename T> inline void changeValueContainer(const T& value) { if (this->value_) { delete this->value_; } this->createNewValueContainer<T>(value); }
+        template <typename T>        void createNewValueContainer(const T& value) { BOOST_STATIC_ASSERT(sizeof(T) == 0); }
+
+        MT_ValueBase* value_;
+        MT_Type 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->type_ == MT_char);        }
+template <> inline bool MultiType::isType<unsigned char>()        const { return (this->type_ == MT_uchar);       }
+template <> inline bool MultiType::isType<short>()                const { return (this->type_ == MT_short);       }
+template <> inline bool MultiType::isType<unsigned short>()       const { return (this->type_ == MT_ushort);      }
+template <> inline bool MultiType::isType<int>()                  const { return (this->type_ == MT_int);         }
+template <> inline bool MultiType::isType<unsigned int>()         const { return (this->type_ == MT_uint);        }
+template <> inline bool MultiType::isType<long>()                 const { return (this->type_ == MT_long);        }
+template <> inline bool MultiType::isType<unsigned long>()        const { return (this->type_ == MT_ulong);       }
+template <> inline bool MultiType::isType<long long>()            const { return (this->type_ == MT_longlong);    }
+template <> inline bool MultiType::isType<unsigned long long>()   const { return (this->type_ == MT_ulonglong);   }
+template <> inline bool MultiType::isType<float>()                const { return (this->type_ == MT_float);       }
+template <> inline bool MultiType::isType<double>()               const { return (this->type_ == MT_double);      }
+template <> inline bool MultiType::isType<long double>()          const { return (this->type_ == MT_longdouble);  }
+template <> inline bool MultiType::isType<bool>()                 const { return (this->type_ == MT_bool);        }
+template <> inline bool MultiType::isType<void*>()                const { return (this->type_ == MT_void);        }
+template <> inline bool MultiType::isType<std::string>()          const { return (this->type_ == MT_string);      }
+template <> inline bool MultiType::isType<orxonox::Vector2>()     const { return (this->type_ == MT_vector2);     }
+template <> inline bool MultiType::isType<orxonox::Vector3>()     const { return (this->type_ == MT_vector3);     }
+template <> inline bool MultiType::isType<orxonox::Vector4>()     const { return (this->type_ == MT_vector4);     }
+template <> inline bool MultiType::isType<orxonox::ColourValue>() const { return (this->type_ == MT_colourvalue); }
+template <> inline bool MultiType::isType<orxonox::Quaternion>()  const { return (this->type_ == MT_quaternion);  }
+template <> inline bool MultiType::isType<orxonox::Radian>()      const { return (this->type_ == MT_radian);      }
+template <> inline bool MultiType::isType<orxonox::Degree>()      const { return (this->type_ == MT_degree);      }
+
+template <> inline void MultiType::convert<const std::string&>()          { this->convert<std::string>();          }
+template <> inline void MultiType::convert<const orxonox::Vector2&>()     { this->convert<orxonox::Vector2>();     }
+template <> inline void MultiType::convert<const orxonox::Vector3&>()     { this->convert<orxonox::Vector3>();     }
+template <> inline void MultiType::convert<const orxonox::Vector4&>()     { this->convert<orxonox::Vector4>();     }
+template <> inline void MultiType::convert<const orxonox::ColourValue&>() { this->convert<orxonox::ColourValue>(); }
+template <> inline void MultiType::convert<const orxonox::Quaternion&>()  { this->convert<orxonox::Quaternion>();  }
+template <> inline void MultiType::convert<const orxonox::Radian&>()      { this->convert<orxonox::Radian>();      }
+template <> inline void MultiType::convert<const orxonox::Degree&>()      { this->convert<orxonox::Degree>();      }
+
+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 void MultiType::setValue(const char* value) { if (this->value_) { this->value_->setValue(std::string(value)); } else { this->createNewValueContainer(std::string(value)); } }
+
+/*
+
+(*) = funktion 2x:
+function(...) : bezieht sich auf aktuellen type
+function<T>(...) : bezieht sich auf type T
+
+constructor(V value) : zuweisung
+(*) operator=(V value) : zuweisung
+(*) setValue(V value) : zuweisung
+
+(*) == != > < <= >= : template
+
+(*) reset() : zurück auf 0 (bzw "")
+setType<T>() : setzt type und macht reset
+convert<T>() : setzt type und konvertiert
+
+(T) : return konvertiert
+
+isType<T>() : return bool
+getType() : return MT_Type
+getTypename() : return string
+
+toString() : return string
+(*) fromString(string value) : konvertiert string
+operator<< : toString()
+
+*/
+
+#if ORXONOX_COMPILER == ORXONOX_COMPILER_MSVC
+#pragma warning(pop)
+#endif
+
 #endif /* _MultiType_H__ */

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

@@ -66 +66 @@
             inline OutputBuffer& operator<<(const OutputBuffer& object)
             {
-                this->stream_ << object.stream_;
+                this->stream_ << object.stream_.rdbuf();
                 this->callListeners();
                 return *this;

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

@@ -63 +63 @@
 class Convert;
 class ExprParser;
-class MultiTypePrimitive;
-class MultiTypeString;
-class MultiTypeMath;
+class MultiType;
 class SubString;