Format the dump() example with the pinned astyle

The "check" job runs astyle over the documentation examples once it gets past the amalgamation step. Signed-off-by: Niels Lohmann <mail@nlohmann.me>
Mark the cases of the view's serializer that tests cannot reach
2026-09-30 19:50:34 +00:00 · 2026-09-30 21:01:46 +02:00 · 2026-09-30 21:01:45 +02:00 · 2026-09-30 21:01:44 +02:00 · 2026-09-30 21:01:43 +02:00 · 2026-09-30 21:01:42 +02:00
22 changed files with 1497 additions and 3 deletions
@@ -79,6 +79,7 @@ cc_library(
        "include/nlohmann/detail/view/number.hpp",
        "include/nlohmann/detail/view/pointer.hpp",
        "include/nlohmann/detail/view/scan.hpp",
+        "include/nlohmann/detail/view/serializer.hpp",
        "include/nlohmann/detail/view/string_ref.hpp",
        "include/nlohmann/detail/view/value.hpp",
        "include/nlohmann/json.hpp",
@@ -150,6 +150,7 @@ INSERT INTO searchIndex(name, type, path) VALUES ('basic_json_view::cbegin', 'Me
 INSERT INTO searchIndex(name, type, path) VALUES ('basic_json_view::cend', 'Method', 'api/basic_json_view/cend/index.html');
 INSERT INTO searchIndex(name, type, path) VALUES ('basic_json_view::contains', 'Method', 'api/basic_json_view/contains/index.html');
 INSERT INTO searchIndex(name, type, path) VALUES ('basic_json_view::count', 'Method', 'api/basic_json_view/count/index.html');
+INSERT INTO searchIndex(name, type, path) VALUES ('basic_json_view::dump', 'Method', 'api/basic_json_view/dump/index.html');
 INSERT INTO searchIndex(name, type, path) VALUES ('basic_json_view::empty', 'Method', 'api/basic_json_view/empty/index.html');
 INSERT INTO searchIndex(name, type, path) VALUES ('basic_json_view::end', 'Method', 'api/basic_json_view/end/index.html');
 INSERT INTO searchIndex(name, type, path) VALUES ('basic_json_view::find', 'Method', 'api/basic_json_view/find/index.html');
@@ -172,8 +173,10 @@ INSERT INTO searchIndex(name, type, path) VALUES ('basic_json_view::is_string',
 INSERT INTO searchIndex(name, type, path) VALUES ('basic_json_view::is_structured', 'Method', 'api/basic_json_view/is_structured/index.html');
 INSERT INTO searchIndex(name, type, path) VALUES ('basic_json_view::items', 'Method', 'api/basic_json_view/items/index.html');
 INSERT INTO searchIndex(name, type, path) VALUES ('basic_json_view::materialize', 'Method', 'api/basic_json_view/materialize/index.html');
+INSERT INTO searchIndex(name, type, path) VALUES ('basic_json_view::number_format', 'Enum', 'api/basic_json_view/number_format/index.html');
 INSERT INTO searchIndex(name, type, path) VALUES ('basic_json_view::number_token', 'Method', 'api/basic_json_view/number_token/index.html');
 INSERT INTO searchIndex(name, type, path) VALUES ('basic_json_view::operator bool', 'Method', 'api/basic_json_view/operator_bool/index.html');
+INSERT INTO searchIndex(name, type, path) VALUES ('basic_json_view::operator<<', 'Operator', 'api/basic_json_view/operator_ltlt/index.html');
 INSERT INTO searchIndex(name, type, path) VALUES ('basic_json_view::operator[]', 'Operator', 'api/basic_json_view/operator[]/index.html');
 INSERT INTO searchIndex(name, type, path) VALUES ('basic_json_view::size', 'Method', 'api/basic_json_view/size/index.html');
 INSERT INTO searchIndex(name, type, path) VALUES ('basic_json_view::source_offset', 'Method', 'api/basic_json_view/source_offset/index.html');
@@ -86,6 +86,8 @@ Binary values are serialized as an object containing two keys:

 - [to_string](to_string.md) returns a string representation of a JSON value
 - [operator<<](../operator_ltlt.md) serialize to stream
+- [`basic_json_view::dump`](../basic_json_view/dump.md) the corresponding function of `basic_json_view`, serializing
+  directly from a flat index without building a `basic_json` value
 - [Serialization](../../features/serialization.md) - the serialization article

 ## Version history
@@ -0,0 +1,102 @@
+# <small>nlohmann::basic_json_view::</small>dump
+
+```cpp
+string_t dump(const int indent = -1,
+              const char indent_char = ' ',
+              const bool ensure_ascii = false,
+              const number_format numbers = number_format::shortest) const;
+```
+
+Serializes this value (and its subtree) directly from the flat index, without ever building a `BasicJsonType` value
+first. With the default `#!cpp numbers == number_format::shortest`, the result is the same string
+[`BasicJsonType::dump`](../basic_json/dump.md) would produce for the value
+[`BasicJsonType::parse()`](../basic_json/parse.md) builds from the same source text, called with the same `indent`,
+`indent_char`, and `ensure_ascii` -- except that members of an object appear in document order rather than sorted by
+key, and *every* occurrence of a repeated key is written rather than only the last one (see
+[Notes on duplicate keys](operator[].md#notes)). For a `json_view` (whose `BasicJsonType` is not ordered), this means
+`dump()` can print an object's members in a different order than [`materialize()`](materialize.md)`.dump()` of the
+same subtree.
+
+## Parameters
+
+`indent` (in)
+:   If `indent` is nonnegative, array elements and object members are pretty-printed with that indent level. An
+    indent level of `0` only inserts newlines. `-1` (the default) selects the most compact representation.
+
+`indent_char` (in)
+:   The character used for indentation if `indent` is greater than `0`. The default is ` ` (space).
+
+`ensure_ascii` (in)
+:   If `ensure_ascii` is `#!cpp true`, all non-ASCII characters in the output are escaped with `\uXXXX` sequences, and
+    the result consists of ASCII characters only.
+
+`numbers` (in)
+:   how to write numbers, see [`number_format`](number_format.md): `shortest` (the default) writes them the way
+    [`BasicJsonType::dump`](../basic_json/dump.md) would; `source` copies every number exactly as it appears in the
+    source text.
+
+## Return value
+
+string containing the serialization of this value, or `#!cpp "<discarded>"` if the view is
+[discarded](is_discarded.md).
+
+## Exception safety
+
+Strong exception safety: if an exception is thrown, there are no changes to the view or the document it refers to.
+
+## Exceptions
+
+May throw `#!cpp std::bad_alloc` if allocating the output string fails. Unlike
+[`BasicJsonType::dump`](../basic_json/dump.md), there is no `error_handler` parameter and no
+[`type_error.316`](../../home/exceptions.md#jsonexceptiontype_error316): the view only ever holds text the parser
+already validated as UTF-8, so there is nothing to replace or ignore.
+
+## Complexity
+
+Linear in the size of the output text.
+
+## Notes
+
+The walk over the subtree is iterative, so the nesting depth it can write is limited by available memory only, not by
+the call stack -- as for [`materialize()`](materialize.md).
+
+Strings are escaped by the same rules as [`BasicJsonType::dump`](../basic_json/dump.md). With
+`#!cpp numbers == number_format::shortest`, floats are written with the library's shortest round-trip conversion,
+exactly as [`BasicJsonType::dump`](../basic_json/dump.md) would (e.g. `#!cpp 1.5`, `#!cpp 100.0`, `#!cpp 1e+100`), and
+integers are copied from the source text -- already canonical in JSON, so this matches their shortest form too --
+except that `#!cpp -0` is written as `#!cpp 0`, the way [`BasicJsonType::parse()`](../basic_json/parse.md) reads it.
+`#!cpp number_format::source` copies every number exactly as written in the source text instead, with no exception
+for `#!cpp -0` -- `#!cpp 1.50`, `#!cpp 1E2`, `#!cpp -0.0`, `#!cpp -0`, or all digits of an integer literal with more
+digits than any number type holds (such a literal is itself classified as a float, see
+[What is different](../../features/json_view.md#what-is-different)) -- something `BasicJsonType` cannot do, since
+parsing already reduces every number to its parsed value.
+
+## Examples
+
+??? example
+
+    The example below forwards a single record out of a larger batch, and re-serializes a configuration file, both
+    without ever building a `BasicJsonType` value for the surrounding array or for the parts of it that were not
+    needed. It also shows that [`materialize()`](materialize.md)`.dump()` of the configuration sorts its keys, where
+    `dump()` on the view keeps the order they appear in the source text.
+
+    ```cpp
+    --8<-- "examples/basic_json_view__dump.cpp"
+    ```
+
+    Output:
+
+    ```json
+    --8<-- "examples/basic_json_view__dump.output"
+    ```
+
+## See also
+
+- [`number_format`](number_format.md) - how `dump()` writes numbers
+- [operator<<](operator_ltlt.md) - serialize this value to a stream
+- [materialize](materialize.md) - build a `BasicJsonType` value, e.g. to use `BasicJsonType::dump`'s `error_handler`
+- [`BasicJsonType::dump`](../basic_json/dump.md) - the corresponding function of `basic_json`
+
+## Version history
+
+- Added in version 3.13.0.
@@ -23,7 +23,7 @@ Moving the document itself does not invalidate its views: the index is heap-allo
 access, lookup, iteration, and conversion -- [`get<T>()`](get.md), [`get_string()`](get_string.md),
 [`number_token()`](number_token.md), and [`materialize()`](materialize.md) to build the `BasicJsonType` value of a
 subtree on demand. [`operator[]`](operator%5B%5D.md), [`at`](at.md), [`contains`](contains.md), and
-[`value`](value.md) also accept a [`json_pointer`](../json_pointer/index.md). It does not (yet) provide `dump()` or
+[`value`](value.md) also accept a [`json_pointer`](../json_pointer/index.md). It does not (yet) provide
 comparison.

 ## Template parameters
@@ -47,6 +47,7 @@ comparison.
 - **iterator**, **const_iterator** - a forward iterator over the elements of an array or the member values of an
  object, in document order; both names refer to the same type, since a view is always read-only
 - **item** - a (key, value) pair produced by [`items()`](items.md)
+- [**number_format**](number_format.md) - how [`dump()`](dump.md) writes numbers

 ## Member functions

@@ -106,6 +107,11 @@ comparison.
 - [**number_token**](number_token.md) - get a number's token text without a copy
 - [**materialize**](materialize.md) - build the `BasicJsonType` value of this subtree

+### Serialization
+
+- [**dump**](dump.md) - serialize to a JSON-formatted string
+- [**operator<<**](operator_ltlt.md) - serialize to stream
+
 ### Source access

 - [**source_offset**](source_offset.md) - byte offset of this value in the document's source text
@@ -0,0 +1,51 @@
+# <small>nlohmann::basic_json_view::</small>number_format
+
+```cpp
+enum class number_format {
+    shortest,
+    source
+};
+```
+
+This enumeration is used in [`dump`](dump.md) to choose how numbers are written. Two values are differentiated:
+
+shortest
+:   integers are copied from the source text -- already canonical in JSON -- except that `#!cpp -0` becomes
+    `#!cpp 0`, the way [`BasicJsonType::parse()`](../basic_json/parse.md) reads it; floats are written with the
+    library's shortest round-trip conversion, exactly as [`BasicJsonType::dump()`](../basic_json/dump.md) would (e.g.
+    `#!cpp 1.5`, `#!cpp 100.0`, `#!cpp 1e+100`)
+
+source
+:   every number is copied exactly as it appears in the source text -- `#!cpp 1.50`, `#!cpp 1E2`, `#!cpp -0`, all
+    digits of an integer literal with more digits than any number type holds -- something `BasicJsonType` cannot do,
+    since parsing already reduces every number to its parsed value
+
+## Examples
+
+??? example
+
+    The example below writes back a price list received from a supplier: with `number_format::shortest` (the
+    default), a trailing zero and scientific notation are normalized away and a long account number that overflows
+    every number type is rounded, the same way `#!cpp materialize().dump()` (or `basic_json::dump()`) would;
+    `number_format::source` keeps every number exactly as it was written in the source text instead.
+
+    ```cpp
+    --8<-- "examples/basic_json_view__number_format.cpp"
+    ```
+
+    Output:
+
+    ```json
+    --8<-- "examples/basic_json_view__number_format.output"
+    ```
+
+## See also
+
+- [dump](dump.md) - serialize to a JSON-formatted string
+- [number_token](number_token.md) - get a single number's token text without dumping the whole value
+- [`BasicJsonType::error_handler_t`](../basic_json/error_handler_t.md) - the analogous enumeration for
+  `BasicJsonType::dump`'s decoding-error behavior
+
+## Version history
+
+- Added in version 3.13.0.
@@ -0,0 +1,74 @@
+# <small>nlohmann::basic_json_view::</small>operator<<
+
+```cpp
+std::ostream& operator<<(std::ostream& o, const basic_json_view& v);
+```
+
+Not available when [`JSON_NO_IO`](../macros/json_no_io.md) is defined.
+
+Serializes the given view `v` to the output stream `o`, using [`dump`](dump.md) -- exactly as
+`#!cpp operator<<(std::ostream&, const basic_json&)` does for a `basic_json` value.
+
+- The indentation of the output can be controlled with the member variable `width` of the output stream `o`. For
+  instance, using the manipulator `std::setw(4)` on `o` sets the indentation level to `4`, and the serialization
+  result is the same as calling `#!cpp v.dump(4)`. A `width` of `0` or less (the default) selects the most compact
+  representation, as `#!cpp v.dump(-1)` does.
+- The indentation character can be controlled with the member variable `fill` of the output stream `o`. For instance,
+  the manipulator `std::setfill('\t')` sets indentation to use a tab character rather than the default space
+  character.
+- As for `basic_json`, `o`'s `width` is reset to `0` after this call, whether or not it was greater than `0` before.
+
+Numbers are always written as `#!cpp v.dump()` writes them by default, i.e. as with
+[`number_format::shortest`](number_format.md); there is no way to select `#!cpp number_format::source` through the
+stream.
+
+## Parameters
+
+`o` (in, out)
+:   stream to write to
+
+`v` (in)
+:   view to serialize
+
+## Return value
+
+the stream `o`
+
+## Exceptions
+
+May throw `#!cpp std::bad_alloc`, propagated from [`dump`](dump.md#exceptions). Unlike
+`#!cpp operator<<(std::ostream&, const basic_json&)`, there is no UTF-8 decoding step that could throw
+[`type_error.316`](../../home/exceptions.md#jsonexceptiontype_error316), and no `error_handler` to choose between --
+see the [Exceptions](dump.md#exceptions) of `dump`.
+
+## Complexity
+
+Linear, as [`dump`](dump.md#complexity).
+
+## Examples
+
+??? example
+
+    The example below writes one record out of a larger batch straight to a log stream -- compact for a one-line
+    entry, and pretty-printed with `std::setw`/`std::setfill` for a readable dump -- without ever building a
+    `BasicJsonType` value for the record, or for the rest of the batch.
+
+    ```cpp
+    --8<-- "examples/basic_json_view__operator_ltlt.cpp"
+    ```
+
+    Output:
+
+    ```json
+    --8<-- "examples/basic_json_view__operator_ltlt.output"
+    ```
+
+## See also
+
+- [dump](dump.md) - serialize to a JSON-formatted string
+- [`operator<<(std::ostream&)`](../operator_ltlt.md) - the corresponding operator for `basic_json`
+- [`JSON_NO_IO`](../macros/json_no_io.md) - switch off functions relying on certain C++ I/O headers
+
+## Version history
+
+- Added in version 3.13.0.
@@ -84,6 +84,8 @@ Linear.
 ## See also

 - [dump](basic_json/dump.md) - serialize to a JSON-formatted string
+- [`basic_json_view::operator<<`](basic_json_view/operator_ltlt.md) - the corresponding operator for
+  `basic_json_view`
 - [Serialization](../features/serialization.md) - the serialization article

 ## Version history
@@ -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';
+}
@@ -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
+}
@@ -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';
+}
@@ -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}]
@@ -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';
+}
@@ -0,0 +1,10 @@
+{"id":2,"item":"adapter"}
+{
+  "id": 2,
+  "item": "adapter"
+}
+
+{
+	"id": 2,
+	"item": "adapter"
+}
@@ -139,8 +139,8 @@ whenever any of the other conditions above was not met.
  element access and lookup functions never carry the JSON Pointer path `JSON_DIAGNOSTICS` would otherwise add: the
  view has no `basic_json` value to point at, so the exception is created without one, regardless of how
  `BasicJsonType` was built.
- **`dump()` and comparison are not (yet) provided** by `basic_json_view`. For now,
-  [`materialize()`](../api/basic_json_view/materialize.md) is the way to get a value you can do those things with.
+- **Comparison is not (yet) provided** by `basic_json_view`. For now,
+  [`materialize()`](../api/basic_json_view/materialize.md) is the way to get a value you can compare.

 ## Getting values out without copying

@@ -166,6 +166,23 @@ Two conversions never copy at all:

 Both results are only valid as long as the view -- and, for a string with no escapes, the borrowed source text -- is.

+## Writing a view back
+
+[`dump()`](../api/basic_json_view/dump.md) serializes a view directly from the flat index, without ever building a
+`basic_json` value. An object's members are written in document order, not sorted by key, and *every* occurrence of a
+repeated key is written, not only the last one -- the same two ways [iteration](#what-is-different) already differs
+from a [`materialize()`](../api/basic_json_view/materialize.md)d value, see above. `#!cpp materialize().dump()` gives
+a different result in both respects for a `json_view`.
+
+By default, numbers are written the way [`basic_json::dump()`](../api/basic_json/dump.md) would.
+[`number_format::source`](../api/basic_json_view/number_format.md) instead copies every number exactly as it was
+written in the source text -- a price like `#!cpp 19.90`, a long order or account ID with more digits than any number
+type holds, or a high-precision coordinate -- something `basic_json` cannot do at all, since parsing already reduces
+a number to its parsed `#!cpp double`/`#!cpp int64_t` value.
+
+[`operator<<`](../api/basic_json_view/operator_ltlt.md) writes a view to a stream the way `basic_json`'s does, using
+the stream's `width`/`fill` for indentation.
+
 ## Choosing between `json`, `ordered_json`, the SAX interface, and `json_view`

 | | [`json`](../api/json.md) / [`ordered_json`](../api/ordered_json.md) | [SAX interface](parsing/sax_interface.md) | [`json_document`](../api/json_document.md) / [`json_view`](../api/json_view.md) |
@@ -253,6 +253,7 @@ nav:
          - 'cend': api/basic_json_view/cend.md
          - 'contains': api/basic_json_view/contains.md
          - 'count': api/basic_json_view/count.md
+          - 'dump': api/basic_json_view/dump.md
          - 'empty': api/basic_json_view/empty.md
          - 'end': api/basic_json_view/end.md
          - 'find': api/basic_json_view/find.md
@@ -275,8 +276,10 @@ nav:
          - 'is_structured': api/basic_json_view/is_structured.md
          - 'items': api/basic_json_view/items.md
          - 'materialize': api/basic_json_view/materialize.md
+          - 'number_format': api/basic_json_view/number_format.md
          - 'number_token': api/basic_json_view/number_token.md
          - 'operator bool': api/basic_json_view/operator_bool.md
+          - 'operator<<': api/basic_json_view/operator_ltlt.md
          - 'operator[]': api/basic_json_view/operator[].md
          - 'size': api/basic_json_view/size.md
          - 'source_offset': api/basic_json_view/source_offset.md
@@ -0,0 +1,419 @@
+//     __ _____ _____ _____
+//  __|  |   __|     |   | |  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 <algorithm> // max
+#include <array> // array
+#include <cmath> // isfinite
+#include <cstddef> // size_t
+#include <cstdint> // uint8_t, uint32_t
+#include <cstring> // memcpy, memset
+#include <limits> // numeric_limits
+#include <type_traits> // integral_constant
+#include <vector> // vector
+
+#include <nlohmann/json.hpp>
+#include <nlohmann/detail/view/document_data.hpp>
+#include <nlohmann/detail/view/macro_scope.hpp>
+#include <nlohmann/detail/view/node.hpp>
+#include <nlohmann/detail/view/number.hpp>
+
+NLOHMANN_JSON_NAMESPACE_BEGIN
+namespace detail
+{
+namespace view
+{
+
+/// append-only output buffer: writes through a raw pointer into a string that
+/// is resized ahead, and trimmed by finish()
+template<typename StringType>
+class output_buffer
+{
+  public:
+    output_buffer(StringType& out, std::size_t estimate)
+        : m_out(sized(out, estimate))
+        , m_pos(&m_out[0])
+        , m_end(m_pos + m_out.size())
+    {}
+
+    void finish()
+    {
+        m_out.resize(static_cast<std::size_t>(m_pos - m_out.data()));
+    }
+
+    NLOHMANN_VIEW_ALWAYS_INLINE void reserve(std::size_t n)
+    {
+        if (NLOHMANN_VIEW_UNLIKELY(static_cast<std::size_t>(m_end - m_pos) < n))
+        {
+            grow(n);
+        }
+    }
+
+    NLOHMANN_VIEW_ALWAYS_INLINE void put(char c)
+    {
+        reserve(1);
+        *m_pos++ = c;
+    }
+
+    NLOHMANN_VIEW_ALWAYS_INLINE void put(const char* s, std::size_t n)
+    {
+        reserve(n);
+        std::memcpy(m_pos, s, n);
+        m_pos += n;
+    }
+
+    void put_repeated(char c, std::size_t n)
+    {
+        reserve(n);
+        std::memset(m_pos, c, n);
+        m_pos += n;
+    }
+
+  private:
+    static StringType& sized(StringType& out, std::size_t estimate)
+    {
+        out.resize((std::max)(estimate, static_cast<std::size_t>(64)));
+        return out;
+    }
+
+    NLOHMANN_VIEW_NOINLINE void grow(std::size_t n)
+    {
+        const auto used = static_cast<std::size_t>(m_pos - m_out.data());
+        m_out.resize((std::max)(m_out.size() * 2, used + n + 256));
+        m_pos = &m_out[0] + used;
+        m_end = &m_out[0] + m_out.size();
+    }
+
+    StringType& m_out;
+    char* m_pos;
+    char* m_end;
+};
+
+/// how the view's dump() writes a value
+struct dump_style
+{
+    bool pretty = false;           ///< indent >= 0
+    std::size_t indent = 0;        ///< characters per level
+    char indent_char = ' ';
+    bool ensure_ascii = false;
+    bool source_numbers = false;   ///< copy number tokens from the source
+};
+
+/*!
+@brief write a view's subtree as basic_json::dump() writes the value
+
+The output of a subtree equals ordered_json::parse(text).dump() of it for
+the same arguments (members in document order): strings are escaped by the
+same rules, with the library's scanning kernels; floats are written with
+the library's conversion; integers are copied from the source, where they
+are canonical (except "-0", which parse() reads as 0). The walk is
+iterative, so the nesting depth is limited by memory only.
+*/
+template<typename BasicJsonType>
+class view_serializer
+{
+    using string_t = typename BasicJsonType::string_t;
+    using number_float_t = typename BasicJsonType::number_float_t;
+
+  public:
+    view_serializer(const document_data& d, string_t& out, std::size_t estimate, const dump_style& style)
+        : m_doc(d), m_out(out, estimate), m_style(style)
+    {}
+
+    void dump(const node* root)
+    {
+        struct frame
+        {
+            const node* pos; ///< next element, or key of the next member
+            const node* end;
+            bool object;
+            bool first;  ///< nothing written yet
+        };
+        std::vector<frame> stack;
+        const node* n = root;
+        for (;;)
+        {
+            // write the value at n
+            if (is_container(*n))
+            {
+                const bool object = n->kind == static_cast<std::uint8_t>(value_t::object);
+                if (n->len == 0)
+                {
+                    m_out.put(object ? "{}" : "[]", 2);
+                }
+                else
+                {
+                    m_out.put(object ? '{' : '[');
+                    stack.push_back(frame{document_data::first_child(n), document_data::child_end(n), object, true});
+                }
+            }
+            else
+            {
+                write_scalar(*n);
+            }
+
+            // go to the next value: close finished containers, then separate
+            for (;;)
+            {
+                if (stack.empty())
+                {
+                    m_out.finish();
+                    return;
+                }
+                frame& f = stack.back();
+                if (f.pos == f.end)
+                {
+                    const bool object = f.object;
+                    stack.pop_back();
+                    newline(stack.size());
+                    m_out.put(object ? '}' : ']');
+                    continue;
+                }
+                if (!f.first)
+                {
+                    m_out.put(',');
+                }
+                f.first = false;
+                newline(stack.size());
+                if (f.object)
+                {
+                    write_string(*f.pos);
+                    if (m_style.pretty)
+                    {
+                        m_out.put(": ", 2);
+                    }
+                    else
+                    {
+                        m_out.put(':');
+                    }
+                    n = f.pos + 1;
+                }
+                else
+                {
+                    n = f.pos;
+                }
+                f.pos = document_data::after(n);
+                break;
+            }
+        }
+    }
+
+  private:
+    void newline(std::size_t level)
+    {
+        if (m_style.pretty)
+        {
+            m_out.put('\n');
+            m_out.put_repeated(m_style.indent_char, level * m_style.indent);
+        }
+    }
+
+    void write_scalar(const node& n)
+    {
+        switch (static_cast<value_t>(n.kind))
+        {
+            case value_t::null:
+                m_out.put("null", 4);
+                break;
+            case value_t::boolean:
+                if ((n.flags & node_flags::is_true) != 0)
+                {
+                    m_out.put("true", 4);
+                }
+                else
+                {
+                    m_out.put("false", 5);
+                }
+                break;
+            case value_t::string:
+                write_string(n);
+                break;
+            case value_t::number_integer:
+            case value_t::number_unsigned:
+            {
+                const char* const token = m_doc.str(n);
+                const std::uint32_t len = number_length(n);
+                if (!m_style.source_numbers && len == 2 && token[0] == '-' && token[1] == '0')
+                {
+                    m_out.put('0'); // parse() reads -0 as the integer 0
+                }
+                else
+                {
+                    m_out.put(token, len);
+                }
+                break;
+            }
+            case value_t::number_float:
+                if (m_style.source_numbers)
+                {
+                    m_out.put(m_doc.str(n), n.len);
+                }
+                else
+                {
+                    write_float(float_value<number_float_t>(m_doc.str(n), n));
+                }
+                break;
+            case value_t::object:    // LCOV_EXCL_LINE (containers are written by dump())
+            case value_t::array:     // LCOV_EXCL_LINE
+            case value_t::binary:    // LCOV_EXCL_LINE (not in a document)
+            case value_t::discarded: // LCOV_EXCL_LINE
+            default:                 // LCOV_EXCL_LINE
+                break;               // LCOV_EXCL_LINE
+        }
+    }
+
+    /// as serializer::dump_float()
+    void write_float(number_float_t x)
+    {
+        if (!std::isfinite(x))
+        {
+            m_out.put("null", 4);
+            return;
+        }
+        write_float(x, std::integral_constant < bool,
+                    (std::numeric_limits<number_float_t>::is_iec559 && std::numeric_limits<number_float_t>::digits == 24 && std::numeric_limits<number_float_t>::max_exponent == 128)
+                    || (std::numeric_limits<number_float_t>::is_iec559 && std::numeric_limits<number_float_t>::digits == 53 && std::numeric_limits<number_float_t>::max_exponent == 1024) > {});
+    }
+
+    void write_float(number_float_t x, std::true_type /*is_ieee_single_or_double*/)
+    {
+        std::array<char, 64> buf{};
+        const char* const end = ::nlohmann::detail::to_chars(buf.data(), buf.data() + buf.size(), x);
+        m_out.put(buf.data(), static_cast<std::size_t>(end - buf.data()));
+    }
+
+    void write_float(number_float_t x, std::false_type /*is_ieee_single_or_double*/)
+    {
+        // other types (e.g. long double) are rare: the library writes them
+        const string_t s = BasicJsonType(x).dump();
+        m_out.put(s.data(), s.size());
+    }
+
+    void write_string(const node& n)
+    {
+        const char* const s = m_doc.str(n);
+        m_out.put('"');
+        if ((n.flags & node_flags::escaped) == 0 && !m_style.ensure_ascii)
+        {
+            // a string without escape sequences has nothing to escape
+            m_out.put(s, n.len);
+        }
+        else if (m_style.ensure_ascii)
+        {
+            write_escaped<true>(reinterpret_cast<const unsigned char*>(s), n.len); // NOLINT(cppcoreguidelines-pro-type-reinterpret-cast)
+        }
+        else
+        {
+            write_escaped<false>(reinterpret_cast<const unsigned char*>(s), n.len); // NOLINT(cppcoreguidelines-pro-type-reinterpret-cast)
+        }
+        m_out.put('"');
+    }
+
+    /// as serializer::dump_escaped() for valid UTF-8 (the view has no other)
+    template<bool EnsureAscii>
+    void write_escaped(const unsigned char* s, std::size_t n)
+    {
+        std::size_t i = 0;
+        while (i < n)
+        {
+            std::size_t run = 0;
+            if (!EnsureAscii)
+            {
+                run = string_bulk_run(s + i, n - i);
+            }
+            else if (is_ascii_copyable(s[i]))
+            {
+                run = find_ascii_copyable_run(s + i, n - i);
+            }
+            if (run != 0)
+            {
+                m_out.put(reinterpret_cast<const char*>(s + i), run); // NOLINT(cppcoreguidelines-pro-type-reinterpret-cast)
+                i += run;
+                continue;
+            }
+            std::uint32_t codepoint = s[i];
+            std::size_t len = 1;
+            if (codepoint >= 0xC0)
+            {
+                len = 2;
+                if (codepoint >= 0xE0)
+                {
+                    len = codepoint >= 0xF0 ? 4 : 3;
+                }
+                codepoint &= 0xFFu >> (len + 1);
+                for (std::size_t k = 1; k < len; ++k)
+                {
+                    codepoint = (codepoint << 6u) | (s[i + k] & 0x3Fu);
+                }
+            }
+            write_codepoint<EnsureAscii>(codepoint, s + i, len);
+            i += len;
+        }
+    }
+
+    template<bool EnsureAscii>
+    void write_codepoint(std::uint32_t codepoint, const unsigned char* bytes, std::size_t len)
+    {
+        switch (codepoint)
+        {
+            case 0x08:
+                m_out.put("\\b", 2);
+                return;
+            case 0x09:
+                m_out.put("\\t", 2);
+                return;
+            case 0x0A:
+                m_out.put("\\n", 2);
+                return;
+            case 0x0C:
+                m_out.put("\\f", 2);
+                return;
+            case 0x0D:
+                m_out.put("\\r", 2);
+                return;
+            case 0x22:
+                m_out.put("\\\"", 2);
+                return;
+            case 0x5C:
+                m_out.put("\\\\", 2);
+                return;
+            default:
+                break;
+        }
+        if (codepoint <= 0x1F || (EnsureAscii && codepoint >= 0x7F))
+        {
+            if (codepoint <= 0xFFFF)
+            {
+                write_u_escape(codepoint);
+            }
+            else
+            {
+                write_u_escape(0xD7C0u + (codepoint >> 10u));
+                write_u_escape(0xDC00u + (codepoint & 0x3FFu));
+            }
+            return;
+        }
+        m_out.put(reinterpret_cast<const char*>(bytes), len); // NOLINT(cppcoreguidelines-pro-type-reinterpret-cast) LCOV_EXCL_LINE (printable characters are copied in runs)
+    }
+
+    void write_u_escape(std::uint32_t u)
+    {
+        static constexpr const char* hex = "0123456789abcdef";
+        const std::array<char, 6> e = {{'\\', 'u', hex[(u >> 12u) & 0xFu], hex[(u >> 8u) & 0xFu], hex[(u >> 4u) & 0xFu], hex[u & 0xFu]}};
+        m_out.put(e.data(), e.size());
+    }
+
+    const document_data& m_doc;
+    output_buffer<string_t> m_out;
+    const dump_style m_style;
+};
+
+}  // namespace view
+}  // namespace detail
+NLOHMANN_JSON_NAMESPACE_END
@@ -29,6 +29,9 @@
 #include <iterator> // distance, input_iterator_tag, iterator_traits
 #include <map> // map
 #include <memory> // unique_ptr
+#ifndef JSON_NO_IO
+    #include <ostream> // ostream
+#endif
 #include <string> // string
 #include <tuple> // tuple_element, tuple_size
 #include <type_traits> // decay, enable_if, integral_constant, is_arithmetic, is_base_of, is_integral, is_same, remove_cv, remove_extent
@@ -53,6 +56,7 @@
 #include <nlohmann/detail/view/materialize.hpp>
 #include <nlohmann/detail/view/node.hpp>
 #include <nlohmann/detail/view/pointer.hpp>
+#include <nlohmann/detail/view/serializer.hpp>
 #include <nlohmann/detail/view/string_ref.hpp>
 #include <nlohmann/detail/view/value.hpp>

@@ -547,6 +551,58 @@ class basic_json_view
        return {m_doc->str(*m_node), detail::view::number_length(*m_node)};
    }

+    ///////////////////
+    // serialization //
+    ///////////////////
+
+    /// how dump() writes numbers
+    enum class number_format
+    {
+        /// as basic_json::dump(): integers canonically, floats with the
+        /// library's shortest round-trip digits ("1.5", "100.0", "1e+100")
+        shortest,
+        /// the number text of the source as it is ("1.50", "1E2", "-0", all
+        /// digits of a long integer)
+        source,
+    };
+
+    /// the text of this value; with number_format::shortest, the output of
+    /// ordered_json::parse(text).dump() with the same arguments (members in
+    /// document order, all of them should a key occur more than once)
+    string_t dump(const int indent = -1, const char indent_char = ' ', const bool ensure_ascii = false,
+                  const number_format numbers = number_format::shortest) const
+    {
+        string_t out;
+        if (m_node == nullptr)
+        {
+            out = "<discarded>"; // as basic_json::dump() of a discarded value
+            return out;
+        }
+        detail::view::dump_style style;
+        style.pretty = indent >= 0;
+        style.indent = indent >= 0 ? static_cast<std::size_t>(indent) : 0;
+        style.indent_char = indent_char;
+        style.ensure_ascii = ensure_ascii;
+        style.source_numbers = numbers == number_format::source;
+        // the compact text is about as long as the source text of the value
+        const std::size_t estimate = source_extent() + (style.pretty ? source_extent() / 2 : 0) + 64;
+        detail::view::view_serializer<BasicJsonType>(*m_doc, out, estimate, style).dump(m_node);
+        return out;
+    }
+
+#ifndef JSON_NO_IO
+    /// as operator<< of basic_json: a stream width > 0 is the indentation,
+    /// the fill character the indentation character
+    friend std::ostream& operator<<(std::ostream& o, const basic_json_view& v)
+    {
+        const bool pretty = o.width() > 0;
+        const auto indentation = pretty ? o.width() : 0;
+        o.width(0);
+        const string_t s = v.dump(pretty ? static_cast<int>(indentation) : -1, o.fill());
+        return o.write(s.data(), static_cast<std::streamsize>(s.size()));
+    }
+#endif
+
    /////////////////
    // materialize //
    /////////////////
@@ -579,6 +635,23 @@ class basic_json_view
        : m_doc(d), m_node(n)
    {}

+    /// the number of source bytes of this value (estimated for values with
+    /// decoded strings)
+    std::size_t source_extent() const noexcept
+    {
+        const node* const next = document_data::after(m_node);
+        const bool in_source = (m_node->flags & detail::view::node_flags::storage) == 0;
+        if (!in_source)
+        {
+            return m_node->len;
+        }
+        if (next != m_doc->tape + m_doc->tape_size && (next->flags & detail::view::node_flags::storage) == 0 && next->off >= m_node->off)
+        {
+            return next->off - m_node->off;
+        }
+        return m_doc->size - m_node->off;
+    }
+
    /// the value of the first member with this key, or a discarded view
    /// (object required)
    NLOHMANN_VIEW_ALWAYS_INLINE basic_json_view lookup(string_view_t key) const noexcept
@@ -29,6 +29,9 @@
 #include <iterator> // distance, input_iterator_tag, iterator_traits
 #include <map> // map
 #include <memory> // unique_ptr
+#ifndef JSON_NO_IO
+    #include <ostream> // ostream
+#endif
 #include <string> // string
 #include <tuple> // tuple_element, tuple_size
 #include <type_traits> // decay, enable_if, integral_constant, is_arithmetic, is_base_of, is_integral, is_same, remove_cv, remove_extent
@@ -2563,6 +2566,431 @@ View resolve_pointer(View cur, const Tokens& tokens, pointer_mode mode)
 }  // namespace detail
 NLOHMANN_JSON_NAMESPACE_END

+// #include <nlohmann/detail/view/serializer.hpp>
+//     __ _____ _____ _____
+//  __|  |   __|     |   | |  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
+
+
+
+#include <algorithm> // max
+#include <array> // array
+#include <cmath> // isfinite
+#include <cstddef> // size_t
+#include <cstdint> // uint8_t, uint32_t
+#include <cstring> // memcpy, memset
+#include <limits> // numeric_limits
+#include <type_traits> // integral_constant
+#include <vector> // vector
+
+// #include <nlohmann/json.hpp>
+// #include <nlohmann/detail/view/document_data.hpp>
+
+// #include <nlohmann/detail/view/macro_scope.hpp>
+
+// #include <nlohmann/detail/view/node.hpp>
+
+// #include <nlohmann/detail/view/number.hpp>
+
+
+NLOHMANN_JSON_NAMESPACE_BEGIN
+namespace detail
+{
+namespace view
+{
+
+/// append-only output buffer: writes through a raw pointer into a string that
+/// is resized ahead, and trimmed by finish()
+template<typename StringType>
+class output_buffer
+{
+  public:
+    output_buffer(StringType& out, std::size_t estimate)
+        : m_out(sized(out, estimate))
+        , m_pos(&m_out[0])
+        , m_end(m_pos + m_out.size())
+    {}
+
+    void finish()
+    {
+        m_out.resize(static_cast<std::size_t>(m_pos - m_out.data()));
+    }
+
+    NLOHMANN_VIEW_ALWAYS_INLINE void reserve(std::size_t n)
+    {
+        if (NLOHMANN_VIEW_UNLIKELY(static_cast<std::size_t>(m_end - m_pos) < n))
+        {
+            grow(n);
+        }
+    }
+
+    NLOHMANN_VIEW_ALWAYS_INLINE void put(char c)
+    {
+        reserve(1);
+        *m_pos++ = c;
+    }
+
+    NLOHMANN_VIEW_ALWAYS_INLINE void put(const char* s, std::size_t n)
+    {
+        reserve(n);
+        std::memcpy(m_pos, s, n);
+        m_pos += n;
+    }
+
+    void put_repeated(char c, std::size_t n)
+    {
+        reserve(n);
+        std::memset(m_pos, c, n);
+        m_pos += n;
+    }
+
+  private:
+    static StringType& sized(StringType& out, std::size_t estimate)
+    {
+        out.resize((std::max)(estimate, static_cast<std::size_t>(64)));
+        return out;
+    }
+
+    NLOHMANN_VIEW_NOINLINE void grow(std::size_t n)
+    {
+        const auto used = static_cast<std::size_t>(m_pos - m_out.data());
+        m_out.resize((std::max)(m_out.size() * 2, used + n + 256));
+        m_pos = &m_out[0] + used;
+        m_end = &m_out[0] + m_out.size();
+    }
+
+    StringType& m_out;
+    char* m_pos;
+    char* m_end;
+};
+
+/// how the view's dump() writes a value
+struct dump_style
+{
+    bool pretty = false;           ///< indent >= 0
+    std::size_t indent = 0;        ///< characters per level
+    char indent_char = ' ';
+    bool ensure_ascii = false;
+    bool source_numbers = false;   ///< copy number tokens from the source
+};
+
+/*!
+@brief write a view's subtree as basic_json::dump() writes the value
+
+The output of a subtree equals ordered_json::parse(text).dump() of it for
+the same arguments (members in document order): strings are escaped by the
+same rules, with the library's scanning kernels; floats are written with
+the library's conversion; integers are copied from the source, where they
+are canonical (except "-0", which parse() reads as 0). The walk is
+iterative, so the nesting depth is limited by memory only.
+*/
+template<typename BasicJsonType>
+class view_serializer
+{
+    using string_t = typename BasicJsonType::string_t;
+    using number_float_t = typename BasicJsonType::number_float_t;
+
+  public:
+    view_serializer(const document_data& d, string_t& out, std::size_t estimate, const dump_style& style)
+        : m_doc(d), m_out(out, estimate), m_style(style)
+    {}
+
+    void dump(const node* root)
+    {
+        struct frame
+        {
+            const node* pos; ///< next element, or key of the next member
+            const node* end;
+            bool object;
+            bool first;  ///< nothing written yet
+        };
+        std::vector<frame> stack;
+        const node* n = root;
+        for (;;)
+        {
+            // write the value at n
+            if (is_container(*n))
+            {
+                const bool object = n->kind == static_cast<std::uint8_t>(value_t::object);
+                if (n->len == 0)
+                {
+                    m_out.put(object ? "{}" : "[]", 2);
+                }
+                else
+                {
+                    m_out.put(object ? '{' : '[');
+                    stack.push_back(frame{document_data::first_child(n), document_data::child_end(n), object, true});
+                }
+            }
+            else
+            {
+                write_scalar(*n);
+            }
+
+            // go to the next value: close finished containers, then separate
+            for (;;)
+            {
+                if (stack.empty())
+                {
+                    m_out.finish();
+                    return;
+                }
+                frame& f = stack.back();
+                if (f.pos == f.end)
+                {
+                    const bool object = f.object;
+                    stack.pop_back();
+                    newline(stack.size());
+                    m_out.put(object ? '}' : ']');
+                    continue;
+                }
+                if (!f.first)
+                {
+                    m_out.put(',');
+                }
+                f.first = false;
+                newline(stack.size());
+                if (f.object)
+                {
+                    write_string(*f.pos);
+                    if (m_style.pretty)
+                    {
+                        m_out.put(": ", 2);
+                    }
+                    else
+                    {
+                        m_out.put(':');
+                    }
+                    n = f.pos + 1;
+                }
+                else
+                {
+                    n = f.pos;
+                }
+                f.pos = document_data::after(n);
+                break;
+            }
+        }
+    }
+
+  private:
+    void newline(std::size_t level)
+    {
+        if (m_style.pretty)
+        {
+            m_out.put('\n');
+            m_out.put_repeated(m_style.indent_char, level * m_style.indent);
+        }
+    }
+
+    void write_scalar(const node& n)
+    {
+        switch (static_cast<value_t>(n.kind))
+        {
+            case value_t::null:
+                m_out.put("null", 4);
+                break;
+            case value_t::boolean:
+                if ((n.flags & node_flags::is_true) != 0)
+                {
+                    m_out.put("true", 4);
+                }
+                else
+                {
+                    m_out.put("false", 5);
+                }
+                break;
+            case value_t::string:
+                write_string(n);
+                break;
+            case value_t::number_integer:
+            case value_t::number_unsigned:
+            {
+                const char* const token = m_doc.str(n);
+                const std::uint32_t len = number_length(n);
+                if (!m_style.source_numbers && len == 2 && token[0] == '-' && token[1] == '0')
+                {
+                    m_out.put('0'); // parse() reads -0 as the integer 0
+                }
+                else
+                {
+                    m_out.put(token, len);
+                }
+                break;
+            }
+            case value_t::number_float:
+                if (m_style.source_numbers)
+                {
+                    m_out.put(m_doc.str(n), n.len);
+                }
+                else
+                {
+                    write_float(float_value<number_float_t>(m_doc.str(n), n));
+                }
+                break;
+            case value_t::object:    // LCOV_EXCL_LINE (containers are written by dump())
+            case value_t::array:     // LCOV_EXCL_LINE
+            case value_t::binary:    // LCOV_EXCL_LINE (not in a document)
+            case value_t::discarded: // LCOV_EXCL_LINE
+            default:                 // LCOV_EXCL_LINE
+                break;               // LCOV_EXCL_LINE
+        }
+    }
+
+    /// as serializer::dump_float()
+    void write_float(number_float_t x)
+    {
+        if (!std::isfinite(x))
+        {
+            m_out.put("null", 4);
+            return;
+        }
+        write_float(x, std::integral_constant < bool,
+                    (std::numeric_limits<number_float_t>::is_iec559 && std::numeric_limits<number_float_t>::digits == 24 && std::numeric_limits<number_float_t>::max_exponent == 128)
+                    || (std::numeric_limits<number_float_t>::is_iec559 && std::numeric_limits<number_float_t>::digits == 53 && std::numeric_limits<number_float_t>::max_exponent == 1024) > {});
+    }
+
+    void write_float(number_float_t x, std::true_type /*is_ieee_single_or_double*/)
+    {
+        std::array<char, 64> buf{};
+        const char* const end = ::nlohmann::detail::to_chars(buf.data(), buf.data() + buf.size(), x);
+        m_out.put(buf.data(), static_cast<std::size_t>(end - buf.data()));
+    }
+
+    void write_float(number_float_t x, std::false_type /*is_ieee_single_or_double*/)
+    {
+        // other types (e.g. long double) are rare: the library writes them
+        const string_t s = BasicJsonType(x).dump();
+        m_out.put(s.data(), s.size());
+    }
+
+    void write_string(const node& n)
+    {
+        const char* const s = m_doc.str(n);
+        m_out.put('"');
+        if ((n.flags & node_flags::escaped) == 0 && !m_style.ensure_ascii)
+        {
+            // a string without escape sequences has nothing to escape
+            m_out.put(s, n.len);
+        }
+        else if (m_style.ensure_ascii)
+        {
+            write_escaped<true>(reinterpret_cast<const unsigned char*>(s), n.len); // NOLINT(cppcoreguidelines-pro-type-reinterpret-cast)
+        }
+        else
+        {
+            write_escaped<false>(reinterpret_cast<const unsigned char*>(s), n.len); // NOLINT(cppcoreguidelines-pro-type-reinterpret-cast)
+        }
+        m_out.put('"');
+    }
+
+    /// as serializer::dump_escaped() for valid UTF-8 (the view has no other)
+    template<bool EnsureAscii>
+    void write_escaped(const unsigned char* s, std::size_t n)
+    {
+        std::size_t i = 0;
+        while (i < n)
+        {
+            std::size_t run = 0;
+            if (!EnsureAscii)
+            {
+                run = string_bulk_run(s + i, n - i);
+            }
+            else if (is_ascii_copyable(s[i]))
+            {
+                run = find_ascii_copyable_run(s + i, n - i);
+            }
+            if (run != 0)
+            {
+                m_out.put(reinterpret_cast<const char*>(s + i), run); // NOLINT(cppcoreguidelines-pro-type-reinterpret-cast)
+                i += run;
+                continue;
+            }
+            std::uint32_t codepoint = s[i];
+            std::size_t len = 1;
+            if (codepoint >= 0xC0)
+            {
+                len = 2;
+                if (codepoint >= 0xE0)
+                {
+                    len = codepoint >= 0xF0 ? 4 : 3;
+                }
+                codepoint &= 0xFFu >> (len + 1);
+                for (std::size_t k = 1; k < len; ++k)
+                {
+                    codepoint = (codepoint << 6u) | (s[i + k] & 0x3Fu);
+                }
+            }
+            write_codepoint<EnsureAscii>(codepoint, s + i, len);
+            i += len;
+        }
+    }
+
+    template<bool EnsureAscii>
+    void write_codepoint(std::uint32_t codepoint, const unsigned char* bytes, std::size_t len)
+    {
+        switch (codepoint)
+        {
+            case 0x08:
+                m_out.put("\\b", 2);
+                return;
+            case 0x09:
+                m_out.put("\\t", 2);
+                return;
+            case 0x0A:
+                m_out.put("\\n", 2);
+                return;
+            case 0x0C:
+                m_out.put("\\f", 2);
+                return;
+            case 0x0D:
+                m_out.put("\\r", 2);
+                return;
+            case 0x22:
+                m_out.put("\\\"", 2);
+                return;
+            case 0x5C:
+                m_out.put("\\\\", 2);
+                return;
+            default:
+                break;
+        }
+        if (codepoint <= 0x1F || (EnsureAscii && codepoint >= 0x7F))
+        {
+            if (codepoint <= 0xFFFF)
+            {
+                write_u_escape(codepoint);
+            }
+            else
+            {
+                write_u_escape(0xD7C0u + (codepoint >> 10u));
+                write_u_escape(0xDC00u + (codepoint & 0x3FFu));
+            }
+            return;
+        }
+        m_out.put(reinterpret_cast<const char*>(bytes), len); // NOLINT(cppcoreguidelines-pro-type-reinterpret-cast) LCOV_EXCL_LINE (printable characters are copied in runs)
+    }
+
+    void write_u_escape(std::uint32_t u)
+    {
+        static constexpr const char* hex = "0123456789abcdef";
+        const std::array<char, 6> e = {{'\\', 'u', hex[(u >> 12u) & 0xFu], hex[(u >> 8u) & 0xFu], hex[(u >> 4u) & 0xFu], hex[u & 0xFu]}};
+        m_out.put(e.data(), e.size());
+    }
+
+    const document_data& m_doc;
+    output_buffer<string_t> m_out;
+    const dump_style m_style;
+};
+
+}  // namespace view
+}  // namespace detail
+NLOHMANN_JSON_NAMESPACE_END
+
 // #include <nlohmann/detail/view/string_ref.hpp>
 //     __ _____ _____ _____
 //  __|  |   __|     |   | |  JSON for Modern C++
@@ -3284,6 +3712,58 @@ class basic_json_view
        return {m_doc->str(*m_node), detail::view::number_length(*m_node)};
    }

+    ///////////////////
+    // serialization //
+    ///////////////////
+
+    /// how dump() writes numbers
+    enum class number_format
+    {
+        /// as basic_json::dump(): integers canonically, floats with the
+        /// library's shortest round-trip digits ("1.5", "100.0", "1e+100")
+        shortest,
+        /// the number text of the source as it is ("1.50", "1E2", "-0", all
+        /// digits of a long integer)
+        source,
+    };
+
+    /// the text of this value; with number_format::shortest, the output of
+    /// ordered_json::parse(text).dump() with the same arguments (members in
+    /// document order, all of them should a key occur more than once)
+    string_t dump(const int indent = -1, const char indent_char = ' ', const bool ensure_ascii = false,
+                  const number_format numbers = number_format::shortest) const
+    {
+        string_t out;
+        if (m_node == nullptr)
+        {
+            out = "<discarded>"; // as basic_json::dump() of a discarded value
+            return out;
+        }
+        detail::view::dump_style style;
+        style.pretty = indent >= 0;
+        style.indent = indent >= 0 ? static_cast<std::size_t>(indent) : 0;
+        style.indent_char = indent_char;
+        style.ensure_ascii = ensure_ascii;
+        style.source_numbers = numbers == number_format::source;
+        // the compact text is about as long as the source text of the value
+        const std::size_t estimate = source_extent() + (style.pretty ? source_extent() / 2 : 0) + 64;
+        detail::view::view_serializer<BasicJsonType>(*m_doc, out, estimate, style).dump(m_node);
+        return out;
+    }
+
+#ifndef JSON_NO_IO
+    /// as operator<< of basic_json: a stream width > 0 is the indentation,
+    /// the fill character the indentation character
+    friend std::ostream& operator<<(std::ostream& o, const basic_json_view& v)
+    {
+        const bool pretty = o.width() > 0;
+        const auto indentation = pretty ? o.width() : 0;
+        o.width(0);
+        const string_t s = v.dump(pretty ? static_cast<int>(indentation) : -1, o.fill());
+        return o.write(s.data(), static_cast<std::streamsize>(s.size()));
+    }
+#endif
+
    /////////////////
    // materialize //
    /////////////////
@@ -3316,6 +3796,23 @@ class basic_json_view
        : m_doc(d), m_node(n)
    {}

+    /// the number of source bytes of this value (estimated for values with
+    /// decoded strings)
+    std::size_t source_extent() const noexcept
+    {
+        const node* const next = document_data::after(m_node);
+        const bool in_source = (m_node->flags & detail::view::node_flags::storage) == 0;
+        if (!in_source)
+        {
+            return m_node->len;
+        }
+        if (next != m_doc->tape + m_doc->tape_size && (next->flags & detail::view::node_flags::storage) == 0 && next->off >= m_node->off)
+        {
+            return next->off - m_node->off;
+        }
+        return m_doc->size - m_node->off;
+    }
+
    /// the value of the first member with this key, or a discarded view
    /// (object required)
    NLOHMANN_VIEW_ALWAYS_INLINE basic_json_view lookup(string_view_t key) const noexcept
@@ -21,6 +21,7 @@ Micro-benchmarks for parsing, serialization and the binary formats, written with
 | `ViewParseIndented` | as `ParseIndented`, with a reused `json_document` |
 | `ViewAccept` | validate with `json_document::accept`; compare with `Accept` |
 | `ViewMaterialize` | convert a parsed `json_document` into a `json` value |
+| `ViewDump` | serialize a parsed `json_document`; compare with `Dump` |

 The input files are those of [nativejson-benchmark](https://github.com/miloyip/nativejson-benchmark) (`canada`,
 `citm_catalog`, `twitter`), a large `jeopardy` file, and number-heavy files (`floats`, `signed_ints`, ...).
@@ -144,3 +144,37 @@ static void ViewMaterialize(benchmark::State& state, const char* filename)
    state.SetBytesProcessed(state.iterations() * str.size());
 }
 JSON_VIEW_BENCHMARK_FILES(ViewMaterialize);
+
+//////////////////////////////////////////////////////////////////////////////
+// serialize a parsed document (compare with Dump)
+//////////////////////////////////////////////////////////////////////////////
+
+static void ViewDump(benchmark::State& state, const char* filename, int indent)
+{
+    const std::string str = read_file(filename);
+    const json_document d = json_document::parse(str);
+
+    while (state.KeepRunning())
+    {
+        std::string output = d.root().dump(indent);
+        benchmark::DoNotOptimize(output);
+    }
+
+    state.SetBytesProcessed(state.iterations() * d.root().dump(indent).size());
+}
+BENCHMARK_CAPTURE(ViewDump, jeopardy / -,          TEST_DATA_DIRECTORY "/jeopardy/jeopardy.json",                 -1);
+BENCHMARK_CAPTURE(ViewDump, jeopardy / 4,          TEST_DATA_DIRECTORY "/jeopardy/jeopardy.json",                 4);
+BENCHMARK_CAPTURE(ViewDump, canada / -,            TEST_DATA_DIRECTORY "/nativejson-benchmark/canada.json",       -1);
+BENCHMARK_CAPTURE(ViewDump, canada / 4,            TEST_DATA_DIRECTORY "/nativejson-benchmark/canada.json",       4);
+BENCHMARK_CAPTURE(ViewDump, citm_catalog / -,      TEST_DATA_DIRECTORY "/nativejson-benchmark/citm_catalog.json", -1);
+BENCHMARK_CAPTURE(ViewDump, citm_catalog / 4,      TEST_DATA_DIRECTORY "/nativejson-benchmark/citm_catalog.json", 4);
+BENCHMARK_CAPTURE(ViewDump, twitter / -,           TEST_DATA_DIRECTORY "/nativejson-benchmark/twitter.json",      -1);
+BENCHMARK_CAPTURE(ViewDump, twitter / 4,           TEST_DATA_DIRECTORY "/nativejson-benchmark/twitter.json",      4);
+BENCHMARK_CAPTURE(ViewDump, floats / -,            TEST_DATA_DIRECTORY "/regression/floats.json",                 -1);
+BENCHMARK_CAPTURE(ViewDump, floats / 4,            TEST_DATA_DIRECTORY "/regression/floats.json",                 4);
+BENCHMARK_CAPTURE(ViewDump, signed_ints / -,       TEST_DATA_DIRECTORY "/regression/signed_ints.json",            -1);
+BENCHMARK_CAPTURE(ViewDump, signed_ints / 4,       TEST_DATA_DIRECTORY "/regression/signed_ints.json",            4);
+BENCHMARK_CAPTURE(ViewDump, unsigned_ints / -,     TEST_DATA_DIRECTORY "/regression/unsigned_ints.json",          -1);
+BENCHMARK_CAPTURE(ViewDump, unsigned_ints / 4,     TEST_DATA_DIRECTORY "/regression/unsigned_ints.json",          4);
+BENCHMARK_CAPTURE(ViewDump, small_signed_ints / -, TEST_DATA_DIRECTORY "/regression/small_signed_ints.json",      -1);
+BENCHMARK_CAPTURE(ViewDump, small_signed_ints / 4, TEST_DATA_DIRECTORY "/regression/small_signed_ints.json",      4);
@@ -22,6 +22,7 @@ using nlohmann::ordered_json_view;
 #include <cstdint>
 #include <cstdio>
 #include <cstring>
+#include <iomanip>
 #include <iterator>
 #include <list>
 #include <map>
@@ -1081,3 +1082,106 @@ TEST_CASE("json_view JSON pointers")
    }
 #endif
 }
+
+TEST_CASE("json_view dump")
+{
+    SECTION("the output of ordered_json::dump()")
+    {
+        generator g;
+        for (int i = 0; i < 2000; ++i)
+        {
+            std::string text;
+            g.value(text, 0);
+            const ordered_json_document d = ordered_json_document::parse(text);
+            if (has_duplicate_keys(d.root()))
+            {
+                continue;
+            }
+            CAPTURE(text);
+            const ordered_json j = ordered_json::parse(text);
+            for (const int indent :
+                    {
+                        -1, 0, 2
+                    })
+            {
+                for (const bool ensure_ascii :
+                        {
+                            false, true
+                        })
+                {
+                    CHECK(d.root().dump(indent, i % 2 == 0 ? ' ' : '\t', ensure_ascii) == j.dump(indent, i % 2 == 0 ? ' ' : '\t', ensure_ascii));
+                }
+            }
+            // also of each element
+            for (const ordered_json_view e : d.root())
+            {
+                CHECK(e.dump() == e.materialize().dump());
+            }
+        }
+    }
+
+    SECTION("strings")
+    {
+        const std::string text = R"(["plain", "\u0000\u0001\u001f\u007f\u0080é€😀", "\"\\\/\b\f\n\r\t", "aéあ😀b", "long text beyond the eight bytes of a word \n with an escape in the middle"])";
+        const ordered_json_document d = ordered_json_document::parse(text);
+        const ordered_json j = ordered_json::parse(text);
+        CHECK(d.root().dump() == j.dump());
+        CHECK(d.root().dump(-1, ' ', true) == j.dump(-1, ' ', true));
+        CHECK(d.root().dump(4, ' ', true) == j.dump(4, ' ', true));
+        const ordered_json_document keys = ordered_json_document::parse(R"({"é\n": {"\"": [], "": {}}})");
+        CHECK(keys.root().dump(2, ' ', true) == ordered_json::parse(R"({"é\n": {"\"": [], "": {}}})").dump(2, ' ', true));
+    }
+
+    SECTION("numbers")
+    {
+        const std::string text = "[1.50, 1E2, -0, -0.0, 123456789012345678901234567890, 18446744073709551615, -9223372036854775808, 0.1, 1e-7, 5e-324]";
+        const json_document d = json_document::parse(text);
+        CHECK(d.root().dump() == json::parse(text).dump());
+        CHECK(d.root().dump() == "[1.5,100.0,0,-0.0,1.2345678901234568e+29,18446744073709551615,-9223372036854775808,0.1,1e-07,5e-324]");
+        CHECK(d.root().dump(-1, ' ', false, json_view::number_format::source) == "[1.50,1E2,-0,-0.0,123456789012345678901234567890,18446744073709551615,-9223372036854775808,0.1,1e-7,5e-324]");
+
+        // random doubles, written as parse() and dump() would
+        std::mt19937_64 rng(1170); // NOLINT(cert-msc32-c,cert-msc51-cpp,bugprone-random-generator-seed)
+        std::string many = "[";
+        for (int i = 0; i < 5000; ++i)
+        {
+            const std::uint64_t bits = rng();
+            double x = 0;
+            std::memcpy(&x, &bits, sizeof(x));
+            if (std::isfinite(x))
+            {
+                many += (many.size() > 1 ? "," : "") + json(x).dump();
+            }
+        }
+        many += ']';
+        CHECK(json_document::parse(many).root().dump() == json::parse(many).dump());
+
+        using json_float = nlohmann::basic_json<std::map, std::vector, std::string, bool, std::int64_t, std::uint64_t, float>;
+        CHECK(nlohmann::basic_json_document<json_float>::parse("[0.1, 1.5e10, 3.4028235e38]").root().dump() == json_float::parse("[0.1, 1.5e10, 3.4028235e38]").dump());
+    }
+
+    SECTION("members in document order, all of them")
+    {
+        const json_document d = json_document::parse(R"({"b": 1, "a": 2, "b": 3})");
+        CHECK(d.root().dump() == R"({"b":1,"a":2,"b":3})");
+        CHECK(d.root().dump(1) == "{\n \"b\": 1,\n \"a\": 2,\n \"b\": 3\n}");
+    }
+
+    SECTION("deep nesting")
+    {
+        const std::string deep = std::string(100000, '[') + std::string(100000, ']');
+        CHECK(json_document::parse(deep).root().dump() == deep);
+    }
+
+    SECTION("streams and discarded views")
+    {
+        const json_document d = json_document::parse(R"({"a": [1, 2]})");
+        std::ostringstream compact;
+        compact << d.root();
+        CHECK(compact.str() == R"({"a":[1,2]})");
+        std::ostringstream pretty;
+        pretty << std::setw(2) << std::setfill('.') << d.root() << d.root()["a"];
+        CHECK(pretty.str() == "{\n..\"a\": [\n....1,\n....2\n..]\n}[1,2]");
+        CHECK(json_view().dump() == json(json::value_t::discarded).dump());
+    }
+}
Author	SHA1	Message	Date
Niels Lohmann	bc56ac6d9a	Format the dump() example with the pinned astyle The "check" job runs astyle over the documentation examples once it gets past the amalgamation step. Signed-off-by: Niels Lohmann <mail@nlohmann.me>	2026-09-30 21:01:46 +02:00
Niels Lohmann	bfb2b0cb48	Mark the cases of the view's serializer that tests cannot reach Signed-off-by: Niels Lohmann <mail@nlohmann.me>	2026-09-30 21:01:45 +02:00
Niels Lohmann	8cccae029b	Address the clang-tidy findings of dump() The output buffer initializes its members in the initializer list, and the escaping has no nested conditional operators; the test marks a fixed seed. Signed-off-by: Niels Lohmann <mail@nlohmann.me>	2026-09-30 21:01:44 +02:00
Niels Lohmann	c7e534d41e	Document dump() of json_view - API pages for dump, number_format, and operator<< of basic_json_view, linked both ways with the basic_json pages - the feature page describes document order and number_format::source - the examples show when the view helps: forwarding part of a message and writing numbers exactly as they were read Signed-off-by: Niels Lohmann <mail@nlohmann.me>	2026-09-30 21:01:43 +02:00
Niels Lohmann	83d72fd7a7	Add dump() to json_view basic_json_view::dump(indent, indent_char, ensure_ascii, number_format) writes the text of a value as ordered_json::parse(text).dump() writes it for the same arguments: members in document order (all of them, should a key occur more than once), strings escaped by the same rules and with the library's scanning kernels, floats with the library's conversion, and integers copied from the source, where they are canonical except "-0". With number_format::source, numbers are copied as they appear in the source ("1.50", "1E2", "-0", all digits of long integers). operator<< takes the indentation from the stream width, as for basic_json. The writer (detail/view/serializer.hpp) writes through a raw pointer into a string sized from the source extent of the value, and walks the index iteratively, so the nesting depth is limited by memory only. Tests compare the output of 2,000 generated documents with ordered_json::dump() for several indentations and ensure_ascii, strings with every kind of escape, numbers (5,000 random doubles, float as number_float_t), duplicate keys, 100,000 levels of nesting, and streams. ViewDump joins the benchmarks. Signed-off-by: Niels Lohmann <mail@nlohmann.me>	2026-09-30 21:01:42 +02:00