From 4e632511e464d6cd7cc59da08217232ab703479d Mon Sep 17 00:00:00 2001 From: Ingo Weinhold Date: Wed, 22 Apr 2009 11:55:26 +0000 Subject: [PATCH] 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 | 1 + src/apps/debuganalyzer/Variant.cpp | 285 ++++++++++++++++++++++++++ src/apps/debuganalyzer/Variant.h | 309 +++++++++++++++++++++++++++++ 3 files changed, 595 insertions(+) create mode 100644 src/apps/debuganalyzer/Variant.cpp create mode 100644 src/apps/debuganalyzer/Variant.h diff --git a/src/apps/debuganalyzer/Jamfile b/src/apps/debuganalyzer/Jamfile index c118a01fa8..98e83d4e87 100644 --- a/src/apps/debuganalyzer/Jamfile +++ b/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 diff --git a/src/apps/debuganalyzer/Variant.cpp b/src/apps/debuganalyzer/Variant.cpp new file mode 100644 index 0000000000..94ee9f6138 --- /dev/null +++ b/src/apps/debuganalyzer/Variant.cpp @@ -0,0 +1,285 @@ +/* + * Copyright 2009, Ingo Weinhold, ingo_weinhold@gmx.de. + * Distributed under the terms of the MIT License. + */ + +#include "Variant.h" + +#include +#include + + +template +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(); +} + + +uint8 +Variant::ToUInt8() const +{ + return _ToNumber(); +} + + +int16 +Variant::ToInt16() const +{ + return _ToNumber(); +} + + +uint16 +Variant::ToUInt16() const +{ + return _ToNumber(); +} + + +int32 +Variant::ToInt32() const +{ + return _ToNumber(); +} + + +uint32 +Variant::ToUInt32() const +{ + return _ToNumber(); +} + + +int64 +Variant::ToInt64() const +{ + return _ToNumber(); +} + + +uint64 +Variant::ToUInt64() const +{ + return _ToNumber(); +} + + +float +Variant::ToFloat() const +{ + return _ToNumber(); +} + + +double +Variant::ToDouble() const +{ + return _ToNumber(); +} + + +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; +} + diff --git a/src/apps/debuganalyzer/Variant.h b/src/apps/debuganalyzer/Variant.h new file mode 100644 index 0000000000..b959304c3c --- /dev/null +++ b/src/apps/debuganalyzer/Variant.h @@ -0,0 +1,309 @@ +/* + * Copyright 2009, Ingo Weinhold, ingo_weinhold@gmx.de. + * Distributed under the terms of the MIT License. + */ +#ifndef VARIANT_H +#define VARIANT_H + + +#include +#include + + +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 + 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