Added class Variant, a typed union-like wrapper for a single value.

git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@30321 a95241bf-73f2-0310-859d-f6bbb57e9c96

src/apps/debuganalyzer/Jamfile

@@ -12,6 +12,7 @@ Application DebugAnalyzer
 	ModelLoader.cpp
 	Table.cpp
 	ThreadsPage.cpp
+	Variant.cpp
 
 	: libcolumnlistview.a libdebug.so be
 	: DebugAnalyzer.rdef

src/apps/debuganalyzer/Variant.cpp

@@ -0,0 +1,285 @@
+/*
+ * Copyright 2009, Ingo Weinhold, [email protected].
+ * Distributed under the terms of the MIT License.
+ */
+
+#include "Variant.h"
+
+#include <stdlib.h>
+#include <string.h>
+
+
+template<typename NumberType>
+inline NumberType
+Variant::_ToNumber() const
+{
+	switch (fType) {
+		case B_INT8_TYPE:
+			return (NumberType)fInt8;
+		case B_UINT8_TYPE:
+			return (NumberType)fUInt8;
+		case B_INT16_TYPE:
+			return (NumberType)fInt16;
+		case B_UINT16_TYPE:
+			return (NumberType)fUInt16;
+		case B_INT32_TYPE:
+			return (NumberType)fInt32;
+		case B_UINT32_TYPE:
+			return (NumberType)fUInt32;
+		case B_INT64_TYPE:
+			return (NumberType)fInt64;
+		case B_UINT64_TYPE:
+			return (NumberType)fUInt64;
+		case B_FLOAT_TYPE:
+			return (NumberType)fFloat;
+		case B_DOUBLE_TYPE:
+			return (NumberType)fDouble;
+		default:
+			return 0;
+	}
+}
+
+
+Variant::~Variant()
+{
+	Unset();
+}
+
+
+void
+Variant::Unset()
+{
+	if ((fFlags & VARIANT_OWNS_DATA) != 0) {
+		switch (fType) {
+			case B_STRING_TYPE:
+				free(fString);
+				break;
+			default:
+				break;
+		}
+	}
+
+	fType = 0;
+	fFlags = 0;
+}
+
+
+int8
+Variant::ToInt8() const
+{
+	return _ToNumber<int8>();
+}
+
+
+uint8
+Variant::ToUInt8() const
+{
+	return _ToNumber<uint8>();
+}
+
+
+int16
+Variant::ToInt16() const
+{
+	return _ToNumber<int16>();
+}
+
+
+uint16
+Variant::ToUInt16() const
+{
+	return _ToNumber<uint16>();
+}
+
+
+int32
+Variant::ToInt32() const
+{
+	return _ToNumber<int32>();
+}
+
+
+uint32
+Variant::ToUInt32() const
+{
+	return _ToNumber<uint32>();
+}
+
+
+int64
+Variant::ToInt64() const
+{
+	return _ToNumber<int64>();
+}
+
+
+uint64
+Variant::ToUInt64() const
+{
+	return _ToNumber<uint64>();
+}
+
+
+float
+Variant::ToFloat() const
+{
+	return _ToNumber<float>();
+}
+
+
+double
+Variant::ToDouble() const
+{
+	return _ToNumber<double>();
+}
+
+
+void*
+Variant::ToPointer() const
+{
+	return fType == B_POINTER_TYPE ? fString : NULL;
+}
+
+
+const char*
+Variant::ToString() const
+{
+	return fType == B_STRING_TYPE ? fString : NULL;
+}
+
+
+void
+Variant::_SetTo(const Variant& other)
+{
+	if ((other.fFlags & VARIANT_OWNS_DATA) != 0) {
+		switch (other.fType) {
+			case B_STRING_TYPE:
+				fType = B_STRING_TYPE;
+				fString = strdup(other.fString);
+				fFlags = VARIANT_OWNS_DATA;
+				return;
+			default:
+				break;
+		}
+	}
+
+	memcpy(this, &other, sizeof(Variant));
+}
+
+
+void
+Variant::_SetTo(int8 value)
+{
+	fType = B_INT8_TYPE;
+	fFlags = 0;
+	fInt8 = value;
+}
+
+
+void
+Variant::_SetTo(uint8 value)
+{
+	fType = B_UINT8_TYPE;
+	fFlags = 0;
+	fUInt8 = value;
+}
+
+
+void
+Variant::_SetTo(int16 value)
+{
+	fType = B_INT16_TYPE;
+	fFlags = 0;
+	fInt16 = value;
+}
+
+
+void
+Variant::_SetTo(uint16 value)
+{
+	fType = B_UINT16_TYPE;
+	fFlags = 0;
+	fUInt16 = value;
+}
+
+
+void
+Variant::_SetTo(int32 value)
+{
+	fType = B_INT32_TYPE;
+	fFlags = 0;
+	fInt32 = value;
+}
+
+
+void
+Variant::_SetTo(uint32 value)
+{
+	fType = B_UINT32_TYPE;
+	fFlags = 0;
+	fUInt32 = value;
+}
+
+
+void
+Variant::_SetTo(int64 value)
+{
+	fType = B_INT64_TYPE;
+	fFlags = 0;
+	fInt64 = value;
+}
+
+
+void
+Variant::_SetTo(uint64 value)
+{
+	fType = B_UINT64_TYPE;
+	fFlags = 0;
+	fUInt64 = value;
+}
+
+
+void
+Variant::_SetTo(float value)
+{
+	fType = B_FLOAT_TYPE;
+	fFlags = 0;
+	fFloat = value;
+}
+
+
+void
+Variant::_SetTo(double value)
+{
+	fType = B_DOUBLE_TYPE;
+	fFlags = 0;
+	fDouble = value;
+}
+
+
+void
+Variant::_SetTo(const void* value)
+{
+	fType = B_POINTER_TYPE;
+	fFlags = 0;
+	fPointer = (void*)value;
+}
+
+
+void
+Variant::_SetTo(const char* value, uint32 flags)
+{
+	fType = B_STRING_TYPE;
+
+	if (value != NULL) {
+		if ((flags & VARIANT_DONT_COPY_DATA) == 0) {
+			fString = strdup(value);
+			fFlags |= VARIANT_OWNS_DATA;
+		} else {
+			fString = (char*)value;
+			fFlags |= flags & VARIANT_OWNS_DATA;
+		}
+	} else
+		fString = NULL;
+}
+

