Flatten deeply nested values without recursing per nesting level

[nlohmann]

Fixes the remaining part of #5393.

#5393 reported three functions that recurse once per nesting level: diff(), merge_patch() and flatten(). #5547 and #5548 fixed the first two, and the issue was closed when #5548 merged. json_pointer::flatten() is still recursive on develop, so

json::parse(std::string(100000, '[') + "0" + std::string(100000, ']')).flatten();

still crashes with SIGSEGV (exit 139, macOS/arm64, -O2).

Change

json_pointer::flatten() now walks the value with an explicit stack of frames. Like diff_iteratively, it keeps the path in one buffer that grows and shrinks with the stack. The signature and the output stay the same, including the entry order of an ordered_json result.

Unlike diff and merge_patch, this version doesn't recurse first and switch to the explicit stack at recursion_depth_limit(). It has one code path. The old version built a new path string for every child, which costs time quadratic in the depth. Sharing one buffer avoids that, so the iterative version is no slower even on shallow values.

Benchmark

Best-of-7 time per call to flatten(), -O2, Apple clang 21, arm64. Old and new produced identical dump() output in every case.

input	type	old	new	new/old
wide, ~1.2 MB, 80,000 leaves	json	15.20 ms	14.55 ms	0.96
wide	ordered_json	2511 ms	2514 ms	1.00
nested, depth 7, 59,296 leaves	json	15.31 ms	13.13 ms	0.86
nested	ordered_json	3406 ms	3416 ms	1.00
10,000 nested arrays	json	4.80 ms	0.183 ms	0.04
10,000 nested objects	json	4.76 ms	0.177 ms	0.04

Tests

New TEST_CASE("flatten of structured values") in unit-json_pointer.cpp:

• 100,000-level arrays and objects flatten to a single entry with the full path
• interleaved objects and arrays, with empty containers and keys that need escaping (~, /), compared with a result written out by hand
• entry order of an ordered_json result

Locally: test-json_pointer_cpp11, test-json_pointer_cpp20 and test-json_patch_cpp11 pass, and the build shows no warnings.

The round-trip through unflatten() is only tested at 500 levels. At 100,000 levels unflatten() used about 9.6 GB of memory and was still running after 8 minutes, apparently because it copies pointer prefixes in an amount that grows quadratically with the depth. That's a separate problem and isn't touched here.

Public API

No breaking changes: flatten() keeps its signature and its output, and only the internals of json_pointer::flatten change.

🤖 Generated with Claude Code

[gregmarr]

emplace_back?

[nlohmann]

Done in e82b29b: the frame got a constructor (C++11 can't emplace_back an aggregate), and both call sites use emplace_back now.

Written by Claude Code.

[gregmarr]

emplace_back?

[nlohmann]

Done in e82b29b: the frame got a constructor (C++11 can't emplace_back an aggregate), and both call sites use emplace_back now.

Written by Claude Code.