diff --git a/docs/mkdocs/docs/api/basic_json_document/index.md b/docs/mkdocs/docs/api/basic_json_document/index.md index 3d7f41aad3..c31857bb3b 100644 --- a/docs/mkdocs/docs/api/basic_json_document/index.md +++ b/docs/mkdocs/docs/api/basic_json_document/index.md @@ -100,7 +100,8 @@ points apply to every edit: [`root()`](root.md). New values (and the element sequences of an edited array/object) go to storage owned by the document, allocated on demand. - **A view keeps referring to the same value.** After [`set`](set.md) replaces the value a view refers to, that view - sees the new value; a view of a value that a later edit replaces or drops keeps showing what it last held. An edit + sees the new value; a view of a value that a later edit replaces or drops keeps showing what it last held. Such a + view can still be edited: the edit changes only that detached value, never anything reachable from `root()`. An edit of an array or object, however, **invalidates the iterators taken over it** (its members may now live in a different sequence), and a string obtained with [`get_string()`](../basic_json_view/get_string.md) stays valid even as further edits happen (earlier buffers of edited text are kept alive, not overwritten). diff --git a/docs/mkdocs/docs/api/basic_json_document/set.md b/docs/mkdocs/docs/api/basic_json_document/set.md index 5c68da311a..a983a40552 100644 --- a/docs/mkdocs/docs/api/basic_json_document/set.md +++ b/docs/mkdocs/docs/api/basic_json_document/set.md @@ -164,7 +164,9 @@ general. The same switch happens, for the same reason, when overload 1. replaces a multi-node array/object value with a scalar: the *parent's* element sequence is what has to switch to links, not `target` itself, because the parent originally stepped over `target`'s whole subtree by its node count, which no longer applies once `target` is a -one-node scalar. +one-node scalar. This also holds when `target` is no longer part of the document (an edit erased or replaced it, or +a value that contains it): if the container that `target` was in still uses its parsed layout, it switches to links +(otherwise nothing steps over `target` any more), and only the dropped values change. ## Examples diff --git a/include/nlohmann/detail/view/edit.hpp b/include/nlohmann/detail/view/edit.hpp index 8ddf3f8495..af213e9fdd 100644 --- a/include/nlohmann/detail/view/edit.hpp +++ b/include/nlohmann/detail/view/edit.hpp @@ -384,9 +384,22 @@ class editor // for the container is linear in the size of the document, so // links (which are marked in the slot) avoid it. node* const p = parent_known ? parent : find_parent(m_doc, slot); - if (p != nullptr && ((p->flags & node_flags::moved) == 0 || moved_capacity(m_doc, p) == 0)) + if (p != nullptr) { - block_of(m_doc, p, 0); + if ((p->flags & node_flags::moved) == 0 || moved_capacity(m_doc, p) == 0) + { + block_of(m_doc, p, 0); + } + } + else + { + // the slot is no longer part of the document, but the + // (dropped) container it is in may still step over it + node* const q = find_layout_parent(m_doc, slot); + if (q != nullptr) + { + block_of(m_doc, q, 0); + } } } *slot = e.scalar; diff --git a/include/nlohmann/detail/view/edit_storage.hpp b/include/nlohmann/detail/view/edit_storage.hpp index 34b804c466..d9c0339a7f 100644 --- a/include/nlohmann/detail/view/edit_storage.hpp +++ b/include/nlohmann/detail/view/edit_storage.hpp @@ -194,7 +194,9 @@ inline node* block_of(document_data& d, node* n, std::size_t extra) h->len = n->len; h->next = static_cast(used); node* o = h + 1; - for (const node* c = d.first_child_edited(n), *e = d.child_end_edited(n); c != e;) + // (the bound on o keeps the copy inside the block even if the elements + // disagreed with the element count) + for (const node* c = d.first_child_edited(n), *e = d.child_end_edited(n), *const full = h + used; c != e && o != full;) { if (object) { @@ -276,6 +278,41 @@ inline node* find_parent(const document_data& d, const node* target) } } +/// The container whose contiguous layout (in the parsed index, or in a new +/// value) steps over `target`, also when an edit dropped the container or a +/// value that encloses it; nullptr if there is none, or if the container no +/// longer walks that layout (its elements moved). An edit never gives a node a +/// larger extent than it was parsed or encoded with (a scalar is one node, an +/// assigned array/object keeps the extent of the slot), so the containers whose +/// extent covers `target` are its original ancestors: the nearest one before it +/// is its original parent. The root of a new value that is the element sequence +/// of another container is walked by that container (which find_parent() finds +/// while it still uses the sequence), not by itself. +inline node* find_layout_parent(const document_data& d, const node* target) +{ + const std::less lt{}; + const node* lo = d.nodes; + if (lt(target, lo) || !lt(target, d.nodes + d.node_count)) + { + auto it = d.edits->regions.upper_bound(target); + if (it == d.edits->regions.begin()) + { + return nullptr; // LCOV_EXCL_LINE (an array/object with elements is in the index or a new value) + } + --it; + lo = it->second != nullptr ? it->first + 1 : it->first; + } + for (const node* c = target; c != lo;) + { + --c; + if (is_container(*c) && lt(target, c + c->next)) + { + return (c->flags & node_flags::moved) == 0 ? const_cast(c) : nullptr; // NOLINT(cppcoreguidelines-pro-type-const-cast): the nodes belong to the document + } + } + return nullptr; +} + } // namespace view } // namespace detail NLOHMANN_JSON_NAMESPACE_END diff --git a/single_include/nlohmann/json_view.hpp b/single_include/nlohmann/json_view.hpp index 233a554877..b231990213 100644 --- a/single_include/nlohmann/json_view.hpp +++ b/single_include/nlohmann/json_view.hpp @@ -5564,7 +5564,9 @@ inline node* block_of(document_data& d, node* n, std::size_t extra) h->len = n->len; h->next = static_cast(used); node* o = h + 1; - for (const node* c = d.first_child_edited(n), *e = d.child_end_edited(n); c != e;) + // (the bound on o keeps the copy inside the block even if the elements + // disagreed with the element count) + for (const node* c = d.first_child_edited(n), *e = d.child_end_edited(n), *const full = h + used; c != e && o != full;) { if (object) { @@ -5646,6 +5648,41 @@ inline node* find_parent(const document_data& d, const node* target) } } +/// The container whose contiguous layout (in the parsed index, or in a new +/// value) steps over `target`, also when an edit dropped the container or a +/// value that encloses it; nullptr if there is none, or if the container no +/// longer walks that layout (its elements moved). An edit never gives a node a +/// larger extent than it was parsed or encoded with (a scalar is one node, an +/// assigned array/object keeps the extent of the slot), so the containers whose +/// extent covers `target` are its original ancestors: the nearest one before it +/// is its original parent. The root of a new value that is the element sequence +/// of another container is walked by that container (which find_parent() finds +/// while it still uses the sequence), not by itself. +inline node* find_layout_parent(const document_data& d, const node* target) +{ + const std::less lt{}; + const node* lo = d.nodes; + if (lt(target, lo) || !lt(target, d.nodes + d.node_count)) + { + auto it = d.edits->regions.upper_bound(target); + if (it == d.edits->regions.begin()) + { + return nullptr; // LCOV_EXCL_LINE (an array/object with elements is in the index or a new value) + } + --it; + lo = it->second != nullptr ? it->first + 1 : it->first; + } + for (const node* c = target; c != lo;) + { + --c; + if (is_container(*c) && lt(target, c + c->next)) + { + return (c->flags & node_flags::moved) == 0 ? const_cast(c) : nullptr; // NOLINT(cppcoreguidelines-pro-type-const-cast): the nodes belong to the document + } + } + return nullptr; +} + } // namespace view } // namespace detail NLOHMANN_JSON_NAMESPACE_END @@ -6522,9 +6559,22 @@ class editor // for the container is linear in the size of the document, so // links (which are marked in the slot) avoid it. node* const p = parent_known ? parent : find_parent(m_doc, slot); - if (p != nullptr && ((p->flags & node_flags::moved) == 0 || moved_capacity(m_doc, p) == 0)) + if (p != nullptr) { - block_of(m_doc, p, 0); + if ((p->flags & node_flags::moved) == 0 || moved_capacity(m_doc, p) == 0) + { + block_of(m_doc, p, 0); + } + } + else + { + // the slot is no longer part of the document, but the + // (dropped) container it is in may still step over it + node* const q = find_layout_parent(m_doc, slot); + if (q != nullptr) + { + block_of(m_doc, q, 0); + } } } *slot = e.scalar; diff --git a/tests/src/unit-json_view_edit.cpp b/tests/src/unit-json_view_edit.cpp index db6d3054b1..94b4df7064 100644 --- a/tests/src/unit-json_view_edit.cpp +++ b/tests/src/unit-json_view_edit.cpp @@ -589,6 +589,76 @@ TEST_CASE("json_view edits: a container that was added is replaced by a scalar") CHECK(d.root().materialize() == json::parse(R"({"a":[1,6,{"k":"s"}]})")); } +TEST_CASE("json_view edits: a scalar replaces an array or object that is no longer part of the document") +{ + // the dropped container that the array/object is in still steps over its + // parsed extent: that container switches to links first, as a live one does + SECTION("members of an erased object") + { + json_editable_document d = json_editable_document::parse(R"({"p": {"a": [1, [2]], "b": 3, "e": []}, "q": 0})"); + const json_editable_view p = d.root()["p"]; + const json_editable_view a = p["a"]; + d.erase(d.root(), "p"); + d.set(a[1], 5); + CHECK(p.dump() == R"({"a":[1,5],"b":3,"e":[]})"); + d.set(a, 5); + CHECK(p.size() == 3); + CHECK(p.dump() == R"({"a":5,"b":3,"e":[]})"); + d.push_back(p["e"], 6); + CHECK(p.dump() == R"({"a":5,"b":3,"e":[6]})"); + CHECK(d.root().dump() == R"({"q":0})"); + } + + SECTION("an array whose elements moved") + { + json_editable_document d = json_editable_document::parse(R"({"p": {"a": [1, 2], "b": 3}, "q": 0})"); + const json_editable_view p = d.root()["p"]; + const json_editable_view a = p["a"]; + d.erase(d.root(), "p"); + d.push_back(a, 4); // (the extent of a stays) + d.set(a, 5); + CHECK(p.dump() == R"({"a":5,"b":3})"); + CHECK(d.root().dump() == R"({"q":0})"); + } + + SECTION("an element of an erased array, which grows afterwards") + { + json_editable_document d = json_editable_document::parse(R"({"p": [[0, 0, 0, 0, 0, 0, 0, 0, 0, 0]], "q": 0})"); + const json_editable_view p = d.root()["p"]; + d.erase(d.root(), "p"); + d.set(p[0], 5); + d.push_back(p, 1); + CHECK(p.dump() == "[5,1]"); + CHECK(d.root().dump() == R"({"q":0})"); + } + + SECTION("values in an erased new value") + { + json_editable_document d = json_editable_document::parse("[0]"); + const json_editable_view x = d.push_back(d.root(), json::parse("[[[1, 2]], 3]")); + const json_editable_view y = x[0]; + d.erase(d.root(), 1); + d.set(y[0], 5); + CHECK(x.dump() == "[[5],3]"); + d.set(y, 5); + CHECK(x.dump() == "[5,3]"); + CHECK(d.root().dump() == "[0]"); + } + + SECTION("values in the elements that an array had before it was replaced") + { + json_editable_document d = json_editable_document::parse("[0]"); + d.set(d.root()[0], json::parse("[[[1, 2]]]")); + const json_editable_view y = d.root()[0][0]; + d.set(d.root()[0], json::array({3})); + d.set(y[0], 5); + CHECK(y.dump() == "[5]"); + d.set(y, 5); + CHECK(y.dump() == "5"); + CHECK(d.root().dump() == "[[3]]"); + } +} + #if !defined(JSON_NOEXCEPTION) TEST_CASE("json_view edits: the size of a text arena") {