src/apps/debuganalyzer/Variant.h

@@ -0,0 +1,309 @@
+/*
+ * Copyright 2009, Ingo Weinhold, [email protected].
+ * Distributed under the terms of the MIT License.
+ */
+#ifndef VARIANT_H
+#define VARIANT_H
+
+
+#include <SupportDefs.h>
+#include <TypeConstants.h>
+
+
+enum {
+	VARIANT_DONT_COPY_DATA	= 0x01,
+	VARIANT_OWNS_DATA		= 0x02
+};
+
+
+class Variant {
+public:
+	inline						Variant();
+	inline						Variant(int8 value);
+	inline						Variant(uint8 value);
+	inline						Variant(int16 value);
+	inline						Variant(uint16 value);
+	inline						Variant(int32 value);
+	inline						Variant(uint32 value);
+	inline						Variant(int64 value);
+	inline						Variant(uint64 value);
+	inline						Variant(float value);
+	inline						Variant(double value);
+	inline						Variant(const void* value);
+	inline						Variant(const char* value,
+									uint32 flags = 0);
+	inline						Variant(const Variant& other);
+								~Variant();
+
+	inline	void				SetTo(const Variant& other);
+	inline	void				SetTo(int8 value);
+	inline	void				SetTo(uint8 value);
+	inline	void				SetTo(int16 value);
+	inline	void				SetTo(uint16 value);
+	inline	void				SetTo(int32 value);
+	inline	void				SetTo(uint32 value);
+	inline	void				SetTo(int64 value);
+	inline	void				SetTo(uint64 value);
+	inline	void				SetTo(float value);
+	inline	void				SetTo(double value);
+	inline	void				SetTo(const void* value);
+	inline	void				SetTo(const char* value,
+									uint32 flags = 0);
+			void				Unset();
+
+	inline	Variant&			operator=(const Variant& other);
+
+			type_code			Type() const		{ return fType; }
+
+			int8				ToInt8() const;
+			uint8				ToUInt8() const;
+			int16				ToInt16() const;
+			uint16				ToUInt16() const;
+			int32				ToInt32() const;
+			uint32				ToUInt32() const;
+			int64				ToInt64() const;
+			uint64				ToUInt64() const;
+			float				ToFloat() const;
+			double				ToDouble() const;
+			void*				ToPointer() const;
+			const char*			ToString() const;
+
+private:
+			void				_SetTo(const Variant& other);
+			void				_SetTo(int8 value);
+			void				_SetTo(uint8 value);
+			void				_SetTo(int16 value);
+			void				_SetTo(uint16 value);
+			void				_SetTo(int32 value);
+			void				_SetTo(uint32 value);
+			void				_SetTo(int64 value);
+			void				_SetTo(uint64 value);
+			void				_SetTo(float value);
+			void				_SetTo(double value);
+			void				_SetTo(const void* value);
+			void				_SetTo(const char* value,
+									uint32 flags);
+
+	template<typename NumberType>
+	inline	NumberType			_ToNumber() const;
+
+private:
+			type_code			fType;
+			uint32				fFlags;
+			union {
+				int8			fInt8;
+				uint8			fUInt8;
+				int16			fInt16;
+				uint16			fUInt16;
+				int32			fInt32;
+				uint32			fUInt32;
+				int64			fInt64;
+				uint64			fUInt64;
+				float			fFloat;
+				double			fDouble;
+				void*			fPointer;
+				char*			fString;
+			};
+};
+
+
+Variant::Variant()
+	:
+	fType(0),
+	fFlags(0)
+{
+}
+
+
+Variant::Variant(int8 value)
+{
+	_SetTo(value);
+}
+
+
+Variant::Variant(uint8 value)
+{
+	_SetTo(value);
+}
+
+
+Variant::Variant(int16 value)
+{
+	_SetTo(value);
+}
+
+
+Variant::Variant(uint16 value)
+{
+	_SetTo(value);
+}
+
+
+Variant::Variant(int32 value)
+{
+	_SetTo(value);
+}
+
+
+Variant::Variant(uint32 value)
+{
+	_SetTo(value);
+}
+
+
+Variant::Variant(int64 value)
+{
+	_SetTo(value);
+}
+
+
+Variant::Variant(uint64 value)
+{
+	_SetTo(value);
+}
+
+
+Variant::Variant(float value)
+{
+	_SetTo(value);
+}
+
+
+Variant::Variant(double value)
+{
+	_SetTo(value);
+}
+
+
+Variant::Variant(const void* value)
+{
+	_SetTo(value);
+}
+
+
+Variant::Variant(const char* value, uint32 flags)
+{
+	_SetTo(value, flags);
+}
+
+
+Variant::Variant(const Variant& other)
+{
+	_SetTo(other);
+}
+
+
+Variant&
+Variant::operator=(const Variant& other)
+{
+	Unset();
+	_SetTo(other);
+	return *this;
+}
+
+
+void
+Variant::SetTo(const Variant& other)
+{
+	Unset();
+	_SetTo(other);
+}
+
+
+void
+Variant::SetTo(int8 value)
+{
+	Unset();
+	_SetTo(value);
+}
+
+
+void
+Variant::SetTo(uint8 value)
+{
+	Unset();
+	_SetTo(value);
+}
+
+
+void
+Variant::SetTo(int16 value)
+{
+	Unset();
+	_SetTo(value);
+}
+
+
+void
+Variant::SetTo(uint16 value)
+{
+	Unset();
+	_SetTo(value);
+}
+
+
+void
+Variant::SetTo(int32 value)
+{
+	Unset();
+	_SetTo(value);
+}
+
+
+void
+Variant::SetTo(uint32 value)
+{
+	Unset();
+	_SetTo(value);
+}
+
+
+void
+Variant::SetTo(int64 value)
+{
+	Unset();
+	_SetTo(value);
+}
+
+
+void
+Variant::SetTo(uint64 value)
+{
+	Unset();
+	_SetTo(value);
+}
+
+
+void
+Variant::SetTo(float value)
+{
+	Unset();
+	_SetTo(value);
+}
+
+
+void
+Variant::SetTo(double value)
+{
+	Unset();
+	_SetTo(value);
+}
+
+
+void
+Variant::SetTo(const void* value)
+{
+	Unset();
+	_SetTo(value);
+}
+
+
+void
+Variant::SetTo(const char* value, uint32 flags)
+{
+	Unset();
+	_SetTo(value, flags);
+}
+
+
+#endif	// VARIANT_H