xref: /haiku/headers/private/shared/Variant.h (revision 857b0c2bef2de29d8f02f6daf7c8379bf782dccb) 
1 /*
2  * Copyright 2009, Ingo Weinhold, ingo_weinhold@gmx.de.
3  * Distributed under the terms of the MIT License.
4  */
5 #ifndef _VARIANT_H
6 #define _VARIANT_H
7 
8 
9 #include <SupportDefs.h>
10 #include <TypeConstants.h>
11 
12 #include <Referenceable.h>
13 
14 
15 enum {
16 	B_VARIANT_DONT_COPY_DATA		= 0x01,
17 	B_VARIANT_OWNS_DATA				= 0x02,
18 	B_VARIANT_REFERENCEABLE_DATA	= 0x04
19 };
20 
21 
22 class BVariant {
23 public:
24 	inline						BVariant();
25 	inline						BVariant(bool value);
26 	inline						BVariant(int8 value);
27 	inline						BVariant(uint8 value);
28 	inline						BVariant(int16 value);
29 	inline						BVariant(uint16 value);
30 	inline						BVariant(int32 value);
31 	inline						BVariant(uint32 value);
32 	inline						BVariant(int64 value);
33 	inline						BVariant(uint64 value);
34 	inline						BVariant(float value);
35 	inline						BVariant(double value);
36 	inline						BVariant(const void* value);
37 	inline						BVariant(const char* value,
38 									uint32 flags = 0);
39 	inline						BVariant(BReferenceable* value, type_code type);
40 									// type must be a custom type
41 	inline						BVariant(const BVariant& other);
42 								~BVariant();
43 
44 	inline	void				SetTo(const BVariant& other);
45 	inline	void				SetTo(bool value);
46 	inline	void				SetTo(int8 value);
47 	inline	void				SetTo(uint8 value);
48 	inline	void				SetTo(int16 value);
49 	inline	void				SetTo(uint16 value);
50 	inline	void				SetTo(int32 value);
51 	inline	void				SetTo(uint32 value);
52 	inline	void				SetTo(int64 value);
53 	inline	void				SetTo(uint64 value);
54 	inline	void				SetTo(float value);
55 	inline	void				SetTo(double value);
56 	inline	void				SetTo(const void* value);
57 	inline	void				SetTo(const char* value,
58 									uint32 flags = 0);
59 	inline	void				SetTo(BReferenceable* value, type_code type);
60 									// type must be a custom type
61 			status_t			SetToTypedData(const void* data,
62 									type_code type);
63 			void				Unset();
64 
65 	inline	BVariant&			operator=(const BVariant& other);
66 
67 			bool				operator==(const BVariant& other) const;
68 	inline	bool				operator!=(const BVariant& other) const;
69 
70 	inline	type_code			Type() const		{ return fType; }
71 			size_t				Size() const;
72 			const uint8*		Bytes() const;
73 
74 	inline	bool				IsNumber() const;
75 	inline	bool				IsInteger(bool* _isSigned = NULL) const;
76 	inline	bool				IsFloat() const;
77 									// floating point, not just float
78 
79 			bool				ToBool() const;
80 			int8				ToInt8() const;
81 			uint8				ToUInt8() const;
82 			int16				ToInt16() const;
83 			uint16				ToUInt16() const;
84 			int32				ToInt32() const;
85 			uint32				ToUInt32() const;
86 			int64				ToInt64() const;
87 			uint64				ToUInt64() const;
88 			float				ToFloat() const;
89 			double				ToDouble() const;
90 			void*				ToPointer() const;
91 			const char*			ToString() const;
92 			BReferenceable*		ToReferenceable() const;
93 
94 			void				SwapEndianess();
95 									// has effect only on scalar types (pointer
96 									// counting as scalar, not string, though)
97 
98 	static	size_t				SizeOfType(type_code type);
99 	static	bool				TypeIsNumber(type_code type);
100 	static	bool				TypeIsInteger(type_code type,
101 									bool* _isSigned = NULL);
102 	static	bool				TypeIsFloat(type_code type);
103 
104 private:
105 			void				_SetTo(const BVariant& other);
106 			void				_SetTo(bool value);
107 			void				_SetTo(int8 value);
108 			void				_SetTo(uint8 value);
109 			void				_SetTo(int16 value);
110 			void				_SetTo(uint16 value);
111 			void				_SetTo(int32 value);
112 			void				_SetTo(uint32 value);
113 			void				_SetTo(int64 value);
114 			void				_SetTo(uint64 value);
115 			void				_SetTo(float value);
116 			void				_SetTo(double value);
117 			void				_SetTo(const void* value);
118 			bool				_SetTo(const char* value,
119 									uint32 flags);
120 			void				_SetTo(BReferenceable* value, type_code type);
121 
122 	template<typename NumberType>
123 	inline	NumberType			_ToNumber() const;
124 
125 private:
126 			type_code			fType;
127 			uint32				fFlags;
128 			union {
129 				bool			fBool;
130 				int8			fInt8;
131 				uint8			fUInt8;
132 				int16			fInt16;
133 				uint16			fUInt16;
134 				int32			fInt32;
135 				uint32			fUInt32;
136 				int64			fInt64;
137 				uint64			fUInt64;
138 				float			fFloat;
139 				double			fDouble;
140 				void*			fPointer;
141 				char*			fString;
142 				BReferenceable*	fReferenceable;
143 				uint8			fBytes[8];
144 			};
145 };
146 
147 
148 BVariant::BVariant()
149 	:
150 	fType(0),
151 	fFlags(0)
152 {
153 }
154 
155 
156 BVariant::BVariant(bool value)
157 {
158 	_SetTo(value);
159 }
160 
161 
162 BVariant::BVariant(int8 value)
163 {
164 	_SetTo(value);
165 }
166 
167 
168 BVariant::BVariant(uint8 value)
169 {
170 	_SetTo(value);
171 }
172 
173 
174 BVariant::BVariant(int16 value)
175 {
176 	_SetTo(value);
177 }
178 
179 
180 BVariant::BVariant(uint16 value)
181 {
182 	_SetTo(value);
183 }
184 
185 
186 BVariant::BVariant(int32 value)
187 {
188 	_SetTo(value);
189 }
190 
191 
192 BVariant::BVariant(uint32 value)
193 {
194 	_SetTo(value);
195 }
196 
197 
198 BVariant::BVariant(int64 value)
199 {
200 	_SetTo(value);
201 }
202 
203 
204 BVariant::BVariant(uint64 value)
205 {
206 	_SetTo(value);
207 }
208 
209 
210 BVariant::BVariant(float value)
211 {
212 	_SetTo(value);
213 }
214 
215 
216 BVariant::BVariant(double value)
217 {
218 	_SetTo(value);
219 }
220 
221 
222 BVariant::BVariant(const void* value)
223 {
224 	_SetTo(value);
225 }
226 
227 
228 BVariant::BVariant(const char* value, uint32 flags)
229 {
230 	_SetTo(value, flags);
231 }
232 
233 
234 BVariant::BVariant(BReferenceable* value, type_code type)
235 {
236 	_SetTo(value, type);
237 }
238 
239 
240 BVariant::BVariant(const BVariant& other)
241 {
242 	_SetTo(other);
243 }
244 
245 
246 BVariant&
247 BVariant::operator=(const BVariant& other)
248 {
249 	Unset();
250 	_SetTo(other);
251 	return *this;
252 }
253 
254 
255 bool
256 BVariant::operator!=(const BVariant& other) const
257 {
258 	return !(*this == other);
259 }
260 
261 
262 void
263 BVariant::SetTo(const BVariant& other)
264 {
265 	Unset();
266 	_SetTo(other);
267 }
268 
269 
270 void
271 BVariant::SetTo(bool value)
272 {
273 	Unset();
274 	_SetTo(value);
275 }
276 
277 
278 void
279 BVariant::SetTo(int8 value)
280 {
281 	Unset();
282 	_SetTo(value);
283 }
284 
285 
286 void
287 BVariant::SetTo(uint8 value)
288 {
289 	Unset();
290 	_SetTo(value);
291 }
292 
293 
294 void
295 BVariant::SetTo(int16 value)
296 {
297 	Unset();
298 	_SetTo(value);
299 }
300 
301 
302 void
303 BVariant::SetTo(uint16 value)
304 {
305 	Unset();
306 	_SetTo(value);
307 }
308 
309 
310 void
311 BVariant::SetTo(int32 value)
312 {
313 	Unset();
314 	_SetTo(value);
315 }
316 
317 
318 void
319 BVariant::SetTo(uint32 value)
320 {
321 	Unset();
322 	_SetTo(value);
323 }
324 
325 
326 void
327 BVariant::SetTo(int64 value)
328 {
329 	Unset();
330 	_SetTo(value);
331 }
332 
333 
334 void
335 BVariant::SetTo(uint64 value)
336 {
337 	Unset();
338 	_SetTo(value);
339 }
340 
341 
342 void
343 BVariant::SetTo(float value)
344 {
345 	Unset();
346 	_SetTo(value);
347 }
348 
349 
350 void
351 BVariant::SetTo(double value)
352 {
353 	Unset();
354 	_SetTo(value);
355 }
356 
357 
358 void
359 BVariant::SetTo(const void* value)
360 {
361 	Unset();
362 	_SetTo(value);
363 }
364 
365 
366 void
367 BVariant::SetTo(const char* value, uint32 flags)
368 {
369 	Unset();
370 	_SetTo(value, flags);
371 }
372 
373 
374 void
375 BVariant::SetTo(BReferenceable* value, type_code type)
376 {
377 	Unset();
378 	_SetTo(value, type);
379 }
380 
381 
382 bool
383 BVariant::IsNumber() const
384 {
385 	return TypeIsNumber(fType);
386 }
387 
388 
389 bool
390 BVariant::IsInteger(bool* _isSigned) const
391 {
392 	return TypeIsInteger(fType, _isSigned);
393 }
394 
395 
396 bool
397 BVariant::IsFloat() const
398 {
399 	return TypeIsFloat(fType);
400 }
401 
402 
403 #endif	// _VARIANT_H
404