Planet

navi

home

PPS

about

screenshots

download

development

forum

Context Navigation

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

Last change on this file since 1768 was 1768, checked in by rgrieder, 16 years ago
gcc test commit again
Property svn:eol-style set to `native`
File size: 35.7 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	//virtual void toString(std::ostream& outstream) const = 0;
132	//inline friend virtual std::ostream& operator <<(std::ostream& outstream, const MT_ValueBase& mtb);
133
134	MT_Type type_;
135	};
136
137	public:
138	inline MultiType() : value_(0) {}
139	inline MultiType(const char& value) : value_(0) { this->assignValue(value); }
140	inline MultiType(const unsigned char& value) : value_(0) { this->assignValue(value); }
141	inline MultiType(const short& value) : value_(0) { this->assignValue(value); }
142	inline MultiType(const unsigned short& value) : value_(0) { this->assignValue(value); }
143	inline MultiType(const int& value) : value_(0) { this->assignValue(value); }
144	inline MultiType(const unsigned int& value) : value_(0) { this->assignValue(value); }
145	inline MultiType(const long& value) : value_(0) { this->assignValue(value); }
146	inline MultiType(const unsigned long& value) : value_(0) { this->assignValue(value); }
147	inline MultiType(const long long& value) : value_(0) { this->assignValue(value); }
148	inline MultiType(const unsigned long long& value) : value_(0) { this->assignValue(value); }
149	inline MultiType(const float& value) : value_(0) { this->assignValue(value); }
150	inline MultiType(const double& value) : value_(0) { this->assignValue(value); }
151	inline MultiType(const long double& value) : value_(0) { this->assignValue(value); }
152	inline MultiType(const bool& value) : value_(0) { this->assignValue(value); }
153	inline MultiType( void* const& value) : value_(0) { this->assignValue(value); }
154	inline MultiType(const std::string& value) : value_(0) { this->assignValue(value); }
155	inline MultiType(const orxonox::Vector2& value) : value_(0) { this->assignValue(value); }
156	inline MultiType(const orxonox::Vector3& value) : value_(0) { this->assignValue(value); }
157	inline MultiType(const orxonox::Vector4& value) : value_(0) { this->assignValue(value); }
158	inline MultiType(const orxonox::ColourValue& value) : value_(0) { this->assignValue(value); }
159	inline MultiType(const orxonox::Quaternion& value) : value_(0) { this->assignValue(value); }
160	inline MultiType(const orxonox::Radian& value) : value_(0) { this->assignValue(value); }
161	inline MultiType(const orxonox::Degree& value) : value_(0) { this->assignValue(value); }
162	inline MultiType(const char* value) : value_(0) { this->setValue(std::string(value)); }
163	inline MultiType(const MultiType& other) : value_(0) { this->setValue(other); }
164	inline MultiType(MT_Type type) : value_(0) { this->setType(type); }
165
166	inline ~MultiType() { if (this->value_) { delete this->value_; } }
167
168	template <typename V> inline MultiType& operator=(const V& value) { this->setValue(value); return (*this); }
169	inline MultiType& operator=(const MultiType& other) { this->setValue(other); return (*this); }
170	inline MultiType& operator=(MT_Type type) { this->setType(type); return (*this); }
171
172	inline void setValue(const char& value);
173	inline void setValue(const unsigned char& value);
174	inline void setValue(const short& value);
175	inline void setValue(const unsigned short& value);
176	inline void setValue(const int& value);
177	inline void setValue(const unsigned int& value);
178	inline void setValue(const long& value);
179	inline void setValue(const unsigned long& value);
180	inline void setValue(const long long& value);
181	inline void setValue(const unsigned long long& value);
182	inline void setValue(const float& value);
183	inline void setValue(const double& value);
184	inline void setValue(const long double& value);
185	inline void setValue(const bool& value);
186	inline void setValue( void* const& value);
187	inline void setValue(const std::string& value);
188	inline void setValue(const orxonox::Vector2& value);
189	inline void setValue(const orxonox::Vector3& value);
190	inline void setValue(const orxonox::Vector4& value);
191	inline void setValue(const orxonox::ColourValue& value);
192	inline void setValue(const orxonox::Quaternion& value);
193	inline void setValue(const orxonox::Radian& value);
194	inline void setValue(const orxonox::Degree& value);
195	template <typename V> inline void setValue(V* value) { if (this->value_) { this->value_->setValue((void)value); } else { this->assignValue((void)value); } }
196	void setValue(const MultiType& other) { if (this->value_) { this->value_->assimilate(other); } else { if (other.value_) { this->value_ = other.value_->clone(); } } }
197	template <typename T, typename V> inline void setValue(const V& value) { this->setType<T>(); this->setValue(value); }
198	inline void setValue(const char* value);
199
200	inline void copy(const MultiType& other) { if (this->value_) { delete this->value_; } this->value_ = (other.value_) ? other.value_->clone() : 0; }
201
202	template <typename T> inline void convert() { this->setValue<T>((T)(*this)); }
203	inline void convert(const MultiType& other) { this->convert(other.getType()); }
204	void convert(MT_Type type);
205
206	inline void reset() { if (this->value_) { delete this->value_; this->value_ = 0; } }
207
208	template <typename T> inline void setType() { this->assignValue(T()); }
209	inline void setType(const MultiType& other) { this->setType(other.getType()); }
210	inline void setType(MT_Type type) { this->reset(); this->convert(type); }
211
212	inline MT_Type getType() const { return (this->value_) ? this->value_->type_ : MT_null; }
213	inline bool isType(MT_Type type) const { return (this->value_) ? (this->value_->type_ == type) : (type == MT_null); }
214	template <typename T> inline bool isType() const { return false; }
215	std::string getTypename() const;
216
217	operator char() const;
218	operator unsigned char() const;
219	operator short() const;
220	operator unsigned short() const;
221	operator int() const;
222	operator unsigned int() const;
223	operator long() const;
224	operator unsigned long() const;
225	operator long long() const;
226	operator unsigned long long() const;
227	operator float() const;
228	operator double() const;
229	operator long double() const;
230	operator bool() const;
231	operator void*() const;
232	operator std::string() const;
233	operator orxonox::Vector2() const;
234	operator orxonox::Vector3() const;
235	operator orxonox::Vector4() const;
236	operator orxonox::ColourValue() const;
237	operator orxonox::Quaternion() const;
238	operator orxonox::Radian() const;
239	operator orxonox::Degree() const;
240	template <class T> operator T() const { return ((T)this->operator void*()); }
241
242	inline friend std::ostream& operator<<(std::ostream& outstream, const MultiType& mt) { if (mt.value_) { mt.value_->toString(outstream); } return outstream; }
243
244	inline void getValue(char* value) const { if (this->value_) { (value) = (this->value_); } }
245	inline void getValue(unsigned char* value) const { if (this->value_) { (value) = (this->value_); } }
246	inline void getValue(short* value) const { if (this->value_) { (value) = (this->value_); } }
247	inline void getValue(unsigned short* value) const { if (this->value_) { (value) = (this->value_); } }
248	inline void getValue(int* value) const { if (this->value_) { (value) = (this->value_); } }
249	inline void getValue(unsigned int* value) const { if (this->value_) { (value) = (this->value_); } }
250	inline void getValue(long* value) const { if (this->value_) { (value) = (this->value_); } }
251	inline void getValue(unsigned long* value) const { if (this->value_) { (value) = (this->value_); } }
252	inline void getValue(long long* value) const { if (this->value_) { (value) = (this->value_); } }
253	inline void getValue(unsigned long long* value) const { if (this->value_) { (value) = (this->value_); } }
254	inline void getValue(float* value) const { if (this->value_) { (value) = (this->value_); } }
255	inline void getValue(double* value) const { if (this->value_) { (value) = (this->value_); } }
256	inline void getValue(long double* value) const { if (this->value_) { (value) = (this->value_); } }
257	inline void getValue(bool* value) const { if (this->value_) { (value) = (this->value_); } }
258	inline void getValue(void* value) const { if (this->value_) { value = (*this->value_); } }
259	inline void getValue(std::string* value) const { if (this->value_) { (*value) = this->value_->operator std::string(); } }
260	inline void getValue(orxonox::Vector2* value) const { if (this->value_) { (*value) = this->value_->operator orxonox::Vector2(); } }
261	inline void getValue(orxonox::Vector3* value) const { if (this->value_) { (*value) = this->value_->operator orxonox::Vector3(); } }
262	inline void getValue(orxonox::Vector4* value) const { if (this->value_) { (*value) = this->value_->operator orxonox::Vector4(); } }
263	inline void getValue(orxonox::ColourValue* value) const { if (this->value_) { (*value) = this->value_->operator orxonox::ColourValue(); } }
264	inline void getValue(orxonox::Quaternion* value) const { if (this->value_) { (*value) = this->value_->operator orxonox::Quaternion(); } }
265	inline void getValue(orxonox::Radian* value) const { if (this->value_) { (*value) = this->value_->operator orxonox::Radian(); } }
266	inline void getValue(orxonox::Degree* value) const { if (this->value_) { (*value) = this->value_->operator orxonox::Degree(); } }
267
268	inline char getChar() const { return this->operator char(); }
269	inline unsigned char getUnsignedChar() const { return this->operator unsigned char(); }
270	inline short getShort() const { return this->operator short(); }
271	inline unsigned short getUnsignedShort() const { return this->operator unsigned short(); }
272	inline int getInt() const { return this->operator int(); }
273	inline unsigned int getUnsignedInt() const { return this->operator unsigned int(); }
274	inline long getLong() const { return this->operator long(); }
275	inline unsigned long getUnsignedLong() const { return this->operator unsigned long(); }
276	inline long long getLongLong() const { return this->operator long long(); }
277	inline unsigned long long getUnsignedLongLong() const { return this->operator unsigned long long(); }
278	inline float getFloat() const { return this->operator float(); }
279	inline double getDouble() const { return this->operator double(); }
280	inline long double getLongDouble() const { return this->operator long double(); }
281	inline bool getBool() const { return this->operator bool(); }
282	inline void* getVoid() const { return this->operator void*(); }
283	inline std::string getString() const { return this->operator std::string(); }
284	inline orxonox::Vector2 getVector2() const { return this->operator orxonox::Vector2(); }
285	inline orxonox::Vector3 getVector3() const { return this->operator orxonox::Vector3(); }
286	inline orxonox::Vector4 getVector4() const { return this->operator orxonox::Vector4(); }
287	inline orxonox::ColourValue getColourValue() const { return this->operator orxonox::ColourValue(); }
288	inline orxonox::Quaternion getQuaternion() const { return this->operator orxonox::Quaternion(); }
289	inline orxonox::Radian getRadian() const { return this->operator orxonox::Radian(); }
290	inline orxonox::Degree getDegree() const { return this->operator orxonox::Degree(); }
291	template <typename T> inline T* getPointer() const { return ((T*)this->getVoid()); }
292
293	private:
294	inline void assignValue(const char& value) { if (this->value_ && this->value_->type_ == MT_char) { this->value_->setValue(value); } else { this->changeValueContainer<char>(value); } }
295	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); } }
296	inline void assignValue(const short& value) { if (this->value_ && this->value_->type_ == MT_short) { this->value_->setValue(value); } else { this->changeValueContainer<short>(value); } }
297	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); } }
298	inline void assignValue(const int& value) { if (this->value_ && this->value_->type_ == MT_int) { this->value_->setValue(value); } else { this->changeValueContainer<int>(value); } }
299	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); } }
300	inline void assignValue(const long& value) { if (this->value_ && this->value_->type_ == MT_long) { this->value_->setValue(value); } else { this->changeValueContainer<long>(value); } }
301	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); } }
302	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); } }
303	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); } }
304	inline void assignValue(const float& value) { if (this->value_ && this->value_->type_ == MT_float) { this->value_->setValue(value); } else { this->changeValueContainer<float>(value); } }
305	inline void assignValue(const double& value) { if (this->value_ && this->value_->type_ == MT_double) { this->value_->setValue(value); } else { this->changeValueContainer<double>(value); } }
306	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); } }
307	inline void assignValue(const bool& value) { if (this->value_ && this->value_->type_ == MT_bool) { this->value_->setValue(value); } else { this->changeValueContainer<bool>(value); } }
308	inline void assignValue( void* const& value) { if (this->value_ && this->value_->type_ == MT_void) { this->value_->setValue(value); } else { this->changeValueContainer<void*>(value); } }
309	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); } }
310	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); } }
311	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); } }
312	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); } }
313	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); } }
314	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); } }
315	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); } }
316	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); } }
317
318	template <typename T> inline void changeValueContainer(const T& value) { if (this->value_) { delete this->value_; } this->createNewValueContainer<T>(value); }
319	template <typename T> void createNewValueContainer(const T& value) { BOOST_STATIC_ASSERT(sizeof(T) == 0); }
320
321	MT_ValueBase* value_;
322	};
323
324	//_UtilExport inline std::ostream& operator<<(std::ostream& outstream, const MultiType& mt) { if (mt.value_) { mt.value_->toString(outstream); } return outstream; }
325
326	template <> inline bool MultiType::isType<char>() const { return (this->value_ && this->value_->type_ == MT_char); }
327	template <> inline bool MultiType::isType<unsigned char>() const { return (this->value_ && this->value_->type_ == MT_uchar); }
328	template <> inline bool MultiType::isType<short>() const { return (this->value_ && this->value_->type_ == MT_short); }
329	template <> inline bool MultiType::isType<unsigned short>() const { return (this->value_ && this->value_->type_ == MT_ushort); }
330	template <> inline bool MultiType::isType<int>() const { return (this->value_ && this->value_->type_ == MT_int); }
331	template <> inline bool MultiType::isType<unsigned int>() const { return (this->value_ && this->value_->type_ == MT_uint); }
332	template <> inline bool MultiType::isType<long>() const { return (this->value_ && this->value_->type_ == MT_long); }
333	template <> inline bool MultiType::isType<unsigned long>() const { return (this->value_ && this->value_->type_ == MT_ulong); }
334	template <> inline bool MultiType::isType<long long>() const { return (this->value_ && this->value_->type_ == MT_longlong); }
335	template <> inline bool MultiType::isType<unsigned long long>() const { return (this->value_ && this->value_->type_ == MT_ulonglong); }
336	template <> inline bool MultiType::isType<float>() const { return (this->value_ && this->value_->type_ == MT_float); }
337	template <> inline bool MultiType::isType<double>() const { return (this->value_ && this->value_->type_ == MT_double); }
338	template <> inline bool MultiType::isType<long double>() const { return (this->value_ && this->value_->type_ == MT_longdouble); }
339	template <> inline bool MultiType::isType<bool>() const { return (this->value_ && this->value_->type_ == MT_bool); }
340	template <> inline bool MultiType::isType<void*>() const { return (this->value_ && this->value_->type_ == MT_void); }
341	template <> inline bool MultiType::isType<std::string>() const { return (this->value_ && this->value_->type_ == MT_string); }
342	template <> inline bool MultiType::isType<orxonox::Vector2>() const { return (this->value_ && this->value_->type_ == MT_vector2); }
343	template <> inline bool MultiType::isType<orxonox::Vector3>() const { return (this->value_ && this->value_->type_ == MT_vector3); }
344	template <> inline bool MultiType::isType<orxonox::Vector4>() const { return (this->value_ && this->value_->type_ == MT_vector4); }
345	template <> inline bool MultiType::isType<orxonox::ColourValue>() const { return (this->value_ && this->value_->type_ == MT_colourvalue); }
346	template <> inline bool MultiType::isType<orxonox::Quaternion>() const { return (this->value_ && this->value_->type_ == MT_quaternion); }
347	template <> inline bool MultiType::isType<orxonox::Radian>() const { return (this->value_ && this->value_->type_ == MT_radian); }
348	template <> inline bool MultiType::isType<orxonox::Degree>() const { return (this->value_ && this->value_->type_ == MT_degree); }
349
350	template <> inline void MultiType::convert<std::string>() { this->setValue<std::string> (this->operator std::string()); }
351	template <> inline void MultiType::convert<orxonox::Vector2>() { this->setValue<orxonox::Vector2> (this->operator orxonox::Vector2()); }
352	template <> inline void MultiType::convert<orxonox::Vector3>() { this->setValue<orxonox::Vector3> (this->operator orxonox::Vector3()); }
353	template <> inline void MultiType::convert<orxonox::Vector4>() { this->setValue<orxonox::Vector4> (this->operator orxonox::Vector4()); }
354	template <> inline void MultiType::convert<orxonox::ColourValue>() { this->setValue<orxonox::ColourValue>(this->operator orxonox::ColourValue()); }
355	template <> inline void MultiType::convert<orxonox::Quaternion>() { this->setValue<orxonox::Quaternion> (this->operator orxonox::Quaternion()); }
356	template <> inline void MultiType::convert<orxonox::Radian>() { this->setValue<orxonox::Radian> (this->operator orxonox::Radian()); }
357	template <> inline void MultiType::convert<orxonox::Degree>() { this->setValue<orxonox::Degree> (this->operator orxonox::Degree()); }
358
359	template <> inline void MultiType::convert<const std::string&>() { this->convert<std::string>(); }
360	template <> inline void MultiType::convert<const orxonox::Vector2&>() { this->convert<orxonox::Vector2>(); }
361	template <> inline void MultiType::convert<const orxonox::Vector3&>() { this->convert<orxonox::Vector3>(); }
362	template <> inline void MultiType::convert<const orxonox::Vector4&>() { this->convert<orxonox::Vector4>(); }
363	template <> inline void MultiType::convert<const orxonox::ColourValue&>() { this->convert<orxonox::ColourValue>(); }
364	template <> inline void MultiType::convert<const orxonox::Quaternion&>() { this->convert<orxonox::Quaternion>(); }
365	template <> inline void MultiType::convert<const orxonox::Radian&>() { this->convert<orxonox::Radian>(); }
366	template <> inline void MultiType::convert<const orxonox::Degree&>() { this->convert<orxonox::Degree>(); }
367
368	template <> void MultiType::createNewValueContainer(const char& value);
369	template <> void MultiType::createNewValueContainer(const unsigned char& value);
370	template <> void MultiType::createNewValueContainer(const short& value);
371	template <> void MultiType::createNewValueContainer(const unsigned short& value);
372	template <> void MultiType::createNewValueContainer(const int& value);
373	template <> void MultiType::createNewValueContainer(const unsigned int& value);
374	template <> void MultiType::createNewValueContainer(const long& value);
375	template <> void MultiType::createNewValueContainer(const unsigned long& value);
376	template <> void MultiType::createNewValueContainer(const long long& value);
377	template <> void MultiType::createNewValueContainer(const unsigned long long& value);
378	template <> void MultiType::createNewValueContainer(const float& value);
379	template <> void MultiType::createNewValueContainer(const double& value);
380	template <> void MultiType::createNewValueContainer(const bool& value);
381	template <> void MultiType::createNewValueContainer(const long double& value);
382	template <> void MultiType::createNewValueContainer( void* const& value);
383	template <> void MultiType::createNewValueContainer(const std::string& value);
384	template <> void MultiType::createNewValueContainer(const orxonox::Vector2& value);
385	template <> void MultiType::createNewValueContainer(const orxonox::Vector3& value);
386	template <> void MultiType::createNewValueContainer(const orxonox::Vector4& value);
387	template <> void MultiType::createNewValueContainer(const orxonox::ColourValue& value);
388	template <> void MultiType::createNewValueContainer(const orxonox::Quaternion& value);
389	template <> void MultiType::createNewValueContainer(const orxonox::Radian& value);
390	template <> void MultiType::createNewValueContainer(const orxonox::Degree& value);
391
392	inline void MultiType::setValue(const char& value) { if (this->value_) { this->value_->setValue(value); } else { this->assignValue(value); } }
393	inline void MultiType::setValue(const unsigned char& value) { if (this->value_) { this->value_->setValue(value); } else { this->assignValue(value); } }
394	inline void MultiType::setValue(const short& value) { if (this->value_) { this->value_->setValue(value); } else { this->assignValue(value); } }
395	inline void MultiType::setValue(const unsigned short& value) { if (this->value_) { this->value_->setValue(value); } else { this->assignValue(value); } }
396	inline void MultiType::setValue(const int& value) { if (this->value_) { this->value_->setValue(value); } else { this->assignValue(value); } }
397	inline void MultiType::setValue(const unsigned int& value) { if (this->value_) { this->value_->setValue(value); } else { this->assignValue(value); } }
398	inline void MultiType::setValue(const long& value) { if (this->value_) { this->value_->setValue(value); } else { this->assignValue(value); } }
399	inline void MultiType::setValue(const unsigned long& value) { if (this->value_) { this->value_->setValue(value); } else { this->assignValue(value); } }
400	inline void MultiType::setValue(const long long& value) { if (this->value_) { this->value_->setValue(value); } else { this->assignValue(value); } }
401	inline void MultiType::setValue(const unsigned long long& value) { if (this->value_) { this->value_->setValue(value); } else { this->assignValue(value); } }
402	inline void MultiType::setValue(const float& value) { if (this->value_) { this->value_->setValue(value); } else { this->assignValue(value); } }
403	inline void MultiType::setValue(const double& value) { if (this->value_) { this->value_->setValue(value); } else { this->assignValue(value); } }
404	inline void MultiType::setValue(const long double& value) { if (this->value_) { this->value_->setValue(value); } else { this->assignValue(value); } }
405	inline void MultiType::setValue(const bool& value) { if (this->value_) { this->value_->setValue(value); } else { this->assignValue(value); } }
406	inline void MultiType::setValue( void* const& value) { if (this->value_) { this->value_->setValue(value); } else { this->assignValue(value); } }
407	inline void MultiType::setValue(const std::string& value) { if (this->value_) { this->value_->setValue(value); } else { this->assignValue(value); } }
408	inline void MultiType::setValue(const orxonox::Vector2& value) { if (this->value_) { this->value_->setValue(value); } else { this->assignValue(value); } }
409	inline void MultiType::setValue(const orxonox::Vector3& value) { if (this->value_) { this->value_->setValue(value); } else { this->assignValue(value); } }
410	inline void MultiType::setValue(const orxonox::Vector4& value) { if (this->value_) { this->value_->setValue(value); } else { this->assignValue(value); } }
411	inline void MultiType::setValue(const orxonox::ColourValue& value) { if (this->value_) { this->value_->setValue(value); } else { this->assignValue(value); } }
412	inline void MultiType::setValue(const orxonox::Quaternion& value) { if (this->value_) { this->value_->setValue(value); } else { this->assignValue(value); } }
413	inline void MultiType::setValue(const orxonox::Radian& value) { if (this->value_) { this->value_->setValue(value); } else { this->assignValue(value); } }
414	inline void MultiType::setValue(const orxonox::Degree& value) { if (this->value_) { this->value_->setValue(value); } else { this->assignValue(value); } }
415
416	inline void MultiType::setValue(const char* value) { if (this->value_) { this->value_->setValue(std::string(value)); } else { this->assignValue(std::string(value)); } }
417
418	#endif /* _MultiType_H__ */

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

Download in other formats: