Planet
navi homePPSaboutscreenshotsdownloaddevelopmentforum

source: code/trunk/src/libraries/util/MultiType.h @ 7401

Last change on this file since 7401 was 7401, checked in by landauf, 14 years ago

merged doc branch back to trunk

  • Property svn:eol-style set to native
File size: 60.0 KB
Line 
1/*
2 *   ORXONOX - the hottest 3D action shooter ever to exist
3 *                    > www.orxonox.net <
4 *
5 *
6 *   License notice:
7 *
8 *   This program is free software; you can redistribute it and/or
9 *   modify it under the terms of the GNU General Public License
10 *   as published by the Free Software Foundation; either version 2
11 *   of the License, or (at your option) any later version.
12 *
13 *   This program is distributed in the hope that it will be useful,
14 *   but WITHOUT ANY WARRANTY; without even the implied warranty of
15 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
16 *   GNU General Public License for more details.
17 *
18 *   You should have received a copy of the GNU General Public License
19 *   along with this program; if not, write to the Free Software
20 *   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
21 *
22 *   Author:
23 *      Fabian 'x3n' Landau
24 *   Co-authors:
25 *      ...
26 *
27 */
28
29/**
30    @defgroup MultiType MultiType
31    @ingroup Util
32*/
33
34/**
35    @file
36    @ingroup MultiType
37    @brief Declaration of the MultiType and some helper constructs.
38
39    @anchor MultiTypeExamples
40
41    The MultiType can hold a value of one of the following types:
42     - all primitives (int, float, bool, etc.)
43     - all pointers (void* and T*)
44     - std::string
45     - Vector2, Vector3, Vector4
46     - Quaternion
47     - ColourValue
48     - Radian, Degree
49
50    The MultiType has an internal "type" determined by the first assigned value, using one of these ways:
51     - @ref orxonox::MultiType::MultiType "The constructor"
52     - The assignment operator= (orxonox::MultiType::operator=())
53     - @ref orxonox::MultiType::setValue() "setValue(value)"
54
55    If you assign another value of another type, the MultiType keeps "its" type and
56    converts the new value to the old type.
57
58    If you want to change the type, there are three possibilities:
59     - @ref orxonox::MultiType::convert "convert<T>()" sets the type to T and converts the currently assigned value
60     - @ref orxonox::MultiType::setType "setType<T>()" sets the type to T and resets the value to zero using zeroise<T>()
61     - setValue<T>(value) assigns a new value and changes the type to T.
62
63    Examples:
64    @code
65    MultiType a = 10;          // a has now the type int and the value 10
66    a.setValue("3.14");        // a has still the type int and "3.14" gets converted, therefore the value is now 3
67    a.setValue<float>("3.14"); // a has now the type float and "3.14" gets converted to 3.14f
68    a.convert<bool>();         // converts 3.14f to bool, which is true
69    a = false;                 // assigns false, this is equivalent to a.setValue(false)
70    @endcode
71
72    You can pass a MultiType to a function as an argument, even if the argument is
73    not of type MultiType. This works, because the MultiType is automatically converted
74    to the right type.
75
76    Example:
77    @code
78    void myfunction(int value)
79    {
80        COUT(0) << "doubled value is " << (2 * value) << std::endl;
81    }
82
83    MultiType a = "50";        // Note: We assigned a string
84    myfunction(a);             // a is converted to int and passed to the function, which prints "value is 100"
85    @endcode
86
87    Note however that it is of course quite expensive to convert values, especially std::string <-> value.
88    So if you can, always assign a value with the right type to avoid conversion.
89
90    @note
91    Whenever a value gets converted, there is a boolean return value telling you whether it was
92    successful or not. If it wasn't a zero value is assigned with the help of zeroise<T>().
93*/
94
95#ifndef _MultiType_H__
96#define _MultiType_H__
97
98#include "UtilPrereqs.h"
99
100#include <cassert>
101#include <string>
102#include <OgreVector2.h>
103#include <OgreVector3.h>
104#include <OgreVector4.h>
105#include <OgreQuaternion.h>
106#include <OgreColourValue.h>
107#include <loki/TypeTraits.h>
108#include "mbool.h"
109
110namespace orxonox
111{
112    /**
113        @brief Enum of all possible types of a MultiType.
114    */
115    namespace MT_Type
116    {
117        enum Value
118        {
119            Null,
120            Char,
121            UnsignedChar,
122            Short,
123            UnsignedShort,
124            Int,
125            UnsignedInt,
126            Long,
127            UnsignedLong,
128            LongLong,
129            UnsignedLongLong,
130            Float,
131            Double,
132            LongDouble,
133            Bool,
134            VoidPointer,
135            String,
136            Vector2,
137            Vector3,
138            Vector4,
139            ColourValue,
140            Quaternion,
141            Radian,
142            Degree
143        };
144    }
145
146    /**
147        @brief The MultiType can hold a value of many possible types and convert them to other types.
148
149        The following types are supported by the MultiType:
150         - all primitves
151         - all pointers
152         - string
153         - Vector2, Vector3, Vector4
154         - Quaternion
155         - ColourValue
156         - Radian, Degree
157
158        For more information and some examples see the description @ref MultiTypeExamples "here".
159
160        @see MultiType.h
161    */
162    class _UtilExport MultiType
163    {
164        _UtilExport friend std::ostream& operator<<(std::ostream& outstream, const MultiType& mt);
165        template <typename T> friend class MT_Value;
166
167    public:
168        /**
169            @brief MT_ValueBase is an almost pure virtual baseclass of MT_Value<T>, which holds the value of the MultiType.
170            This class is only used within the MultiType.
171        */
172        class _UtilExport MT_ValueBase
173        {
174        public:
175            MT_ValueBase(MT_Type::Value type) : type_(type), bHasDefaultValue_(false) {}
176            virtual ~MT_ValueBase() {}
177
178            virtual MT_ValueBase* clone() const = 0;
179
180            virtual void reset() = 0;
181            virtual bool assimilate(const MultiType& other) = 0;
182
183            /// Returns the type of the current value.
184            const MT_Type::Value& getType() const { return this->type_; }
185
186            /// Checks whether the value is a default one.
187            bool hasDefaultValue()   const { return this->bHasDefaultValue_; }
188
189            virtual bool setValue(const char& value)                 = 0;
190            virtual bool setValue(const unsigned char& value)        = 0;
191            virtual bool setValue(const short& value)                = 0;
192            virtual bool setValue(const unsigned short& value)       = 0;
193            virtual bool setValue(const int& value)                  = 0;
194            virtual bool setValue(const unsigned int& value)         = 0;
195            virtual bool setValue(const long& value)                 = 0;
196            virtual bool setValue(const unsigned long& value)        = 0;
197            virtual bool setValue(const long long& value)            = 0;
198            virtual bool setValue(const unsigned long long& value)   = 0;
199            virtual bool setValue(const float& value)                = 0;
200            virtual bool setValue(const double& value)               = 0;
201            virtual bool setValue(const long double& value)          = 0;
202            virtual bool setValue(const bool& value)                 = 0;
203            virtual bool setValue(      void* const& value)          = 0;
204            virtual bool setValue(const std::string& value)          = 0;
205            virtual bool setValue(const orxonox::Vector2& value)     = 0;
206            virtual bool setValue(const orxonox::Vector3& value)     = 0;
207            virtual bool setValue(const orxonox::Vector4& value)     = 0;
208            virtual bool setValue(const orxonox::ColourValue& value) = 0;
209            virtual bool setValue(const orxonox::Quaternion& value)  = 0;
210            virtual bool setValue(const orxonox::Radian& value)      = 0;
211            virtual bool setValue(const orxonox::Degree& value)      = 0;
212
213            virtual bool getValue(char*                 value) const = 0;
214            virtual bool getValue(unsigned char*        value) const = 0;
215            virtual bool getValue(short*                value) const = 0;
216            virtual bool getValue(unsigned short*       value) const = 0;
217            virtual bool getValue(int*                  value) const = 0;
218            virtual bool getValue(unsigned int*         value) const = 0;
219            virtual bool getValue(long*                 value) const = 0;
220            virtual bool getValue(unsigned long*        value) const = 0;
221            virtual bool getValue(long long*            value) const = 0;
222            virtual bool getValue(unsigned long long*   value) const = 0;
223            virtual bool getValue(float*                value) const = 0;
224            virtual bool getValue(double*               value) const = 0;
225            virtual bool getValue(long double*          value) const = 0;
226            virtual bool getValue(bool*                 value) const = 0;
227            virtual bool getValue(void**                value) const = 0;
228            virtual bool getValue(std::string*          value) const = 0;
229            virtual bool getValue(orxonox::Vector2*     value) const = 0;
230            virtual bool getValue(orxonox::Vector3*     value) const = 0;
231            virtual bool getValue(orxonox::Vector4*     value) const = 0;
232            virtual bool getValue(orxonox::ColourValue* value) const = 0;
233            virtual bool getValue(orxonox::Quaternion*  value) const = 0;
234            virtual bool getValue(orxonox::Radian*      value) const = 0;
235            virtual bool getValue(orxonox::Degree*      value) const = 0;
236
237            virtual operator char()                 const = 0;
238            virtual operator unsigned char()        const = 0;
239            virtual operator short()                const = 0;
240            virtual operator unsigned short()       const = 0;
241            virtual operator int()                  const = 0;
242            virtual operator unsigned int()         const = 0;
243            virtual operator long()                 const = 0;
244            virtual operator unsigned long()        const = 0;
245            virtual operator long long()            const = 0;
246            virtual operator unsigned long long()   const = 0;
247            virtual operator float()                const = 0;
248            virtual operator double()               const = 0;
249            virtual operator long double()          const = 0;
250            virtual operator bool()                 const = 0;
251            virtual operator void*()                const = 0;
252            virtual operator std::string()          const = 0;
253            virtual operator orxonox::Vector2()     const = 0;
254            virtual operator orxonox::Vector3()     const = 0;
255            virtual operator orxonox::Vector4()     const = 0;
256            virtual operator orxonox::ColourValue() const = 0;
257            virtual operator orxonox::Quaternion()  const = 0;
258            virtual operator orxonox::Radian()      const = 0;
259            virtual operator orxonox::Degree()      const = 0;
260
261            virtual void toString(std::ostream& outstream) const = 0;
262
263            virtual void importData( uint8_t*& mem )=0;
264            virtual void exportData( uint8_t*& mem ) const=0;
265            virtual uint8_t getSize() const=0;
266
267            MT_Type::Value type_;   ///< The type of the current value
268            bool bHasDefaultValue_; ///< True if the last conversion wasn't successful
269        };
270
271        public:
272            inline MultiType()                                  : value_(0) {}                                      ///< Default constructor: Assigns no value and no type. The type will be determined by the first assignment of a value.
273            inline MultiType(const char& value)                 : value_(0) { this->assignValue(value); }           ///< Constructor: Assigns the given value and sets the type.
274            inline MultiType(const unsigned char& value)        : value_(0) { this->assignValue(value); }           ///< Constructor: Assigns the given value and sets the type.
275            inline MultiType(const short& value)                : value_(0) { this->assignValue(value); }           ///< Constructor: Assigns the given value and sets the type.
276            inline MultiType(const unsigned short& value)       : value_(0) { this->assignValue(value); }           ///< Constructor: Assigns the given value and sets the type.
277            inline MultiType(const int& value)                  : value_(0) { this->assignValue(value); }           ///< Constructor: Assigns the given value and sets the type.
278            inline MultiType(const unsigned int& value)         : value_(0) { this->assignValue(value); }           ///< Constructor: Assigns the given value and sets the type.
279            inline MultiType(const long& value)                 : value_(0) { this->assignValue(value); }           ///< Constructor: Assigns the given value and sets the type.
280            inline MultiType(const unsigned long& value)        : value_(0) { this->assignValue(value); }           ///< Constructor: Assigns the given value and sets the type.
281            inline MultiType(const long long& value)            : value_(0) { this->assignValue(value); }           ///< Constructor: Assigns the given value and sets the type.
282            inline MultiType(const unsigned long long& value)   : value_(0) { this->assignValue(value); }           ///< Constructor: Assigns the given value and sets the type.
283            inline MultiType(const float& value)                : value_(0) { this->assignValue(value); }           ///< Constructor: Assigns the given value and sets the type.
284            inline MultiType(const double& value)               : value_(0) { this->assignValue(value); }           ///< Constructor: Assigns the given value and sets the type.
285            inline MultiType(const long double& value)          : value_(0) { this->assignValue(value); }           ///< Constructor: Assigns the given value and sets the type.
286            inline MultiType(const bool& value)                 : value_(0) { this->assignValue(value); }           ///< Constructor: Assigns the given value and sets the type.
287            inline MultiType(      void* const& value)          : value_(0) { this->assignValue(value); }           ///< Constructor: Assigns the given value and sets the type.
288            inline MultiType(const std::string& value)          : value_(0) { this->assignValue(value); }           ///< Constructor: Assigns the given value and sets the type.
289            inline MultiType(const orxonox::Vector2& value)     : value_(0) { this->assignValue(value); }           ///< Constructor: Assigns the given value and sets the type.
290            inline MultiType(const orxonox::Vector3& value)     : value_(0) { this->assignValue(value); }           ///< Constructor: Assigns the given value and sets the type.
291            inline MultiType(const orxonox::Vector4& value)     : value_(0) { this->assignValue(value); }           ///< Constructor: Assigns the given value and sets the type.
292            inline MultiType(const orxonox::ColourValue& value) : value_(0) { this->assignValue(value); }           ///< Constructor: Assigns the given value and sets the type.
293            inline MultiType(const orxonox::Quaternion& value)  : value_(0) { this->assignValue(value); }           ///< Constructor: Assigns the given value and sets the type.
294            inline MultiType(const orxonox::Radian& value)      : value_(0) { this->assignValue(value); }           ///< Constructor: Assigns the given value and sets the type.
295            inline MultiType(const orxonox::Degree& value)      : value_(0) { this->assignValue(value); }           ///< Constructor: Assigns the given value and sets the type.
296            inline MultiType(const orxonox::mbool& value)       : value_(0) { this->assignValue((bool)value); }     ///< Constructor: Assigns the given mbool and converts it to bool.
297            inline MultiType(const char* value)                 : value_(0) { this->setValue(std::string(value)); } ///< Constructor: Converts the char array to a std::string, assigns the value and sets the type.
298            inline MultiType(const MultiType& other)            : value_(0) { this->setValue(other); }              ///< Copyconstructor: Assigns value and type of the other MultiType.
299            inline MultiType(MT_Type::Value type)               : value_(0) { this->setType(type); }                ///< Constructor: Sets the type, the next assignment will determine the value.
300
301            /// Destructor: Deletes the MT_Value.
302            inline ~MultiType() { if (this->value_) { delete this->value_; } }
303
304            template <typename V> inline MultiType& operator=(const V& value)         { this->setValue(value); return (*this); } ///< Assigns a new value. The value will be converted to the current type of the MultiType.
305            template <typename V> inline MultiType& operator=(V* value)               { this->setValue(value); return (*this); } ///< Assigns a pointer.
306            inline                       MultiType& operator=(const MultiType& other) { this->setValue(other); return (*this); } ///< Assigns the value of the other MultiType and converts it to the current type of the MultiType.
307            inline                       MultiType& operator=(MT_Type::Value type)    { this->setType(type);   return (*this); } ///< Resets the value and changes the type.
308
309            inline bool                                   setValue(const char& value);
310            inline bool                                   setValue(const unsigned char& value);
311            inline bool                                   setValue(const short& value);
312            inline bool                                   setValue(const unsigned short& value);
313            inline bool                                   setValue(const int& value);
314            inline bool                                   setValue(const unsigned int& value);
315            inline bool                                   setValue(const long& value);
316            inline bool                                   setValue(const unsigned long& value);
317            inline bool                                   setValue(const long long& value);
318            inline bool                                   setValue(const unsigned long long& value);
319            inline bool                                   setValue(const float& value);
320            inline bool                                   setValue(const double& value);
321            inline bool                                   setValue(const long double& value);
322            inline bool                                   setValue(const bool& value);
323            inline bool                                   setValue(      void* const& value);
324            inline bool                                   setValue(const std::string& value);
325            inline bool                                   setValue(const orxonox::Vector2& value);
326            inline bool                                   setValue(const orxonox::Vector3& value);
327            inline bool                                   setValue(const orxonox::Vector4& value);
328            inline bool                                   setValue(const orxonox::ColourValue& value);
329            inline bool                                   setValue(const orxonox::Quaternion& value);
330            inline bool                                   setValue(const orxonox::Radian& value);
331            inline bool                                   setValue(const orxonox::Degree& value);
332            inline bool                                   setValue(const char* value);
333            /// Assigns a pointer.
334            template <typename V> inline bool setValue(V* value)
335            {
336                if (this->value_)
337                    return this->value_->setValue(static_cast<void*>(const_cast<typename Loki::TypeTraits<V>::UnqualifiedType*>(value)));
338                else
339                    return this->assignValue     (static_cast<void*>(const_cast<typename Loki::TypeTraits<V>::UnqualifiedType*>(value)));
340            }
341            /// Assigns the value of the other MultiType and converts it to the current type.
342            bool                                          setValue(const MultiType& other) { if (this->value_) { return this->value_->assimilate(other); } else { if (other.value_) { this->value_ = other.value_->clone(); } return true; } }
343            /// Changes the type to T and assigns the new value (which might be of another type than T - it gets converted).
344            template <typename T, typename V> inline bool setValue(const V& value) { this->setType<T>(); return this->setValue(value); }
345
346
347            /// Copies the other MultiType by assigning value and type.
348            inline void                       copy(const MultiType& other)    { if (this == &other) { return; } if (this->value_) { delete this->value_; } this->value_ = (other.value_) ? other.value_->clone() : 0; }
349
350            /// Converts the current value to type T.
351            template <typename T> inline bool convert()                       { return this->setValue<T>((typename Loki::TypeTraits<T>::UnqualifiedReferredType)(*this));  }
352            /// Converts the current value to the type of the other MultiType.
353            inline bool                       convert(const MultiType& other) { return this->convert(other.getType()); }
354            bool                              convert(MT_Type::Value type);
355
356            /// Current content gets deleted. New type is MT_Type::Null
357            inline void                       reset()                         { if (this->value_) delete this->value_; this->value_ = 0; }
358            /// Current content gets overridden with default zero value
359            inline void                       resetValue()                    { if (this->value_) this->value_->reset(); }
360
361            /// Resets the value and changes the internal type to T.
362            template <typename T> inline void setType()                       { this->assignValue(typename Loki::TypeTraits<T>::UnqualifiedReferredType()); }
363            /// Resets the value and changes the internal type to the type of the other MultiType.
364            inline void                       setType(const MultiType& other) { this->setType(other.getType());                                             }
365            /// Resets the value and changes the internal type to the given type.
366            inline void                       setType(MT_Type::Value type)    { this->reset(); this->convert(type); this->resetValue();                     }
367
368            /// Returns the current type.
369            inline MT_Type::Value             getType()                   const { return (this->value_) ? this->value_->type_ : MT_Type::Null; }
370            /// Returns true if the current type equals the given type.
371            inline bool                       isType(MT_Type::Value type) const { return (this->value_) ? (this->value_->type_ == type) : (type == MT_Type::Null); }
372            /// Returns true if the current type is T.
373            template <typename T> inline bool isType()                    const { return false; } // Only works for specialized values - see below
374            std::string                       getTypename()               const;
375
376            /// Saves the value of the MT to a bytestream (pointed at by mem) and increases mem pointer by size of MT
377            inline void                       exportData(uint8_t*& mem) const { assert(sizeof(MT_Type::Value)<=8); *static_cast<uint8_t*>(mem) = this->getType(); mem+=sizeof(uint8_t); this->value_->exportData(mem); }
378            /// Loads the value of the MT from a bytestream (pointed at by mem) and increases mem pointer by size of MT
379            inline void                       importData(uint8_t*& mem) { assert(sizeof(MT_Type::Value)<=8); this->setType(static_cast<MT_Type::Value>(*static_cast<uint8_t*>(mem))); mem+=sizeof(uint8_t); this->value_->importData(mem); }
380            /// Saves the value of the MT to a bytestream and increases pointer to bytestream by size of MT
381            inline uint8_t*&                  operator << (uint8_t*& mem) { importData(mem); return mem; }
382            /// Loads the value of the MT to a bytestream and increases pointer to bytestream by size of MT
383            inline void                       operator >> (uint8_t*& mem) const { exportData(mem); }
384            inline uint32_t                   getNetworkSize() const { assert(this->value_); return this->value_->getSize() + sizeof(uint8_t); }
385
386            /// Checks whether the value is a default one (assigned after a failed conversion)
387            bool                              hasDefaultValue() const { return this->value_->hasDefaultValue(); }
388
389            /// Checks if the MT contains no value.
390            bool                              null() const { return (!this->value_); }
391
392            operator char()                  const;
393            operator unsigned char()         const;
394            operator short()                 const;
395            operator unsigned short()        const;
396            operator int()                   const;
397            operator unsigned int()          const;
398            operator long()                  const;
399            operator unsigned long()         const;
400            operator long long()             const;
401            operator unsigned long long()    const;
402            operator float()                 const;
403            operator double()                const;
404            operator long double()           const;
405            operator bool()                  const;
406            operator void*()                 const;
407            operator std::string()           const;
408            operator orxonox::Vector2()      const;
409            operator orxonox::Vector3()      const;
410            operator orxonox::Vector4()      const;
411            operator orxonox::ColourValue()  const;
412            operator orxonox::Quaternion()   const;
413            operator orxonox::Radian()       const;
414            operator orxonox::Degree()       const;
415            /// Returns the current value, converted to a T* pointer.
416            template <class T> operator T*() const { return (static_cast<T*>(this->operator void*())); }
417
418            inline bool getValue(char*                 value) const { if (this->value_) { return this->value_->getValue(value); } return false; } ///< Assigns the value to the given pointer. The value gets converted if the types don't match.
419            inline bool getValue(unsigned char*        value) const { if (this->value_) { return this->value_->getValue(value); } return false; } ///< Assigns the value to the given pointer. The value gets converted if the types don't match.
420            inline bool getValue(short*                value) const { if (this->value_) { return this->value_->getValue(value); } return false; } ///< Assigns the value to the given pointer. The value gets converted if the types don't match.
421            inline bool getValue(unsigned short*       value) const { if (this->value_) { return this->value_->getValue(value); } return false; } ///< Assigns the value to the given pointer. The value gets converted if the types don't match.
422            inline bool getValue(int*                  value) const { if (this->value_) { return this->value_->getValue(value); } return false; } ///< Assigns the value to the given pointer. The value gets converted if the types don't match.
423            inline bool getValue(unsigned int*         value) const { if (this->value_) { return this->value_->getValue(value); } return false; } ///< Assigns the value to the given pointer. The value gets converted if the types don't match.
424            inline bool getValue(long*                 value) const { if (this->value_) { return this->value_->getValue(value); } return false; } ///< Assigns the value to the given pointer. The value gets converted if the types don't match.
425            inline bool getValue(unsigned long*        value) const { if (this->value_) { return this->value_->getValue(value); } return false; } ///< Assigns the value to the given pointer. The value gets converted if the types don't match.
426            inline bool getValue(long long*            value) const { if (this->value_) { return this->value_->getValue(value); } return false; } ///< Assigns the value to the given pointer. The value gets converted if the types don't match.
427            inline bool getValue(unsigned long long*   value) const { if (this->value_) { return this->value_->getValue(value); } return false; } ///< Assigns the value to the given pointer. The value gets converted if the types don't match.
428            inline bool getValue(float*                value) const { if (this->value_) { return this->value_->getValue(value); } return false; } ///< Assigns the value to the given pointer. The value gets converted if the types don't match.
429            inline bool getValue(double*               value) const { if (this->value_) { return this->value_->getValue(value); } return false; } ///< Assigns the value to the given pointer. The value gets converted if the types don't match.
430            inline bool getValue(long double*          value) const { if (this->value_) { return this->value_->getValue(value); } return false; } ///< Assigns the value to the given pointer. The value gets converted if the types don't match.
431            inline bool getValue(bool*                 value) const { if (this->value_) { return this->value_->getValue(value); } return false; } ///< Assigns the value to the given pointer. The value gets converted if the types don't match.
432            inline bool getValue(void**                value) const { if (this->value_) { return this->value_->getValue(value); } return false; } ///< Assigns the value to the given pointer. The value gets converted if the types don't match.
433            inline bool getValue(std::string*          value) const { if (this->value_) { return this->value_->getValue(value); } return false; } ///< Assigns the value to the given pointer. The value gets converted if the types don't match.
434            inline bool getValue(orxonox::Vector2*     value) const { if (this->value_) { return this->value_->getValue(value); } return false; } ///< Assigns the value to the given pointer. The value gets converted if the types don't match.
435            inline bool getValue(orxonox::Vector3*     value) const { if (this->value_) { return this->value_->getValue(value); } return false; } ///< Assigns the value to the given pointer. The value gets converted if the types don't match.
436            inline bool getValue(orxonox::Vector4*     value) const { if (this->value_) { return this->value_->getValue(value); } return false; } ///< Assigns the value to the given pointer. The value gets converted if the types don't match.
437            inline bool getValue(orxonox::ColourValue* value) const { if (this->value_) { return this->value_->getValue(value); } return false; } ///< Assigns the value to the given pointer. The value gets converted if the types don't match.
438            inline bool getValue(orxonox::Quaternion*  value) const { if (this->value_) { return this->value_->getValue(value); } return false; } ///< Assigns the value to the given pointer. The value gets converted if the types don't match.
439            inline bool getValue(orxonox::Radian*      value) const { if (this->value_) { return this->value_->getValue(value); } return false; } ///< Assigns the value to the given pointer. The value gets converted if the types don't match.
440            inline bool getValue(orxonox::Degree*      value) const { if (this->value_) { return this->value_->getValue(value); } return false; } ///< Assigns the value to the given pointer. The value gets converted if the types don't match.
441
442            inline char                     getChar()             const { return this->operator char();                 } ///< Returns the current value, converted to the requested type.
443            inline unsigned char            getUnsignedChar()     const { return this->operator unsigned char();        } ///< Returns the current value, converted to the requested type.
444            inline short                    getShort()            const { return this->operator short();                } ///< Returns the current value, converted to the requested type.
445            inline unsigned short           getUnsignedShort()    const { return this->operator unsigned short();       } ///< Returns the current value, converted to the requested type.
446            inline int                      getInt()              const { return this->operator int();                  } ///< Returns the current value, converted to the requested type.
447            inline unsigned int             getUnsignedInt()      const { return this->operator unsigned int();         } ///< Returns the current value, converted to the requested type.
448            inline long                     getLong()             const { return this->operator long();                 } ///< Returns the current value, converted to the requested type.
449            inline unsigned long            getUnsignedLong()     const { return this->operator unsigned long();        } ///< Returns the current value, converted to the requested type.
450            inline long long                getLongLong()         const { return this->operator long long();            } ///< Returns the current value, converted to the requested type.
451            inline unsigned long long       getUnsignedLongLong() const { return this->operator unsigned long long();   } ///< Returns the current value, converted to the requested type.
452            inline float                    getFloat()            const { return this->operator float();                } ///< Returns the current value, converted to the requested type.
453            inline double                   getDouble()           const { return this->operator double();               } ///< Returns the current value, converted to the requested type.
454            inline long double              getLongDouble()       const { return this->operator long double();          } ///< Returns the current value, converted to the requested type.
455            inline bool                     getBool()             const { return this->operator bool();                 } ///< Returns the current value, converted to the requested type.
456            inline void*                    getVoid()             const { return this->operator void*();                } ///< Returns the current value, converted to the requested type.
457            inline std::string              getString()           const { return this->operator std::string();          } ///< Returns the current value, converted to the requested type.
458            inline orxonox::Vector2         getVector2()          const { return this->operator orxonox::Vector2();     } ///< Returns the current value, converted to the requested type.
459            inline orxonox::Vector3         getVector3()          const { return this->operator orxonox::Vector3();     } ///< Returns the current value, converted to the requested type.
460            inline orxonox::Vector4         getVector4()          const { return this->operator orxonox::Vector4();     } ///< Returns the current value, converted to the requested type.
461            inline orxonox::ColourValue     getColourValue()      const { return this->operator orxonox::ColourValue(); } ///< Returns the current value, converted to the requested type.
462            inline orxonox::Quaternion      getQuaternion()       const { return this->operator orxonox::Quaternion();  } ///< Returns the current value, converted to the requested type.
463            inline orxonox::Radian          getRadian()           const { return this->operator orxonox::Radian();      } ///< Returns the current value, converted to the requested type.
464            inline orxonox::Degree          getDegree()           const { return this->operator orxonox::Degree();      } ///< Returns the current value, converted to the requested type.
465            template <typename T> inline T* getPointer()          const { return static_cast<T*>(this->getVoid());      } ///< Returns the current value, converted to a T* pointer.
466
467        private:
468            inline bool assignValue(const char& value)                 { if (this->value_ && this->value_->type_ == MT_Type::Char)             { return this->value_->setValue(value); } else { this->changeValueContainer<char>(value);                 return true; } } ///< Assigns a new value by changing type and creating a new container.
469            inline bool assignValue(const unsigned char& value)        { if (this->value_ && this->value_->type_ == MT_Type::UnsignedChar)     { return this->value_->setValue(value); } else { this->changeValueContainer<unsigned char>(value);        return true; } } ///< Assigns a new value by changing type and creating a new container.
470            inline bool assignValue(const short& value)                { if (this->value_ && this->value_->type_ == MT_Type::Short)            { return this->value_->setValue(value); } else { this->changeValueContainer<short>(value);                return true; } } ///< Assigns a new value by changing type and creating a new container.
471            inline bool assignValue(const unsigned short& value)       { if (this->value_ && this->value_->type_ == MT_Type::UnsignedShort)    { return this->value_->setValue(value); } else { this->changeValueContainer<unsigned short>(value);       return true; } } ///< Assigns a new value by changing type and creating a new container.
472            inline bool assignValue(const int& value)                  { if (this->value_ && this->value_->type_ == MT_Type::Int)              { return this->value_->setValue(value); } else { this->changeValueContainer<int>(value);                  return true; } } ///< Assigns a new value by changing type and creating a new container.
473            inline bool assignValue(const unsigned int& value)         { if (this->value_ && this->value_->type_ == MT_Type::UnsignedInt)      { return this->value_->setValue(value); } else { this->changeValueContainer<unsigned int>(value);         return true; } } ///< Assigns a new value by changing type and creating a new container.
474            inline bool assignValue(const long& value)                 { if (this->value_ && this->value_->type_ == MT_Type::Long)             { return this->value_->setValue(value); } else { this->changeValueContainer<long>(value);                 return true; } } ///< Assigns a new value by changing type and creating a new container.
475            inline bool assignValue(const unsigned long& value)        { if (this->value_ && this->value_->type_ == MT_Type::UnsignedLong)     { return this->value_->setValue(value); } else { this->changeValueContainer<unsigned long>(value);        return true; } } ///< Assigns a new value by changing type and creating a new container.
476            inline bool assignValue(const long long& value)            { if (this->value_ && this->value_->type_ == MT_Type::LongLong)         { return this->value_->setValue(value); } else { this->changeValueContainer<long long>(value);            return true; } } ///< Assigns a new value by changing type and creating a new container.
477            inline bool assignValue(const unsigned long long& value)   { if (this->value_ && this->value_->type_ == MT_Type::UnsignedLongLong) { return this->value_->setValue(value); } else { this->changeValueContainer<unsigned long long>(value);   return true; } } ///< Assigns a new value by changing type and creating a new container.
478            inline bool assignValue(const float& value)                { if (this->value_ && this->value_->type_ == MT_Type::Float)            { return this->value_->setValue(value); } else { this->changeValueContainer<float>(value);                return true; } } ///< Assigns a new value by changing type and creating a new container.
479            inline bool assignValue(const double& value)               { if (this->value_ && this->value_->type_ == MT_Type::Double)           { return this->value_->setValue(value); } else { this->changeValueContainer<double>(value);               return true; } } ///< Assigns a new value by changing type and creating a new container.
480            inline bool assignValue(const long double& value)          { if (this->value_ && this->value_->type_ == MT_Type::LongDouble)       { return this->value_->setValue(value); } else { this->changeValueContainer<long double>(value);          return true; } } ///< Assigns a new value by changing type and creating a new container.
481            inline bool assignValue(const bool& value)                 { if (this->value_ && this->value_->type_ == MT_Type::Bool)             { return this->value_->setValue(value); } else { this->changeValueContainer<bool>(value);                 return true; } } ///< Assigns a new value by changing type and creating a new container.
482            inline bool assignValue(      void* const& value)          { if (this->value_ && this->value_->type_ == MT_Type::VoidPointer)      { return this->value_->setValue(value); } else { this->changeValueContainer<void*>(value);                return true; } } ///< Assigns a new value by changing type and creating a new container.
483            inline bool assignValue(const std::string& value)          { if (this->value_ && this->value_->type_ == MT_Type::String)           { return this->value_->setValue(value); } else { this->changeValueContainer<std::string>(value);          return true; } } ///< Assigns a new value by changing type and creating a new container.
484            inline bool assignValue(const orxonox::Vector2& value)     { if (this->value_ && this->value_->type_ == MT_Type::Vector2)          { return this->value_->setValue(value); } else { this->changeValueContainer<orxonox::Vector2>(value);     return true; } } ///< Assigns a new value by changing type and creating a new container.
485            inline bool assignValue(const orxonox::Vector3& value)     { if (this->value_ && this->value_->type_ == MT_Type::Vector3)          { return this->value_->setValue(value); } else { this->changeValueContainer<orxonox::Vector3>(value);     return true; } } ///< Assigns a new value by changing type and creating a new container.
486            inline bool assignValue(const orxonox::Vector4& value)     { if (this->value_ && this->value_->type_ == MT_Type::Vector4)          { return this->value_->setValue(value); } else { this->changeValueContainer<orxonox::Vector4>(value);     return true; } } ///< Assigns a new value by changing type and creating a new container.
487            inline bool assignValue(const orxonox::ColourValue& value) { if (this->value_ && this->value_->type_ == MT_Type::ColourValue)      { return this->value_->setValue(value); } else { this->changeValueContainer<orxonox::ColourValue>(value); return true; } } ///< Assigns a new value by changing type and creating a new container.
488            inline bool assignValue(const orxonox::Quaternion& value)  { if (this->value_ && this->value_->type_ == MT_Type::Quaternion)       { return this->value_->setValue(value); } else { this->changeValueContainer<orxonox::Quaternion>(value);  return true; } } ///< Assigns a new value by changing type and creating a new container.
489            inline bool assignValue(const orxonox::Radian& value)      { if (this->value_ && this->value_->type_ == MT_Type::Radian)           { return this->value_->setValue(value); } else { this->changeValueContainer<orxonox::Radian>(value);      return true; } } ///< Assigns a new value by changing type and creating a new container.
490            inline bool assignValue(const orxonox::Degree& value)      { if (this->value_ && this->value_->type_ == MT_Type::Degree)           { return this->value_->setValue(value); } else { this->changeValueContainer<orxonox::Degree>(value);      return true; } } ///< Assigns a new value by changing type and creating a new container.
491
492            /// Changes the value container.
493            template <typename T> inline void changeValueContainer(const T& value) { if (this->value_) { delete this->value_; } this->createNewValueContainer<T>(value); }
494            /// Creates a new value container (works only with specialized types).
495            template <typename T>        void createNewValueContainer(const T& value) { /* STATIC ASSERT */ *****value; return false; }
496
497            MT_ValueBase* value_; //!< A pointer to the value container
498    };
499
500    /// Puts the MultiType on a stream by using the native << operator of the current type.
501    _UtilExport inline std::ostream& operator<<(std::ostream& outstream, const MultiType& mt) { if (mt.value_) { mt.value_->toString(outstream); } return outstream; }
502
503    template <> inline bool MultiType::isType<char>()                 const { return (this->value_ && this->value_->type_ == MT_Type::Char);             } ///< Returns true if the current type equals the given type.
504    template <> inline bool MultiType::isType<unsigned char>()        const { return (this->value_ && this->value_->type_ == MT_Type::UnsignedChar);     } ///< Returns true if the current type equals the given type.
505    template <> inline bool MultiType::isType<short>()                const { return (this->value_ && this->value_->type_ == MT_Type::Short);            } ///< Returns true if the current type equals the given type.
506    template <> inline bool MultiType::isType<unsigned short>()       const { return (this->value_ && this->value_->type_ == MT_Type::UnsignedShort);    } ///< Returns true if the current type equals the given type.
507    template <> inline bool MultiType::isType<int>()                  const { return (this->value_ && this->value_->type_ == MT_Type::Int);              } ///< Returns true if the current type equals the given type.
508    template <> inline bool MultiType::isType<unsigned int>()         const { return (this->value_ && this->value_->type_ == MT_Type::UnsignedInt);      } ///< Returns true if the current type equals the given type.
509    template <> inline bool MultiType::isType<long>()                 const { return (this->value_ && this->value_->type_ == MT_Type::Long);             } ///< Returns true if the current type equals the given type.
510    template <> inline bool MultiType::isType<unsigned long>()        const { return (this->value_ && this->value_->type_ == MT_Type::UnsignedLong);     } ///< Returns true if the current type equals the given type.
511    template <> inline bool MultiType::isType<long long>()            const { return (this->value_ && this->value_->type_ == MT_Type::LongLong);         } ///< Returns true if the current type equals the given type.
512    template <> inline bool MultiType::isType<unsigned long long>()   const { return (this->value_ && this->value_->type_ == MT_Type::UnsignedLongLong); } ///< Returns true if the current type equals the given type.
513    template <> inline bool MultiType::isType<float>()                const { return (this->value_ && this->value_->type_ == MT_Type::Float);            } ///< Returns true if the current type equals the given type.
514    template <> inline bool MultiType::isType<double>()               const { return (this->value_ && this->value_->type_ == MT_Type::Double);           } ///< Returns true if the current type equals the given type.
515    template <> inline bool MultiType::isType<long double>()          const { return (this->value_ && this->value_->type_ == MT_Type::LongDouble);       } ///< Returns true if the current type equals the given type.
516    template <> inline bool MultiType::isType<bool>()                 const { return (this->value_ && this->value_->type_ == MT_Type::Bool);             } ///< Returns true if the current type equals the given type.
517    template <> inline bool MultiType::isType<void*>()                const { return (this->value_ && this->value_->type_ == MT_Type::VoidPointer);      } ///< Returns true if the current type equals the given type.
518    template <> inline bool MultiType::isType<std::string>()          const { return (this->value_ && this->value_->type_ == MT_Type::String);           } ///< Returns true if the current type equals the given type.
519    template <> inline bool MultiType::isType<orxonox::Vector2>()     const { return (this->value_ && this->value_->type_ == MT_Type::Vector2);          } ///< Returns true if the current type equals the given type.
520    template <> inline bool MultiType::isType<orxonox::Vector3>()     const { return (this->value_ && this->value_->type_ == MT_Type::Vector3);          } ///< Returns true if the current type equals the given type.
521    template <> inline bool MultiType::isType<orxonox::Vector4>()     const { return (this->value_ && this->value_->type_ == MT_Type::Vector4);          } ///< Returns true if the current type equals the given type.
522    template <> inline bool MultiType::isType<orxonox::ColourValue>() const { return (this->value_ && this->value_->type_ == MT_Type::ColourValue);      } ///< Returns true if the current type equals the given type.
523    template <> inline bool MultiType::isType<orxonox::Quaternion>()  const { return (this->value_ && this->value_->type_ == MT_Type::Quaternion);       } ///< Returns true if the current type equals the given type.
524    template <> inline bool MultiType::isType<orxonox::Radian>()      const { return (this->value_ && this->value_->type_ == MT_Type::Radian);           } ///< Returns true if the current type equals the given type.
525    template <> inline bool MultiType::isType<orxonox::Degree>()      const { return (this->value_ && this->value_->type_ == MT_Type::Degree);           } ///< Returns true if the current type equals the given type.
526
527    /// Deletes the content, type becomes MT_Type::Null.
528    template <> inline bool MultiType::convert<void>()                 { this->reset(); return true; }
529
530    // Specialization to avoid ambiguities with the conversion operator
531    template <> inline bool MultiType::convert<std::string>()          { return this->setValue<std::string>         (this->operator std::string());          } ///< Converts the current value to the given type.
532    template <> inline bool MultiType::convert<orxonox::Vector2>()     { return this->setValue<orxonox::Vector2>    (this->operator orxonox::Vector2());     } ///< Converts the current value to the given type.
533    template <> inline bool MultiType::convert<orxonox::Vector3>()     { return this->setValue<orxonox::Vector3>    (this->operator orxonox::Vector3());     } ///< Converts the current value to the given type.
534    template <> inline bool MultiType::convert<orxonox::Vector4>()     { return this->setValue<orxonox::Vector4>    (this->operator orxonox::Vector4());     } ///< Converts the current value to the given type.
535    template <> inline bool MultiType::convert<orxonox::ColourValue>() { return this->setValue<orxonox::ColourValue>(this->operator orxonox::ColourValue()); } ///< Converts the current value to the given type.
536    template <> inline bool MultiType::convert<orxonox::Quaternion>()  { return this->setValue<orxonox::Quaternion> (this->operator orxonox::Quaternion());  } ///< Converts the current value to the given type.
537    template <> inline bool MultiType::convert<orxonox::Radian>()      { return this->setValue<orxonox::Radian>     (this->operator orxonox::Radian());      } ///< Converts the current value to the given type.
538    template <> inline bool MultiType::convert<orxonox::Degree>()      { return this->setValue<orxonox::Degree>     (this->operator orxonox::Degree());      } ///< Converts the current value to the given type.
539
540    // Specialization to avoid ambiguities with the conversion operator
541    template <> inline bool MultiType::convert<const std::string&>()          { return this->convert<std::string>();          } ///< Converts the current value to the given type.
542    template <> inline bool MultiType::convert<const orxonox::Vector2&>()     { return this->convert<orxonox::Vector2>();     } ///< Converts the current value to the given type.
543    template <> inline bool MultiType::convert<const orxonox::Vector3&>()     { return this->convert<orxonox::Vector3>();     } ///< Converts the current value to the given type.
544    template <> inline bool MultiType::convert<const orxonox::Vector4&>()     { return this->convert<orxonox::Vector4>();     } ///< Converts the current value to the given type.
545    template <> inline bool MultiType::convert<const orxonox::ColourValue&>() { return this->convert<orxonox::ColourValue>(); } ///< Converts the current value to the given type.
546    template <> inline bool MultiType::convert<const orxonox::Quaternion&>()  { return this->convert<orxonox::Quaternion>();  } ///< Converts the current value to the given type.
547    template <> inline bool MultiType::convert<const orxonox::Radian&>()      { return this->convert<orxonox::Radian>();      } ///< Converts the current value to the given type.
548    template <> inline bool MultiType::convert<const orxonox::Degree&>()      { return this->convert<orxonox::Degree>();      } ///< Converts the current value to the given type.
549
550    template <> _UtilExport void MultiType::createNewValueContainer(const char& value);
551    template <> _UtilExport void MultiType::createNewValueContainer(const unsigned char& value);
552    template <> _UtilExport void MultiType::createNewValueContainer(const short& value);
553    template <> _UtilExport void MultiType::createNewValueContainer(const unsigned short& value);
554    template <> _UtilExport void MultiType::createNewValueContainer(const int& value);
555    template <> _UtilExport void MultiType::createNewValueContainer(const unsigned int& value);
556    template <> _UtilExport void MultiType::createNewValueContainer(const long& value);
557    template <> _UtilExport void MultiType::createNewValueContainer(const unsigned long& value);
558    template <> _UtilExport void MultiType::createNewValueContainer(const long long& value);
559    template <> _UtilExport void MultiType::createNewValueContainer(const unsigned long long& value);
560    template <> _UtilExport void MultiType::createNewValueContainer(const float& value);
561    template <> _UtilExport void MultiType::createNewValueContainer(const double& value);
562    template <> _UtilExport void MultiType::createNewValueContainer(const bool& value);
563    template <> _UtilExport void MultiType::createNewValueContainer(const long double& value);
564    template <> _UtilExport void MultiType::createNewValueContainer(      void* const& value);
565    template <> _UtilExport void MultiType::createNewValueContainer(const std::string& value);
566    template <> _UtilExport void MultiType::createNewValueContainer(const orxonox::Vector2& value);
567    template <> _UtilExport void MultiType::createNewValueContainer(const orxonox::Vector3& value);
568    template <> _UtilExport void MultiType::createNewValueContainer(const orxonox::Vector4& value);
569    template <> _UtilExport void MultiType::createNewValueContainer(const orxonox::ColourValue& value);
570    template <> _UtilExport void MultiType::createNewValueContainer(const orxonox::Quaternion& value);
571    template <> _UtilExport void MultiType::createNewValueContainer(const orxonox::Radian& value);
572    template <> _UtilExport void MultiType::createNewValueContainer(const orxonox::Degree& value);
573
574    inline bool MultiType::setValue(const char& value)                  { if (this->value_) { return this->value_->setValue(value); } else { return this->assignValue(value); } } ///< Assigns the given value and converts it to the current type.
575    inline bool MultiType::setValue(const unsigned char& value)         { if (this->value_) { return this->value_->setValue(value); } else { return this->assignValue(value); } } ///< Assigns the given value and converts it to the current type.
576    inline bool MultiType::setValue(const short& value)                 { if (this->value_) { return this->value_->setValue(value); } else { return this->assignValue(value); } } ///< Assigns the given value and converts it to the current type.
577    inline bool MultiType::setValue(const unsigned short& value)        { if (this->value_) { return this->value_->setValue(value); } else { return this->assignValue(value); } } ///< Assigns the given value and converts it to the current type.
578    inline bool MultiType::setValue(const int& value)                   { if (this->value_) { return this->value_->setValue(value); } else { return this->assignValue(value); } } ///< Assigns the given value and converts it to the current type.
579    inline bool MultiType::setValue(const unsigned int& value)          { if (this->value_) { return this->value_->setValue(value); } else { return this->assignValue(value); } } ///< Assigns the given value and converts it to the current type.
580    inline bool MultiType::setValue(const long& value)                  { if (this->value_) { return this->value_->setValue(value); } else { return this->assignValue(value); } } ///< Assigns the given value and converts it to the current type.
581    inline bool MultiType::setValue(const unsigned long& value)         { if (this->value_) { return this->value_->setValue(value); } else { return this->assignValue(value); } } ///< Assigns the given value and converts it to the current type.
582    inline bool MultiType::setValue(const long long& value)             { if (this->value_) { return this->value_->setValue(value); } else { return this->assignValue(value); } } ///< Assigns the given value and converts it to the current type.
583    inline bool MultiType::setValue(const unsigned long long& value)    { if (this->value_) { return this->value_->setValue(value); } else { return this->assignValue(value); } } ///< Assigns the given value and converts it to the current type.
584    inline bool MultiType::setValue(const float& value)                 { if (this->value_) { return this->value_->setValue(value); } else { return this->assignValue(value); } } ///< Assigns the given value and converts it to the current type.
585    inline bool MultiType::setValue(const double& value)                { if (this->value_) { return this->value_->setValue(value); } else { return this->assignValue(value); } } ///< Assigns the given value and converts it to the current type.
586    inline bool MultiType::setValue(const long double& value)           { if (this->value_) { return this->value_->setValue(value); } else { return this->assignValue(value); } } ///< Assigns the given value and converts it to the current type.
587    inline bool MultiType::setValue(const bool& value)                  { if (this->value_) { return this->value_->setValue(value); } else { return this->assignValue(value); } } ///< Assigns the given value and converts it to the current type.
588    inline bool MultiType::setValue(      void* const& value)           { if (this->value_) { return this->value_->setValue(value); } else { return this->assignValue(value); } } ///< Assigns the given value and converts it to the current type.
589    inline bool MultiType::setValue(const std::string& value)           { if (this->value_) { return this->value_->setValue(value); } else { return this->assignValue(value); } } ///< Assigns the given value and converts it to the current type.
590    inline bool MultiType::setValue(const orxonox::Vector2& value)      { if (this->value_) { return this->value_->setValue(value); } else { return this->assignValue(value); } } ///< Assigns the given value and converts it to the current type.
591    inline bool MultiType::setValue(const orxonox::Vector3& value)      { if (this->value_) { return this->value_->setValue(value); } else { return this->assignValue(value); } } ///< Assigns the given value and converts it to the current type.
592    inline bool MultiType::setValue(const orxonox::Vector4& value)      { if (this->value_) { return this->value_->setValue(value); } else { return this->assignValue(value); } } ///< Assigns the given value and converts it to the current type.
593    inline bool MultiType::setValue(const orxonox::ColourValue& value)  { if (this->value_) { return this->value_->setValue(value); } else { return this->assignValue(value); } } ///< Assigns the given value and converts it to the current type.
594    inline bool MultiType::setValue(const orxonox::Quaternion& value)   { if (this->value_) { return this->value_->setValue(value); } else { return this->assignValue(value); } } ///< Assigns the given value and converts it to the current type.
595    inline bool MultiType::setValue(const orxonox::Radian& value)       { if (this->value_) { return this->value_->setValue(value); } else { return this->assignValue(value); } } ///< Assigns the given value and converts it to the current type.
596    inline bool MultiType::setValue(const orxonox::Degree& value)       { if (this->value_) { return this->value_->setValue(value); } else { return this->assignValue(value); } } ///< Assigns the given value and converts it to the current type.
597
598    /// Assigns the given value and converts it to the current type.
599    inline bool MultiType::setValue(const char* value)                  { if (this->value_) { return this->value_->setValue(std::string(value)); } else { return this->assignValue(std::string(value)); } }
600}
601
602#endif /* _MultiType_H__ */
Note: See TracBrowser for help on using the repository browser.