Merge pull request #1 from Tencent/master

PR for commits 2021/01/12

include/rapidjson/document.h

@@ -289,12 +289,14 @@ class GenericMemberIterator;
 //! non-const GenericMemberIterator
 template <typename Encoding, typename Allocator>
 class GenericMemberIterator<false,Encoding,Allocator> {
+public:
     //! use plain pointer as iterator type
     typedef GenericMember<Encoding,Allocator>* Iterator;
 };
 //! const GenericMemberIterator
 template <typename Encoding, typename Allocator>
 class GenericMemberIterator<true,Encoding,Allocator> {
+public:
     //! use plain const pointer as iterator type
     typedef const GenericMember<Encoding,Allocator>* Iterator;
 };
@@ -2001,17 +2003,18 @@ private:
 
         // Initial flags of different types.
         kNullFlag = kNullType,
-        kTrueFlag = kTrueType | kBoolFlag,
+        // These casts are added to suppress the warning on MSVC about bitwise operations between enums of different types.
-        kFalseFlag = kFalseType | kBoolFlag,
+        kTrueFlag = static_cast<int>(kTrueType) | static_cast<int>(kBoolFlag),
-        kNumberIntFlag = kNumberType | kNumberFlag | kIntFlag | kInt64Flag,
+        kFalseFlag = static_cast<int>(kFalseType) | static_cast<int>(kBoolFlag),
-        kNumberUintFlag = kNumberType | kNumberFlag | kUintFlag | kUint64Flag | kInt64Flag,
+        kNumberIntFlag = static_cast<int>(kNumberType) | static_cast<int>(kNumberFlag | kIntFlag | kInt64Flag),
-        kNumberInt64Flag = kNumberType | kNumberFlag | kInt64Flag,
+        kNumberUintFlag = static_cast<int>(kNumberType) | static_cast<int>(kNumberFlag | kUintFlag | kUint64Flag | kInt64Flag),
-        kNumberUint64Flag = kNumberType | kNumberFlag | kUint64Flag,
+        kNumberInt64Flag = static_cast<int>(kNumberType) | static_cast<int>(kNumberFlag | kInt64Flag),
-        kNumberDoubleFlag = kNumberType | kNumberFlag | kDoubleFlag,
+        kNumberUint64Flag = static_cast<int>(kNumberType) | static_cast<int>(kNumberFlag | kUint64Flag),
-        kNumberAnyFlag = kNumberType | kNumberFlag | kIntFlag | kInt64Flag | kUintFlag | kUint64Flag | kDoubleFlag,
+        kNumberDoubleFlag = static_cast<int>(kNumberType) | static_cast<int>(kNumberFlag | kDoubleFlag),
-        kConstStringFlag = kStringType | kStringFlag,
+        kNumberAnyFlag = static_cast<int>(kNumberType) | static_cast<int>(kNumberFlag | kIntFlag | kInt64Flag | kUintFlag | kUint64Flag | kDoubleFlag),
-        kCopyStringFlag = kStringType | kStringFlag | kCopyFlag,
+        kConstStringFlag = static_cast<int>(kStringType) | static_cast<int>(kStringFlag),
-        kShortStringFlag = kStringType | kStringFlag | kCopyFlag | kInlineStrFlag,
+        kCopyStringFlag = static_cast<int>(kStringType) | static_cast<int>(kStringFlag | kCopyFlag),
+        kShortStringFlag = static_cast<int>(kStringType) | static_cast<int>(kStringFlag | kCopyFlag | kInlineStrFlag),
         kObjectFlag = kObjectType,
         kArrayFlag = kArrayType,
 
@@ -2609,6 +2612,7 @@ public:
     GenericArray& operator=(const GenericArray& rhs) { value_ = rhs.value_; return *this; }
     ~GenericArray() {}
 
+    operator ValueType&() const { return value_; }
     SizeType Size() const { return value_.Size(); }
     SizeType Capacity() const { return value_.Capacity(); }
     bool Empty() const { return value_.Empty(); }
@@ -2664,6 +2668,7 @@ public:
     GenericObject& operator=(const GenericObject& rhs) { value_ = rhs.value_; return *this; }
     ~GenericObject() {}
 
+    operator ValueType&() const { return value_; }
     SizeType MemberCount() const { return value_.MemberCount(); }
     SizeType MemberCapacity() const { return value_.MemberCapacity(); }
     bool ObjectEmpty() const { return value_.ObjectEmpty(); }

test/unittest/pointertest.cpp

@@ -1529,6 +1529,38 @@ TEST(Pointer, Ambiguity) {
     }
 }
 
+TEST(Pointer, ResolveOnObject) {
+    Document d;
+    EXPECT_FALSE(d.Parse("{\"a\": 123}").HasParseError());
+
+    {
+        Value::ConstObject o = static_cast<const Document&>(d).GetObject();
+        EXPECT_EQ(123, Pointer("/a").Get(o)->GetInt());
+    }
+
+    {
+        Value::Object o = d.GetObject();
+        Pointer("/a").Set(o, 456, d.GetAllocator());
+        EXPECT_EQ(456, Pointer("/a").Get(o)->GetInt());
+    }
+}
+
+TEST(Pointer, ResolveOnArray) {
+    Document d;
+    EXPECT_FALSE(d.Parse("[1, 2, 3]").HasParseError());
+
+    {
+        Value::ConstArray a = static_cast<const Document&>(d).GetArray();
+        EXPECT_EQ(2, Pointer("/1").Get(a)->GetInt());
+    }
+
+    {
+        Value::Array a = d.GetArray();
+        Pointer("/1").Set(a, 123, d.GetAllocator());
+        EXPECT_EQ(123, Pointer("/1").Get(a)->GetInt());
+    }
+}
+
 TEST(Pointer, LessThan) {
     static const struct {
         const char *str;

test/unittest/schematest.cpp

@@ -2038,8 +2038,13 @@ TEST(SchemaValidator, Ref_remote_issue1210) {
     class SchemaDocumentProvider : public IRemoteSchemaDocumentProvider {
         SchemaDocument** collection;
 
-        SchemaDocumentProvider(const SchemaDocumentProvider&);
+        // Dummy private copy constructor & assignment operator.
-        SchemaDocumentProvider& operator=(const SchemaDocumentProvider&);
+        // Function bodies added so that they compile in MSVC 2019.
+        SchemaDocumentProvider(const SchemaDocumentProvider&) : collection(NULL) {
+        }
+        SchemaDocumentProvider& operator=(const SchemaDocumentProvider&) {
+            return *this;
+        }
 
         public:
           SchemaDocumentProvider(SchemaDocument** collection) : collection(collection) { }