457 lines
7.5 KiB
C++
457 lines
7.5 KiB
C++
/*
|
|
* Copyright 2009, Ingo Weinhold, ingo_weinhold@gmx.de.
|
|
* Copyright 2011, Rene Gollent, rene@gollent.com.
|
|
* Distributed under the terms of the MIT License.
|
|
*/
|
|
#ifndef _VARIANT_H
|
|
#define _VARIANT_H
|
|
|
|
|
|
#include <Rect.h>
|
|
#include <SupportDefs.h>
|
|
#include <TypeConstants.h>
|
|
|
|
#include <Referenceable.h>
|
|
|
|
|
|
enum {
|
|
B_VARIANT_DONT_COPY_DATA = 0x01,
|
|
B_VARIANT_OWNS_DATA = 0x02,
|
|
B_VARIANT_REFERENCEABLE_DATA = 0x04
|
|
};
|
|
|
|
|
|
class BMessage;
|
|
|
|
|
|
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 BRect &value);
|
|
inline BVariant(float left, float top, float right,
|
|
float bottom);
|
|
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 BRect& value);
|
|
inline void SetTo(float left, float top, float right,
|
|
float bottom);
|
|
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;
|
|
BRect ToRect() const;
|
|
BReferenceable* ToReferenceable() const;
|
|
|
|
void SwapEndianess();
|
|
// has effect only on scalar types (pointer
|
|
// counting as scalar, not string, though)
|
|
|
|
status_t AddToMessage(BMessage& message,
|
|
const char* fieldName) const;
|
|
status_t SetFromMessage(const BMessage& message,
|
|
const char* fieldName);
|
|
|
|
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);
|
|
void _SetTo(float left, float top, float right,
|
|
float bottom);
|
|
bool _SetTo(const char* value,
|
|
uint32 flags);
|
|
void _SetTo(BReferenceable* value, type_code type);
|
|
|
|
template<typename NumberType>
|
|
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;
|
|
struct {
|
|
float left;
|
|
float top;
|
|
float right;
|
|
float bottom;
|
|
} fRect;
|
|
uint8 fBytes[sizeof(float) * 4];
|
|
};
|
|
};
|
|
|
|
|
|
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 BRect& value)
|
|
{
|
|
_SetTo(value.left, value.top, value.right, value.bottom);
|
|
}
|
|
|
|
|
|
BVariant::BVariant(float left, float top, float right, float bottom)
|
|
{
|
|
_SetTo(left, top, right, bottom);
|
|
}
|
|
|
|
|
|
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 BRect& value)
|
|
{
|
|
Unset();
|
|
_SetTo(value.left, value.top, value.right, value.bottom);
|
|
}
|
|
|
|
|
|
void
|
|
BVariant::SetTo(float left, float top, float right, float bottom)
|
|
{
|
|
Unset();
|
|
_SetTo(left, top, right, bottom);
|
|
}
|
|
|
|
|
|
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
|