Add templated accessors
This commit is contained in:
Milo Yip
parent
23e410b18a
commit
4d648fdcd8
@ -393,6 +393,87 @@ template <typename T> struct IsGenericValue : IsGenericValueImpl<T>::Type {};
|
||||
|
||||
} // namespace internal
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
// TypeHelper
|
||||
|
||||
namespace internal {
|
||||
|
||||
template <typename ValueType, typename T>
|
||||
struct TypeHelper {
|
||||
static bool Is(const ValueType&) { RAPIDJSON_ASSERT(false && "Unsupport type"); }
|
||||
static T Get(const ValueType&) { RAPIDJSON_ASSERT(false && "Unsupport type"); }
|
||||
static ValueType& Set(ValueType&, T) { RAPIDJSON_ASSERT(false && "Unsupport type"); }
|
||||
static ValueType& Set(ValueType&, T, typename ValueType::AllocatorType&) { RAPIDJSON_ASSERT(false && "Unsupport type"); }
|
||||
};
|
||||
|
||||
template<typename ValueType>
|
||||
struct TypeHelper<ValueType, bool> {
|
||||
static bool Is(const ValueType& v) { return v.IsBool(); }
|
||||
static bool Get(const ValueType& v) { return v.GetBool(); }
|
||||
static ValueType& Set(ValueType& v, bool data) { return v.SetBool(data); }
|
||||
static ValueType& Set(ValueType& v, bool data, typename ValueType::AllocatorType&) { return v.SetBool(data); }
|
||||
};
|
||||
|
||||
template<typename ValueType>
|
||||
struct TypeHelper<ValueType, int> {
|
||||
static bool Is(const ValueType& v) { return v.IsInt(); }
|
||||
static int Get(const ValueType& v) { return v.GetInt(); }
|
||||
static ValueType& Set(ValueType& v, int data) { return v.SetInt(data); }
|
||||
static ValueType& Set(ValueType& v, int data, typename ValueType::AllocatorType&) { return v.SetInt(data); }
|
||||
};
|
||||
|
||||
template<typename ValueType>
|
||||
struct TypeHelper<ValueType, unsigned> {
|
||||
static bool Is(const ValueType& v) { return v.IsUint(); }
|
||||
static unsigned Get(const ValueType& v) { return v.GetUint(); }
|
||||
static ValueType& Set(ValueType& v, unsigned data) { return v.SetUint(data); }
|
||||
static ValueType& Set(ValueType& v, unsigned data, typename ValueType::AllocatorType&) { return v.SetUint(data); }
|
||||
};
|
||||
|
||||
template<typename ValueType>
|
||||
struct TypeHelper<ValueType, int64_t> {
|
||||
static bool Is(const ValueType& v) { return v.IsInt64(); }
|
||||
static int64_t Get(const ValueType& v) { return v.GetInt64(); }
|
||||
static ValueType& Set(ValueType& v, int64_t data) { return v.SetInt64(data); }
|
||||
static ValueType& Set(ValueType& v, int64_t data, typename ValueType::AllocatorType&) { return v.SetInt64(data); }
|
||||
};
|
||||
|
||||
template<typename ValueType>
|
||||
struct TypeHelper<ValueType, uint64_t> {
|
||||
static bool Is(const ValueType& v) { return v.IsUint64(); }
|
||||
static uint64_t Get(const ValueType& v) { return v.GetUint64(); }
|
||||
static ValueType& Set(ValueType& v, uint64_t data) { return v.SetUint64(data); }
|
||||
static ValueType& Set(ValueType& v, uint64_t data, typename ValueType::AllocatorType&) { return v.SetUint64(data); }
|
||||
};
|
||||
|
||||
template<typename ValueType>
|
||||
struct TypeHelper<ValueType, double> {
|
||||
static bool Is(const ValueType& v) { return v.IsDouble(); }
|
||||
static double Get(const ValueType& v) { return v.GetDouble(); }
|
||||
static ValueType& Set(ValueType& v, double data) { return v.SetDouble(data); }
|
||||
static ValueType& Set(ValueType& v, double data, typename ValueType::AllocatorType&) { return v.SetDouble(data); }
|
||||
};
|
||||
|
||||
template<typename ValueType>
|
||||
struct TypeHelper<ValueType, float> {
|
||||
static bool Is(const ValueType& v) { return v.IsFloat(); }
|
||||
static float Get(const ValueType& v) { return v.GetFloat(); }
|
||||
static ValueType& Set(ValueType& v, float data) { return v.SetFloat(data); }
|
||||
static ValueType& Set(ValueType& v, float data, typename ValueType::AllocatorType&) { return v.SetFloat(data); }
|
||||
};
|
||||
|
||||
#if RAPIDJSON_HAS_STDSTRING
|
||||
template<typename ValueType>
|
||||
struct TypeHelper<ValueType, std::basic_string<typename ValueType::Ch> > {
|
||||
typedef std::basic_string<typename ValueType::Ch> StringType;
|
||||
static bool Is(const ValueType& v) { return v.IsString(); }
|
||||
static StringType Get(const ValueType& v) { return v.GetString(); }
|
||||
static ValueType& Set(ValueType& v, const StringType& data, typename ValueType::AllocatorType& a) { return v.SetString(data, a); }
|
||||
};
|
||||
#endif
|
||||
|
||||
} // namespace internal
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
// GenericValue
|
||||
|
||||
@ -1484,6 +1565,7 @@ public:
|
||||
/*! \note If the value is 64-bit integer type, it may lose precision. Use \c IsLosslessFloat() to check whether the converison is lossless.
|
||||
*/
|
||||
double GetFloat() const {
|
||||
RAPIDJSON_ASSERT(IsFloat());
|
||||
return static_cast<float>(GetDouble());
|
||||
}
|
||||
|
||||
@ -1554,6 +1636,22 @@ public:
|
||||
|
||||
//@}
|
||||
|
||||
//! Templated version for checking whether this value is type T.
|
||||
/*!
|
||||
\tparam T Either \c bool, \c int, \c unsigned, \c int64_t, \c uint64_t, \c double, \c float, \c std::basic_string<Ch>
|
||||
*/
|
||||
template <typename T>
|
||||
bool Is() const { return internal::TypeHelper<ValueType, T>::Is(*this); }
|
||||
|
||||
template <typename T>
|
||||
T Get() const { return internal::TypeHelper<ValueType, T>::Get(*this); }
|
||||
|
||||
template<typename T>
|
||||
ValueType& Set(const T& data) { return internal::TypeHelper<ValueType, T>::Set(*this, data); }
|
||||
|
||||
template<typename T>
|
||||
ValueType& Set(const T& data, AllocatorType& allocator) { return internal::TypeHelper<ValueType, T>::Set(*this, data, allocator); }
|
||||
|
||||
//! Generate events of this value to a Handler.
|
||||
/*! This function adopts the GoF visitor pattern.
|
||||
Typical usage is to output this JSON value as JSON text via Writer, which is a Handler.
|
||||
|
||||
@ -335,6 +335,12 @@ TEST(Value, True) {
|
||||
Value z;
|
||||
z.SetBool(true);
|
||||
EXPECT_TRUE(z.IsTrue());
|
||||
|
||||
// Templated functions
|
||||
EXPECT_TRUE(z.Is<bool>());
|
||||
EXPECT_TRUE(z.Get<bool>());
|
||||
EXPECT_FALSE(z.Set<bool>(false).Get<bool>());
|
||||
EXPECT_TRUE(z.Set(true).Get<bool>());
|
||||
}
|
||||
|
||||
TEST(Value, False) {
|
||||
@ -414,6 +420,12 @@ TEST(Value, Int) {
|
||||
// operator=(int)
|
||||
z = 5678;
|
||||
EXPECT_EQ(5678, z.GetInt());
|
||||
|
||||
// Templated functions
|
||||
EXPECT_TRUE(z.Is<int>());
|
||||
EXPECT_EQ(5678, z.Get<int>());
|
||||
EXPECT_EQ(5679, z.Set(5679).Get<int>());
|
||||
EXPECT_EQ(5680, z.Set<int>(5680).Get<int>());
|
||||
}
|
||||
|
||||
TEST(Value, Uint) {
|
||||
@ -453,6 +465,12 @@ TEST(Value, Uint) {
|
||||
EXPECT_EQ(2147483648u, z.GetUint());
|
||||
EXPECT_FALSE(z.IsInt());
|
||||
EXPECT_TRUE(z.IsInt64()); // Issue 41: Incorrect parsing of unsigned int number types
|
||||
|
||||
// Templated functions
|
||||
EXPECT_TRUE(z.Is<unsigned>());
|
||||
EXPECT_EQ(2147483648u, z.Get<unsigned>());
|
||||
EXPECT_EQ(2147483649u, z.Set(2147483649u).Get<unsigned>());
|
||||
EXPECT_EQ(2147483650u, z.Set<unsigned>(2147483650u).Get<unsigned>());
|
||||
}
|
||||
|
||||
TEST(Value, Int64) {
|
||||
@ -505,8 +523,15 @@ TEST(Value, Int64) {
|
||||
EXPECT_FALSE(z.IsInt());
|
||||
EXPECT_NEAR(-2147483649.0, z.GetDouble(), 0.0);
|
||||
|
||||
z.SetInt64(static_cast<int64_t>(RAPIDJSON_UINT64_C2(0x80000000, 00000000)));
|
||||
int64_t i = static_cast<int64_t>(RAPIDJSON_UINT64_C2(0x80000000, 00000000));
|
||||
z.SetInt64(i);
|
||||
EXPECT_DOUBLE_EQ(-9223372036854775808.0, z.GetDouble());
|
||||
|
||||
// Templated functions
|
||||
EXPECT_TRUE(z.Is<int64_t>());
|
||||
EXPECT_EQ(i, z.Get<int64_t>());
|
||||
EXPECT_EQ(i - 1, z.Set(i - 1).Get<int64_t>());
|
||||
EXPECT_EQ(i - 2, z.Set<int64_t>(i - 2).Get<int64_t>());
|
||||
}
|
||||
|
||||
TEST(Value, Uint64) {
|
||||
@ -547,10 +572,17 @@ TEST(Value, Uint64) {
|
||||
EXPECT_FALSE(z.IsUint());
|
||||
EXPECT_TRUE(z.IsInt64());
|
||||
|
||||
z.SetUint64(RAPIDJSON_UINT64_C2(0x80000000, 0x00000000)); // 2^63 cannot cast as int64
|
||||
uint64_t u = RAPIDJSON_UINT64_C2(0x80000000, 0x00000000);
|
||||
z.SetUint64(u); // 2^63 cannot cast as int64
|
||||
EXPECT_FALSE(z.IsInt64());
|
||||
EXPECT_EQ(RAPIDJSON_UINT64_C2(0x80000000, 0x00000000), z.GetUint64()); // Issue 48
|
||||
EXPECT_EQ(u, z.GetUint64()); // Issue 48
|
||||
EXPECT_DOUBLE_EQ(9223372036854775808.0, z.GetDouble());
|
||||
|
||||
// Templated functions
|
||||
EXPECT_TRUE(z.Is<uint64_t>());
|
||||
EXPECT_EQ(u, z.Get<uint64_t>());
|
||||
EXPECT_EQ(u + 1, z.Set(u + 1).Get<uint64_t>());
|
||||
EXPECT_EQ(u + 2, z.Set<uint64_t>(u + 2).Get<uint64_t>());
|
||||
}
|
||||
|
||||
TEST(Value, Double) {
|
||||
@ -577,6 +609,12 @@ TEST(Value, Double) {
|
||||
|
||||
z = 56.78;
|
||||
EXPECT_NEAR(56.78, z.GetDouble(), 0.0);
|
||||
|
||||
// Templated functions
|
||||
EXPECT_TRUE(z.Is<double>());
|
||||
EXPECT_EQ(56.78, z.Get<double>());
|
||||
EXPECT_EQ(57.78, z.Set(57.78).Get<double>());
|
||||
EXPECT_EQ(58.78, z.Set<double>(58.78).Get<double>());
|
||||
}
|
||||
|
||||
TEST(Value, Float) {
|
||||
@ -604,6 +642,12 @@ TEST(Value, Float) {
|
||||
|
||||
z = 56.78f;
|
||||
EXPECT_NEAR(56.78f, z.GetFloat(), 0.0f);
|
||||
|
||||
// Templated functions
|
||||
EXPECT_TRUE(z.Is<float>());
|
||||
EXPECT_EQ(56.78f, z.Get<float>());
|
||||
EXPECT_EQ(57.78f, z.Set(57.78f).Get<float>());
|
||||
EXPECT_EQ(58.78f, z.Set<float>(58.78f).Get<float>());
|
||||
}
|
||||
|
||||
TEST(Value, IsLosslessDouble) {
|
||||
@ -759,6 +803,12 @@ TEST(Value, String) {
|
||||
vs1 = StringRef(str);
|
||||
TestEqual(str, vs1);
|
||||
TestEqual(vs0, vs1);
|
||||
|
||||
// Templated function.
|
||||
EXPECT_TRUE(vs0.Is<std::string>());
|
||||
EXPECT_EQ(str, vs0.Get<std::string>());
|
||||
EXPECT_EQ(std::string("Apple"), vs0.Set<std::string>(std::string("Apple"), allocator).template Get<std::string>());
|
||||
EXPECT_EQ(std::string("Orange"), vs0.Set(std::string("Orange"), allocator).template Get<std::string>());
|
||||
}
|
||||
#endif // RAPIDJSON_HAS_STDSTRING
|
||||
}
|
||||
|
||||
Loading…
x
Reference in New Issue
Block a user