mirror of
https://github.com/nlohmann/json.git
synced 2026-10-03 13:10:33 +00:00
Niels Lohmann
76897a9b9b
basic_json_document<BasicJsonType, true> (json_editable_document,
ordered_json_editable_document) can be edited:
- set(view, value): replace a value
- set(object, key, value): assign a member, or add it (a null becomes an
object); with duplicate keys, the first is assigned and the others go
- set(array, index, value): assign an element
- set(json_pointer, value): the member, element, or ("-", or the size of
the array) the end of an array a pointer names
- push_back(array, value): append (a null becomes an array)
Values are views (of any document, copied), BasicJsonType values, and
everything BasicJsonType can be constructed from. The source text is never
written, and the parsed index never moves: new values and element
sequences go to storage owned by the document (edit_storage.hpp), so views
stay valid, and a view keeps referring to its value (after an assignment,
it sees the new one). Read-only documents are unchanged; editing one does
not compile.
Errors are those of basic_json where the operation corresponds
(type_error.305/308, out_of_range.401/403/405, parse_error.106/109); a view
of another document is invalid_iterator.202. Strings are checked for UTF-8
when they enter the document, with the type_error.316 that
basic_json::dump() throws for the same string, so that a document only
holds valid UTF-8. Binary values cannot be stored (the new
type_error.319), and edits of 4 GiB or more end with out_of_range.416.
Views of editable and read-only documents compare with each other.
Tests (unit-json_view_edit.cpp): random assignments, member and element
changes, copies within and between documents, and pushes, applied to an
ordered_json_editable_document and to the ordered_json value; after every
edit both must serialize (also indented and with ensure_ascii),
materialize, compare, and read back the same. Further: the errors, strings
that stay valid while the edit arena grows, numbers (NaN, infinities,
extremes; number_format::source), nulls that become containers, the root
replaced, duplicate keys, values of other documents, large objects, and
documents reused with read().
Signed-off-by: Niels Lohmann <mail@nlohmann.me>
705 lines
23 KiB
C++
705 lines
23 KiB
C++
// __ _____ _____ _____
|
|
// __| | __| | | | JSON for Modern C++
|
|
// | | |__ | | | | | | version 3.12.0
|
|
// |_____|_____|_____|_|___| https://github.com/nlohmann/json
|
|
//
|
|
// SPDX-FileCopyrightText: 2013-2026 Niels Lohmann <https://nlohmann.me>
|
|
// SPDX-License-Identifier: MIT
|
|
|
|
#pragma once
|
|
|
|
#include <array> // array
|
|
#include <cmath> // isinf, isnan
|
|
#include <cstddef> // size_t
|
|
#include <cstdint> // int64_t, uint8_t, uint32_t, uint64_t
|
|
#include <cstring> // memcmp, memmove
|
|
#include <limits> // numeric_limits
|
|
#include <string> // string, to_string
|
|
#include <type_traits> // decay, enable_if, integral_constant, is_arithmetic, is_convertible, is_floating_point, is_same, is_signed
|
|
#include <utility> // forward
|
|
|
|
#include <nlohmann/json.hpp>
|
|
#include <nlohmann/detail/view/document_data.hpp>
|
|
#include <nlohmann/detail/view/edit_storage.hpp>
|
|
#include <nlohmann/detail/view/errors.hpp>
|
|
#include <nlohmann/detail/view/lookup.hpp>
|
|
#include <nlohmann/detail/view/macro_scope.hpp>
|
|
#include <nlohmann/detail/view/node.hpp>
|
|
|
|
NLOHMANN_JSON_NAMESPACE_BEGIN
|
|
|
|
template<typename BasicJsonType, bool Editable>
|
|
class basic_json_view;
|
|
|
|
namespace detail
|
|
{
|
|
namespace view
|
|
{
|
|
|
|
/// Checks a string the way basic_json's serializer does when it writes it
|
|
/// (type_error.316 with the same message), so that an editable document
|
|
/// only holds valid UTF-8: the error is at the first byte that no
|
|
/// well-formed sequence can continue with (Unicode, Table 3-7).
|
|
inline void check_utf8(const char* s, std::size_t n)
|
|
{
|
|
const auto* const p = reinterpret_cast<const unsigned char*>(s); // NOLINT(cppcoreguidelines-pro-type-reinterpret-cast)
|
|
const auto hex = [](unsigned char c)
|
|
{
|
|
constexpr const char* digits = "0123456789ABCDEF";
|
|
return std::string{digits[c >> 4u], digits[c & 0xFu]};
|
|
};
|
|
for (std::size_t i = 0; i < n;)
|
|
{
|
|
const unsigned char c = p[i];
|
|
if (c < 0x80)
|
|
{
|
|
++i;
|
|
continue;
|
|
}
|
|
std::size_t len = 0;
|
|
unsigned char lo = 0x80;
|
|
unsigned char hi = 0xBF;
|
|
if (c >= 0xC2 && c <= 0xDF)
|
|
{
|
|
len = 2;
|
|
}
|
|
else if (c >= 0xE0 && c <= 0xEF)
|
|
{
|
|
len = 3;
|
|
lo = c == 0xE0 ? 0xA0 : 0x80;
|
|
hi = c == 0xED ? 0x9F : 0xBF;
|
|
}
|
|
else if (c >= 0xF0 && c <= 0xF4)
|
|
{
|
|
len = 4;
|
|
lo = c == 0xF0 ? 0x90 : 0x80;
|
|
hi = c == 0xF4 ? 0x8F : 0xBF;
|
|
}
|
|
else
|
|
{
|
|
throw_type_error(316, concat("invalid UTF-8 byte at index ", std::to_string(i), ": 0x", hex(c)));
|
|
}
|
|
for (std::size_t k = 1; k < len; ++k)
|
|
{
|
|
if (i + k == n)
|
|
{
|
|
throw_type_error(316, concat("incomplete UTF-8 string; last byte: 0x", hex(p[n - 1])));
|
|
}
|
|
const unsigned char b = p[i + k];
|
|
if (b < (k == 1 ? lo : 0x80) || b > (k == 1 ? hi : 0xBF))
|
|
{
|
|
throw_type_error(316, concat("invalid UTF-8 byte at index ", std::to_string(i + k), ": 0x", hex(b)));
|
|
}
|
|
}
|
|
i += len;
|
|
}
|
|
}
|
|
|
|
/*!
|
|
@brief the edits of an editable basic_json_document
|
|
|
|
Values are accepted as views (of any document), BasicJsonType values, and
|
|
everything BasicJsonType can be constructed from. The source text is never
|
|
written: new values go to storage owned by the document (see
|
|
edit_storage.hpp).
|
|
*/
|
|
template<typename BasicJsonType, typename View>
|
|
class editor
|
|
{
|
|
using number_integer_t = typename BasicJsonType::number_integer_t;
|
|
using number_unsigned_t = typename BasicJsonType::number_unsigned_t;
|
|
using number_float_t = typename BasicJsonType::number_float_t;
|
|
using string_t = typename BasicJsonType::string_t;
|
|
using string_view_t = typename View::string_view_t;
|
|
using nav = navigation<true>;
|
|
|
|
public:
|
|
explicit editor(document_data& d) noexcept
|
|
: m_doc(d)
|
|
{}
|
|
|
|
/// replace a value; returns its view
|
|
template<typename V>
|
|
View set(const View& target, V&& value)
|
|
{
|
|
node* const slot = own(target);
|
|
const encoded e = encode(std::forward<V>(value));
|
|
assign(slot, e, nullptr, false);
|
|
return View(&m_doc, slot);
|
|
}
|
|
|
|
/// set a member (appended if missing; a null value becomes an object);
|
|
/// returns a view of the member value
|
|
template<typename V>
|
|
View set(const View& object, string_view_t key, V&& value)
|
|
{
|
|
node* const o = own(object);
|
|
if (o->kind != static_cast<std::uint8_t>(value_t::object) && o->kind != static_cast<std::uint8_t>(value_t::null))
|
|
{
|
|
throw_type_error(305, "cannot use operator[] with a string argument with ", object.type_name());
|
|
}
|
|
check_utf8(key.data(), key.size());
|
|
const encoded e = encode(std::forward<V>(value));
|
|
if (o->kind == static_cast<std::uint8_t>(value_t::null))
|
|
{
|
|
become_empty(o, value_t::object);
|
|
}
|
|
// an existing member: assign it (and drop later duplicates, so that
|
|
// lookups, iteration, and materialize() agree)
|
|
node* slot = nullptr;
|
|
bool duplicates = false;
|
|
for (const node* k = nav::first(m_doc, o), *end = nav::end(m_doc, o); k != end; k = document_data::after(k + 1))
|
|
{
|
|
if (key_equals(*k, key))
|
|
{
|
|
if (slot != nullptr)
|
|
{
|
|
duplicates = true;
|
|
break;
|
|
}
|
|
slot = const_cast<node*>(nav::value(k + 1)); // NOLINT(cppcoreguidelines-pro-type-const-cast): the nodes belong to this document
|
|
}
|
|
}
|
|
if (slot != nullptr)
|
|
{
|
|
if (duplicates)
|
|
{
|
|
erase_members(o, key, true);
|
|
}
|
|
assign(slot, e, o, true);
|
|
return View(&m_doc, slot);
|
|
}
|
|
const node k = string_node(key.data(), key.size());
|
|
slot = new_slot(e);
|
|
node* const h = block_of(m_doc, o, 2);
|
|
h[h->next] = k;
|
|
make_link(h[h->next + 1], slot);
|
|
h->next += 2;
|
|
++h->len;
|
|
++o->len;
|
|
return View(&m_doc, slot);
|
|
}
|
|
|
|
/// assign an existing array element; returns a view of it
|
|
template<typename V>
|
|
View set(const View& array, std::size_t idx, V&& value)
|
|
{
|
|
node* const a = own(array);
|
|
if (a->kind != static_cast<std::uint8_t>(value_t::array))
|
|
{
|
|
throw_type_error(305, "cannot use operator[] with a numeric argument with ", array.type_name());
|
|
}
|
|
check_index(idx, a->len);
|
|
const encoded e = encode(std::forward<V>(value));
|
|
node* const slot = const_cast<node*>(nav::value(element_at<true>(m_doc, a, idx))); // NOLINT(cppcoreguidelines-pro-type-const-cast)
|
|
assign(slot, e, a, true);
|
|
return View(&m_doc, slot);
|
|
}
|
|
|
|
/// append to an array (a null value becomes an array); returns a view of
|
|
/// the new element
|
|
template<typename V>
|
|
View push_back(const View& array, V&& value)
|
|
{
|
|
node* const a = own(array);
|
|
if (a->kind != static_cast<std::uint8_t>(value_t::array) && a->kind != static_cast<std::uint8_t>(value_t::null))
|
|
{
|
|
throw_type_error(308, "cannot use push_back() with ", array.type_name());
|
|
}
|
|
const encoded e = encode(std::forward<V>(value));
|
|
if (a->kind == static_cast<std::uint8_t>(value_t::null))
|
|
{
|
|
become_empty(a, value_t::array);
|
|
}
|
|
node* const slot = new_slot(e);
|
|
node* const h = block_of(m_doc, a, 1);
|
|
make_link(h[h->next], slot);
|
|
++h->next;
|
|
++h->len;
|
|
++a->len;
|
|
return View(&m_doc, slot);
|
|
}
|
|
|
|
private:
|
|
/// an encoded value: a scalar node, or the root of a new array/object
|
|
struct encoded
|
|
{
|
|
node scalar{};
|
|
node* region = nullptr;
|
|
};
|
|
|
|
/// the node of a view of this document
|
|
node* own(const View& v)
|
|
{
|
|
if (NLOHMANN_VIEW_UNLIKELY(v.m_doc != &m_doc || v.m_node == nullptr))
|
|
{
|
|
throw_invalid_iterator(202, "view does not belong to this document");
|
|
}
|
|
edit_state_of(m_doc);
|
|
return const_cast<node*>(v.m_node); // NOLINT(cppcoreguidelines-pro-type-const-cast): the nodes belong to this document
|
|
}
|
|
|
|
static void check_index(std::size_t idx, std::size_t limit)
|
|
{
|
|
if (idx >= limit)
|
|
{
|
|
throw_out_of_range(401, concat("array index ", std::to_string(idx), " is out of range"));
|
|
}
|
|
}
|
|
|
|
bool key_equals(const node& k, string_view_t key) const noexcept
|
|
{
|
|
return k.len == key.size() && (key.size() == 0 || std::memcmp(m_doc.str(k), key.data(), key.size()) == 0);
|
|
}
|
|
|
|
/// remove the members with this key (all, or all but the first) from an object
|
|
std::size_t erase_members(node* o, string_view_t key, bool keep_first)
|
|
{
|
|
node* const h = block_of(m_doc, o, 0);
|
|
node* w = h + 1;
|
|
std::size_t erased = 0;
|
|
bool kept = false;
|
|
for (node* r = h + 1, *end = h + h->next; r != end; r += 2)
|
|
{
|
|
const bool match = key_equals(*r, key);
|
|
if (match && (kept || !keep_first))
|
|
{
|
|
++erased;
|
|
continue;
|
|
}
|
|
kept = kept || match;
|
|
if (w != r)
|
|
{
|
|
w[0] = r[0];
|
|
w[1] = r[1];
|
|
}
|
|
w += 2;
|
|
}
|
|
h->next = static_cast<std::uint32_t>(w - h);
|
|
h->len -= static_cast<std::uint32_t>(erased);
|
|
o->len -= static_cast<std::uint32_t>(erased);
|
|
return erased;
|
|
}
|
|
|
|
/// turn a null into an empty array/object in place
|
|
static void become_empty(node* n, value_t k) noexcept
|
|
{
|
|
*n = node{};
|
|
n->kind = static_cast<std::uint8_t>(k);
|
|
n->flags = node_flags::is_new;
|
|
n->next = 1;
|
|
}
|
|
|
|
/// Replace the value at slot; `parent` is the container whose elements
|
|
/// include slot (if known).
|
|
void assign(node* slot, const encoded& e, node* parent, bool parent_known)
|
|
{
|
|
if (e.region == nullptr)
|
|
{
|
|
if (is_container(*slot) && slot->next > 1 && slot != m_doc.tape)
|
|
{
|
|
// The slot spans its old elements in the enclosing sequence, but
|
|
// a scalar is one node: the enclosing container first switches to
|
|
// links (then the extent of the slot no longer matters).
|
|
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))
|
|
{
|
|
block_of(m_doc, p, 0);
|
|
}
|
|
}
|
|
*slot = e.scalar;
|
|
return;
|
|
}
|
|
// an array/object: the slot keeps its extent (so that the enclosing
|
|
// sequence still steps over it), and the elements come from the new
|
|
// sequence
|
|
const node* const r = e.region;
|
|
const std::uint32_t extent = is_container(*slot) ? slot->next : 1;
|
|
const bool was_moved = (slot->flags & node_flags::moved) != 0;
|
|
slot->kind = r->kind;
|
|
slot->extra = 0;
|
|
slot->len = r->len;
|
|
slot->next = extent;
|
|
slot->flags = was_moved ? static_cast<std::uint8_t>(node_flags::moved | node_flags::is_new) : std::uint8_t{0};
|
|
set_moved(m_doc, slot, e.region, 0);
|
|
edit_state_of(m_doc).regions[e.region] = slot;
|
|
}
|
|
|
|
/// a node for a new element (links point to it; it never moves)
|
|
node* new_slot(const encoded& e)
|
|
{
|
|
if (e.region != nullptr)
|
|
{
|
|
return e.region;
|
|
}
|
|
node* const s = alloc_nodes(m_doc, 1);
|
|
*s = e.scalar;
|
|
return s;
|
|
}
|
|
|
|
//////////////
|
|
// encoding //
|
|
//////////////
|
|
|
|
template<int N>
|
|
using encode_tag = std::integral_constant<int, N>;
|
|
|
|
template<typename T>
|
|
struct is_view : std::false_type {};
|
|
|
|
template<typename J, bool E>
|
|
struct is_view<basic_json_view<J, E>> : std::true_type {};
|
|
|
|
template<typename V>
|
|
encoded encode(V&& v)
|
|
{
|
|
using D = typename std::decay<V>::type;
|
|
return encode_impl(std::forward<V>(v), encode_tag < is_view<D>::value ? 0
|
|
: std::is_same<D, BasicJsonType>::value ? 1
|
|
: std::is_same<D, std::nullptr_t>::value ? 2
|
|
: std::is_same<D, bool>::value ? 3
|
|
: std::is_arithmetic<D>::value ? 4
|
|
: std::is_convertible<const D&, string_view_t>::value ? 5 : 6 > {});
|
|
}
|
|
|
|
/// a view of any document (copied; nothing is shared with it)
|
|
template<typename J, bool E>
|
|
encoded encode_impl(const basic_json_view<J, E>& v, encode_tag<0> /*view*/)
|
|
{
|
|
if (NLOHMANN_VIEW_UNLIKELY(v.m_node == nullptr))
|
|
{
|
|
throw_type_error(302, "type must be a value, but is ", "discarded");
|
|
}
|
|
encoded r;
|
|
if (!is_container(*v.m_node))
|
|
{
|
|
r.scalar = copy_scalar(*v.m_doc, *v.m_node);
|
|
return r;
|
|
}
|
|
r.region = alloc_nodes(m_doc, count_nodes<E>(*v.m_doc, v.m_node));
|
|
fill_nodes<E>(*v.m_doc, v.m_node, r.region);
|
|
edit_state_of(m_doc).regions.emplace(r.region, nullptr);
|
|
return r;
|
|
}
|
|
|
|
encoded encode_impl(const BasicJsonType& j, encode_tag<1> /*json*/)
|
|
{
|
|
encoded r;
|
|
if (!j.is_structured())
|
|
{
|
|
r.scalar = json_scalar(j);
|
|
return r;
|
|
}
|
|
r.region = alloc_nodes(m_doc, count_nodes(j));
|
|
fill_nodes(j, r.region);
|
|
edit_state_of(m_doc).regions.emplace(r.region, nullptr);
|
|
return r;
|
|
}
|
|
|
|
encoded encode_impl(std::nullptr_t /*unused*/, encode_tag<2> /*null*/)
|
|
{
|
|
encoded r;
|
|
r.scalar = plain_node(value_t::null);
|
|
return r;
|
|
}
|
|
|
|
encoded encode_impl(bool b, encode_tag<3> /*boolean*/)
|
|
{
|
|
encoded r;
|
|
r.scalar = plain_node(value_t::boolean);
|
|
r.scalar.flags = static_cast<std::uint8_t>(r.scalar.flags | (b ? node_flags::is_true : 0));
|
|
return r;
|
|
}
|
|
|
|
template<typename T>
|
|
encoded encode_impl(T x, encode_tag<4> /*number*/)
|
|
{
|
|
encoded r;
|
|
r.scalar = number_node(x, std::integral_constant < int, std::is_floating_point<T>::value ? 0 : (std::is_signed<T>::value ? 1 : 2) > {});
|
|
return r;
|
|
}
|
|
|
|
template<typename T>
|
|
encoded encode_impl(const T& s, encode_tag<5> /*string*/)
|
|
{
|
|
const string_view_t sv(s);
|
|
check_utf8(sv.data(), sv.size());
|
|
encoded r;
|
|
r.scalar = string_node(sv.data(), sv.size());
|
|
return r;
|
|
}
|
|
|
|
template<typename T>
|
|
encoded encode_impl(T&& x, encode_tag<6> /*other*/)
|
|
{
|
|
return encode_impl(BasicJsonType(std::forward<T>(x)), encode_tag<1> {});
|
|
}
|
|
|
|
static node plain_node(value_t k) noexcept
|
|
{
|
|
node n{};
|
|
n.kind = static_cast<std::uint8_t>(k);
|
|
n.flags = node_flags::is_new;
|
|
return n;
|
|
}
|
|
|
|
template<typename T>
|
|
node number_node(T x, std::integral_constant<int, 0> /*floating-point*/)
|
|
{
|
|
return float_node(static_cast<number_float_t>(x));
|
|
}
|
|
|
|
template<typename T>
|
|
node number_node(T x, std::integral_constant<int, 1> /*signed*/)
|
|
{
|
|
return integer_node(static_cast<std::uint64_t>(static_cast<std::int64_t>(x)), value_t::number_integer);
|
|
}
|
|
|
|
template<typename T>
|
|
node number_node(T x, std::integral_constant<int, 2> /*unsigned*/)
|
|
{
|
|
return integer_node(static_cast<std::uint64_t>(x), value_t::number_unsigned);
|
|
}
|
|
|
|
/// an integer with its canonical token in the edit arena
|
|
node integer_node(std::uint64_t bits, value_t k)
|
|
{
|
|
const bool negative = k == value_t::number_integer && static_cast<std::int64_t>(bits) < 0;
|
|
std::uint64_t magnitude = negative ? 0 - bits : bits;
|
|
std::array<char, 24> buf{};
|
|
char* p = buf.data() + buf.size();
|
|
do
|
|
{
|
|
*--p = static_cast<char>('0' + (magnitude % 10));
|
|
magnitude /= 10;
|
|
}
|
|
while (magnitude != 0);
|
|
if (negative)
|
|
{
|
|
*--p = '-';
|
|
}
|
|
const auto len = static_cast<std::size_t>(buf.data() + buf.size() - p);
|
|
node n = plain_node(k);
|
|
n.flags = static_cast<std::uint8_t>(n.flags | node_flags::edited);
|
|
n.off = append_text(m_doc, p, len);
|
|
// number_length() adds one for the sign of number_integer nodes
|
|
n.extra = static_cast<std::uint16_t>(k == value_t::number_integer ? len - 1 : len);
|
|
set_integer_bits(n, bits);
|
|
return n;
|
|
}
|
|
|
|
/// a float with its shortest round-trip token (as basic_json::dump()
|
|
/// writes it), or nan, inf, -inf, in the edit arena
|
|
node float_node(number_float_t x)
|
|
{
|
|
string_t text;
|
|
if (std::isnan(x))
|
|
{
|
|
text = "nan";
|
|
}
|
|
else if (std::isinf(x))
|
|
{
|
|
text = x > 0 ? "inf" : "-inf";
|
|
}
|
|
else
|
|
{
|
|
text = BasicJsonType(x).dump();
|
|
}
|
|
node n = plain_node(value_t::number_float);
|
|
n.flags = static_cast<std::uint8_t>(n.flags | node_flags::edited);
|
|
n.extra = 0xFFFFu; // (the digit layout is not recorded)
|
|
n.off = append_text(m_doc, text.data(), text.size());
|
|
n.len = static_cast<std::uint32_t>(text.size());
|
|
return n;
|
|
}
|
|
|
|
/// a string (or key) in the edit arena
|
|
node string_node(const char* s, std::size_t len)
|
|
{
|
|
if (NLOHMANN_VIEW_UNLIKELY(len >= 0xFFFFFFFFu))
|
|
{
|
|
throw_out_of_range(416, "strings of 4 GiB or more are not supported by json_document"); // LCOV_EXCL_LINE
|
|
}
|
|
node n = plain_node(value_t::string);
|
|
n.flags = static_cast<std::uint8_t>(n.flags | node_flags::edited);
|
|
n.off = append_text(m_doc, s, len);
|
|
n.len = static_cast<std::uint32_t>(len);
|
|
return n;
|
|
}
|
|
|
|
/// a scalar of a view (of any document) as a node of this document
|
|
node copy_scalar(const document_data& from, const node& n)
|
|
{
|
|
if (&from == &m_doc)
|
|
{
|
|
return n; // the same storage
|
|
}
|
|
switch (static_cast<value_t>(n.kind))
|
|
{
|
|
case value_t::string:
|
|
return string_node(from.str(n), n.len);
|
|
case value_t::number_integer:
|
|
case value_t::number_unsigned:
|
|
return integer_node(integer_bits(n), static_cast<value_t>(n.kind));
|
|
case value_t::number_float:
|
|
{
|
|
node r = plain_node(value_t::number_float);
|
|
r.flags = static_cast<std::uint8_t>(r.flags | node_flags::edited);
|
|
r.off = append_text(m_doc, from.str(n), n.len);
|
|
r.len = n.len;
|
|
r.extra = n.extra;
|
|
return r;
|
|
}
|
|
case value_t::boolean:
|
|
{
|
|
node r = plain_node(value_t::boolean);
|
|
r.flags = static_cast<std::uint8_t>(r.flags | (n.flags & node_flags::is_true));
|
|
return r;
|
|
}
|
|
case value_t::null:
|
|
case value_t::object:
|
|
case value_t::array:
|
|
case value_t::binary:
|
|
case value_t::discarded:
|
|
default:
|
|
return plain_node(value_t::null);
|
|
}
|
|
}
|
|
|
|
node json_scalar(const BasicJsonType& j)
|
|
{
|
|
switch (j.type())
|
|
{
|
|
case value_t::null:
|
|
return plain_node(value_t::null);
|
|
case value_t::boolean:
|
|
{
|
|
node r = plain_node(value_t::boolean);
|
|
r.flags = static_cast<std::uint8_t>(r.flags | (j.template get<bool>() ? node_flags::is_true : 0));
|
|
return r;
|
|
}
|
|
case value_t::number_integer:
|
|
return integer_node(static_cast<std::uint64_t>(static_cast<std::int64_t>(j.template get<number_integer_t>())), value_t::number_integer);
|
|
case value_t::number_unsigned:
|
|
return integer_node(static_cast<std::uint64_t>(j.template get<number_unsigned_t>()), value_t::number_unsigned);
|
|
case value_t::number_float:
|
|
return float_node(j.template get<number_float_t>());
|
|
case value_t::string:
|
|
{
|
|
const auto& s = j.template get_ref<const string_t&>();
|
|
check_utf8(s.data(), s.size());
|
|
return string_node(s.data(), s.size());
|
|
}
|
|
case value_t::binary:
|
|
throw_type_error(319, "cannot store a binary value in a json_document", "");
|
|
case value_t::discarded:
|
|
case value_t::object:
|
|
case value_t::array:
|
|
default:
|
|
throw_type_error(302, "type must be a value, but is ", "discarded");
|
|
}
|
|
}
|
|
|
|
/// number of nodes of a subtree (containers, keys, scalars)
|
|
template<bool E>
|
|
static std::size_t count_nodes(const document_data& d, const node* n)
|
|
{
|
|
if (!is_container(*n))
|
|
{
|
|
return 1;
|
|
}
|
|
const bool object = n->kind == static_cast<std::uint8_t>(value_t::object);
|
|
std::size_t r = 1;
|
|
for (const node* c = navigation<E>::first(d, n), *end = navigation<E>::end(d, n); c != end;)
|
|
{
|
|
const node* const v = object ? c + 1 : c;
|
|
r += (object ? 1 : 0) + count_nodes<E>(d, navigation<E>::value(v));
|
|
c = document_data::after(v);
|
|
}
|
|
return r;
|
|
}
|
|
|
|
/// copy a subtree (of any document) as a contiguous sequence; returns its end
|
|
template<bool E>
|
|
node* fill_nodes(const document_data& d, const node* n, node* out)
|
|
{
|
|
if (!is_container(*n))
|
|
{
|
|
*out = copy_scalar(d, *n);
|
|
return out + 1;
|
|
}
|
|
node* const self = out++;
|
|
*self = plain_node(static_cast<value_t>(n->kind));
|
|
self->len = n->len;
|
|
const bool object = n->kind == static_cast<std::uint8_t>(value_t::object);
|
|
for (const node* c = navigation<E>::first(d, n), *end = navigation<E>::end(d, n); c != end;)
|
|
{
|
|
if (object)
|
|
{
|
|
*out++ = copy_scalar(d, *c);
|
|
++c;
|
|
}
|
|
out = fill_nodes<E>(d, navigation<E>::value(c), out);
|
|
c = document_data::after(c);
|
|
}
|
|
self->next = static_cast<std::uint32_t>(out - self);
|
|
return out;
|
|
}
|
|
|
|
static std::size_t count_nodes(const BasicJsonType& j)
|
|
{
|
|
std::size_t r = 1;
|
|
if (j.is_object())
|
|
{
|
|
for (const auto& member : j.items())
|
|
{
|
|
r += 1 + count_nodes(member.value());
|
|
}
|
|
}
|
|
else if (j.is_array())
|
|
{
|
|
for (const auto& e : j)
|
|
{
|
|
r += count_nodes(e);
|
|
}
|
|
}
|
|
return r;
|
|
}
|
|
|
|
node* fill_nodes(const BasicJsonType& j, node* out)
|
|
{
|
|
if (!j.is_structured())
|
|
{
|
|
*out = json_scalar(j);
|
|
return out + 1;
|
|
}
|
|
node* const self = out++;
|
|
*self = plain_node(j.type());
|
|
self->len = static_cast<std::uint32_t>(j.size());
|
|
if (j.is_object())
|
|
{
|
|
for (const auto& member : j.items())
|
|
{
|
|
check_utf8(member.key().data(), member.key().size());
|
|
*out++ = string_node(member.key().data(), member.key().size());
|
|
out = fill_nodes(member.value(), out);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
for (const auto& e : j)
|
|
{
|
|
out = fill_nodes(e, out);
|
|
}
|
|
}
|
|
self->next = static_cast<std::uint32_t>(out - self);
|
|
return out;
|
|
}
|
|
|
|
document_data& m_doc;
|
|
};
|
|
|
|
} // namespace view
|
|
} // namespace detail
|
|
NLOHMANN_JSON_NAMESPACE_END
|