Merge regex into schema

include/rapidjson/document.h

@@ -1213,6 +1213,31 @@ public:
         return pos;
     }
 
+    //! Erase a member in object by its name.
+    /*! \param name Name of member to be removed.
+        \return Whether the member existed.
+        \note Linear time complexity.
+    */
+    bool EraseMember(const Ch* name) {
+        GenericValue n(StringRef(name));
+        return EraseMember(n);
+    }
+
+#if RAPIDJSON_HAS_STDSTRING
+    bool EraseMember(const std::basic_string<Ch>& name) { return EraseMember(GenericValue(StringRef(name))); }
+#endif
+
+    template <typename SourceAllocator>
+    bool EraseMember(const GenericValue<Encoding, SourceAllocator>& name) {
+        MemberIterator m = FindMember(name);
+        if (m != MemberEnd()) {
+            EraseMember(m);
+            return true;
+        }
+        else
+            return false;
+    }
+
     //@}
 
     //!@name Array

include/rapidjson/pointer.h

@@ -689,34 +689,37 @@ public:
 
         ValueType* v = &root;
         const Token* last = tokens_ + (tokenCount_ - 1);
-        for (const Token *t = tokens_; t != tokens_ + tokenCount_; ++t) {
+        for (const Token *t = tokens_; t != last; ++t) {
             switch (v->GetType()) {
             case kObjectType:
                 {
                     typename ValueType::MemberIterator m = v->FindMember(GenericStringRef<Ch>(t->name, t->length));
                     if (m == v->MemberEnd())
                         return false;
-                    if (t == last) {
-                        v->EraseMember(m);
-                        return true;
-                    }
                     v = &m->value;
                 }
                 break;
             case kArrayType:
                 if (t->index == kPointerInvalidIndex || t->index >= v->Size())
                     return false;
-                if (t == last) {
-                    v->Erase(v->Begin() + t->index);
-                    return true;
-                }
                 v = &((*v)[t->index]);
                 break;
             default:
                 return false;
             }
         }
-        return false;
+
+        switch (v->GetType()) {
+        case kObjectType:
+            return v->EraseMember(GenericStringRef<Ch>(last->name, last->length));
+        case kArrayType:
+            if (last->index == kPointerInvalidIndex || last->index >= v->Size())
+                return false;
+            v->Erase(v->Begin() + last->index);
+            return true;
+        default:
+            return false;
+        }
     }
 
 private:

include/rapidjson/reader.h

