haiku/headers/private/shared/Variant.h

404 lines
6.4 KiB
C
Raw Normal View History

/*
* Copyright 2009, Ingo Weinhold, ingo_weinhold@gmx.de.
* Distributed under the terms of the MIT License.
*/
#ifndef _VARIANT_H
#define _VARIANT_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 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<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;
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