Add templated accessors

include/rapidjson/document.h

@@ -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.

test/unittest/valuetest.cpp

@@ -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
 }