Planet

navi

home

PPS

about

screenshots

download

development

forum

Context Navigation

source: code/branches/core3/src/util/MultiType.h @ 1746

Last change on this file since 1746 was 1729, checked in by rgrieder, 16 years ago
Suppressing compiler warnings is not anymore necessary in MultiType (no inheritance with assignment operators).
Property svn:eol-style set to `native`
File size: 35.4 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	#ifndef _MultiType_H__
30	#define _MultiType_H__
31
32	#include "UtilPrereqs.h"
33
34	#include <boost/static_assert.hpp>
35
36	#include "Math.h"
37
38	enum MT_Type
39	{
40	MT_null,
41	MT_char,
42	MT_uchar,
43	MT_short,
44	MT_ushort,
45	MT_int,
46	MT_uint,
47	MT_long,
48	MT_ulong,
49	MT_longlong,
50	MT_ulonglong,
51	MT_float,
52	MT_double,
53	MT_longdouble,
54	MT_bool,
55	MT_void,
56	MT_string,
57	MT_vector2,
58	MT_vector3,
59	MT_vector4,
60	MT_colourvalue,
61	MT_quaternion,
62	MT_radian,
63	MT_degree
64	};
65
66	class _UtilExport MultiType
67	{
68	_UtilExport friend std::ostream& operator<<(std::ostream& outstream, const MultiType& mt);
69	template <typename T> friend struct MT_Value;
70
71	struct _UtilExport MT_ValueBase
72	{
73	MT_ValueBase(MT_Type type) : type_(type) {}
74	virtual ~MT_ValueBase() {}
75
76	virtual MT_ValueBase* clone() const = 0;
77
78	virtual void reset() = 0;
79	virtual void assimilate(const MultiType& other) = 0;
80	const MT_Type& getType() const { return this->type_; }
81
82	virtual void setValue(const char& value) = 0;
83	virtual void setValue(const unsigned char& value) = 0;
84	virtual void setValue(const short& value) = 0;
85	virtual void setValue(const unsigned short& value) = 0;
86	virtual void setValue(const int& value) = 0;
87	virtual void setValue(const unsigned int& value) = 0;
88	virtual void setValue(const long& value) = 0;
89	virtual void setValue(const unsigned long& value) = 0;
90	virtual void setValue(const long long& value) = 0;
91	virtual void setValue(const unsigned long long& value) = 0;
92	virtual void setValue(const float& value) = 0;
93	virtual void setValue(const double& value) = 0;
94	virtual void setValue(const long double& value) = 0;
95	virtual void setValue(const bool& value) = 0;
96	virtual void setValue( void* const& value) = 0;
97	virtual void setValue(const std::string& value) = 0;
98	virtual void setValue(const orxonox::Vector2& value) = 0;
99	virtual void setValue(const orxonox::Vector3& value) = 0;
100	virtual void setValue(const orxonox::Vector4& value) = 0;
101	virtual void setValue(const orxonox::ColourValue& value) = 0;
102	virtual void setValue(const orxonox::Quaternion& value) = 0;
103	virtual void setValue(const orxonox::Radian& value) = 0;
104	virtual void setValue(const orxonox::Degree& value) = 0;
105
106	virtual operator char() const = 0;
107	virtual operator unsigned char() const = 0;
108	virtual operator short() const = 0;
109	virtual operator unsigned short() const = 0;
110	virtual operator int() const = 0;
111	virtual operator unsigned int() const = 0;
112	virtual operator long() const = 0;
113	virtual operator unsigned long() const = 0;
114	virtual operator long long() const = 0;
115	virtual operator unsigned long long() const = 0;
116	virtual operator float() const = 0;
117	virtual operator double() const = 0;
118	virtual operator long double() const = 0;
119	virtual operator bool() const = 0;
120	virtual operator void*() const = 0;
121	virtual operator std::string() const = 0;
122	virtual operator orxonox::Vector2() const = 0;
123	virtual operator orxonox::Vector3() const = 0;
124	virtual operator orxonox::Vector4() const = 0;
125	virtual operator orxonox::ColourValue() const = 0;
126	virtual operator orxonox::Quaternion() const = 0;
127	virtual operator orxonox::Radian() const = 0;
128	virtual operator orxonox::Degree() const = 0;
129
130	virtual void toString(std::ostream& outstream) const = 0;
131
132	MT_Type type_;
133	};
134
135	public:
136	inline MultiType() : value_(0) {}
137	inline MultiType(const char& value) : value_(0) { this->assignValue(value); }
138	inline MultiType(const unsigned char& value) : value_(0) { this->assignValue(value); }
139	inline MultiType(const short& value) : value_(0) { this->assignValue(value); }
140	inline MultiType(const unsigned short& value) : value_(0) { this->assignValue(value); }
141	inline MultiType(const int& value) : value_(0) { this->assignValue(value); }
142	inline MultiType(const unsigned int& value) : value_(0) { this->assignValue(value); }
143	inline MultiType(const long& value) : value_(0) { this->assignValue(value); }
144	inline MultiType(const unsigned long& value) : value_(0) { this->assignValue(value); }
145	inline MultiType(const long long& value) : value_(0) { this->assignValue(value); }
146	inline MultiType(const unsigned long long& value) : value_(0) { this->assignValue(value); }
147	inline MultiType(const float& value) : value_(0) { this->assignValue(value); }
148	inline MultiType(const double& value) : value_(0) { this->assignValue(value); }
149	inline MultiType(const long double& value) : value_(0) { this->assignValue(value); }
150	inline MultiType(const bool& value) : value_(0) { this->assignValue(value); }
151	inline MultiType( void* const& value) : value_(0) { this->assignValue(value); }
152	inline MultiType(const std::string& value) : value_(0) { this->assignValue(value); }
153	inline MultiType(const orxonox::Vector2& value) : value_(0) { this->assignValue(value); }
154	inline MultiType(const orxonox::Vector3& value) : value_(0) { this->assignValue(value); }
155	inline MultiType(const orxonox::Vector4& value) : value_(0) { this->assignValue(value); }
156	inline MultiType(const orxonox::ColourValue& value) : value_(0) { this->assignValue(value); }
157	inline MultiType(const orxonox::Quaternion& value) : value_(0) { this->assignValue(value); }
158	inline MultiType(const orxonox::Radian& value) : value_(0) { this->assignValue(value); }
159	inline MultiType(const orxonox::Degree& value) : value_(0) { this->assignValue(value); }
160	inline MultiType(const char* value) : value_(0) { this->setValue(std::string(value)); }
161	inline MultiType(const MultiType& other) : value_(0) { this->setValue(other); }
162	inline MultiType(MT_Type type) : value_(0) { this->setType(type); }
163
164	inline ~MultiType() { if (this->value_) { delete this->value_; } }
165
166	template <typename V> inline MultiType& operator=(const V& value) { this->setValue(value); return (*this); }
167	inline MultiType& operator=(const MultiType& other) { this->setValue(other); return (*this); }
168	inline MultiType& operator=(MT_Type type) { this->setType(type); return (*this); }
169
170	inline void setValue(const char& value);
171	inline void setValue(const unsigned char& value);
172	inline void setValue(const short& value);
173	inline void setValue(const unsigned short& value);
174	inline void setValue(const int& value);
175	inline void setValue(const unsigned int& value);
176	inline void setValue(const long& value);
177	inline void setValue(const unsigned long& value);
178	inline void setValue(const long long& value);
179	inline void setValue(const unsigned long long& value);
180	inline void setValue(const float& value);
181	inline void setValue(const double& value);
182	inline void setValue(const long double& value);
183	inline void setValue(const bool& value);
184	inline void setValue( void* const& value);
185	inline void setValue(const std::string& value);
186	inline void setValue(const orxonox::Vector2& value);
187	inline void setValue(const orxonox::Vector3& value);
188	inline void setValue(const orxonox::Vector4& value);
189	inline void setValue(const orxonox::ColourValue& value);
190	inline void setValue(const orxonox::Quaternion& value);
191	inline void setValue(const orxonox::Radian& value);
192	inline void setValue(const orxonox::Degree& value);
193	template <typename V> inline void setValue(V* value) { if (this->value_) { this->value_->setValue((void)value); } else { this->assignValue((void)value); } }
194	void setValue(const MultiType& other) { if (this->value_) { this->value_->assimilate(other); } else { if (other.value_) { this->value_ = other.value_->clone(); } } }
195	template <typename T, typename V> inline void setValue(const V& value) { this->setType<T>(); this->setValue(value); }
196	inline void setValue(const char* value);
197
198	inline void copy(const MultiType& other) { if (this->value_) { delete this->value_; } this->value_ = (other.value_) ? other.value_->clone() : 0; }
199
200	template <typename T> inline void convert() { this->setValue<T>((T)(*this)); }
201	inline void convert(const MultiType& other) { this->convert(other.getType()); }
202	void convert(MT_Type type);
203
204	inline void reset() { if (this->value_) { delete this->value_; this->value_ = 0; } }
205
206	template <typename T> inline void setType() { this->assignValue(T()); }
207	inline void setType(const MultiType& other) { this->setType(other.getType()); }
208	inline void setType(MT_Type type) { this->reset(); this->convert(type); }
209
210	inline MT_Type getType() const { return (this->value_) ? this->value_->type_ : MT_null; }
211	inline bool isType(MT_Type type) const { return (this->value_) ? (this->value_->type_ == type) : (type == MT_null); }
212	template <typename T> inline bool isType() const { return false; }
213	std::string getTypename() const;
214
215	operator char() const;
216	operator unsigned char() const;
217	operator short() const;
218	operator unsigned short() const;
219	operator int() const;
220	operator unsigned int() const;
221	operator long() const;
222	operator unsigned long() const;
223	operator long long() const;
224	operator unsigned long long() const;
225	operator float() const;
226	operator double() const;
227	operator long double() const;
228	operator bool() const;
229	operator void*() const;
230	operator std::string() const;
231	operator orxonox::Vector2() const;
232	operator orxonox::Vector3() const;
233	operator orxonox::Vector4() const;
234	operator orxonox::ColourValue() const;
235	operator orxonox::Quaternion() const;
236	operator orxonox::Radian() const;
237	operator orxonox::Degree() const;
238	template <class T> operator T() const { return ((T)this->operator void*()); }
239
240	inline void getValue(char* value) const { if (this->value_) { (value) = (this->value_); } }
241	inline void getValue(unsigned char* value) const { if (this->value_) { (value) = (this->value_); } }
242	inline void getValue(short* value) const { if (this->value_) { (value) = (this->value_); } }
243	inline void getValue(unsigned short* value) const { if (this->value_) { (value) = (this->value_); } }
244	inline void getValue(int* value) const { if (this->value_) { (value) = (this->value_); } }
245	inline void getValue(unsigned int* value) const { if (this->value_) { (value) = (this->value_); } }
246	inline void getValue(long* value) const { if (this->value_) { (value) = (this->value_); } }
247	inline void getValue(unsigned long* value) const { if (this->value_) { (value) = (this->value_); } }
248	inline void getValue(long long* value) const { if (this->value_) { (value) = (this->value_); } }
249	inline void getValue(unsigned long long* value) const { if (this->value_) { (value) = (this->value_); } }
250	inline void getValue(float* value) const { if (this->value_) { (value) = (this->value_); } }
251	inline void getValue(double* value) const { if (this->value_) { (value) = (this->value_); } }
252	inline void getValue(long double* value) const { if (this->value_) { (value) = (this->value_); } }
253	inline void getValue(bool* value) const { if (this->value_) { (value) = (this->value_); } }
254	inline void getValue(void* value) const { if (this->value_) { value = (*this->value_); } }
255	inline void getValue(std::string* value) const { if (this->value_) { (*value) = this->value_->operator std::string(); } }
256	inline void getValue(orxonox::Vector2* value) const { if (this->value_) { (*value) = this->value_->operator orxonox::Vector2(); } }
257	inline void getValue(orxonox::Vector3* value) const { if (this->value_) { (*value) = this->value_->operator orxonox::Vector3(); } }
258	inline void getValue(orxonox::Vector4* value) const { if (this->value_) { (*value) = this->value_->operator orxonox::Vector4(); } }
259	inline void getValue(orxonox::ColourValue* value) const { if (this->value_) { (*value) = this->value_->operator orxonox::ColourValue(); } }
260	inline void getValue(orxonox::Quaternion* value) const { if (this->value_) { (*value) = this->value_->operator orxonox::Quaternion(); } }
261	inline void getValue(orxonox::Radian* value) const { if (this->value_) { (*value) = this->value_->operator orxonox::Radian(); } }
262	inline void getValue(orxonox::Degree* value) const { if (this->value_) { (*value) = this->value_->operator orxonox::Degree(); } }
263
264	inline char getChar() const { return this->operator char(); }
265	inline unsigned char getUnsignedChar() const { return this->operator unsigned char(); }
266	inline short getShort() const { return this->operator short(); }
267	inline unsigned short getUnsignedShort() const { return this->operator unsigned short(); }
268	inline int getInt() const { return this->operator int(); }
269	inline unsigned int getUnsignedInt() const { return this->operator unsigned int(); }
270	inline long getLong() const { return this->operator long(); }
271	inline unsigned long getUnsignedLong() const { return this->operator unsigned long(); }
272	inline long long getLongLong() const { return this->operator long long(); }
273	inline unsigned long long getUnsignedLongLong() const { return this->operator unsigned long long(); }
274	inline float getFloat() const { return this->operator float(); }
275	inline double getDouble() const { return this->operator double(); }
276	inline long double getLongDouble() const { return this->operator long double(); }
277	inline bool getBool() const { return this->operator bool(); }
278	inline void* getVoid() const { return this->operator void*(); }
279	inline std::string getString() const { return this->operator std::string(); }
280	inline orxonox::Vector2 getVector2() const { return this->operator orxonox::Vector2(); }
281	inline orxonox::Vector3 getVector3() const { return this->operator orxonox::Vector3(); }
282	inline orxonox::Vector4 getVector4() const { return this->operator orxonox::Vector4(); }
283	inline orxonox::ColourValue getColourValue() const { return this->operator orxonox::ColourValue(); }
284	inline orxonox::Quaternion getQuaternion() const { return this->operator orxonox::Quaternion(); }
285	inline orxonox::Radian getRadian() const { return this->operator orxonox::Radian(); }
286	inline orxonox::Degree getDegree() const { return this->operator orxonox::Degree(); }
287	template <typename T> inline T* getPointer() const { return ((T*)this->getVoid()); }
288
289	private:
290	inline void assignValue(const char& value) { if (this->value_ && this->value_->type_ == MT_char) { this->value_->setValue(value); } else { this->changeValueContainer<char>(value); } }
291	inline void assignValue(const unsigned char& value) { if (this->value_ && this->value_->type_ == MT_uchar) { this->value_->setValue(value); } else { this->changeValueContainer<unsigned char>(value); } }
292	inline void assignValue(const short& value) { if (this->value_ && this->value_->type_ == MT_short) { this->value_->setValue(value); } else { this->changeValueContainer<short>(value); } }
293	inline void assignValue(const unsigned short& value) { if (this->value_ && this->value_->type_ == MT_ushort) { this->value_->setValue(value); } else { this->changeValueContainer<unsigned short>(value); } }
294	inline void assignValue(const int& value) { if (this->value_ && this->value_->type_ == MT_int) { this->value_->setValue(value); } else { this->changeValueContainer<int>(value); } }
295	inline void assignValue(const unsigned int& value) { if (this->value_ && this->value_->type_ == MT_uint) { this->value_->setValue(value); } else { this->changeValueContainer<unsigned int>(value); } }
296	inline void assignValue(const long& value) { if (this->value_ && this->value_->type_ == MT_long) { this->value_->setValue(value); } else { this->changeValueContainer<long>(value); } }
297	inline void assignValue(const unsigned long& value) { if (this->value_ && this->value_->type_ == MT_ulong) { this->value_->setValue(value); } else { this->changeValueContainer<unsigned long>(value); } }
298	inline void assignValue(const long long& value) { if (this->value_ && this->value_->type_ == MT_longlong) { this->value_->setValue(value); } else { this->changeValueContainer<long long>(value); } }
299	inline void assignValue(const unsigned long long& value) { if (this->value_ && this->value_->type_ == MT_ulonglong) { this->value_->setValue(value); } else { this->changeValueContainer<unsigned long long>(value); } }
300	inline void assignValue(const float& value) { if (this->value_ && this->value_->type_ == MT_float) { this->value_->setValue(value); } else { this->changeValueContainer<float>(value); } }
301	inline void assignValue(const double& value) { if (this->value_ && this->value_->type_ == MT_double) { this->value_->setValue(value); } else { this->changeValueContainer<double>(value); } }
302	inline void assignValue(const long double& value) { if (this->value_ && this->value_->type_ == MT_longdouble) { this->value_->setValue(value); } else { this->changeValueContainer<long double>(value); } }
303	inline void assignValue(const bool& value) { if (this->value_ && this->value_->type_ == MT_bool) { this->value_->setValue(value); } else { this->changeValueContainer<bool>(value); } }
304	inline void assignValue( void* const& value) { if (this->value_ && this->value_->type_ == MT_void) { this->value_->setValue(value); } else { this->changeValueContainer<void*>(value); } }
305	inline void assignValue(const std::string& value) { if (this->value_ && this->value_->type_ == MT_string) { this->value_->setValue(value); } else { this->changeValueContainer<std::string>(value); } }
306	inline void assignValue(const orxonox::Vector2& value) { if (this->value_ && this->value_->type_ == MT_vector2) { this->value_->setValue(value); } else { this->changeValueContainer<orxonox::Vector2>(value); } }
307	inline void assignValue(const orxonox::Vector3& value) { if (this->value_ && this->value_->type_ == MT_vector3) { this->value_->setValue(value); } else { this->changeValueContainer<orxonox::Vector3>(value); } }
308	inline void assignValue(const orxonox::Vector4& value) { if (this->value_ && this->value_->type_ == MT_vector4) { this->value_->setValue(value); } else { this->changeValueContainer<orxonox::Vector4>(value); } }
309	inline void assignValue(const orxonox::ColourValue& value) { if (this->value_ && this->value_->type_ == MT_colourvalue) { this->value_->setValue(value); } else { this->changeValueContainer<orxonox::ColourValue>(value); } }
310	inline void assignValue(const orxonox::Quaternion& value) { if (this->value_ && this->value_->type_ == MT_quaternion) { this->value_->setValue(value); } else { this->changeValueContainer<orxonox::Quaternion>(value); } }
311	inline void assignValue(const orxonox::Radian& value) { if (this->value_ && this->value_->type_ == MT_radian) { this->value_->setValue(value); } else { this->changeValueContainer<orxonox::Radian>(value); } }
312	inline void assignValue(const orxonox::Degree& value) { if (this->value_ && this->value_->type_ == MT_degree) { this->value_->setValue(value); } else { this->changeValueContainer<orxonox::Degree>(value); } }
313
314	template <typename T> inline void changeValueContainer(const T& value) { if (this->value_) { delete this->value_; } this->createNewValueContainer<T>(value); }
315	template <typename T> void createNewValueContainer(const T& value) { BOOST_STATIC_ASSERT(sizeof(T) == 0); }
316
317	MT_ValueBase* value_;
318	};
319
320	_UtilExport inline std::ostream& operator<<(std::ostream& outstream, const MultiType& mt) { if (mt.value_) { mt.value_->toString(outstream); } return outstream; }
321
322	template <> inline bool MultiType::isType<char>() const { return (this->value_ && this->value_->type_ == MT_char); }
323	template <> inline bool MultiType::isType<unsigned char>() const { return (this->value_ && this->value_->type_ == MT_uchar); }
324	template <> inline bool MultiType::isType<short>() const { return (this->value_ && this->value_->type_ == MT_short); }
325	template <> inline bool MultiType::isType<unsigned short>() const { return (this->value_ && this->value_->type_ == MT_ushort); }
326	template <> inline bool MultiType::isType<int>() const { return (this->value_ && this->value_->type_ == MT_int); }
327	template <> inline bool MultiType::isType<unsigned int>() const { return (this->value_ && this->value_->type_ == MT_uint); }
328	template <> inline bool MultiType::isType<long>() const { return (this->value_ && this->value_->type_ == MT_long); }
329	template <> inline bool MultiType::isType<unsigned long>() const { return (this->value_ && this->value_->type_ == MT_ulong); }
330	template <> inline bool MultiType::isType<long long>() const { return (this->value_ && this->value_->type_ == MT_longlong); }
331	template <> inline bool MultiType::isType<unsigned long long>() const { return (this->value_ && this->value_->type_ == MT_ulonglong); }
332	template <> inline bool MultiType::isType<float>() const { return (this->value_ && this->value_->type_ == MT_float); }
333	template <> inline bool MultiType::isType<double>() const { return (this->value_ && this->value_->type_ == MT_double); }
334	template <> inline bool MultiType::isType<long double>() const { return (this->value_ && this->value_->type_ == MT_longdouble); }
335	template <> inline bool MultiType::isType<bool>() const { return (this->value_ && this->value_->type_ == MT_bool); }
336	template <> inline bool MultiType::isType<void*>() const { return (this->value_ && this->value_->type_ == MT_void); }
337	template <> inline bool MultiType::isType<std::string>() const { return (this->value_ && this->value_->type_ == MT_string); }
338	template <> inline bool MultiType::isType<orxonox::Vector2>() const { return (this->value_ && this->value_->type_ == MT_vector2); }
339	template <> inline bool MultiType::isType<orxonox::Vector3>() const { return (this->value_ && this->value_->type_ == MT_vector3); }
340	template <> inline bool MultiType::isType<orxonox::Vector4>() const { return (this->value_ && this->value_->type_ == MT_vector4); }
341	template <> inline bool MultiType::isType<orxonox::ColourValue>() const { return (this->value_ && this->value_->type_ == MT_colourvalue); }
342	template <> inline bool MultiType::isType<orxonox::Quaternion>() const { return (this->value_ && this->value_->type_ == MT_quaternion); }
343	template <> inline bool MultiType::isType<orxonox::Radian>() const { return (this->value_ && this->value_->type_ == MT_radian); }
344	template <> inline bool MultiType::isType<orxonox::Degree>() const { return (this->value_ && this->value_->type_ == MT_degree); }
345
346	template <> inline void MultiType::convert<std::string>() { this->setValue<std::string> (this->operator std::string()); }
347	template <> inline void MultiType::convert<orxonox::Vector2>() { this->setValue<orxonox::Vector2> (this->operator orxonox::Vector2()); }
348	template <> inline void MultiType::convert<orxonox::Vector3>() { this->setValue<orxonox::Vector3> (this->operator orxonox::Vector3()); }
349	template <> inline void MultiType::convert<orxonox::Vector4>() { this->setValue<orxonox::Vector4> (this->operator orxonox::Vector4()); }
350	template <> inline void MultiType::convert<orxonox::ColourValue>() { this->setValue<orxonox::ColourValue>(this->operator orxonox::ColourValue()); }
351	template <> inline void MultiType::convert<orxonox::Quaternion>() { this->setValue<orxonox::Quaternion> (this->operator orxonox::Quaternion()); }
352	template <> inline void MultiType::convert<orxonox::Radian>() { this->setValue<orxonox::Radian> (this->operator orxonox::Radian()); }
353	template <> inline void MultiType::convert<orxonox::Degree>() { this->setValue<orxonox::Degree> (this->operator orxonox::Degree()); }
354
355	template <> inline void MultiType::convert<const std::string&>() { this->convert<std::string>(); }
356	template <> inline void MultiType::convert<const orxonox::Vector2&>() { this->convert<orxonox::Vector2>(); }
357	template <> inline void MultiType::convert<const orxonox::Vector3&>() { this->convert<orxonox::Vector3>(); }
358	template <> inline void MultiType::convert<const orxonox::Vector4&>() { this->convert<orxonox::Vector4>(); }
359	template <> inline void MultiType::convert<const orxonox::ColourValue&>() { this->convert<orxonox::ColourValue>(); }
360	template <> inline void MultiType::convert<const orxonox::Quaternion&>() { this->convert<orxonox::Quaternion>(); }
361	template <> inline void MultiType::convert<const orxonox::Radian&>() { this->convert<orxonox::Radian>(); }
362	template <> inline void MultiType::convert<const orxonox::Degree&>() { this->convert<orxonox::Degree>(); }
363
364	template <> void MultiType::createNewValueContainer(const char& value);
365	template <> void MultiType::createNewValueContainer(const unsigned char& value);
366	template <> void MultiType::createNewValueContainer(const short& value);
367	template <> void MultiType::createNewValueContainer(const unsigned short& value);
368	template <> void MultiType::createNewValueContainer(const int& value);
369	template <> void MultiType::createNewValueContainer(const unsigned int& value);
370	template <> void MultiType::createNewValueContainer(const long& value);
371	template <> void MultiType::createNewValueContainer(const unsigned long& value);
372	template <> void MultiType::createNewValueContainer(const long long& value);
373	template <> void MultiType::createNewValueContainer(const unsigned long long& value);
374	template <> void MultiType::createNewValueContainer(const float& value);
375	template <> void MultiType::createNewValueContainer(const double& value);
376	template <> void MultiType::createNewValueContainer(const bool& value);
377	template <> void MultiType::createNewValueContainer(const long double& value);
378	template <> void MultiType::createNewValueContainer( void* const& value);
379	template <> void MultiType::createNewValueContainer(const std::string& value);
380	template <> void MultiType::createNewValueContainer(const orxonox::Vector2& value);
381	template <> void MultiType::createNewValueContainer(const orxonox::Vector3& value);
382	template <> void MultiType::createNewValueContainer(const orxonox::Vector4& value);
383	template <> void MultiType::createNewValueContainer(const orxonox::ColourValue& value);
384	template <> void MultiType::createNewValueContainer(const orxonox::Quaternion& value);
385	template <> void MultiType::createNewValueContainer(const orxonox::Radian& value);
386	template <> void MultiType::createNewValueContainer(const orxonox::Degree& value);
387
388	inline void MultiType::setValue(const char& value) { if (this->value_) { this->value_->setValue(value); } else { this->assignValue(value); } }
389	inline void MultiType::setValue(const unsigned char& value) { if (this->value_) { this->value_->setValue(value); } else { this->assignValue(value); } }
390	inline void MultiType::setValue(const short& value) { if (this->value_) { this->value_->setValue(value); } else { this->assignValue(value); } }
391	inline void MultiType::setValue(const unsigned short& value) { if (this->value_) { this->value_->setValue(value); } else { this->assignValue(value); } }
392	inline void MultiType::setValue(const int& value) { if (this->value_) { this->value_->setValue(value); } else { this->assignValue(value); } }
393	inline void MultiType::setValue(const unsigned int& value) { if (this->value_) { this->value_->setValue(value); } else { this->assignValue(value); } }
394	inline void MultiType::setValue(const long& value) { if (this->value_) { this->value_->setValue(value); } else { this->assignValue(value); } }
395	inline void MultiType::setValue(const unsigned long& value) { if (this->value_) { this->value_->setValue(value); } else { this->assignValue(value); } }
396	inline void MultiType::setValue(const long long& value) { if (this->value_) { this->value_->setValue(value); } else { this->assignValue(value); } }
397	inline void MultiType::setValue(const unsigned long long& value) { if (this->value_) { this->value_->setValue(value); } else { this->assignValue(value); } }
398	inline void MultiType::setValue(const float& value) { if (this->value_) { this->value_->setValue(value); } else { this->assignValue(value); } }
399	inline void MultiType::setValue(const double& value) { if (this->value_) { this->value_->setValue(value); } else { this->assignValue(value); } }
400	inline void MultiType::setValue(const long double& value) { if (this->value_) { this->value_->setValue(value); } else { this->assignValue(value); } }
401	inline void MultiType::setValue(const bool& value) { if (this->value_) { this->value_->setValue(value); } else { this->assignValue(value); } }
402	inline void MultiType::setValue( void* const& value) { if (this->value_) { this->value_->setValue(value); } else { this->assignValue(value); } }
403	inline void MultiType::setValue(const std::string& value) { if (this->value_) { this->value_->setValue(value); } else { this->assignValue(value); } }
404	inline void MultiType::setValue(const orxonox::Vector2& value) { if (this->value_) { this->value_->setValue(value); } else { this->assignValue(value); } }
405	inline void MultiType::setValue(const orxonox::Vector3& value) { if (this->value_) { this->value_->setValue(value); } else { this->assignValue(value); } }
406	inline void MultiType::setValue(const orxonox::Vector4& value) { if (this->value_) { this->value_->setValue(value); } else { this->assignValue(value); } }
407	inline void MultiType::setValue(const orxonox::ColourValue& value) { if (this->value_) { this->value_->setValue(value); } else { this->assignValue(value); } }
408	inline void MultiType::setValue(const orxonox::Quaternion& value) { if (this->value_) { this->value_->setValue(value); } else { this->assignValue(value); } }
409	inline void MultiType::setValue(const orxonox::Radian& value) { if (this->value_) { this->value_->setValue(value); } else { this->assignValue(value); } }
410	inline void MultiType::setValue(const orxonox::Degree& value) { if (this->value_) { this->value_->setValue(value); } else { this->assignValue(value); } }
411
412	inline void MultiType::setValue(const char* value) { if (this->value_) { this->value_->setValue(std::string(value)); } else { this->assignValue(std::string(value)); } }
413
414	#endif /* _MultiType_H__ */

Note: See TracBrowser for help on using the repository browser.

Download in other formats: