deploy: 4155e2938f

examples/basic_json_document__accept.cpp

@@ -0,0 +1,19 @@
+#include <iostream>
+#include <nlohmann/json.hpp>
+#include <nlohmann/json_view.hpp>
+
+using json_document = nlohmann::json_document;
+
+int main()
+{
+    std::cout << std::boolalpha;
+
+    // accept() behaves exactly like basic_json::accept(): the same inputs are
+    // accepted or rejected, with the same ignore_comments/ignore_trailing_commas
+    // options
+    std::cout << json_document::accept(R"({"a": 1})") << '\n';
+    std::cout << json_document::accept(R"({"a": 1,})") << '\n'; // trailing comma: rejected by default
+    std::cout << json_document::accept(R"({"a": 1,})", false, true) << '\n'; // ignore_trailing_commas
+
+    std::cout << (json_document::accept(R"({"a": 1})") == nlohmann::json::accept(R"({"a": 1})")) << '\n';
+}

examples/basic_json_document__accept.output

@@ -0,0 +1,4 @@
+true
+false
+true
+true

examples/basic_json_document__basic_json_document.cpp

@@ -0,0 +1,23 @@
+#include <iostream>
+#include <utility>
+#include <nlohmann/json_view.hpp>
+
+using json_document = nlohmann::json_document;
+
+int main()
+{
+    std::cout << std::boolalpha;
+
+    // the default constructor creates an empty (discarded) document
+    json_document empty;
+    std::cout << empty.is_discarded() << '\n';
+
+    // json_document is move-only: parse() itself returns by value (moved out),
+    // and a document can be moved again, e.g. into a container
+    json_document doc = json_document::parse(R"({"a": 1})");
+    json_document moved = std::move(doc);
+    std::cout << moved.root().is_object() << '\n';
+
+    // copying is disabled at compile time:
+    // json_document another = moved; // does not compile
+}

examples/basic_json_document__basic_json_document.output

@@ -0,0 +1,2 @@
+true
+true

examples/basic_json_document__erase.cpp

@@ -0,0 +1,38 @@
+#include <iostream>
+#include <nlohmann/json_view.hpp>
+
+using json = nlohmann::json;
+using json_editable_document = nlohmann::json_editable_document;
+using json_editable_view = nlohmann::json_editable_view;
+
+int main()
+{
+    // a deprecated field is dropped from a configuration file, and a
+    // decommissioned replica is removed from the list -- "price" keeps its
+    // trailing zero, and the fields around the removed ones keep their order
+    const std::string text = R"({
+  "name": "cache",
+  "legacy_host": "db0",
+  "host": "db1",
+  "price": 19.90,
+  "replicas": ["db2", "db3", "db4"]
+})";
+
+    json_editable_document doc = json_editable_document::parse(text);
+
+    doc.erase(doc.root(), "legacy_host");                                      // (1) an object member
+    doc.erase(doc.root()["replicas"], 1);                                      // (2) an array element ("db3")
+    const std::size_t removed = doc.erase(json::json_pointer("/replicas/0"));  // (3) via a JSON pointer
+
+    std::cout << removed << '\n';
+    std::cout << doc.root().dump(2, ' ', false, json_editable_view::number_format::source) << "\n\n";
+
+    // the same edits on a plain json value: object_t is a std::map, so
+    // parsing already sorted the keys, and dump() rewrites every number to
+    // its shortest form, even "price", which was never touched
+    json plain = json::parse(text);
+    plain.erase("legacy_host");
+    plain["replicas"].erase(1);
+    plain["replicas"].erase(0);
+    std::cout << plain.dump(2) << '\n';
+}

examples/basic_json_document__erase.output

@@ -0,0 +1,18 @@
+1
+{
+  "name": "cache",
+  "host": "db1",
+  "price": 19.90,
+  "replicas": [
+    "db4"
+  ]
+}
+
+{
+  "host": "db1",
+  "name": "cache",
+  "price": 19.9,
+  "replicas": [
+    "db4"
+  ]
+}

examples/basic_json_document__insert.cpp

@@ -0,0 +1,38 @@
+#include <iostream>
+#include <nlohmann/json_view.hpp>
+
+using json = nlohmann::json;
+using json_editable_document = nlohmann::json_editable_document;
+using json_editable_view = nlohmann::json_editable_view;
+
+int main()
+{
+    // a deployment plan -- "budget" is written with a trailing zero that has
+    // no effect on its value
+    const std::string text = R"({
+  "release": "2026.09",
+  "steps": ["build", "test", "deploy"],
+  "budget": 19.90
+})";
+
+    json_editable_document doc = json_editable_document::parse(text);
+
+    const std::size_t deploy_index = 2;
+    const auto deploy = doc.root()["steps"][deploy_index];  // held across the insert
+
+    doc.insert(doc.root()["steps"], deploy_index, "smoke-test"); // insert before "deploy"
+
+    // the held view still refers to "deploy", even though its index moved
+    // from 2 to 3, and nothing else in the document was touched
+    std::cout << deploy.dump() << '\n';
+    std::cout << doc.root().dump(2, ' ', false, json_editable_view::number_format::source) << "\n\n";
+
+    // the same edit on a plain json value: an index held from before the
+    // insert now refers to whatever moved into that slot, and dump()
+    // rewrites "budget" to its shortest form even though it was never
+    // touched
+    json plain = json::parse(text);
+    plain["steps"].insert(plain["steps"].begin() + static_cast<std::ptrdiff_t>(deploy_index), "smoke-test");
+    std::cout << plain["steps"][deploy_index].dump() << '\n';
+    std::cout << plain.dump(2) << '\n';
+}

examples/basic_json_document__insert.output

@@ -0,0 +1,23 @@
+"deploy"
+{
+  "release": "2026.09",
+  "steps": [
+    "build",
+    "test",
+    "smoke-test",
+    "deploy"
+  ],
+  "budget": 19.90
+}
+
+"smoke-test"
+{
+  "budget": 19.9,
+  "release": "2026.09",
+  "steps": [
+    "build",
+    "test",
+    "smoke-test",
+    "deploy"
+  ]
+}

examples/basic_json_document__is_discarded.cpp

@@ -0,0 +1,19 @@
+#include <iostream>
+#include <nlohmann/json_view.hpp>
+
+using json_document = nlohmann::json_document;
+
+int main()
+{
+    std::cout << std::boolalpha;
+
+    // with allow_exceptions == false, a parse error produces a discarded
+    // document instead of throwing -- exactly like basic_json::parse()
+    json_document doc = json_document::parse(R"({"a": )", /* allow_exceptions */ false);
+    std::cout << doc.is_discarded() << '\n';
+    std::cout << doc.root().is_discarded() << '\n';
+
+    // a successful parse is never discarded
+    json_document ok = json_document::parse(R"({"a": 1})", false);
+    std::cout << ok.is_discarded() << '\n';
+}

examples/basic_json_document__is_discarded.output

@@ -0,0 +1,3 @@
+true
+true
+false

examples/basic_json_document__load.cpp

@@ -0,0 +1,52 @@
+#include <cstdint>
+#include <iostream>
+#include <string>
+#include <vector>
+#include <nlohmann/json_view.hpp>
+
+using json = nlohmann::json;
+using json_document = nlohmann::json_document;
+using image_check = json_document::image_check;
+
+int main()
+{
+    std::cout << std::boolalpha;
+
+    // the image of a parsed document -- as if read back from a cache file or
+    // received from another process running the same build of the library
+    const std::string text = R"({"name": "cache", "note": "caf\u00e9", "replicas": ["db2", "db3"]})";
+    const json_document parsed = json_document::parse(text);
+    const std::vector<std::uint8_t> image = parsed.save();
+
+    // (1)/(2) load() needs no parsing, yet dumps exactly what parsing did
+    const json_document borrowed = json_document::load(image);
+    std::cout << (borrowed.root().dump() == parsed.root().dump()) << '\n';
+    std::cout << borrowed.owns_source() << '\n'; // borrowed: still points into `image`
+
+    // (3) load(std::move(image)) keeps the vector instead of copying it
+    std::vector<std::uint8_t> to_move = image;
+    const json_document owned = json_document::load(std::move(to_move));
+    std::cout << owned.owns_source() << '\n';
+
+    // a damaged image -- the last byte of the decoded string "note" holds
+    // (an escape sequence, so it was unescaped into the document's own
+    // buffer), flipped, as storage or transport corruption might do
+    std::vector<std::uint8_t> damaged = image;
+    damaged[damaged.size() - 2] = 0xFF;
+
+    // image_check::full inspects strings and numbers, so it catches the damage
+    try
+    {
+        static_cast<void>(json_document::load(damaged, image_check::full));
+    }
+    catch (const json::parse_error& e)
+    {
+        std::cout << e.id << '\n';
+    }
+
+    // image_check::bounds only checks structure and bounds, so a cache the
+    // process already trusts loads without the extra scan -- reading a value
+    // the damage did not touch is still safe
+    const json_document trusted = json_document::load(damaged, image_check::bounds);
+    std::cout << trusted.root()["name"].get<std::string>() << '\n';
+}

examples/basic_json_document__load.output

@@ -0,0 +1,5 @@
+true
+false
+true
+116
+cache

examples/basic_json_document__memory_usage.cpp

@@ -0,0 +1,28 @@
+#include <iostream>
+#include <string>
+#include <nlohmann/json_view.hpp>
+
+using json_document = nlohmann::json_document;
+
+int main()
+{
+    std::cout << std::boolalpha;
+
+    // long enough that copying it needs a real (heap) allocation, so the
+    // comparison below does not depend on the standard library's small
+    // string optimization threshold
+    const std::string text = std::string(200, ' ') + "[1, 2, 3, 4, 5]";
+
+    // memory_usage() is not portable across platforms/allocators/compilers, so
+    // compare it relatively instead of printing the raw byte count
+    json_document borrowed = json_document::parse(text);
+    json_document owned = json_document::parse_copy(text);
+
+    // the owned document additionally stores its own copy of the source text
+    std::cout << (owned.memory_usage() > borrowed.memory_usage()) << '\n';
+
+    // a document with more values needs a larger index
+    json_document small = json_document::parse(std::string("[1]"));
+    json_document large = json_document::parse(std::string("[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]"));
+    std::cout << (large.memory_usage() > small.memory_usage()) << '\n';
+}

examples/basic_json_document__memory_usage.output

@@ -0,0 +1,2 @@
+true
+true

examples/basic_json_document__node_count.cpp

@@ -0,0 +1,15 @@
+#include <iostream>
+#include <nlohmann/json_view.hpp>
+
+using json_document = nlohmann::json_document;
+
+int main()
+{
+    // node_count() is the size of the flat index: one 16-byte node per value,
+    // plus one per object key (values and keys are all the index stores)
+    json_document scalar = json_document::parse("42");
+    std::cout << scalar.node_count() << '\n';
+
+    json_document doc = json_document::parse(R"({"a": 1, "b": [1, 2]})");
+    std::cout << doc.node_count() << '\n';
+}

examples/basic_json_document__node_count.output

@@ -0,0 +1,2 @@
+1
+7

examples/basic_json_document__owns_source.cpp

@@ -0,0 +1,24 @@
+#include <iostream>
+#include <string>
+#include <nlohmann/json_view.hpp>
+
+using json_document = nlohmann::json_document;
+
+int main()
+{
+    std::cout << std::boolalpha;
+
+    std::string text = R"({"a": 1})";
+
+    // borrowed: the document only points into `text`; `text` must outlive it
+    json_document borrowed = json_document::parse(text);
+    std::cout << borrowed.owns_source() << '\n';
+
+    // owned: parse_copy() always takes its own copy
+    json_document copied = json_document::parse_copy(text);
+    std::cout << copied.owns_source() << '\n';
+
+    // owned: an rvalue std::string is moved in, not copied, but still owned
+    json_document moved_in = json_document::parse(std::string(text));
+    std::cout << moved_in.owns_source() << '\n';
+}

examples/basic_json_document__owns_source.output

@@ -0,0 +1,3 @@
+false
+true
+true

examples/basic_json_document__parse.cpp

@@ -0,0 +1,33 @@
+#include <iostream>
+#include <string>
+#include <nlohmann/json.hpp>
+#include <nlohmann/json_view.hpp>
+
+using json_document = nlohmann::json_document;
+
+int main()
+{
+    std::cout << std::boolalpha;
+
+    // an lvalue std::string is BORROWED: the document only stores a pointer
+    // into `text`, so `text` must outlive `borrowed`
+    std::string text = R"({"count": 3})";
+    json_document borrowed = json_document::parse(text);
+    std::cout << borrowed.owns_source() << '\n'; // false
+
+    // an rvalue std::string is MOVED into the document -- no copy of the text
+    json_document owned = json_document::parse(std::string(R"({"count": 3})"));
+    std::cout << owned.owns_source() << '\n'; // true
+
+    // errors are identical to basic_json::parse: same exception id, message,
+    // and position, because the library parser runs on the same bytes on a
+    // failing input
+    try
+    {
+        static_cast<void>(json_document::parse(R"({"count": )"));
+    }
+    catch (const nlohmann::json::parse_error& e)
+    {
+        std::cout << e.id << '\n';
+    }
+}

examples/basic_json_document__parse.output

@@ -0,0 +1,3 @@
+false
+true
+101

examples/basic_json_document__parse_copy.cpp

@@ -0,0 +1,22 @@
+#include <iostream>
+#include <nlohmann/json_view.hpp>
+
+using json_document = nlohmann::json_document;
+
+json_document parse_from_temporary_buffer()
+{
+    char buffer[] = R"({"a": 1})";
+    // parse() would borrow `buffer`, which is about to go out of scope;
+    // parse_copy() takes its own copy instead, so the returned document does
+    // not depend on `buffer` afterward
+    return json_document::parse_copy(buffer);
+}
+
+int main()
+{
+    std::cout << std::boolalpha;
+
+    json_document doc = parse_from_temporary_buffer();
+    std::cout << doc.owns_source() << '\n';
+    std::cout << doc.root().is_object() << '\n';
+}

examples/basic_json_document__parse_copy.output

@@ -0,0 +1,2 @@
+true
+true

examples/basic_json_document__parse_iterator_pair.cpp

@@ -0,0 +1,22 @@
+#include <iostream>
+#include <vector>
+#include <nlohmann/json_view.hpp>
+
+using json_document = nlohmann::json_document;
+
+int main()
+{
+    std::cout << std::boolalpha;
+
+    // a JSON value embedded in a larger, non-null-terminated buffer (e.g. a
+    // slice received over the network)
+    std::vector<char> buffer = {'[', '1', ',', '2', ']', 'j', 'u', 'n', 'k'};
+
+    // a pointer pair is BORROWED, exactly like a byte container lvalue: the
+    // document points into the buffer. (From C++20 on, std::vector<char>
+    // iterators are borrowed as well; before, they are copied.)
+    const char* first = buffer.data();
+    json_document doc = json_document::parse(first, first + 5);
+    std::cout << doc.root().is_array() << ' ' << doc.root().size() << '\n';
+    std::cout << doc.owns_source() << '\n'; // false: borrowed
+}

examples/basic_json_document__parse_iterator_pair.output

@@ -0,0 +1,2 @@
+true 2
+false

examples/basic_json_document__push_back.cpp

@@ -0,0 +1,24 @@
+#include <iostream>
+#include <nlohmann/json_view.hpp>
+
+using json = nlohmann::json;
+using json_editable_document = nlohmann::json_editable_document;
+
+int main()
+{
+    // "events" starts out null -- the first push_back() turns it into an
+    // array, exactly like set() turns a null object member into an object
+    json_editable_document doc = json_editable_document::parse(R"({"source": "sensor-1", "events": null})");
+
+    const auto first = doc.push_back(doc.root()["events"], json{{"type", "start"}, {"t", 0}});
+    for (int t = 1; t <= 3; ++t)
+    {
+        doc.push_back(doc.root()["events"], json{{"type", "tick"}, {"t", t}});
+    }
+
+    // push_back() never moves an existing element: a view taken from an
+    // earlier call still refers to the same element after later ones
+    std::cout << first.dump() << '\n';
+    std::cout << doc.root()["events"].size() << '\n';
+    std::cout << doc.root().dump(2) << '\n';
+}

examples/basic_json_document__push_back.output

@@ -0,0 +1,23 @@
+{"t":0,"type":"start"}
+4
+{
+  "source": "sensor-1",
+  "events": [
+    {
+      "t": 0,
+      "type": "start"
+    },
+    {
+      "t": 1,
+      "type": "tick"
+    },
+    {
+      "t": 2,
+      "type": "tick"
+    },
+    {
+      "t": 3,
+      "type": "tick"
+    }
+  ]
+}

examples/basic_json_document__read.cpp

@@ -0,0 +1,31 @@
+#include <iostream>
+#include <string>
+#include <vector>
+#include <nlohmann/json_view.hpp>
+
+using json_document = nlohmann::json_document;
+
+int main()
+{
+    std::cout << std::boolalpha;
+
+    std::vector<std::string> messages =
+    {
+        R"({"id": 1})", R"({"id": 2, "tag": "x"})", R"({"id": 3})"
+    };
+
+    // parse into the same document over and over: its node index and decode
+    // buffer are reused instead of being freed and reallocated for each message
+    json_document doc;
+    std::size_t total = 0;
+    for (const auto& msg : messages)
+    {
+        doc.read(msg);
+        total += doc.root().size();
+    }
+    std::cout << total << '\n';
+
+    // read() can also change what kind of input is owned/borrowed between calls
+    doc.read(std::string(R"({"owned": true})"));
+    std::cout << doc.owns_source() << '\n';
+}

examples/basic_json_document__read.output

@@ -0,0 +1,2 @@
+4
+true

examples/basic_json_document__root.cpp

@@ -0,0 +1,19 @@
+#include <iostream>
+#include <nlohmann/json_view.hpp>
+
+using json_document = nlohmann::json_document;
+
+int main()
+{
+    std::cout << std::boolalpha;
+
+    json_document doc = json_document::parse(R"({"greeting": "hi"})");
+    std::cout << doc.root().is_object() << '\n';
+
+    // root() is a cheap handle, not a copy: repeated calls observe the same value
+    std::cout << (doc.root().type() == doc.root().type()) << '\n';
+
+    // the root of a failed parse (allow_exceptions == false) is discarded
+    json_document failed = json_document::parse("{", false);
+    std::cout << failed.root().is_discarded() << '\n';
+}

examples/basic_json_document__root.output

@@ -0,0 +1,3 @@
+true
+true
+true

examples/basic_json_document__save.cpp

@@ -0,0 +1,30 @@
+#include <cstdint>
+#include <iostream>
+#include <string>
+#include <vector>
+#include <nlohmann/json_view.hpp>
+
+using json_document = nlohmann::json_document;
+
+int main()
+{
+    std::cout << std::boolalpha;
+
+    // a configuration a service parses once and then caches as an image, so
+    // that later requests can load() it instead of parsing the text again
+    const std::string text = R"({"name": "cache", "host": "db1", "port": 6379, "replicas": ["db2", "db3"]})";
+    const json_document config = json_document::parse(text);
+
+    // save() turns the parsed document into a byte buffer: a 64-byte header,
+    // the node index, the source text, and the decoded strings
+    const std::vector<std::uint8_t> image = config.save();
+    std::cout << image.size() << '\n';
+
+    // the same document always saves to the same bytes
+    std::cout << (image == json_document::parse(text).save()) << '\n';
+
+    // loading the image back needs no parsing, yet dumps exactly what
+    // parsing the text produced
+    const json_document reloaded = json_document::load(image);
+    std::cout << (reloaded.root().dump() == config.root().dump()) << '\n';
+}

examples/basic_json_document__save.output

@@ -0,0 +1,3 @@
+316
+true
+true

examples/basic_json_document__set.cpp

@@ -0,0 +1,41 @@
+#include <iostream>
+#include <nlohmann/json_view.hpp>
+
+using json = nlohmann::json;
+using json_editable_document = nlohmann::json_editable_document;
+using json_editable_view = nlohmann::json_editable_view;
+
+int main()
+{
+    // a configuration file, as it might be read from disk -- "price" is
+    // written with a trailing zero that has no effect on its value
+    const std::string text = R"({
+  "name": "cache",
+  "host": "db1",
+  "port": 6379,
+  "price": 19.90,
+  "replicas": ["db2", "db3"],
+  "timeout": 30
+})";
+
+    json_editable_document doc = json_editable_document::parse(text);
+
+    doc.set(doc.root()["port"], 6380);                    // (1) replace a value
+    doc.set(doc.root(), "region", "us-east");              // (2) add a member
+    doc.set(doc.root()["replicas"], 0, "db4");             // (3) assign an element
+    doc.set(json::json_pointer("/timeout"), 45);           // (4) via a JSON pointer
+
+    // members stay in document order (the new one at the end), and a number
+    // that was not itself edited keeps its exact spelling
+    std::cout << doc.root().dump(2, ' ', false, json_editable_view::number_format::source) << "\n\n";
+
+    // the same edits on a plain json value: object_t is a std::map, so
+    // parsing already sorted the keys, and dump() rewrites every number to
+    // its shortest form, even "price", which was never touched
+    json plain = json::parse(text);
+    plain["port"] = 6380;
+    plain["region"] = "us-east";
+    plain["replicas"][0] = "db4";
+    plain[json::json_pointer("/timeout")] = 45;
+    std::cout << plain.dump(2) << '\n';
+}

examples/basic_json_document__set.output

@@ -0,0 +1,25 @@
+{
+  "name": "cache",
+  "host": "db1",
+  "port": 6380,
+  "price": 19.90,
+  "replicas": [
+    "db4",
+    "db3"
+  ],
+  "timeout": 45,
+  "region": "us-east"
+}
+
+{
+  "host": "db1",
+  "name": "cache",
+  "port": 6380,
+  "price": 19.9,
+  "region": "us-east",
+  "replicas": [
+    "db4",
+    "db3"
+  ],
+  "timeout": 45
+}

examples/basic_json_document__shrink_to_fit.cpp

@@ -0,0 +1,44 @@
+#include <iostream>
+#include <sstream>
+#include <string>
+#include <nlohmann/json_view.hpp>
+
+using json_document = nlohmann::json_document;
+
+int main()
+{
+    std::cout << std::boolalpha;
+
+    // build a large array (many nodes), then read a small one into the same
+    // document: the index grown for the large input is still allocated
+    std::ostringstream big;
+    big << '[';
+    for (int i = 0; i < 500; ++i)
+    {
+        if (i != 0)
+        {
+            big << ',';
+        }
+        big << i;
+    }
+    big << ']';
+
+    json_document doc;
+    doc.read(big.str());
+    const std::size_t big_nodes = doc.node_count();
+
+    doc.read(std::string("[1]"));
+    std::cout << (doc.node_count() < big_nodes) << '\n'; // far fewer live nodes now
+    const std::size_t before = doc.memory_usage();
+
+    // shrink_to_fit() moves the index into a block sized for what is actually
+    // used. This INVALIDATES every view taken from this document before the
+    // call (they point into the old, now-freed block) -- take fresh ones from
+    // root() afterward.
+    doc.shrink_to_fit();
+    const std::size_t after = doc.memory_usage();
+    std::cout << (after <= before) << '\n';
+
+    // a freshly taken view is valid and correct
+    std::cout << doc.root().is_array() << ' ' << doc.root().size() << '\n';
+}

examples/basic_json_document__shrink_to_fit.output

@@ -0,0 +1,3 @@
+true
+true
+true 1

examples/basic_json_document__source.cpp

@@ -0,0 +1,20 @@
+#include <iostream>
+#include <string>
+#include <nlohmann/json_view.hpp>
+
+using json_document = nlohmann::json_document;
+
+int main()
+{
+    std::cout << std::boolalpha;
+
+    std::string text = R"({"a": 1})";
+    json_document doc = json_document::parse(text);
+
+    // source() is the parsed text, whether borrowed or owned
+    std::cout << (doc.source().size() == text.size()) << '\n';
+    std::cout << std::string(doc.source().data(), doc.source().size()) << '\n';
+
+    // for a borrowed document, source() points right into the caller's buffer
+    std::cout << (doc.source().data() == text.data()) << '\n';
+}

examples/basic_json_document__source.output

@@ -0,0 +1,3 @@
+true
+{"a": 1}
+true

examples/basic_json_view__at.cpp

@@ -0,0 +1,36 @@
+#include <iostream>
+#include <nlohmann/json_view.hpp>
+
+using json_document = nlohmann::json_document;
+using json_view = nlohmann::json_view;
+
+int main()
+{
+    // required fields of a service configuration -- at() reports a missing
+    // or wrong-typed field with the very same exception basic_json::at()
+    // would throw for the equivalent nlohmann::json value, so error
+    // handling written against basic_json::at() keeps working unchanged
+    json_document config = json_document::parse(R"({"name": "cache", "port": "6379"})");
+    const json_view service = config.root();
+
+    std::cout << service.at("port").materialize().dump() << '\n';
+
+    try
+    {
+        // "port" is a string, not an array
+        static_cast<void>(service.at("port").at(0));
+    }
+    catch (const nlohmann::json::type_error& e)
+    {
+        std::cout << e.what() << '\n';
+    }
+
+    try
+    {
+        static_cast<void>(service.at("timeout"));
+    }
+    catch (const nlohmann::json::out_of_range& e)
+    {
+        std::cout << e.what() << '\n';
+    }
+}

examples/basic_json_view__at.output

@@ -0,0 +1,3 @@
+"6379"
+[json.exception.type_error.304] cannot use at() with string
+[json.exception.out_of_range.403] key 'timeout' not found

examples/basic_json_view__at_json_pointer.cpp

@@ -0,0 +1,34 @@
+#include <iostream>
+#include <nlohmann/json_view.hpp>
+
+using json_document = nlohmann::json_document;
+using json_pointer = nlohmann::json::json_pointer;
+
+int main()
+{
+    json_document doc = json_document::parse(R"({"region": "eu", "servers": ["eu-1", "eu-2"]})");
+    const auto root = doc.root();
+
+    std::cout << root.at(json_pointer("/servers/1")).materialize().dump() << '\n';
+
+    // at() throws for every resolution failure -- with the very same
+    // message json::at(ptr) would throw for the same pointer and the same
+    // document
+    try
+    {
+        static_cast<void>(root.at(json_pointer("/servers/5")));
+    }
+    catch (const nlohmann::json::out_of_range& e)
+    {
+        std::cout << e.what() << '\n';
+    }
+
+    try
+    {
+        static_cast<void>(root.at(json_pointer("/missing")));
+    }
+    catch (const nlohmann::json::out_of_range& e)
+    {
+        std::cout << e.what() << '\n';
+    }
+}

examples/basic_json_view__at_json_pointer.output

@@ -0,0 +1,3 @@
+"eu-2"
+[json.exception.out_of_range.401] array index 5 is out of range
+[json.exception.out_of_range.403] key 'missing' not found

examples/basic_json_view__back.cpp

@@ -0,0 +1,25 @@
+#include <iostream>
+#include <nlohmann/json_view.hpp>
+
+using json_document = nlohmann::json_document;
+
+int main()
+{
+    // the same build log; back() reads only the final status. It is linear
+    // in the number of events (unlike front(), which is constant), but
+    // still far less work than materializing the whole array
+    json_document log = json_document::parse(R"(["queued", "started", "compiling", "linking", "done"])");
+    std::cout << log.root().back().materialize().dump() << '\n';
+
+    // an empty log -- back() throws instead of the undefined behavior
+    // basic_json::back() has for an empty array
+    json_document empty_log = json_document::parse("[]");
+    try
+    {
+        static_cast<void>(empty_log.root().back());
+    }
+    catch (const nlohmann::json::invalid_iterator& e)
+    {
+        std::cout << e.what() << '\n';
+    }
+}

examples/basic_json_view__back.output

@@ -0,0 +1,2 @@
+"done"
+[json.exception.invalid_iterator.214] cannot get value

examples/basic_json_view__basic_json_view.cpp

@@ -0,0 +1,17 @@
+#include <iostream>
+#include <nlohmann/json_view.hpp>
+
+int main()
+{
+    std::cout << std::boolalpha;
+
+    // the default constructor is the only public one: it creates an invalid
+    // (discarded) view, useful as a "no value yet" placeholder
+    nlohmann::json_view v;
+    std::cout << v.is_discarded() << '\n';
+
+    // views are trivially copyable handles (two pointers); the document owns
+    // the actual data
+    nlohmann::json_view copy = v;
+    std::cout << copy.is_discarded() << '\n';
+}

examples/basic_json_view__basic_json_view.output

@@ -0,0 +1,2 @@
+true
+true

examples/basic_json_view__begin.cpp

@@ -0,0 +1,18 @@
+#include <iostream>
+#include <nlohmann/json_view.hpp>
+
+using json_document = nlohmann::json_document;
+
+int main()
+{
+    // a log record: the fields matter in the order they were written, e.g.
+    // to reproduce the record as it was logged. A nlohmann::json object
+    // sorts its keys, so materializing and iterating it would instead print
+    // them alphabetically ("level", "message", "time")
+    json_document record = json_document::parse(R"({"time": "10:00:01", "level": "info", "message": "started"})");
+
+    for (auto it = record.root().begin(); it != record.root().end(); ++it)
+    {
+        std::cout << it.key() << '=' << it->materialize().dump() << '\n';
+    }
+}

examples/basic_json_view__begin.output

@@ -0,0 +1,3 @@
+time="10:00:01"
+level="info"
+message="started"

examples/basic_json_view__cbegin.cpp

@@ -0,0 +1,24 @@
+#include <iostream>
+#include <numeric>
+#include <nlohmann/json_view.hpp>
+
+using json_document = nlohmann::json_document;
+using json_view = nlohmann::json_view;
+
+int main()
+{
+    // sum many measurements with std::accumulate; cbegin()/cend() (identical
+    // to begin()/end() here -- the view is always read-only) let the view be
+    // used with standard algorithms without ever materializing the whole
+    // array into a nlohmann::json value
+    json_document measurements = json_document::parse("[3, 1, 4, 1, 5, 9, 2, 6]");
+    const auto values = measurements.root();
+
+    const int sum = std::accumulate(values.cbegin(), values.cend(), 0,
+                                    [](int total, const json_view & v)
+    {
+        return total + v.materialize().get<int>();
+    });
+
+    std::cout << sum << '\n';
+}

examples/basic_json_view__cbegin.output

@@ -0,0 +1 @@
+31

examples/basic_json_view__cend.cpp

@@ -0,0 +1,24 @@
+#include <algorithm>
+#include <iostream>
+#include <nlohmann/json_view.hpp>
+
+using json_document = nlohmann::json_document;
+using json_view = nlohmann::json_view;
+
+int main()
+{
+    // check that every element of a (possibly large) batch is an object,
+    // before materializing any of them -- cbegin()/cend() (identical to
+    // begin()/end() here) work as the range for std::all_of like they would
+    // for any standard container
+    json_document batch = json_document::parse(R"([{"id": 1}, {"id": 2}, {"id": 3}])");
+    const auto records = batch.root();
+
+    const bool all_objects = std::all_of(records.cbegin(), records.cend(),
+                                         [](const json_view & v)
+    {
+        return v.is_object();
+    });
+
+    std::cout << std::boolalpha << all_objects << '\n';
+}

examples/basic_json_view__cend.output

@@ -0,0 +1 @@
+true

examples/basic_json_view__contains.cpp

@@ -0,0 +1,30 @@
+#include <iostream>
+#include <nlohmann/json_view.hpp>
+
+using json_document = nlohmann::json_document;
+
+int main()
+{
+    // count how many of many incoming records carry an optional "retry_of"
+    // field -- contains() only walks the flat index, so scanning a large
+    // batch like this never builds a single nlohmann::json value
+    json_document batch = json_document::parse(R"(
+      [
+        {"id": 1},
+        {"id": 2, "retry_of": 1},
+        {"id": 3},
+        {"id": 4, "retry_of": 3}
+      ]
+    )");
+
+    const auto records = batch.root();
+    std::size_t retries = 0;
+    for (std::size_t i = 0; i < records.size(); ++i)
+    {
+        if (records[i].contains("retry_of"))
+        {
+            ++retries;
+        }
+    }
+    std::cout << retries << " of " << records.size() << " records are retries\n";
+}

examples/basic_json_view__contains.output

@@ -0,0 +1 @@
+2 of 4 records are retries

examples/basic_json_view__contains_json_pointer.cpp

@@ -0,0 +1,39 @@
+#include <iostream>
+#include <nlohmann/json_view.hpp>
+
+using json_document = nlohmann::json_document;
+using json_pointer = nlohmann::json::json_pointer;
+
+int main()
+{
+    // "retry_of" is only present on some records, nested a level down
+    // inside "meta"
+    json_document batch = json_document::parse(R"(
+      [
+        {"id": 1, "meta": {}},
+        {"id": 2, "meta": {"retry_of": 1}}
+      ]
+    )");
+
+    const auto records = batch.root();
+    const json_pointer retry_of("/meta/retry_of");
+    for (std::size_t i = 0; i < records.size(); ++i)
+    {
+        const auto record = records[i];
+        if (record.contains(retry_of))
+        {
+            std::cout << "record " << i << " is a retry of " << record[retry_of].get<int>() << '\n';
+        }
+        else
+        {
+            std::cout << "record " << i << " is original\n";
+        }
+    }
+
+    // contains() with a JSON pointer never throws -- not even for a
+    // pointer that indexes into a primitive ("/0/id/x") or uses a
+    // malformed array index ("/01"), either of which would need a
+    // try/catch with json::contains(ptr)
+    std::cout << std::boolalpha << records.contains(json_pointer("/0/id/x")) << '\n';
+    std::cout << std::boolalpha << records.contains(json_pointer("/01")) << '\n';
+}

examples/basic_json_view__contains_json_pointer.output

@@ -0,0 +1,4 @@
+record 0 is original
+record 1 is a retry of 1
+false
+false

examples/basic_json_view__count.cpp

@@ -0,0 +1,31 @@
+#include <iostream>
+#include <nlohmann/json_view.hpp>
+
+using json_document = nlohmann::json_document;
+
+int main()
+{
+    // validate that every transaction of a batch carries exactly one
+    // "amount" field before materializing any of them into a nlohmann::json
+    // value -- count() counts every member with the key
+    json_document batch = json_document::parse(R"(
+      [
+        {"id": 1, "amount": 9.99},
+        {"id": 2},
+        {"id": 3, "amount": 5.00, "amount": 500.00}
+      ]
+    )");
+
+    const auto transactions = batch.root();
+    for (std::size_t i = 0; i < transactions.size(); ++i)
+    {
+        const auto transaction = transactions[i];
+        const auto amounts = transaction.count("amount");
+        if (amounts != 1)
+        {
+            std::cout << "transaction " << i << " has " << amounts << " \"amount\" fields\n";
+            continue;
+        }
+        std::cout << "transaction " << i << ": " << transaction["amount"].materialize().dump() << '\n';
+    }
+}

examples/basic_json_view__count.output

@@ -0,0 +1,3 @@
+transaction 0: 9.99
+transaction 1 has 0 "amount" fields
+transaction 2 has 2 "amount" fields

examples/basic_json_view__dump.cpp

@@ -0,0 +1,25 @@
+#include <iostream>
+#include <nlohmann/json_view.hpp>
+
+using json_document = nlohmann::json_document;
+using json_view = nlohmann::json_view;
+
+int main()
+{
+    // a large batch of sensor readings -- forward just the one that changed,
+    // without ever building a basic_json value for the batch or for the
+    // readings that are not needed
+    const json_document batch = json_document::parse(R"(
+      [{"id": 1, "temp": 21.5}, {"id": 2, "temp": 87.3}, {"id": 3, "temp": 21.7}]
+    )");
+    const json_view readings = batch.root();
+    std::cout << readings[1].dump() << '\n';
+
+    // a configuration file -- dump() on the view keeps the member order of
+    // the source text; a json value's object_t is std::map, so
+    // materialize().dump() of the very same view sorts the keys instead
+    const json_document config = json_document::parse(
+                                     R"({"name": "cache", "host": "db1", "port": 6379, "timeout": 30})");
+    std::cout << config.root().dump(2) << "\n\n";
+    std::cout << config.root().materialize().dump(2) << '\n';
+}

examples/basic_json_view__dump.output

@@ -0,0 +1,14 @@
+{"id":2,"temp":87.3}
+{
+  "name": "cache",
+  "host": "db1",
+  "port": 6379,
+  "timeout": 30
+}
+
+{
+  "host": "db1",
+  "name": "cache",
+  "port": 6379,
+  "timeout": 30
+}

examples/basic_json_view__end.cpp

@@ -0,0 +1,27 @@
+#include <iostream>
+#include <nlohmann/json_view.hpp>
+
+using json_document = nlohmann::json_document;
+
+int main()
+{
+    // scan a (possibly large) array of readings for the first one over a
+    // threshold; the loop stops at end() as soon as one is found, and only
+    // the matching reading is ever materialized
+    json_document readings = json_document::parse("[12, 18, 25, 31, 9]");
+    const auto values = readings.root();
+
+    auto it = values.begin();
+    for (; it != values.end(); ++it)
+    {
+        if (it->materialize().get<int>() > 20)
+        {
+            break;
+        }
+    }
+
+    if (it != values.end())
+    {
+        std::cout << "first reading over 20: " << it->materialize().dump() << '\n';
+    }
+}

examples/basic_json_view__end.output

@@ -0,0 +1 @@
+first reading over 20: 25

examples/basic_json_view__find.cpp

@@ -0,0 +1,29 @@
+#include <iostream>
+#include <nlohmann/json_view.hpp>
+
+using json_document = nlohmann::json_document;
+
+int main()
+{
+    // a batch of incoming events; only some carry a "user_id" -- find()
+    // locates it without throwing for the events that turn out to not be
+    // objects, and without materializing an event that does not match
+    json_document batch = json_document::parse(R"(
+      [
+        {"type": "click", "user_id": 42},
+        {"type": "ping"},
+        {"type": "click", "user_id": 7}
+      ]
+    )");
+
+    const auto events = batch.root();
+    for (std::size_t i = 0; i < events.size(); ++i)
+    {
+        const auto event = events[i];
+        const auto it = event.find("user_id");
+        if (it != event.end())
+        {
+            std::cout << "user " << it->materialize().dump() << '\n';
+        }
+    }
+}

examples/basic_json_view__find.output

@@ -0,0 +1,2 @@
+user 42
+user 7

examples/basic_json_view__front.cpp

@@ -0,0 +1,24 @@
+#include <iostream>
+#include <nlohmann/json_view.hpp>
+
+using json_document = nlohmann::json_document;
+
+int main()
+{
+    // the build log of a running job; front() reads just the earliest event
+    // without materializing the (possibly long) rest of the log
+    json_document log = json_document::parse(R"(["queued", "started", "compiling", "linking", "done"])");
+    std::cout << log.root().front().materialize().dump() << '\n';
+
+    // an empty log -- front() throws instead of the undefined behavior
+    // basic_json::front() has for an empty array
+    json_document empty_log = json_document::parse("[]");
+    try
+    {
+        static_cast<void>(empty_log.root().front());
+    }
+    catch (const nlohmann::json::invalid_iterator& e)
+    {
+        std::cout << e.what() << '\n';
+    }
+}

examples/basic_json_view__front.output

@@ -0,0 +1,2 @@
+"queued"
+[json.exception.invalid_iterator.214] cannot get value

examples/basic_json_view__get.cpp

@@ -0,0 +1,55 @@
+#include <iostream>
+#include <nlohmann/json_view.hpp>
+#include <string>
+#include <vector>
+
+using json_document = nlohmann::json_document;
+using json_view = nlohmann::json_view;
+
+// address has no direct conversion in get<T>(), so get<address>() falls back
+// to materialize().get<address>() -- a real nlohmann::json value is built
+// for just this one member, and its own from_json() runs on that
+struct address
+{
+    std::string city;
+    int zip = 0;
+};
+
+void from_json(const nlohmann::json& j, address& a)
+{
+    j.at("city").get_to(a.city);
+    j.at("zip").get_to(a.zip);
+}
+
+int main()
+{
+    json_document doc = json_document::parse(R"(
+      {
+        "name": "Alice",
+        "active": true,
+        "orders": [1, 2, 3],
+        "address": {"city": "Berlin", "zip": 10115}
+      }
+    )");
+    const json_view customer = doc.root();
+
+    // read typed fields straight into C++ variables -- none of these build
+    // a nlohmann::json value
+    const std::string name = customer["name"].get<std::string>();
+    const bool active = customer["active"].get<bool>();
+    std::cout << name << (active ? " (active)" : " (inactive)") << '\n';
+
+    // std::vector<json_view> keeps views of the array elements instead of
+    // copies of their values
+    bool first = true;
+    for (const json_view order : customer["orders"].get<std::vector<json_view>>())
+    {
+        std::cout << (first ? "" : " ") << order.get<int>();
+        first = false;
+    }
+    std::cout << '\n';
+
+    // everything else goes through materialize()
+    const address a = customer["address"].get<address>();
+    std::cout << a.city << ' ' << a.zip << '\n';
+}

examples/basic_json_view__get.output

@@ -0,0 +1,3 @@
+Alice (active)
+1 2 3
+Berlin 10115

examples/basic_json_view__get_string.cpp

@@ -0,0 +1,31 @@
+#include <iostream>
+#include <nlohmann/json_view.hpp>
+#include <string>
+
+using json_document = nlohmann::json_document;
+using json_view = nlohmann::json_view;
+
+int main()
+{
+    // a "large response" stand-in: only the "id" field is ever read out of it
+    const std::string text =
+        R"({"id": "8f14e45f-ceea-467e-bb92-963f5e3c7a08", "note": "created via API\n", "payload": "..."})";
+    const json_document doc = json_document::parse(text);
+    const json_view response = doc.root();
+
+    const json_view::string_view_t id = response["id"].get_string();
+    std::cout << id << '\n';
+
+    // no std::string was allocated for "id": its bytes still live inside
+    // the original buffer, so id's data lies inside [text.data(),
+    // text.data() + text.size())
+    const bool id_in_source = id.data() >= text.data() && id.data() + id.size() <= text.data() + text.size();
+    std::cout << std::boolalpha << id_in_source << '\n';
+
+    // "note" contains an escape sequence ('\n'), so it was decoded once
+    // into the document's own buffer -- get_string() still avoids a copy
+    // into a new std::string, but the bytes no longer live inside "text"
+    const json_view::string_view_t note = response["note"].get_string();
+    const bool note_in_source = note.data() >= text.data() && note.data() + note.size() <= text.data() + text.size();
+    std::cout << std::boolalpha << note_in_source << '\n';
+}

examples/basic_json_view__get_string.output

@@ -0,0 +1,3 @@
+8f14e45f-ceea-467e-bb92-963f5e3c7a08
+true
+false

examples/basic_json_view__get_to.cpp

@@ -0,0 +1,28 @@
+#include <iostream>
+#include <nlohmann/json_view.hpp>
+#include <string>
+
+using json_document = nlohmann::json_document;
+using json_view = nlohmann::json_view;
+
+int main()
+{
+    json_document doc = json_document::parse(R"({"host": "db.example.com", "port": 5432, "ssl": true})");
+    const json_view config = doc.root();
+
+    // get_to() writes directly into existing variables -- handy for filling
+    // in the members of a struct one field at a time, without an
+    // intermediate value from get<T>() for each one
+    std::string host;
+    int port = 0;
+    bool ssl = false;
+    config["host"].get_to(host);
+    config["port"].get_to(port);
+    config["ssl"].get_to(ssl);
+    std::cout << host << ':' << port << (ssl ? " (tls)" : "") << '\n';
+
+    // the return value is a reference to the argument, so a call can be
+    // used directly in a larger expression
+    std::string other_host;
+    std::cout << config["host"].get_to(other_host).size() << '\n';
+}

examples/basic_json_view__get_to.output

@@ -0,0 +1,2 @@
+db.example.com:5432 (tls)
+14

examples/basic_json_view__items.cpp

@@ -0,0 +1,22 @@
+#include <iostream>
+#include <nlohmann/json_view.hpp>
+
+using json_document = nlohmann::json_document;
+
+int main()
+{
+    // a settings object whose source text records every update to a key as
+    // a duplicate member. items() visits all of them, in document order, so
+    // the update history is visible; operator[] only ever sees the first
+    // one, and materialize() -- like basic_json::parse() -- keeps the last
+    json_document updates = json_document::parse(R"({"retries": 1, "timeout": 30, "retries": 5})");
+    const auto settings = updates.root();
+
+    for (const auto& item : settings.items())
+    {
+        std::cout << item.key() << '=' << item.value().materialize().dump() << '\n';
+    }
+
+    std::cout << "first \"retries\" seen by operator[]: " << settings["retries"].materialize().dump() << '\n';
+    std::cout << "last \"retries\" kept by materialize(): " << settings.materialize()["retries"].dump() << '\n';
+}

examples/basic_json_view__items.output

@@ -0,0 +1,5 @@
+retries=1
+timeout=30
+retries=5
+first "retries" seen by operator[]: 1
+last "retries" kept by materialize(): 5

examples/basic_json_view__materialize.cpp

@@ -0,0 +1,33 @@
+#include <array>
+#include <iostream>
+#include <nlohmann/json_view.hpp>
+
+using json_document = nlohmann::json_document;
+
+int main()
+{
+    // three incoming messages; skip the ones that are not useful without ever
+    // building a nlohmann::json value for them
+    json_document heartbeat = json_document::parse("null");
+    json_document empty_batch = json_document::parse("[]");
+    json_document batch = json_document::parse(R"([{"id": 1}, {"id": 2}, {"id": 3}])");
+    std::array<const json_document*, 3> messages = {{&heartbeat, &empty_batch, &batch}};
+
+    for (const json_document* d : messages)
+    {
+        // is_array()/empty() only look at the flat index: a discarded
+        // heartbeat or an empty batch is never turned into a nlohmann::json
+        // value, so no per-element allocation happens for them
+        if (!d->root().is_array() || d->root().empty())
+        {
+            std::cout << "skipped\n";
+            continue;
+        }
+
+        // materialize() replays the subtree through the same SAX builder
+        // basic_json::parse() uses, so the result is exactly what
+        // basic_json::parse() would have produced for the same text
+        nlohmann::json value = d->root().materialize();
+        std::cout << value.dump() << '\n';
+    }
+}

examples/basic_json_view__materialize.output

@@ -0,0 +1,3 @@
+skipped
+skipped
+[{"id":1},{"id":2},{"id":3}]

examples/basic_json_view__number_format.cpp

@@ -0,0 +1,28 @@
+#include <iostream>
+#include <nlohmann/json_view.hpp>
+
+using json_document = nlohmann::json_document;
+using json_view = nlohmann::json_view;
+
+int main()
+{
+    // a price list received from a supplier feed -- prices and account
+    // numbers must be forwarded exactly, e.g. into an invoice
+    const json_document doc = json_document::parse(R"(
+      [{"sku": "A1", "price": 19.90, "account_id": 12345678901234567890123456},
+       {"sku": "A2", "price": 1E2, "account_id": 98765432109876543210987654}]
+    )");
+    const json_view list = doc.root();
+
+    // number_format::shortest (the default) writes numbers the way
+    // basic_json::dump() would: "19.90" becomes "19.9", "1E2" becomes
+    // "100.0", and each account number -- far beyond any 64-bit integer --
+    // is rounded to the nearest double, exactly as materialize().dump()
+    // (or a plain nlohmann::json) would round it
+    std::cout << list.dump() << '\n';
+
+    // number_format::source copies every number exactly as it was written
+    // in the source text instead -- something basic_json cannot do at all,
+    // since parsing already reduces every number to its parsed value
+    std::cout << list.dump(-1, ' ', false, json_view::number_format::source) << '\n';
+}

examples/basic_json_view__number_format.output

@@ -0,0 +1,2 @@
+[{"sku":"A1","price":19.9,"account_id":1.2345678901234568e+25},{"sku":"A2","price":100.0,"account_id":9.876543210987655e+25}]
+[{"sku":"A1","price":19.90,"account_id":12345678901234567890123456},{"sku":"A2","price":1E2,"account_id":98765432109876543210987654}]

examples/basic_json_view__number_token.cpp

@@ -0,0 +1,29 @@
+#include <iostream>
+#include <nlohmann/json_view.hpp>
+
+using json_document = nlohmann::json_document;
+using json_view = nlohmann::json_view;
+
+int main()
+{
+    // a price and an order id from an incoming order -- both need to be
+    // reproduced exactly, e.g. for an invoice or an audit log
+    json_document doc = json_document::parse(R"(
+      {"price": 19.90, "order_id": 1234567890123456789012345, "quantity": 3}
+    )");
+    const json_view order = doc.root();
+
+    // number_token() returns the number exactly as written in the source
+    std::cout << order["price"].number_token() << '\n';
+    std::cout << order["order_id"].number_token() << '\n';
+
+    // get<double>() converts it instead -- the exact source text is gone:
+    // "19.90" becomes the double closest to 19.9, printed without the
+    // trailing zero, and the 25-digit order id -- far beyond any 64-bit
+    // integer -- can only be approximated as a double
+    std::cout << order["price"].get<double>() << '\n';
+    std::cout << order.materialize()["order_id"].dump() << '\n';
+
+    // an ordinary quantity has nothing to lose either way
+    std::cout << order["quantity"].number_token() << " == " << order["quantity"].get<int>() << '\n';
+}

examples/basic_json_view__number_token.output

@@ -0,0 +1,5 @@
+19.90
+1234567890123456789012345
+19.9
+1.2345678901234568e+24
+3 == 3

examples/basic_json_view__operator[].cpp

@@ -0,0 +1,44 @@
+#include <iostream>
+#include <nlohmann/json_view.hpp>
+
+using json_document = nlohmann::json_document;
+
+int main()
+{
+    // two user records from a large API response; only the fields that are
+    // actually read are ever touched, and no nlohmann::json tree is built
+    // for the batch
+    json_document batch = json_document::parse(R"(
+      [
+        {"name": "Alice", "email": "alice@example.com", "tags": ["admin", "ops"]},
+        {"name": "Bob", "tags": []}
+      ]
+    )");
+
+    const auto users = batch.root();
+    for (std::size_t i = 0; i < users.size(); ++i)
+    {
+        const auto user = users[i];
+        std::cout << user["name"].materialize().dump();
+
+        // operator[] on a missing object key gives a discarded view -- test
+        // it with is_discarded(). The const overload of json::operator[]
+        // would instead be undefined behavior (guarded by an assertion) for
+        // a missing key
+        const auto email = user["email"];
+        if (!email.is_discarded())
+        {
+            std::cout << " <" << email.materialize().dump() << ">";
+        }
+
+        // the same holds for an array index past the end: a discarded view,
+        // not undefined behavior
+        const auto first_tag = user["tags"][0];
+        if (!first_tag.is_discarded())
+        {
+            std::cout << " #" << first_tag.materialize().dump();
+        }
+
+        std::cout << '\n';
+    }
+}

examples/basic_json_view__operator[].output

@@ -0,0 +1,2 @@
+"Alice" <"alice@example.com"> #"admin"
+"Bob"

examples/basic_json_view__operator[]_json_pointer.cpp

@@ -0,0 +1,48 @@
+#include <iostream>
+#include <nlohmann/json_view.hpp>
+
+using json_document = nlohmann::json_document;
+using json_pointer = nlohmann::json::json_pointer;
+
+int main()
+{
+    // a larger document; operator[] with a JSON pointer reaches straight to
+    // one deeply nested field, without ever building a tree for the rest
+    json_document doc = json_document::parse(R"(
+      {
+        "region": {
+          "servers": [
+            {"name": "eu-1", "metrics": {"cpu": 0.42}},
+            {"name": "eu-2", "metrics": {"cpu": 0.71}}
+          ]
+        }
+      }
+    )");
+
+    const auto root = doc.root();
+    std::cout << root[json_pointer("/region/servers/1/metrics/cpu")].materialize().dump() << '\n';
+
+    // a missing key or an out-of-range index along the path gives a
+    // discarded view, exactly where const json::operator[] would be
+    // undefined behavior for the same pointer
+    const auto missing = root[json_pointer("/region/servers/5/metrics/cpu")];
+    if (!missing.is_discarded())
+    {
+        std::cout << missing.materialize().dump() << '\n';
+    }
+    else
+    {
+        std::cout << "no such server\n";
+    }
+
+    // indexing into a primitive still throws, as basic_json::operator[]
+    // does for the same pointer
+    try
+    {
+        static_cast<void>(root[json_pointer("/region/servers/0/name/x")]);
+    }
+    catch (const nlohmann::json::out_of_range& e)
+    {
+        std::cout << e.what() << '\n';
+    }
+}

examples/basic_json_view__operator[]_json_pointer.output

@@ -0,0 +1,3 @@
+0.71
+no such server
+[json.exception.out_of_range.404] unresolved reference token 'x'

examples/basic_json_view__operator_eq.cpp

@@ -0,0 +1,30 @@
+#include <iostream>
+#include <nlohmann/json_view.hpp>
+
+using json_document = nlohmann::json_document;
+using json = nlohmann::json;
+
+int main()
+{
+    // two snapshots of a polled configuration endpoint -- compare them
+    // directly as views, without ever building a nlohmann::json value for
+    // either one
+    const json_document previous = json_document::parse(
+                                       R"({"name": "cache", "port": 6379, "timeout": 30})");
+    const json_document current = json_document::parse(
+                                      R"({"port": 6379.0, "timeout": 30, "name": "cache"})");
+
+    // same members, reordered, and 6379 written as a float -- operator==
+    // treats them the same way BasicJsonType::operator== would
+    std::cout << std::boolalpha << (previous.root() == current.root()) << '\n';
+
+    // an actually changed value is detected the same way
+    const json_document changed = json_document::parse(
+                                      R"({"name": "cache", "port": 6380, "timeout": 30})");
+    std::cout << (previous.root() == changed.root()) << '\n';
+
+    // comparing a view directly against an expected json value -- handy in a
+    // test, without materializing the received document at all
+    const json expected = {{"name", "cache"}, {"port", 6379}, {"timeout", 30}};
+    std::cout << (previous.root() == expected) << '\n';
+}

examples/basic_json_view__operator_eq.output

@@ -0,0 +1,3 @@
+true
+false
+true

examples/basic_json_view__operator_ltlt.cpp

@@ -0,0 +1,26 @@
+#include <iostream>
+#include <iomanip>
+#include <nlohmann/json_view.hpp>
+
+using json_document = nlohmann::json_document;
+using json_view = nlohmann::json_view;
+
+int main()
+{
+    // one order out of a large incoming batch -- write it straight to a log
+    // stream without ever building a basic_json value for it, or for the
+    // rest of the batch
+    const json_document doc = json_document::parse(R"(
+      [{"id": 1, "item": "cable"}, {"id": 2, "item": "adapter"}]
+    )");
+    const json_view orders = doc.root();
+
+    // compact, for a one-line log entry
+    std::cout << orders[1] << '\n';
+
+    // std::setw sets the indentation level, exactly as for basic_json
+    std::cout << std::setw(2) << orders[1] << "\n\n";
+
+    // std::setfill changes the indentation character
+    std::cout << std::setw(1) << std::setfill('\t') << orders[1] << '\n';
+}

examples/basic_json_view__operator_ltlt.output

@@ -0,0 +1,10 @@
+{"id":2,"item":"adapter"}
+{
+  "id": 2,
+  "item": "adapter"
+}
+
+{
+	"id": 2,
+	"item": "adapter"
+}

examples/basic_json_view__operator_ne.cpp

@@ -0,0 +1,28 @@
+#include <iostream>
+#include <nlohmann/json_view.hpp>
+
+using json_document = nlohmann::json_document;
+using ordered_json_document = nlohmann::ordered_json_document;
+using json = nlohmann::json;
+
+int main()
+{
+    // assert, as a test would, that a received document differs from an
+    // unwanted shape -- without ever materializing it into a json value just
+    // to compare
+    const json_document received = json_document::parse(
+                                       R"({"status": "ok", "code": 200})");
+    const json unwanted = {{"status", "error"}, {"code", 500}};
+    std::cout << std::boolalpha << (received.root() != unwanted) << '\n';
+
+    // json (std::map) compares object members regardless of order ...
+    const json_document a = json_document::parse(R"({"a": 1, "b": 2})");
+    const json_document b = json_document::parse(R"({"b": 2, "a": 1})");
+    std::cout << (a.root() != b.root()) << '\n';
+
+    // ... but ordered_json (ordered_map) compares them in the order they
+    // appear, so the very same reordering is detected as a difference
+    const ordered_json_document oa = ordered_json_document::parse(R"({"a": 1, "b": 2})");
+    const ordered_json_document ob = ordered_json_document::parse(R"({"b": 2, "a": 1})");
+    std::cout << (oa.root() != ob.root()) << '\n';
+}

examples/basic_json_view__operator_ne.output

@@ -0,0 +1,3 @@
+true
+false
+true

examples/basic_json_view__size_empty.cpp

@@ -0,0 +1,22 @@
+#include <iostream>
+#include <nlohmann/json_view.hpp>
+
+using json_document = nlohmann::json_document;
+
+int main()
+{
+    std::cout << std::boolalpha;
+
+    // decide whether a batch is worth processing before building any
+    // nlohmann::json value for it
+    json_document batch = json_document::parse(R"([1, 2, 3, 4, 5])");
+    json_document empty_batch = json_document::parse("[]");
+
+    std::cout << batch.root().empty() << ' ' << batch.root().size() << '\n';
+    std::cout << empty_batch.root().empty() << ' ' << empty_batch.root().size() << '\n';
+
+    // as for basic_json: null has size 0, every other scalar has size 1
+    json_document n = json_document::parse("null");
+    json_document s = json_document::parse(R"("hi")");
+    std::cout << n.root().size() << ' ' << s.root().size() << '\n';
+}

examples/basic_json_view__size_empty.output

@@ -0,0 +1,3 @@
+false 5
+true 0
+0 1

examples/basic_json_view__source_offset.cpp

@@ -0,0 +1,33 @@
+#include <iostream>
+#include <string>
+#include <nlohmann/json_view.hpp>
+
+using json_document = nlohmann::json_document;
+
+int main()
+{
+    std::cout << std::boolalpha;
+
+    // source_offset() points into source(): useful to report *where* in the
+    // original text a value came from (error messages, syntax highlighting,
+    // forwarding a sub-range verbatim, ...) without materializing it
+    json_document doc = json_document::parse(R"(  123)");
+    auto v = doc.root();
+    std::cout << v.source_offset() << ' '
+              << std::string(doc.source().data() + v.source_offset(), 3) << '\n';
+
+    // a string without escapes also stays in the source text
+    json_document plain = json_document::parse(R"("ab")");
+    std::cout << plain.source()[plain.root().source_offset()] << '\n';
+
+    // a string with escapes is decoded once into the document's own buffer, so
+    // there is no single byte range in source() to point at: source_offset()
+    // returns the "not applicable" sentinel
+    json_document escaped = json_document::parse(R"("a\nb")");
+    std::cout << (escaped.root().source_offset() == static_cast<std::size_t>(-1)) << '\n';
+
+    // a discarded view -- default-constructed, or the root of a failed parse
+    // with allow_exceptions == false -- has no offset either
+    json_document failed = json_document::parse("not json", false);
+    std::cout << (failed.root().source_offset() == static_cast<std::size_t>(-1)) << '\n';
+}

examples/basic_json_view__source_offset.output

@@ -0,0 +1,4 @@
+2 123
+a
+true
+true

examples/basic_json_view__type_name.cpp

@@ -0,0 +1,30 @@
+#include <iostream>
+#include <nlohmann/json_view.hpp>
+
+using json_document = nlohmann::json_document;
+using json_view = nlohmann::json_view;
+
+int main()
+{
+    // report why some parsed messages were rejected, using only
+    // type_name() -- no nlohmann::json value is built for the ones that
+    // are wrong
+    json_document good = json_document::parse(R"({"id": 1})");
+    json_document bad = json_document::parse("[1, 2, 3]");
+    json_document failed = json_document::parse("not json", /* allow_exceptions */ false);
+
+    for (const json_view v :
+            {
+                good.root(), bad.root(), failed.root()
+            })
+    {
+        if (v.is_object())
+        {
+            std::cout << "ok\n";
+        }
+        else
+        {
+            std::cout << "expected an object, got " << v.type_name() << '\n';
+        }
+    }
+}

examples/basic_json_view__type_name.output

@@ -0,0 +1,3 @@
+ok
+expected an object, got array
+expected an object, got discarded

examples/basic_json_view__type_predicates.cpp

@@ -0,0 +1,43 @@
+#include <iostream>
+#include <nlohmann/json_view.hpp>
+
+using json_document = nlohmann::json_document;
+
+int main()
+{
+    std::cout << std::boolalpha;
+
+    // several incoming messages, one json_document per message. type() and
+    // is_*() only look at the flat index built by parse(); no nlohmann::json
+    // tree exists yet, and none is built unless materialize() is called
+    json_document d_null = json_document::parse("null");
+    json_document d_bool = json_document::parse("true");
+    json_document d_int = json_document::parse("-42");
+    json_document d_unsigned = json_document::parse("42");
+    json_document d_float = json_document::parse("4.2");
+    json_document d_string = json_document::parse(R"("hi")");
+    json_document d_array = json_document::parse("[1, 2, 3]");
+    json_document d_object = json_document::parse(R"({"a": 1})");
+
+    std::cout << d_null.root().is_null() << '\n';
+    std::cout << d_bool.root().is_boolean() << '\n';
+    std::cout << d_int.root().is_number() << ' ' << d_int.root().is_number_integer() << '\n';
+    std::cout << d_unsigned.root().is_number_unsigned() << '\n';
+    std::cout << d_float.root().is_number_float() << '\n';
+    std::cout << d_string.root().is_string() << '\n';
+    std::cout << d_array.root().is_array() << ' ' << d_array.root().is_structured() << '\n';
+    std::cout << d_object.root().is_object() << ' ' << d_object.root().is_primitive() << '\n';
+
+    // JSON text can never produce a binary value: is_binary() is always false
+    std::cout << d_array.root().is_binary() << '\n';
+
+    // a default-constructed view, and the root of a document that failed to
+    // parse without exceptions, are both discarded
+    nlohmann::json_view invalid;
+    json_document failed = json_document::parse("not json", /* allow_exceptions */ false);
+    std::cout << invalid.is_discarded() << '\n';
+    std::cout << failed.root().is_discarded() << '\n';
+
+    // type() returns the same value_t enumeration as basic_json::type()
+    std::cout << (d_object.root().type() == nlohmann::json::value_t::object) << '\n';
+}

examples/basic_json_view__type_predicates.output

@@ -0,0 +1,12 @@
+true
+true
+true true
+true
+true
+true
+true true
+true false
+false
+true
+true
+true

examples/basic_json_view__value.cpp

@@ -0,0 +1,29 @@
+#include <iostream>
+#include <nlohmann/json_view.hpp>
+#include <string>
+
+using json_document = nlohmann::json_document;
+using json_view = nlohmann::json_view;
+
+int main()
+{
+    json_document doc = json_document::parse(R"({"server": {"host": "localhost"}})");
+    const json_view server = doc.root()["server"];
+
+    // "port" is missing -- value() returns the default instead of
+    // throwing, so optional configuration fields never need their own
+    // try/catch
+    std::cout << server.value("host", std::string("0.0.0.0")) << '\n';
+    std::cout << server.value("port", 8080) << '\n';
+
+    // a present but wrong-typed default still throws -- value() only
+    // replaces "not found", not "wrong type", exactly as basic_json::value
+    try
+    {
+        static_cast<void>(server.value("host", 0));
+    }
+    catch (const nlohmann::json::type_error& e)
+    {
+        std::cout << e.what() << '\n';
+    }
+}

examples/basic_json_view__value.output

@@ -0,0 +1,3 @@
+localhost
+8080
+[json.exception.type_error.302] type must be number, but is string