Read binary strings/blobs in bulk chunks with a memcpy fast path

[nlohmann]

Summary

The binary reader (binary_reader::get_string / get_binary) read CBOR/MessagePack/BSON/UBJSON strings and byte arrays one byte at a time via get() + push_back(). Worse, the iterator input adapter's get_elements() fallback (input_adapters.hpp) was itself a per-byte loop, so even contiguous inputs (const char*, std::vector/std::string iterators) never benefited from a block copy — get_number's multi-byte reads didn't either.

Changes

1. iterator_input_adapter::get_elements() contiguous fast path. When the underlying iterator refers to a contiguous range, the whole requested range is copied with a single std::memcpy. Contiguity is detected via std::is_pointer on all standards and, under C++20, additionally via std::contiguous_iterator (so std::vector/std::string iterators qualify too). Non-contiguous iterators keep the element-by-element loop.

2. get_string() / get_binary() read in bounded chunks. Both now delegate to a shared get_bytes() that pulls data through get_elements() in capped chunks instead of byte by byte. Capping the chunk size preserves the deliberate "don't reserve(len) for an untrusted length" DoS protection (peak allocation stays bounded regardless of the announced length) while turning the inner loop into block copies. The min(chunk_size, len) computation is width-safe, so a narrow length type (e.g. MessagePack ext-8's uint8_t) cannot truncate chunk_size to zero.

Benchmark

Payload: a 2 MiB text string + 2 MiB binary blob + 2000×1 KiB strings, re-encoded to CBOR/MessagePack and decoded 200× (Apple clang, -O2):

Std	Case	before	after	speedup
C++20	from_cbor(vector)	20.1 ms	1.0 ms	~20×
C++20	from_cbor(pointer)	18.9 ms	1.0 ms	~19×
C++17	from_cbor(pointer)	18.7 ms	1.0 ms	~19× (memcpy path)
C++17	from_cbor(vector)	18.7 ms	4.0 ms	~4.6× (tight loop, no memcpy pre-C++20)

from_msgpack shows the same pattern.

Correctness

• Behavior is unchanged: truncated input still throws parse_error.110 at the same byte offset (verified for lengths straddling the chunk boundary).
• All binary-format unit tests pass (test-cbor, test-msgpack, test-ubjson, test-bson, test-bjdata, test-binary_formats — several million assertions, 0 failures) under C++11.
• Added a regression test (CBOR large strings and binaries (chunked reader)) covering string/binary roundtrips and truncation at lengths of 0, 1, 4095, 4096, 4097, 8192, and 100000 bytes, for both vector and pointer inputs.
• single_include regenerated; make check-amalgamation passes.

🤖 Generated with Claude Code

[nlohmann]

(Claude Code) Addressed the Flawfinder alerts:

• The three buffer/read alerts were false positives triggered by a local variable named read (Flawfinder matches it as the POSIX read() syscall). Renamed it to bytes_read — pure rename, identical semantics.
• The single buffer/memcpy alert is intrinsic to the fast path. The copy is bounds-checked (copied = min(wanted, available)), and it matches the existing unsuppressed std::memcpy uses elsewhere in the library (binary_writer.hpp, to_chars.hpp), so it should be dismissable as a false positive.

Also fixed the GCC -Werror=arith-conversion build failure (narrowing in the chunk-length subtraction for narrow NumberTypes like UBJSON int16) and formatted the new test. All binary-format unit suites pass locally.

[nlohmann]

(Claude Code) Merged latest develop to resolve the conflict in include/nlohmann/detail/input/input_adapters.hpp against #5234 (lazy lexer diagnostics), which touched the same iterator_input_adapter class. The two features are orthogonal — the lexer uses the new get_consumed_count()/copy_consumed_range() helpers, this PR uses get_elements() — and both are preserved. Verified locally: all binary-format suites (CBOR/MessagePack/UBJSON/BSON/BJData) plus the lexer/parser/diagnostic-positions suites pass with the merge in place, and make check-amalgamation is clean.