@@ -967,13 +967,13 @@ private:
         else {
             if (use64bit) {
                 if (minus)
-                    cont = handler.Int64(-(int64_t)i64);
+                    cont = handler.Int64(static_cast<int64_t>(~i64 + 1));
                 else
                     cont = handler.Uint64(i64);
             }
             else {
                 if (minus)
-                    cont = handler.Int(-(int)i);
+                    cont = handler.Int(static_cast<int32_t>(~i + 1));
                 else
                     cont = handler.Uint(i);
             }

test/perftest/rapidjsontest.cpp

@@ -298,11 +298,28 @@ TEST_F(RapidJson, internal_Pow10) {
     EXPECT_GT(sum, 0.0);
 }
 
-TEST_F(RapidJson, SIMD_SUFFIX(Whitespace)) {
+TEST_F(RapidJson, SkipWhitespace_Basic) {
     for (size_t i = 0; i < kTrialCount; i++) {
-        Document doc;
-        ASSERT_TRUE(doc.Parse(whitespace_).IsArray());
-    }       
+        rapidjson::StringStream s(whitespace_);
+        while (s.Peek() == ' ' || s.Peek() == '\n' || s.Peek() == '\r' || s.Peek() == '\t')
+            s.Take();
+        ASSERT_EQ('[', s.Peek());
+    }
+}
+
+TEST_F(RapidJson, SIMD_SUFFIX(SkipWhitespace)) {
+    for (size_t i = 0; i < kTrialCount; i++) {
+        rapidjson::StringStream s(whitespace_);
+        rapidjson::SkipWhitespace(s);
+        ASSERT_EQ('[', s.Peek());
+    }
+}
+
+TEST_F(RapidJson, SkipWhitespace_strspn) {
+    for (size_t i = 0; i < kTrialCount; i++) {
+        const char* s = whitespace_ + std::strspn(whitespace_, " \t\r\n");
+        ASSERT_EQ('[', *s);
+    }
 }
 
 TEST_F(RapidJson, UTF8_Validate) {

test/unittest/CMakeLists.txt

@@ -11,6 +11,7 @@ set(UNITTEST_SOURCES
     pointertest.cpp
     prettywritertest.cpp
     readertest.cpp
+    regextest.cpp
 	schematest.cpp
 	simdtest.cpp
     strfunctest.cpp

test/unittest/pointertest.cpp

@@ -879,7 +879,13 @@ TEST(Pointer, Erase) {
     d.Parse(kJson);
 
     EXPECT_FALSE(Pointer("").Erase(d));
+    EXPECT_FALSE(Pointer("/nonexist").Erase(d));
+    EXPECT_FALSE(Pointer("/nonexist/nonexist").Erase(d));
     EXPECT_FALSE(Pointer("/foo/nonexist").Erase(d));
+    EXPECT_FALSE(Pointer("/foo/nonexist/nonexist").Erase(d));
+    EXPECT_FALSE(Pointer("/foo/0/nonexist").Erase(d));
+    EXPECT_FALSE(Pointer("/foo/0/nonexist/nonexist").Erase(d));
+    EXPECT_FALSE(Pointer("/foo/2/nonexist").Erase(d));
     EXPECT_TRUE(Pointer("/foo/0").Erase(d));
     EXPECT_EQ(1u, d["foo"].Size());
     EXPECT_STREQ("baz", d["foo"][0].GetString());
@@ -887,6 +893,24 @@ TEST(Pointer, Erase) {
     EXPECT_TRUE(d["foo"].Empty());
     EXPECT_TRUE(Pointer("/foo").Erase(d));
     EXPECT_TRUE(Pointer("/foo").Get(d) == 0);
+
+    Pointer("/a/0/b/0").Create(d);
+
+    EXPECT_TRUE(Pointer("/a/0/b/0").Get(d) != 0);
+    EXPECT_TRUE(Pointer("/a/0/b/0").Erase(d));
+    EXPECT_TRUE(Pointer("/a/0/b/0").Get(d) == 0);
+
+    EXPECT_TRUE(Pointer("/a/0/b").Get(d) != 0);
+    EXPECT_TRUE(Pointer("/a/0/b").Erase(d));
+    EXPECT_TRUE(Pointer("/a/0/b").Get(d) == 0);
+
+    EXPECT_TRUE(Pointer("/a/0").Get(d) != 0);
+    EXPECT_TRUE(Pointer("/a/0").Erase(d));
+    EXPECT_TRUE(Pointer("/a/0").Get(d) == 0);
+
+    EXPECT_TRUE(Pointer("/a").Get(d) != 0);
+    EXPECT_TRUE(Pointer("/a").Erase(d));
+    EXPECT_TRUE(Pointer("/a").Get(d) == 0);
 }
 
 TEST(Pointer, CreateValueByPointer) {

test/unittest/valuetest.cpp

@@ -1182,6 +1182,24 @@ TEST(Value, Object) {
     EXPECT_TRUE(z.IsObject());
 }
 
+TEST(Value, EraseMember_String) {
+    Value::AllocatorType allocator;
+    Value x(kObjectType);
+    x.AddMember("A", "Apple", allocator);
+    x.AddMember("B", "Banana", allocator);
+
+    EXPECT_TRUE(x.EraseMember("B"));
+    EXPECT_FALSE(x.HasMember("B"));
+
+    EXPECT_FALSE(x.EraseMember("nonexist"));
+
+    GenericValue<UTF8<>, CrtAllocator> othername("A");
+    EXPECT_TRUE(x.EraseMember(othername));
+    EXPECT_FALSE(x.HasMember("A"));
+
+    EXPECT_TRUE(x.MemberBegin() == x.MemberEnd());
+}
+
 TEST(Value, BigNestedArray) {
     MemoryPoolAllocator<> allocator;
     Value x(kArrayType);