From 2d802ae3a5e4df1ca488e7faed6a856cf7c7641c Mon Sep 17 00:00:00 2001
From: Xie Gengxin <xiegengxin.94@bytedance.com>
Date: Tue, 20 Dec 2022 16:43:40 +0800
Subject: [PATCH 1/2] feat: New APIs of merge, diff and update

---
 include/sonic/dom/dynamicnode.h      |   4 +-
 include/sonic/dom/generic_document.h |  18 +++
 include/sonic/dom/genericnode.h      | 167 ++++++++++++++++++++++++++-
 tests/node_test.cpp                  | 118 +++++++++++++++++++
 4 files changed, 303 insertions(+), 4 deletions(-)

diff --git a/include/sonic/dom/dynamicnode.h b/include/sonic/dom/dynamicnode.h
index e95a5ff0..ca19b0dd 100644
--- a/include/sonic/dom/dynamicnode.h
+++ b/include/sonic/dom/dynamicnode.h
@@ -34,10 +34,10 @@
 namespace sonic_json {
 
 template <typename Allocator = SONIC_DEFAULT_ALLOCATOR>
-class DNode : public GenericNode<DNode, Allocator> {
+class DNode : public GenericNode<DNode<Allocator>> {
  public:
   using NodeType = DNode;
-  using BaseNode = GenericNode<DNode, Allocator>;
+  using BaseNode = GenericNode<DNode>;
   using AllocatorType = Allocator;
   using MemberNode = typename NodeTraits<DNode>::MemberNode;
   using MemberIterator = typename NodeTraits<DNode>::MemberIterator;
diff --git a/include/sonic/dom/generic_document.h b/include/sonic/dom/generic_document.h
index eab9e7d8..710d2f8d 100644
--- a/include/sonic/dom/generic_document.h
+++ b/include/sonic/dom/generic_document.h
@@ -260,4 +260,22 @@ class GenericDocument : public NodeType {
 
 using Document = GenericDocument<DNode<SONIC_DEFAULT_ALLOCATOR>>;
 
+template <typename ReturnDocType, typename T, typename U>
+static ReturnDocType Diff(const T& from, const U& to) {
+  ReturnDocType ret;
+  using RetNodeType = typename ReturnDocType::NodeType;
+  Diff(from, to, (RetNodeType&)(ret), ret.GetAllocator());
+
+  return ret; /* RVO */
+}
+
+template <typename T, typename U>
+static Document Diff(const T& from, const U& to) {
+  Document ret;
+  using RetNodeType = typename Document::NodeType;
+  Diff(from, to, (RetNodeType&)(ret), ret.GetAllocator());
+
+  return ret; /* RVO */
+}
+
 }  // namespace sonic_json
diff --git a/include/sonic/dom/genericnode.h b/include/sonic/dom/genericnode.h
index a895382d..1714b4e5 100644
--- a/include/sonic/dom/genericnode.h
+++ b/include/sonic/dom/genericnode.h
@@ -48,19 +48,37 @@ class MemberNodeT {
 template <typename derived_t>
 struct NodeTraits;
 
+template <bool UpdateExistentKey, typename T, typename S, typename Allocator,
+          typename>
+static inline void Update(T&, const S&, Allocator&);
+//
+// template <typename T, typename S, typename Allocator, bool=false>
+// static inline void Merge(T&, const S&, Allocator&);
+
+// Copied from http://coliru.stacked-crooked.com/a/8dd19d21817cadf5
+template <template <typename...> class C, typename... Ts>
+std::true_type is_base_of_template_impl(const C<Ts...>*);
+
+template <template <typename...> class C>
+std::false_type is_base_of_template_impl(...);
+
+template <typename T, template <typename...> class C>
+using is_base_of_template =
+    decltype(is_base_of_template_impl<C>(std::declval<T*>()));
+
 /**
  * @brief Basic class represent a json value.
  * @tparam tmpalte <typename> class Node  Derived class.
  * @tparam Allocator  Allocator type for derived class, which allocating memory
  * for container and string.
  */
-template <template <typename> class Node, typename Allocator>
+template <typename NodeType>
 class GenericNode {
  public:
-  using NodeType = Node<Allocator>;  ///< Derived class type.
   using alloc_type =
       typename NodeTraits<NodeType>::alloc_type;  ///< Dervied class allocator
                                                   ///< type.
+  using Allocator = alloc_type;
   using MemberNode =
       typename NodeTraits<NodeType>::MemberNode;  ///< Derived class key-value
                                                   ///< pair struct.
@@ -1041,6 +1059,34 @@ class GenericNode {
     return err == kErrorNone ? wb.ToString() : "";
   }
 
+  /**
+   * @brief Json Merge patch, rfc7386
+   */
+  template <typename PatchType,
+            typename std::enable_if<
+                is_base_of_template<PatchType, GenericNode>::value,
+                bool>::type = false>
+  void MergePatch(const PatchType& patch, Allocator& alloc) {
+    return Merge(*(downCast()), patch, alloc);
+  }
+
+  /**
+   * @brief updates from another object. Copying non-existent key. Updating\n
+   *        existent key \b deeply if template parameter is true.
+   * @tparam UpdateExistentKey overwritting existent key
+   * @note cases: \n
+   *   {"a":"b"} .UPDATE. {"a":"c} => {"a":"c"} (UpdateExistedKey == true) \n
+   *   {"a":"b"} .UPDATE. {"a":"c} => {"a":"b"} (UpdateExistedKey == false) \n
+   *   {"a":"b"} .UPDATE. {"b":"c} => {"a":"c", "b":"c"} \n
+   *   {"a":{"bb":1}} .UPDATE. {"a":{"cc":1}} => {"a":{"bb":1, "cc":1}}
+   */
+  template <bool UpdateExistentKey = true, typename S,
+            typename std::enable_if<is_base_of_template<S, GenericNode>::value,
+                                    bool>::type = false>
+  void UpdateFrom(const S& src, Allocator& alloc) {
+    return Update<UpdateExistentKey>(*(downCast()), src, alloc);
+  }
+
  protected:
   sonic_force_inline NodeType* next() noexcept {
     return downCast()->nextImpl();
@@ -1180,4 +1226,121 @@ class GenericNode {
   }
 };
 
+/*
+ * @brief merge two json, rfc 7386
+ * @param alloc Memory Allocator for original
+ */
+template <
+    typename T, typename P, typename Allocator,
+    typename std::enable_if<is_base_of_template<T, GenericNode>::value &&
+                                is_base_of_template<P, GenericNode>::value,
+                            bool>::type = false>
+static inline void Merge(T& original, const P& patch, Allocator& alloc) {
+  if (patch.IsObject()) {
+    if (!original.IsObject()) {
+      original.SetObject();
+    }
+    original.CreateMap(alloc);
+    for (auto itr = patch.MemberBegin(), e = patch.MemberEnd(); itr != e;
+         ++itr) {
+      if (itr->value.IsNull()) {
+        original.RemoveMember(itr->name.GetStringView());
+      } else {
+        auto m = original.FindMember(itr->name.GetStringView());
+        if (m == original.MemberEnd()) {
+          T null_node{};
+          auto n =
+              original.AddMember(itr->name.GetStringView(), null_node, alloc);
+          Merge(n->value, itr->value, alloc);
+        } else {
+          Merge(m->value, itr->value, alloc);
+        }
+      }
+    }
+  } else {
+    original.CopyFrom(patch, alloc);
+  }
+}
+
+template <
+    bool UpdateExistentKey = true, typename T, typename S, typename Allocator,
+    typename std::enable_if<is_base_of_template<T, GenericNode>::value &&
+                                is_base_of_template<S, GenericNode>::value,
+                            bool>::type = false>
+static inline void Update(T& original, const S& src, Allocator& alloc) {
+  if (src.IsObject()) {
+    if (!original.IsObject()) {
+      original.CopyFrom(src, alloc);
+    } else {
+      original.CreateMap(alloc);
+      for (auto itr = src.MemberBegin(), e = src.MemberEnd(); itr != e; ++itr) {
+        auto m = original.FindMember(itr->name.GetStringView());
+        if (m == original.MemberEnd()) {
+          T new_node(itr->value, alloc);
+          original.AddMember(itr->name.GetStringView(), new_node, alloc);
+        } else {
+          Update<UpdateExistentKey>(m->value, itr->value, alloc);
+        }
+      }
+    }
+  } else if (UpdateExistentKey) {
+    original.CopyFrom(src, alloc);
+  }
+}
+
+/*
+ * @brief diff from one json to another
+ * @prarm alloc Memory allocator for patch
+ */
+template <
+    typename T, typename U, typename V, typename Allocator,
+    typename std::enable_if<is_base_of_template<T, GenericNode>::value &&
+                                is_base_of_template<U, GenericNode>::value &&
+                                is_base_of_template<V, GenericNode>::value,
+                            bool>::type = false>
+static bool Diff(const T& from, const U& to, V& patch, Allocator& alloc) {
+  if (from.GetType() != to.GetType()) {
+    if (from.IsString() && from == to) {
+      return false;
+    }
+    patch.CopyFrom(to, alloc);
+    return true;
+  }
+
+  bool is_diff = false;
+  switch (from.GetType()) {
+    case kObject:
+      patch.SetObject();
+      for (auto it = from.MemberBegin(), e = from.MemberEnd(); it != e; ++it) {
+        auto m = to.FindMember(it->name.GetStringView());
+        if (m != to.MemberEnd()) {
+          V tmp;
+          bool b = Diff(it->value, m->value, tmp, alloc);
+          if (b) {
+            is_diff = true;
+            patch.AddMember(it->name.GetStringView(), tmp, alloc);
+          }
+        } else {    // target doesn't have this key
+          V tmp{};  // Null
+          patch.AddMember(it->name.GetStringView(), tmp, alloc);
+        }
+      }
+      for (auto it = to.MemberBegin(), e = to.MemberEnd(); it != e; ++it) {
+        auto m = from.FindMember(it->name.GetStringView());
+        if (m == from.MemberEnd()) {  // only need add non-existed key to patch
+          V tmp{};
+          tmp.CopyFrom(it->value, alloc);
+          patch.AddMember(it->name.GetStringView(), tmp, alloc);
+        }
+      }
+      break;
+    default:
+      if (from != to) {
+        patch.CopyFrom(to, alloc);
+        is_diff = true;
+      }
+  }
+  return is_diff;
+}
+
 }  // namespace sonic_json
diff --git a/tests/node_test.cpp b/tests/node_test.cpp
index 4fb7d635..0f342a59 100644
--- a/tests/node_test.cpp
+++ b/tests/node_test.cpp
@@ -794,4 +794,122 @@ TYPED_TEST(NodeTest, SourceAllocator) {
   EXPECT_TRUE(c.GetStringView() == a.GetStringView());
 }
 
+template <bool UpdateExistedKey>
+void UpdateTestHelper(const std::string& s_dst, const std::string& s_src,
+                      const std::string& s_expect) {
+  using Doc = sonic_json::Document;
+  using Node = typename sonic_json::Document::NodeType;
+
+  Doc expect;
+  expect.Parse(s_expect);
+  {
+    Doc dst, src;
+    dst.Parse(s_dst);
+    src.Parse(s_src);
+
+    Update<UpdateExistedKey>((Node&)(dst), (Node&)(src), dst.GetAllocator());
+    EXPECT_TRUE(dst == expect) << "dst: " << s_dst << std::endl
+                               << "src: " << s_src << std::endl
+                               << "expect: " << s_expect << std::endl
+                               << "actual: " << dst.Dump() << std::endl;
+  }
+  {
+    Doc dst, src;
+    dst.Parse(s_dst);
+    EXPECT_FALSE(dst.HasParseError()) << "dst: " << s_dst << std::endl;
+    src.Parse(s_src);
+    EXPECT_FALSE(src.HasParseError()) << "src: " << s_src << std::endl;
+
+    dst.UpdateFrom<UpdateExistedKey>(src, dst.GetAllocator());
+    EXPECT_TRUE(dst == expect) << "dst: " << s_dst << std::endl
+                               << "src: " << s_src << std::endl
+                               << "expect: " << s_expect << std::endl
+                               << "actual: " << dst.Dump() << std::endl;
+  }
+}
+
+TEST(NodeTest, Update) {
+  UpdateTestHelper<true>(R"({"a":1})", R"({"a":2})", R"({"a":2})");
+  UpdateTestHelper<true>(R"({"a":1})", R"({"b":2})", R"({"a":1, "b":2})");
+  UpdateTestHelper<true>(R"("a")", R"("b")", R"("b")");
+  UpdateTestHelper<true>(R"({"a":1})", R"({"a":{"b":1, "b":1}})",
+                         R"({"a":{"b":1, "b":1}})");
+  UpdateTestHelper<true>(R"({"a":[1,2,3], "b":[], "c":{}})", R"({"a":[]})",
+                         R"({"a":[], "b":[], "c":{}})");
+
+  UpdateTestHelper<false>(R"({"a":1})", R"({"a":2})", R"({"a":1})");
+  UpdateTestHelper<false>(R"({"a":1})", R"({"b":2})", R"({"a":1, "b":2})");
+  UpdateTestHelper<false>(R"("a")", R"("b")", R"("a")");
+  UpdateTestHelper<false>(R"({"a":1})", R"({"c":{"b":1, "b":1}})",
+                          R"({"a":1, "c":{"b":1, "b":1}})");
+}
+
+void MergeTestHelper(const std::string& original, const std::string& patch,
+                     const std::string& result) {
+  using Doc = sonic_json::Document;
+  Doc o, p, r;
+  o.Parse(original);
+  EXPECT_FALSE(o.HasParseError()) << "original: " << original << std::endl;
+  p.Parse(patch);
+  EXPECT_FALSE(p.HasParseError()) << "patch: " << patch << std::endl;
+  r.Parse(result);
+  EXPECT_FALSE(r.HasParseError()) << "result: " << result << std::endl;
+
+  o.MergePatch(p, o.GetAllocator());
+  EXPECT_TRUE(o == r) << "original: " << original << std::endl
+                      << "patch: " << patch << std::endl
+                      << "result: " << result << std::endl
+                      << "actual: " << o.Dump() << std::endl;
+}
+
+TEST(NodeTest, Merge) {
+  MergeTestHelper(R"({"a":"b"})", R"({"a":"c"})", R"({"a":"c"})");
+  MergeTestHelper(R"({"a":"b"})", R"({"b":"c"})", R"({"a":"b","b":"c"})");
+  MergeTestHelper(R"({"a":"b"})", R"({"a":null})", R"({})");
+  MergeTestHelper(R"({"a":"b", "b":"c"})", R"({"a":null})", R"({"b":"c"})");
+  MergeTestHelper(R"({"a":["b"]})", R"({"a":"c"})", R"({"a":"c"})");
+  MergeTestHelper(R"({"a":"c"})", R"({"a":["b"]})", R"({"a":["b"]})");
+  MergeTestHelper(R"({"a":{"b":"c"}})", R"({"a":{"b":"d", "c":null}})",
+                  R"({"a":{"b":"d"}})");
+  MergeTestHelper(R"({"a":[{"b":"c"}]})", R"({"a":[1]})", R"({"a":[1]})");
+  MergeTestHelper(R"(["a","b"])", R"(["c", "d"])", R"(["c", "d"])");
+  MergeTestHelper(R"({"a":"b"})", R"(["c"])", R"(["c"])");
+  MergeTestHelper(R"({"a":"foo"})", R"(null)", R"(null)");
+  MergeTestHelper(R"({"a":"foo"})", R"("bar")", R"("bar")");
+  MergeTestHelper(R"({"e":null})", R"({"a":1})", R"({"e":null, "a":1})");
+  MergeTestHelper(R"([1,2])", R"({"a":"b", "c":null})", R"({"a":"b"})");
+  MergeTestHelper(R"({})", R"({"a":{"bb":{"ccc":null}}})",
+                  R"({"a":{"bb":{}}})");
+}
+
+void DiffTestHelper(const std::string& from, const std::string& to,
+                    const std::string& expect) {
+  using Doc = sonic_json::Document;
+  Doc f, t, e;
+  EXPECT_FALSE(f.Parse(from).HasParseError()) << from << std::endl;
+  EXPECT_FALSE(t.Parse(to).HasParseError()) << to << std::endl;
+  EXPECT_FALSE(e.Parse(expect).HasParseError()) << expect << std::endl;
+  Doc patch = Diff(f, t);
+  EXPECT_TRUE(patch == e) << "From json: " << from << std::endl
+                          << "To json: " << to << std::endl
+                          << "Exepct json: " << expect << std::endl
+                          << "Patch ans: " << patch.Dump() << std::endl;
+}
+
+TEST(NodeTest, Diff) {
+  DiffTestHelper(R"({"a":"b"})", R"({"a":"c"})", R"({"a":"c"})");
+  DiffTestHelper(R"({"a":"b"})", R"({"a":"b","b":"c"})", R"({"b":"c"})");
+  DiffTestHelper(R"({"a":"b"})", R"({})", R"({"a":null})");
+  DiffTestHelper(R"({"a":["b"]})", R"({"a":"c"})", R"({"a":"c"})");
+  DiffTestHelper(R"({"a":"c"})", R"({"a":["b"]})", R"({"a":["b"]})");
+  DiffTestHelper(R"({"a":{"b":"c","c":"d"}})", R"({"a":{"b":"d"}})",
+                 R"({"a":{"b":"d","c":null}})");
+  DiffTestHelper(R"({"a":[{"b":"c"}]})", R"({"a":[1]})", R"({"a":[1]})");
+  DiffTestHelper(R"(["a","b"])", R"(["c","d"])", R"(["c","d"])");
+  DiffTestHelper(R"({"a":"b"})", R"(["c"])", R"(["c"])");
+  DiffTestHelper(R"({"a":"foo"})", R"(null)", R"(null)");
+  DiffTestHelper(R"({"a":"foo"})", R"("bar")", R"("bar")");
+  DiffTestHelper(R"({})", R"({"a":{"bb":{"ccc":null}}})",
+                 R"({"a":{"bb":{"ccc":null}}})");
+}
 }  // namespace

From 6e4a0edb02bfc23369ac29c05dae87b9cf25d435 Mon Sep 17 00:00:00 2001
From: Xie Gengxin <xiegengxin.94@bytedance.com>
Date: Wed, 8 Mar 2023 15:00:04 +0800
Subject: [PATCH 2/2] Remove Diff methods

---
 include/sonic/dom/generic_document.h | 18 ------
 include/sonic/dom/genericnode.h      | 87 +++++++---------------------
 2 files changed, 20 insertions(+), 85 deletions(-)

diff --git a/include/sonic/dom/generic_document.h b/include/sonic/dom/generic_document.h
index 710d2f8d..eab9e7d8 100644
--- a/include/sonic/dom/generic_document.h
+++ b/include/sonic/dom/generic_document.h
@@ -260,22 +260,4 @@ class GenericDocument : public NodeType {
 
 using Document = GenericDocument<DNode<SONIC_DEFAULT_ALLOCATOR>>;
 
-template <typename ReturnDocType, typename T, typename U>
-static ReturnDocType Diff(const T& from, const U& to) {
-  ReturnDocType ret;
-  using RetNodeType = typename ReturnDocType::NodeType;
-  Diff(from, to, (RetNodeType&)(ret), ret.GetAllocator());
-
-  return ret; /* RVO */
-}
-
-template <typename T, typename U>
-static Document Diff(const T& from, const U& to) {
-  Document ret;
-  using RetNodeType = typename Document::NodeType;
-  Diff(from, to, (RetNodeType&)(ret), ret.GetAllocator());
-
-  return ret; /* RVO */
-}
-
 }  // namespace sonic_json
diff --git a/include/sonic/dom/genericnode.h b/include/sonic/dom/genericnode.h
index 1714b4e5..0c8e6c36 100644
--- a/include/sonic/dom/genericnode.h
+++ b/include/sonic/dom/genericnode.h
@@ -51,9 +51,6 @@ struct NodeTraits;
 template <bool UpdateExistentKey, typename T, typename S, typename Allocator,
           typename>
 static inline void Update(T&, const S&, Allocator&);
-//
-// template <typename T, typename S, typename Allocator, bool=false>
-// static inline void Merge(T&, const S&, Allocator&);
 
 // Copied from http://coliru.stacked-crooked.com/a/8dd19d21817cadf5
 template <template <typename...> class C, typename... Ts>
@@ -1061,19 +1058,26 @@ class GenericNode {
 
   /**
    * @brief Json Merge patch, rfc7386
+   * @param copy_const_string whether copy the strings that are managed by
+   *    user.
    */
   template <typename PatchType,
             typename std::enable_if<
                 is_base_of_template<PatchType, GenericNode>::value,
                 bool>::type = false>
-  void MergePatch(const PatchType& patch, Allocator& alloc) {
-    return Merge(*(downCast()), patch, alloc);
+  void MergePatch(const PatchType& patch, alloc_type& alloc,
+          bool copy_const_string=false) {
+    return Merge(*(downCast()), patch, alloc, copy_const_string);
   }
 
   /**
    * @brief updates from another object. Copying non-existent key. Updating\n
    *        existent key \b deeply if template parameter is true.
    * @tparam UpdateExistentKey overwritting existent key
+   * @param src the source node
+   * @param alloc Allocator that manage the memory of *this
+   * @param copy_const_string whether copy the strings that are managed by
+   *    user.
    * @note cases: \n
    *   {"a":"b"} .UPDATE. {"a":"c} => {"a":"c"} (UpdateExistedKey == true) \n
    *   {"a":"b"} .UPDATE. {"a":"c} => {"a":"b"} (UpdateExistedKey == false) \n
@@ -1083,8 +1087,10 @@ class GenericNode {
   template <bool UpdateExistentKey = true, typename S,
             typename std::enable_if<is_base_of_template<S, GenericNode>::value,
                                     bool>::type = false>
-  void UpdateFrom(const S& src, Allocator& alloc) {
-    return Update<UpdateExistentKey>(*(downCast()), src, alloc);
+  void UpdateFrom(const S& src, alloc_type& alloc,
+          bool copy_const_string=false) {
+    return Update<UpdateExistentKey>(*(downCast()), src, alloc,
+            copy_const_string);
   }
 
  protected:
@@ -1235,7 +1241,8 @@ template <
     typename std::enable_if<is_base_of_template<T, GenericNode>::value &&
                                 is_base_of_template<P, GenericNode>::value,
                             bool>::type = false>
-static inline void Merge(T& original, const P& patch, Allocator& alloc) {
+static inline void Merge(T& original, const P& patch, Allocator& alloc,
+        bool copy_const_string=false) {
   if (patch.IsObject()) {
     if (!original.IsObject()) {
       original.SetObject();
@@ -1258,7 +1265,7 @@ static inline void Merge(T& original, const P& patch, Allocator& alloc) {
       }
     }
   } else {
-    original.CopyFrom(patch, alloc);
+    original.CopyFrom(patch, alloc, copy_const_string);
   }
 }
 
@@ -1267,10 +1274,11 @@ template <
     typename std::enable_if<is_base_of_template<T, GenericNode>::value &&
                                 is_base_of_template<S, GenericNode>::value,
                             bool>::type = false>
-static inline void Update(T& original, const S& src, Allocator& alloc) {
+static inline void Update(T& original, const S& src, Allocator& alloc,
+        bool copy_const_string=false) {
   if (src.IsObject()) {
     if (!original.IsObject()) {
-      original.CopyFrom(src, alloc);
+      original.CopyFrom(src, alloc, copy_const_string);
     } else {
       original.CreateMap(alloc);
       for (auto itr = src.MemberBegin(), e = src.MemberEnd(); itr != e; ++itr) {
@@ -1284,63 +1292,8 @@ static inline void Update(T& original, const S& src, Allocator& alloc) {
       }
     }
   } else if (UpdateExistentKey) {
-    original.CopyFrom(src, alloc);
+    original.CopyFrom(src, alloc, copy_const_string);
   }
 }
 
-/*
- * @brief diff from one json to another
- * @prarm alloc Memory allocator for patch
- */
-template <
-    typename T, typename U, typename V, typename Allocator,
-    typename std::enable_if<is_base_of_template<T, GenericNode>::value &&
-                                is_base_of_template<U, GenericNode>::value &&
-                                is_base_of_template<V, GenericNode>::value,
-                            bool>::type = false>
-static bool Diff(const T& from, const U& to, V& patch, Allocator& alloc) {
-  if (from.GetType() != to.GetType()) {
-    if (from.IsString() && from == to) {
-      return false;
-    }
-    patch.CopyFrom(to, alloc);
-    return true;
-  }
-
-  bool is_diff = false;
-  switch (from.GetType()) {
-    case kObject:
-      patch.SetObject();
-      for (auto it = from.MemberBegin(), e = from.MemberEnd(); it != e; ++it) {
-        auto m = to.FindMember(it->name.GetStringView());
-        if (m != to.MemberEnd()) {
-          V tmp;
-          bool b = Diff(it->value, m->value, tmp, alloc);
-          if (b) {
-            is_diff = true;
-            patch.AddMember(it->name.GetStringView(), tmp, alloc);
-          }
-        } else {    // target doesn't have this key
-          V tmp{};  // Null
-          patch.AddMember(it->name.GetStringView(), tmp, alloc);
-        }
-      }
-      for (auto it = to.MemberBegin(), e = to.MemberEnd(); it != e; ++it) {
-        auto m = from.FindMember(it->name.GetStringView());
-        if (m == from.MemberEnd()) {  // only need add non-existed key to patch
-          V tmp{};
-          tmp.CopyFrom(it->value, alloc);
-          patch.AddMember(it->name.GetStringView(), tmp, alloc);
-        }
-      }
-      break;
-    default:
-      if (from != to) {
-        patch.CopyFrom(to, alloc);
-        is_diff = true;
-      }
-  }
-  return is_diff;
-}
-
 }  // namespace sonic_json