Planet
navi homePPSaboutscreenshotsdownloaddevelopmentforum

source: code/branches/core2/src/util/MultiTypeMath.h @ 1001

Last change on this file since 1001 was 1001, checked in by landauf, 16 years ago

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 :D) 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 size: 9.8 KB
Line 
1/*
2 *   ORXONOX - the hottest 3D action shooter ever to exist
3 *
4 *
5 *   License notice:
6 *
7 *   This program is free software; you can redistribute it and/or
8 *   modify it under the terms of the GNU General Public License
9 *   as published by the Free Software Foundation; either version 2
10 *   of the License, or (at your option) any later version.
11 *
12 *   This program is distributed in the hope that it will be useful,
13 *   but WITHOUT ANY WARRANTY; without even the implied warranty of
14 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15 *   GNU General Public License for more details.
16 *
17 *   You should have received a copy of the GNU General Public License
18 *   along with this program; if not, write to the Free Software
19 *   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
20 *
21 *   Author:
22 *      Fabian 'x3n' Landau
23 *   Co-authors:
24 *      ...
25 *
26 *   Inspiration: MultiType by Benjamin Grauer
27 */
28
29#ifndef _MultiTypeMath_H__
30#define _MultiTypeMath_H__
31
32#include "UtilPrereqs.h"
33
34#include "MultiTypeString.h"
35#include "Math.h"
36
37class _UtilExport MultiTypeMath : public MultiTypeString
38{
39    public:
40        MultiTypeMath(MultiType type = MT_null);
41        inline MultiTypeMath(void*          value) : MultiTypeString(value) {}
42        inline MultiTypeMath(int            value) : MultiTypeString(value) {}
43        inline MultiTypeMath(unsigned int   value) : MultiTypeString(value) {}
44        inline MultiTypeMath(char           value) : MultiTypeString(value) {}
45        inline MultiTypeMath(unsigned char  value) : MultiTypeString(value) {}
46        inline MultiTypeMath(short          value) : MultiTypeString(value) {}
47        inline MultiTypeMath(unsigned short value) : MultiTypeString(value) {}
48        inline MultiTypeMath(long           value) : MultiTypeString(value) {}
49        inline MultiTypeMath(unsigned long  value) : MultiTypeString(value) {}
50        inline MultiTypeMath(float          value) : MultiTypeString(value) {}
51        inline MultiTypeMath(double         value) : MultiTypeString(value) {}
52        inline MultiTypeMath(long double    value) : MultiTypeString(value) {}
53        inline MultiTypeMath(bool           value) : MultiTypeString(value) {}
54        inline MultiTypeMath(const char*             value) : MultiTypeString(value) {}
55        inline MultiTypeMath(const std::string&      value) : MultiTypeString(value) {}
56        inline MultiTypeMath(const orxonox::Vector2&     value) { this->setValue(value); }
57        inline MultiTypeMath(const orxonox::Vector3&     value) { this->setValue(value); }
58        inline MultiTypeMath(const orxonox::ColourValue& value) { this->setValue(value); }
59        inline MultiTypeMath(const orxonox::Quaternion&  value) { this->setValue(value); }
60        inline MultiTypeMath(const orxonox::Radian&      value) { this->setValue(value); }
61        inline MultiTypeMath(const orxonox::Degree&      value) { this->setValue(value); }
62        inline MultiTypeMath(const MultiTypeMath& mtm)          { this->setValue(mtm);   }
63        virtual inline ~MultiTypeMath() {}
64
65        using MultiTypeString::operator=;
66        inline MultiTypeMath& operator=(const orxonox::Vector2&     value) { this->setValue(value); return *this; }
67        inline MultiTypeMath& operator=(const orxonox::Vector3&     value) { this->setValue(value); return *this; }
68        inline MultiTypeMath& operator=(const orxonox::ColourValue& value) { this->setValue(value); return *this; }
69        inline MultiTypeMath& operator=(const orxonox::Quaternion&  value) { this->setValue(value); return *this; }
70        inline MultiTypeMath& operator=(const orxonox::Radian&      value) { this->setValue(value); return *this; }
71        inline MultiTypeMath& operator=(const orxonox::Degree&      value) { this->setValue(value); return *this; }
72        inline MultiTypeMath& operator=(const MultiTypeMath& mtm)          { this->setValue(mtm);   return *this; }
73
74        using MultiTypeString::operator==;
75        inline bool operator==(const orxonox::Vector2&     value) const { return (this->vector2_     == value); }
76        inline bool operator==(const orxonox::Vector3&     value) const { return (this->vector3_     == value); }
77        inline bool operator==(const orxonox::ColourValue& value) const { return (this->colourvalue_ == value); }
78        inline bool operator==(const orxonox::Quaternion&  value) const { return (this->quaternion_  == value); }
79        inline bool operator==(const orxonox::Radian&      value) const { return (this->radian_      == value); }
80        inline bool operator==(const orxonox::Degree&      value) const { return (this->degree_      == value); }
81        bool operator==(const MultiTypeMath& mtm) const;
82
83        using MultiTypeString::operator!=;
84        inline bool operator!=(const orxonox::Vector2&     value) const { return (this->vector2_     != value); }
85        inline bool operator!=(const orxonox::Vector3&     value) const { return (this->vector3_     != value); }
86        inline bool operator!=(const orxonox::ColourValue& value) const { return (this->colourvalue_ != value); }
87        inline bool operator!=(const orxonox::Quaternion&  value) const { return (this->quaternion_  != value); }
88        inline bool operator!=(const orxonox::Radian&      value) const { return (this->radian_      != value); }
89        inline bool operator!=(const orxonox::Degree&      value) const { return (this->degree_      != value); }
90        bool operator!=(const MultiTypeMath& mtm) const;
91
92        virtual operator void*()                const;
93        virtual operator int()                  const;
94        virtual operator unsigned int()         const;
95        virtual operator char()                 const;
96        virtual operator unsigned char()        const;
97        virtual operator short()                const;
98        virtual operator unsigned short()       const;
99        virtual operator long()                 const;
100        virtual operator unsigned long()        const;
101        virtual operator float ()               const;
102        virtual operator double ()              const;
103        virtual operator long double()          const;
104        virtual operator bool()                 const;
105        virtual operator std::string()          const;
106        virtual operator const char*()          const;
107        virtual operator orxonox::Vector2()     const;
108        virtual operator orxonox::Vector3()     const;
109        virtual operator orxonox::ColourValue() const;
110        virtual operator orxonox::Quaternion()  const;
111        virtual operator orxonox::Radian()      const;
112        virtual operator orxonox::Degree()      const;
113
114        using MultiTypeString::setValue;
115        inline void setValue(const orxonox::Vector2&     value) { this->type_ = MT_vector2;     this->vector2_     = value; }
116        inline void setValue(const orxonox::Vector3&     value) { this->type_ = MT_vector3;     this->vector3_     = value; }
117        inline void setValue(const orxonox::ColourValue& value) { this->type_ = MT_colourvalue; this->colourvalue_ = value; }
118        inline void setValue(const orxonox::Quaternion&  value) { this->type_ = MT_quaternion;  this->quaternion_  = value; }
119        inline void setValue(const orxonox::Radian&      value) { this->type_ = MT_radian;      this->radian_      = value; }
120        inline void setValue(const orxonox::Degree&      value) { this->type_ = MT_degree;      this->degree_      = value; }
121        void setValue(const MultiTypeMath& mtm);
122
123        inline orxonox::Vector2     getVector2()     const { return this->vector2_;     }
124        inline orxonox::Vector3     getVector3()     const { return this->vector3_;     }
125        inline orxonox::ColourValue getColourValue() const { return this->colourvalue_; }
126        inline orxonox::Quaternion  getQuaternion()  const { return this->quaternion_;  }
127        inline orxonox::Radian      getRadian()      const { return this->radian_;      }
128        inline orxonox::Degree      getDegree()      const { return this->degree_;      }
129
130        inline orxonox::Vector2&     getVector2()     { return this->vector2_;     }
131        inline orxonox::Vector3&     getVector3()     { return this->vector3_;     }
132        inline orxonox::ColourValue& getColourValue() { return this->colourvalue_; }
133        inline orxonox::Quaternion&  getQuaternion()  { return this->quaternion_;  }
134        inline orxonox::Radian&      getRadian()      { return this->radian_;      }
135        inline orxonox::Degree&      getDegree()      { return this->degree_;      }
136
137        using MultiTypeString::getValue;
138        inline void getValue(orxonox::Vector2*     variable) const { (*variable) = orxonox::Vector2     (this->vector2_);     }
139        inline void getValue(orxonox::Vector3*     variable) const { (*variable) = orxonox::Vector3     (this->vector3_);     }
140        inline void getValue(orxonox::ColourValue* variable) const { (*variable) = orxonox::ColourValue (this->colourvalue_); }
141        inline void getValue(orxonox::Quaternion*  variable) const { (*variable) = orxonox::Quaternion  (this->quaternion_);  }
142        inline void getValue(orxonox::Radian*      variable) const { (*variable) = orxonox::Radian      (this->radian_);      }
143        inline void getValue(orxonox::Degree*      variable) const { (*variable) = orxonox::Degree      (this->degree_);      }
144
145        virtual std::string getTypename() const;
146
147        virtual std::string toString() const;
148        virtual bool fromString(const std::string value);
149
150    protected:
151        orxonox::Vector2      vector2_;
152        orxonox::Vector3      vector3_;
153        orxonox::ColourValue  colourvalue_;
154        orxonox::Quaternion   quaternion_;
155        orxonox::Radian       radian_;
156        orxonox::Degree       degree_;
157};
158
159std::ostream& operator<<(std::ostream& out, MultiTypeMath& mtm);
160
161#endif /* _MultiTypeMath_H__ */
Note: See TracBrowser for help on using the repository browser.