/* * Copyright 2009, Ingo Weinhold, ingo_weinhold@gmx.de. * Distributed under the terms of the MIT License. */ #ifndef _VARIANT_H #define _VARIANT_H #include #include #include enum { B_VARIANT_DONT_COPY_DATA = 0x01, B_VARIANT_OWNS_DATA = 0x02, B_VARIANT_REFERENCEABLE_DATA = 0x04 }; class BVariant { public: inline BVariant(); inline BVariant(bool value); inline BVariant(int8 value); inline BVariant(uint8 value); inline BVariant(int16 value); inline BVariant(uint16 value); inline BVariant(int32 value); inline BVariant(uint32 value); inline BVariant(int64 value); inline BVariant(uint64 value); inline BVariant(float value); inline BVariant(double value); inline BVariant(const void* value); inline BVariant(const char* value, uint32 flags = 0); inline BVariant(BReferenceable* value, type_code type); // type must be a custom type inline BVariant(const BVariant& other); ~BVariant(); inline void SetTo(const BVariant& other); inline void SetTo(bool value); 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); inline void SetTo(BReferenceable* value, type_code type); // type must be a custom type status_t SetToTypedData(const void* data, type_code type); void Unset(); inline BVariant& operator=(const BVariant& other); bool operator==(const BVariant& other) const; inline bool operator!=(const BVariant& other) const; inline type_code Type() const { return fType; } size_t Size() const; const uint8* Bytes() const; inline bool IsNumber() const; inline bool IsInteger(bool* _isSigned = NULL) const; inline bool IsFloat() const; // floating point, not just float bool ToBool() const; 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; BReferenceable* ToReferenceable() const; void SwapEndianess(); // has effect only on scalar types (pointer // counting as scalar, not string, though) static size_t SizeOfType(type_code type); static bool TypeIsNumber(type_code type); static bool TypeIsInteger(type_code type, bool* _isSigned = NULL); static bool TypeIsFloat(type_code type); private: void _SetTo(const BVariant& other); void _SetTo(bool value); 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); bool _SetTo(const char* value, uint32 flags); void _SetTo(BReferenceable* value, type_code type); template inline NumberType _ToNumber() const; private: type_code fType; uint32 fFlags; union { bool fBool; int8 fInt8; uint8 fUInt8; int16 fInt16; uint16 fUInt16; int32 fInt32; uint32 fUInt32; int64 fInt64; uint64 fUInt64; float fFloat; double fDouble; void* fPointer; char* fString; BReferenceable* fReferenceable; uint8 fBytes[8]; }; }; BVariant::BVariant() : fType(0), fFlags(0) { } BVariant::BVariant(bool value) { _SetTo(value); } BVariant::BVariant(int8 value) { _SetTo(value); } BVariant::BVariant(uint8 value) { _SetTo(value); } BVariant::BVariant(int16 value) { _SetTo(value); } BVariant::BVariant(uint16 value) { _SetTo(value); } BVariant::BVariant(int32 value) { _SetTo(value); } BVariant::BVariant(uint32 value) { _SetTo(value); } BVariant::BVariant(int64 value) { _SetTo(value); } BVariant::BVariant(uint64 value) { _SetTo(value); } BVariant::BVariant(float value) { _SetTo(value); } BVariant::BVariant(double value) { _SetTo(value); } BVariant::BVariant(const void* value) { _SetTo(value); } BVariant::BVariant(const char* value, uint32 flags) { _SetTo(value, flags); } BVariant::BVariant(BReferenceable* value, type_code type) { _SetTo(value, type); } BVariant::BVariant(const BVariant& other) { _SetTo(other); } BVariant& BVariant::operator=(const BVariant& other) { Unset(); _SetTo(other); return *this; } bool BVariant::operator!=(const BVariant& other) const { return !(*this == other); } void BVariant::SetTo(const BVariant& other) { Unset(); _SetTo(other); } void BVariant::SetTo(bool value) { Unset(); _SetTo(value); } void BVariant::SetTo(int8 value) { Unset(); _SetTo(value); } void BVariant::SetTo(uint8 value) { Unset(); _SetTo(value); } void BVariant::SetTo(int16 value) { Unset(); _SetTo(value); } void BVariant::SetTo(uint16 value) { Unset(); _SetTo(value); } void BVariant::SetTo(int32 value) { Unset(); _SetTo(value); } void BVariant::SetTo(uint32 value) { Unset(); _SetTo(value); } void BVariant::SetTo(int64 value) { Unset(); _SetTo(value); } void BVariant::SetTo(uint64 value) { Unset(); _SetTo(value); } void BVariant::SetTo(float value) { Unset(); _SetTo(value); } void BVariant::SetTo(double value) { Unset(); _SetTo(value); } void BVariant::SetTo(const void* value) { Unset(); _SetTo(value); } void BVariant::SetTo(const char* value, uint32 flags) { Unset(); _SetTo(value, flags); } void BVariant::SetTo(BReferenceable* value, type_code type) { Unset(); _SetTo(value, type); } bool BVariant::IsNumber() const { return TypeIsNumber(fType); } bool BVariant::IsInteger(bool* _isSigned) const { return TypeIsInteger(fType, _isSigned); } bool BVariant::IsFloat() const { return TypeIsFloat(fType); } #endif // _VARIANT_H