release 4.6.4

.github/workflows/ubuntu24.yml

@@ -22,4 +22,4 @@ jobs:
       - name: Build
         run: cmake --build build -j=2
       - name: Test
-        run: ctest --output-on-failure --test-dir build
+        run: ctest --output-on-failure --test-dir build

CMakeLists.txt

@@ -12,7 +12,7 @@ endif()
 project(
     simdjson
     # The version number is modified by tools/release.py
-    VERSION 4.6.1
+    VERSION 4.6.4
     DESCRIPTION "Parsing gigabytes of JSON per second"
     HOMEPAGE_URL "https://simdjson.org/"
     LANGUAGES CXX C
@@ -52,20 +52,6 @@ if(SIMDJSON_DISABLE_DEPRECATED_API)
   )
 endif()
 
-option(SIMDJSON_FEATURE_ONDEMAND_API "Enable ondemand API" ON)
-option(SIMDJSON_FEATURE_DOM_API "Enable DOM API" ON)
-option(SIMDJSON_FEATURE_BUILDER_API "Enable builder API" ON)
-
-if(NOT SIMDJSON_FEATURE_ONDEMAND_API)
-  add_compile_definitions(SIMDJSON_FEATURE_ONDEMAND_API=0)
-endif()
-if(NOT SIMDJSON_FEATURE_DOM_API)
-  add_compile_definitions(SIMDJSON_FEATURE_DOM_API=0)
-endif()
-if(NOT SIMDJSON_FEATURE_BUILDER_API)
-  add_compile_definitions(SIMDJSON_FEATURE_BUILDER_API=0)
-endif()
-
 if(${CMAKE_VERSION} VERSION_GREATER_EQUAL "3.25.0")
     option(SIMDJSON_STATIC_REFLECTION "Enables static reflection (experimental), requires C++26" OFF)
 else()
@@ -181,37 +167,13 @@ if(MSVC)
   endif()
 endif()
 
-
-
 if(SIMDJSON_STATIC_REFLECTION)
-
-
-  if(CMAKE_CXX_COMPILER_ID STREQUAL "Clang" AND CMAKE_CXX_COMPILER_VERSION MATCHES "^21")
-    execute_process(
-        COMMAND ${CMAKE_CXX_COMPILER} --version
-        OUTPUT_VARIABLE CLANG_VERSION_OUTPUT
-        ERROR_VARIABLE CLANG_VERSION_ERROR
-        RESULT_VARIABLE CLANG_VERSION_RESULT
-    )
-    if(CLANG_VERSION_RESULT EQUAL 0 AND CLANG_VERSION_OUTPUT MATCHES "https://github.com/bloomberg/clang-p2996.git")
-        set(IS_BLOOMBERG_P2996_CLANG ON)
-        message(STATUS "Using Bloomberg P2996 Clang fork")
-    endif()
-  endif()
-
   # We would like to require C++26, but no compiler supports that!
   # This is a hack:
-  if(IS_BLOOMBERG_P2996_CLANG)
   simdjson_add_props(
       target_compile_options PUBLIC
       -freflection -fexpansion-statements -stdlib=libc++ -std=c++26
   )
-  else()
-  simdjson_add_props(
-      target_compile_options PUBLIC
-      -freflection -std=c++26
-  )
-  endif()
 else()
   simdjson_add_props(target_compile_features PUBLIC cxx_std_11)
 endif()
@@ -425,25 +387,18 @@ add_subdirectory(fuzz)
 #
 # Source files should be just ASCII
 #
-find_program(FIND_CMD find)
+find_program(FIND find)
-find_program(FILE_CMD file)
+find_program(FILE file)
-find_program(GREP_CMD grep)
+find_program(GREP grep)
-if(FIND_CMD AND FILE_CMD AND GREP_CMD)
+if(FIND AND FILE AND GREP)
   add_test(
       NAME just_ascii
       COMMAND sh -c "\
-non_ascii=$(${FIND_CMD} include src windows tools singleheader tests examples benchmark \
+${FIND} include src windows tools singleheader tests examples benchmark \
-  -path benchmark/checkperf-reference -prune -name '*.h' -o -name '*.cpp' \
+-path benchmark/checkperf-reference -prune -name '*.h' -o -name '*.cpp' \
-  -type f -exec ${FILE_CMD} '{}' \; | ${GREP_CMD} -v ASCII); \
+-type f -exec ${FILE} '{}' \; | ${GREP} -qv ASCII || exit 0  && exit 1"
-if [ -n \"$non_ascii\" ]; then \
-  echo 'The following files contain non-ASCII characters:'; \
-  echo \"$non_ascii\"; \
-  exit 1; \
-fi"
       WORKING_DIRECTORY "${PROJECT_SOURCE_DIR}"
   )
-else()
-  message(WARNING "just_ascii test disabled because required tools were not found: find='${FIND_CMD}', file='${FILE_CMD}', grep='${GREP_CMD}'")
 endif()
 
 ##

Doxyfile

@@ -38,7 +38,7 @@ PROJECT_NAME           = simdjson
 # could be handy for archiving the generated documentation or if some version
 # control system is used.
 
-PROJECT_NUMBER         = "4.6.1"
+PROJECT_NUMBER         = "4.6.4"
 
 # Using the PROJECT_BRIEF tag one can provide an optional one line description
 # for a project that appears at the top of each page and should give viewer a

HACKING.md

@@ -32,24 +32,6 @@ It is similar for Visual Studio users, please see the CMake or Visual Studio doc
 
 By default the library is built in Release mode.
 
-## Optional APIs (Feature Flags)
-
-simdjson provides three APIs:
-- DOM (`simdjson::dom`)
-- OnDemand (`simdjson::ondemand`)
-- Builder (`simdjson::builder`) — requires DOM
-
-You can enable or disable these APIs at compile time to reduce binary size and compile time.
-At least one of DOM or OnDemand must be enabled.
-
-### Configuration
-
-Using CMake:
-
-```bash
-cmake -DSIMDJSON_FEATURE_DOM_API=OFF \
-      -DSIMDJSON_FEATURE_ONDEMAND_API=ON \
-      -DSIMDJSON_FEATURE_BUILDER_API=OFF ..
 
 Assertions and development checks
 ------------------------------

benchmark/partial_tweets/tweet.h

@@ -10,7 +10,7 @@ namespace partial_tweets {
 //     {
 //       "created_at": "Sun Aug 31 00:29:15 +0000 2014",
 //       "id": 505874924095815700,
-//       "text": "@aym0566x ...",
+//       "text": "@aym0566x \n\n名前:前田あゆみ\n第一印象:なんか怖っ！\n今の印象:とりあえずキモい。噛み合わない\n好きなところ:ぶすでキモいとこ😋✨✨\n思い出:んーーー、ありすぎ😊❤️\nLINE交換できる？:あぁ……ごめん✋\nトプ画をみて:照れますがな😘✨\n一言:お前は一生もんのダチ💖",
 //       "in_reply_to_status_id": null,
 //       "user": {
 //         "id": 1186275104,

doc/basics.md

@@ -28,6 +28,8 @@ separate document](https://github.com/simdjson/simdjson/blob/master/doc/builder.
 - [UTF-8 validation (alone)](#utf-8-validation-alone)
 - [JSON Pointer](#json-pointer)
 - [JSONPath](#jsonpath)
+  * [Using `for_each_at_path_with_wildcard` for JSONPath Queries (On-Demand)](#using-for_each_at_path_with_wildcard-for-jsonpath-queries-on-demand)
+    + [Example Usage](#example-usage)
 - [Compile-Time JSONPath and JSON Pointer (C++26 Reflection)](#compile-time-jsonpath-and-json-pointer-c26-reflection)
 - [Error handling](#error-handling)
   * [Error handling examples without exceptions](#error-handling-examples-without-exceptions)
@@ -161,77 +163,54 @@ The basics: loading and parsing JSON documents
 ----------------------------------------------
 
 The simdjson library allows you to navigate and validate JSON documents ([RFC 8259](https://www.tbray.org/ongoing/When/201x/2017/12/14/rfc8259.html)).
-Your JSON document should be a valid Unicode (UTF-8) string.
+As required by the standard, your JSON document should be in a Unicode (UTF-8) string. The whole
+string, from the beginning to the end, needs to be valid: we do not attempt to tolerate bad
+inputs before or after a document.
 
-To parse JSON, create a `ondemand::parser` and call its `iterate()` method on a padded input.
+For efficiency reasons, simdjson requires a string with a few bytes (`simdjson::SIMDJSON_PADDING`)
-The simplest way to load a JSON file is with `padded_string::load`:
+at the end, these bytes may be read but their content does not affect the parsing. In practice,
+it means that the JSON inputs should be stored in a memory region with `simdjson::SIMDJSON_PADDING`
+extra bytes at the end. You do not have to set these bytes to specific values though you may
+want to if you want to avoid runtime warnings with some sanitizers. We expect the user
+of the library to load the data (from disk or from the network) into a padded buffer. To make
+this easy, we provide the `padded_string::load` function which loads files from disk in a padded buffer.
+[You can similarly fetch a file from a URL to a padded string](https://github.com/simdjson/curltostring) using our `simdjson::padded_string_builder`. Advanced users may want to read the section Free Padding in [our performance notes](performance.md).
+
+The simdjson library offers a tree-like [API](https://en.wikipedia.org/wiki/API), which you can
+access by creating a `ondemand::parser` and calling the `iterate()` method. The iterate method
+quickly indexes the input string and may detect some errors. The following example illustrates
+how to get started with an input JSON file (`"twitter.json"`):
 
 ```cpp
 ondemand::parser parser;
-auto json = padded_string::load("twitter.json");
+auto json = padded_string::load("twitter.json"); // load JSON file 'twitter.json'.
-ondemand::document doc = parser.iterate(json);
+ondemand::document doc = parser.iterate(json); // position a pointer at the beginning of the JSON data
 ```
 
-For inline JSON strings, use the `_padded` suffix:
+(Windows users compiling with C++17 or better may use `wchar_t` strings to support non-ASCII
+filenames: `padded_string::load(L"twitter.json")`.)
 
-```cpp
+If you prefer not to create your own `ondemand::parser` instance, you can access
-ondemand::parser parser;
+a thread-local version by calling `ondemand::parser.get_parser()`.
-auto json = "[1,2,3]"_padded;
-ondemand::document doc = parser.iterate(json);
-```
 
-If you are compiling with C++17 or better, you can use `simdjson::padded_input`
-which accepts any string-like input and handles padding automatically:
-
-```cpp
-ondemand::parser parser;
-std::string_view json = "[1,2,3]";
-simdjson::padded_input input(json);
-ondemand::document doc = parser.iterate(input);
-
-// Also works with std::string, considering reserved capacity
-std::string json_str = "[1,2,3]";
-json_str.reserve(100);  // Reserve extra space
-simdjson::padded_input input2(json_str);  // May avoid copying
-ondemand::document doc2 = parser.iterate(input2);
-```
-
-The simdjson library also accepts `std::string` instances directly---if the provided
-reference is non-const, it will allocate padding as needed:
-
-```cpp
-ondemand::parser parser;
-std::string json = "[1,2,3]";
-ondemand::document doc = parser.iterate(json);
-```
-
-By default, the simdjson library throws exceptions (`simdjson_error`) on errors. We omit `try`-`catch` clauses from our illustrating examples: if you omit `try`-`catch` in your code, an uncaught exception will halt your program. It is also possible to use simdjson without generating exceptions, and you may even build the library without exception support at all. See [Error handling](#error-handling) for details.
-
-
-### Advanced input options
-
-This section covers additional ways to provide JSON input to simdjson, including
-options for fine-grained control over padding and memory.
-
-**Thread-local parser.** If you prefer not to create your own `ondemand::parser` instance, you can access
-a thread-local version by calling `ondemand::parser.get_parser()`:
 
 ```cpp
 ondemand::document doc = ondemand::parser.get_parser().iterate(json);
 ```
 
-A parser instance can only be used for one document at a time, so
+However, you should be careful because a parser instance can only be used for one
-the thread-local parser is only applicable when you parse one
+document at a time, thus it is only applicable when you are only parsing one
 document per thread at any one time.
 
-**`padded_input` details (C++17+).** The actual padding only occurs when the JSON string ends near the boundary of a memory page, which is
+You can also create a padded string---and call `iterate()`:
-uncommon. Using a `simdjson::padded_input` is safe although sanitizers and tools like valgrind
-might report illegal reads (which are safe in our case because they remain in the mapped page). You should avoid `simdjson::padded_input`
-on systems without a page size of at least 4096: virtually all systems qualify except for
-some niche embedded systems running custom operating systems. Standard Linux, Windows, macOS, Android, iOS, etc., are all fine. Note that, most times, a `simdjson::padded_input` instance will not copy the data and will only act
-as a view (it does not own the memory).
 
-**User-managed buffers.** If you have a buffer of your own with enough padding already (`SIMDJSON_PADDING` extra bytes allocated), you can use `padded_string_view` to pass it in:
+```cpp
+ondemand::parser parser;
+auto json = "[1,2,3]"_padded; // The _padded suffix creates a simdjson::padded_string instance
+ondemand::document doc = parser.iterate(json); // parse a string
+```
+
+If you have a buffer of your own with enough padding already (SIMDJSON_PADDING extra bytes allocated), you can use `padded_string_view` to pass it in:
 
 ```cpp
 ondemand::parser parser;
@@ -240,72 +219,73 @@ strcpy(json, "[1]");
 ondemand::document doc = parser.iterate(json, strlen(json), sizeof(json));
 ```
 
-**Copying into a `padded_string`.** You can copy your data directly into a `simdjson::padded_string`:
+The simdjson library will also accept `std::string` instances. If the provided
+reference is non-const, it will allocate padding as needed.
+
+You can copy your data directly on a `simdjson::padded_string` as follows:
 
 ```cpp
 const char * data = "my data"; // 7 bytes
 simdjson::padded_string my_padded_data(data, 7); // copies to a padded buffer
 ```
 
-Or from a `std::string`:
+Or as follows...
 
 ```cpp
 std::string data = "my data";
 simdjson::padded_string my_padded_data(data); // copies to a padded buffer
 ```
 
-**`std::string` and sanitizer warnings.** Whenever you pass an `std::string` reference to `parser::iterate`,
+You can then parse the JSON data from the `simdjson::padded_string` instance:
-the parser may access bytes beyond the end of
+
+
+```cpp
+ondemand::document doc = parser.iterate(my_padded_data);
+```
+
+Whenever you pass an `std::string` reference to `parser::iterate`,
+the parser will access the bytes beyond the end of
 the string but before the end of the allocated memory (`std::string::capacity()`).
-Sanitizers that check for reading uninitialized bytes may produce warnings.
+If you are using a sanitizer that checks for reading uninitialized bytes or `std::string`'s
-You can safely ignore these warnings, or call `simdjson::pad(std::string&)` to pad the
+container-overflow checks, you may encounter sanitizer warnings.
-string explicitly:
+You can safely ignore these warnings. Or you can call `simdjson::pad(std::string&)` to pad the
+string with `SIMDJSON_PADDING` spaces: this function returns a `simdjson::padding_string_view` which can be be passed to the parser's iterator function:
 
 ```cpp
 std::string json = "[1]";
 ondemand::document doc = parser.iterate(simdjson::pad(json));
 ```
 
-We recommend against creating many `std::string` or many `std::padded_string` instances in your application to store your JSON data.
+We recommend against creating many `std::string` or many `std::padding_string` instances in your application to store your JSON data.
 Consider reusing the same buffers and limiting memory allocations.
 
-**Memory-file mapping (non-Windows).** You can use memory-file mapping to create a `simdjson::padded_string_view`
+By default, the simdjson library throws exceptions (`simdjson_error`) on errors. We omit `try`-`catch` clauses from our illustrating examples: if you omit `try`-`catch` in your code, an uncaught exception will halt your program. It is also possible to use simdjson without generating exceptions, and you may even build the library without exception support at all. See [Error handling](#error-handling) for details.
-from a file on disk:
 
-```cpp
+Some users may want to browse code along with the compiled assembly. You want to check out the following lists of examples:
-simdjson::padded_memory_map map(myfilename);
-if (!map.is_valid()) { /* handle error */ }
-simdjson::padded_string_view view = map.view();
-ondemand::document doc = parser.iterate(view);
-```
 
-**Windows-specific notes.** Windows users compiling with C++17 or better may use `wchar_t` strings to support non-ASCII
+* [simdjson examples with errors handled through exceptions](https://godbolt.org/z/98Kx9Kqjn)
-filenames: `padded_string::load(L"twitter.json")`. Windows users who need to read files with
+* [simdjson examples with errors without exceptions](https://godbolt.org/z/PKG7GdbPo)
+
+*Windows-specific*:  Windows users who need to read files with
 non-ANSI characters in the name should set their code page to
 UTF-8 (65001). This should be the default with Windows 11 and better.
 Further, they may use the AreFileApisANSI function to determine whether
 the filename is interpreted using the ANSI or the system default OEM
 codepage, and they may call SetFileApisToOEM accordingly.
 
-Some users may want to browse code along with the compiled assembly:
 
-* [simdjson examples with errors handled through exceptions](https://godbolt.org/z/98Kx9Kqjn)
+**Advanced feature:**
-* [simdjson examples with errors without exceptions](https://godbolt.org/z/PKG7GdbPo)
+On non-Windows systems, you can use memory-file mapping to create a `simdjson::padded_string_view`
+from a file on disk.
 
-**Summary of input types:**
+```cpp
-
+// If the macro _WIN32 is defined, this will not work since we do not support memory-file mapping
-
+// under Windows at this time.
-| Input Type / Method                          | Padding Requirement                                                                 | How Padding is Handled                                                                 | Ownership / Copying                          | Notes / Warnings                                                                 |
+simdjson::padded_memory_map map(myfilename);
-|----------------------------------------------|-------------------------------------------------------------------------------------|----------------------------------------------------------------------------------------|----------------------------------------------|----------------------------------------------------------------------------------|
+if (!map.is_valid()) { /* handle error */ }
-| `padded_string::load("file.json")`           | Automatic (SIMDJSON_PADDING extra bytes)                                           | Library allocates padded buffer and loads file into it                                 | Owned by `padded_string`                     | Recommended for files; safest and simplest.                                      |
+simdjson::padded_string_view view = map.view(); // view is usable while padded_memory_map is in scope
-| `"...json..."_padded` literal                | Automatic (built-in padding)                                                        | Creates `padded_string` with padding                                                   | Owned by `padded_string`                     | Convenient for small hardcoded JSON.                                             |
+ondemand::document doc = parser.iterate(view); // parse the JSON
-| `simdjson::padded_input` (C++17+)            | Automatic when needed                                                               | Adds padding **only** if the string ends near a memory page boundary. For `std::string`, considers `capacity()` | Usually a non-owning view (no copy most times) | Safe on standard OS (page size ≥ 4096). May trigger sanitizer/valgrind warnings (harmless). Avoid on niche embedded systems. |
+```
-| User buffer with explicit padding            | Must have at least `SIMDJSON_PADDING` extra allocated bytes after JSON content     | Pass via `iterate(ptr, json_length, total_allocated_size)` or `padded_string_view`     | User-owned (no copy)                         | Use `char buf[len + SIMDJSON_PADDING]`. Library reads (but never writes) into padding. |
-| `std::string` (non-const)                    | Library checks `capacity()`                                                         | If insufficient, library may allocate a padded copy                                    | May copy (depends on capacity)               | Can trigger sanitizer warnings on uninitialized bytes. Use `simdjson::pad(json)` to avoid. |
-| `simdjson::pad(std::string&)`                | Adds padding if needed                                                              | Returns `padded_string_view` pointing to the (possibly resized) string                 | References original string                   | Recommended to silence sanitizers when using `std::string`.                      |
-| `padded_string(data, length)` or `padded_string(std::string)` | Automatic (copies into padded buffer)                                              | Explicit copy into owned padded buffer                                                 | Owned by `padded_string`                     | Safe when you want full ownership and padding guaranteed.                        |
-| `padded_string_view` (manual)                | User guarantees `SIMDJSON_PADDING` extra bytes after the viewed length             | User provides pointer + length + capacity                                              | Non-owning view                              | Low-level; requires careful buffer management.                                   |
-| Memory-mapped file (`padded_memory_map`)     | Automatic via mapping (non-Windows only)                                            | Creates view with sufficient padding                                                   | Non-owning (tied to map lifetime)            | Advanced; efficient for large files on Linux/macOS/etc.                          |
 
 
 Documents are iterators
@@ -1322,6 +1302,10 @@ You can also use the custom `Car` type as part of a template such as `std::vecto
   simdjson::ondemand::parser parser;
   simdjson::ondemand::document doc = parser.iterate(json);
   std::vector<Car> cars(doc);
+  // visual studio users need an explicit call:
+  //   std::vector<Car> cars = doc.get<std::vector<Car>>();
+  // because the compiler does not know whether to convert
+  // doc to an unsigned int or to a vector.
   for(Car& c : cars) {
     std::cout << c.year << std::endl;
   }
@@ -1808,15 +1792,15 @@ int64_t x = obj.at_path("$.c.foo.a[1]"); // 20
 x = obj.at_path("$.d.foo2.a.2"); // 30
 ```
 
-## Using `at_path_with_wildcard` for JSONPath Queries (On-Demand)
+## Using `for_each_at_path_with_wildcard` for JSONPath Queries (On-Demand)
 
-The `at_path_with_wildcard` function in simdjson extends the JSONPath querying capabilities by supporting wildcard expressions (`*`) in JSON paths. This allows users to retrieve multiple elements from a JSON document in a single query. For example, you can use `$.address.*` to fetch all fields within the `address` object or `$.phoneNumbers[*].numbers[*]` to retrieve all phone numbers across multiple objects in an array.
+The `for_each_at_path_with_wildcard` function in simdjson extends the JSONPath querying capabilities by supporting wildcard expressions (`*`) in JSON paths. It calls a user-provided callback for each matching element, avoiding the need to materialize all results into a vector. For example, you can use `$.address.*` to fetch all fields within the `address` object or `$.phoneNumbers[*].numbers[*]` to retrieve all phone numbers across multiple objects in an array.
 
-The `*` wildcard matches all elements at a specific level. For instance, `$.address.*` retrieves all key-value pairs in the `address` object, while `$.*.streetAddress` fetches all `streetAddress` fields across objects at the root level. You can combine wildcards with array indexing. For example, `$.phoneNumbers[*].numbers[1]` retrieves the second number from each `numbers` array in the `phoneNumbers` array. If no elements match the wildcard query, the function returns an empty result. For instance, querying `$.empty_object.*` or `$.empty_array.*` will yield an empty set.
+The `*` wildcard matches all elements at a specific level. For instance, `$.address.*` retrieves all key-value pairs in the `address` object, while `$.*.streetAddress` fetches all `streetAddress` fields across objects at the root level. You can combine wildcards with array indexing. For example, `$.phoneNumbers[*].numbers[1]` retrieves the second number from each `numbers` array in the `phoneNumbers` array. If no elements match the wildcard query, the callback is simply never called. For instance, querying `$.empty_object.*` or `$.empty_array.*` will yield no callbacks.
 
 ### Example Usage
 
-Here is an example demonstrating the use of `at_path_with_wildcard`:
+Here is an example demonstrating the use of `for_each_at_path_with_wildcard`:
 
 ```cpp
 simdjson::padded_string json_string = R"(
@@ -1845,27 +1829,22 @@ ondemand::parser parser;
 ondemand::document doc = parser.iterate(json_string);
 
 // Fetch all fields in the address object
-std::vector<ondemand::value> values;
+auto error = doc.for_each_at_path_with_wildcard("$.address.*",
-auto error = doc.at_path_with_wildcard("$.address.*").get(values);
+    [](ondemand::value value) {
-if (!error) {
+      std::string_view field;
-  for (auto value : values) {
+      if (value.get(field) == SUCCESS) {
-    std::string_view field;
+        std::cout << field << std::endl;
-    if (value.get(field) == SUCCESS) {
+      }
-      std::cout << field << std::endl;
+    });
-    }
-  }
-}
 
 // Fetch all phone numbers
-error = doc.at_path_with_wildcard("$.phoneNumbers[*].numbers[*]").get(values);
+doc.for_each_at_path_with_wildcard("$.phoneNumbers[*].numbers[*]",
-if (!error) {
+    [](ondemand::value value) {
-  for (auto value : values) {
+      std::string_view number;
-    std::string_view number;
+      if (value.get(number) == SUCCESS) {
-    if (value.get(number) == SUCCESS) {
+        std::cout << number << std::endl;
-      std::cout << number << std::endl;
+      }
-    }
+    });
-  }
-}
 ```
 
 This function is particularly useful for extracting data from complex JSON structures with nested arrays and objects. By leveraging wildcards, you can simplify your queries and reduce the need for multiple iterations.

doc/compile_time.md

@@ -32,21 +32,6 @@ your code with the `SIMDJSON_STATIC_REFLECTION` macro set:
 The `simdjson::compile_time::parse_json` function parses a JSON document at **compile time** and returns a `constexpr` structure reflecting its content. We support the full range of JSON values, which are mapped to C++ types as in
 the following table.
 
-For convenience, you can also use the `""_json` user-defined literal operator, which is available in the `simdjson::literals` namespace:
-
-```cpp
-using namespace simdjson::literals;
-
-constexpr auto cfg = R"(
-{
-    "port": 8080,
-    "host": "localhost"
-}
-)"_json;
-```
-
-Alternatively, you can use the qualified name `simdjson::literals::operator""_json`.
-
 
 | JSON type      | C++ type                         |
 |----------------|----------------------------------|
@@ -76,8 +61,6 @@ You can do so, at compile-time, as follows:
 
 
 ```cpp
-using namespace simdjson::literals;
-
 constexpr auto cfg = R"(
 
 {
@@ -96,8 +79,6 @@ constexpr auto cfg = R"(
 You can nest objects and arrays:
 
 ```cpp
-using namespace simdjson::literals;
-
 constexpr auto data = R"(
 
 {
@@ -117,8 +98,6 @@ constexpr auto data = R"(
 Top-level arrays are allowed:
 
 ```cpp
-using namespace simdjson::literals;
-
 constexpr auto arr = R"(
 
 [1, 2, 3]
@@ -137,8 +116,6 @@ want to check that it conforms to your expectation. You can do so with concepts.
 Let us consider this example:
 
 ```cpp
-    using namespace simdjson::literals;
-
     constexpr auto config = R"(
 
     [

doc/dom.md

@@ -882,19 +882,6 @@ simdjson::dom::element element = parser.parse(padded_json_copy.get(), json_len,
 
 Setting the `realloc_if_needed` parameter `false` in this manner may lead to better performance since copies are avoided, but it requires that the user takes more responsibilities: the simdjson library cannot verify that the input buffer was padded with SIMDJSON_PADDING extra bytes.
 
-If you are compiling your project with C++17 or better, you can use a `simdjson::padded_input`:
-
-```cpp
-simdjson::dom::parser parser;
-std::string_view json = "[1,2,3]";
-simdjson::padded_input input(json); // Automatically pads if needed
-simdjson::dom::element element = parser.parse(input);
-```
-
-The actual padding only occurs if the JSON string ends near the boundary of a memory page, which is uncommon. Using a `simdjson::padded_input` is safe although sanitizers and tools like valgrind might report illegal reads (which are safe in our case because they remain in the mapped page). You should avoid `simdjson::padded_input` on systems without a page size of at least 4096: virtually all systems qualify except for some niche embedded systems running custom operating systems. Standard Linux, Windows, macOS, Android, iOS, etc., are all fine.  Note that, most times, an `simdjson::padded_input` instance will not copy the data and will only act
-as a view (it does not own the memory).
-
-
 Performance Tips
 ---------------------
 

doc/performance.md

@@ -204,25 +204,9 @@ but can be significantly larger. E.g., Apple systems favour pages spanning 16 ki
 
 In effect, it means that you can almost always read a few bytes beyond your current buffer---without
 allocating extra memory. However, tools such as valgrind or memory sanitizers will flag such behavior as unsafe.
-You can still make sure of this capability in your code if you are an expert
+Nevertheless, you can still make sure of this capability in your code if you are an expert
-programmer and you are willing to silence sanitizer warnings.
+programmer and you are willing to silence sanitizer warnings. The following code provides
-
+a portable example.
-If you are building simdjson with C++17 or better, you can use `simdjson::padded_input`.
-The `padded_input` struct automatically manages padding for you. It can be constructed from a `std::string_view` or a C-style string with length. If the input already has sufficient padding (up to the end of the memory page), it creates a view without copying. Otherwise, it copies the data into a `padded_string` with proper padding.
-
-Example usage:
-
-```cpp
-std::string_view json = get_json_data();
-simdjson::padded_input input(json);  // Automatically pads if needed
-auto result = parser.parse(input);
-```
-
-This simplifies padding management compared to manually checking and allocating.
-
-
-More generally, the following code provides a portable example.
-
 
 
 The conditional compilation checks for the `_MSC_VER` macro (indicating Microsoft Visual Studio)
@@ -266,7 +250,7 @@ long page_size() {
 }
 
 // Returns true if the buffer + len + simdjson::SIMDJSON_PADDING crosses the
-// page boundary. Assumes len != 0.
+// page boundary.
 bool need_allocation(const char *buf, size_t len) {
   return ((reinterpret_cast<uintptr_t>(buf + len - 1) % page_size())
     + simdjson::SIMDJSON_PADDING >= static_cast<uintptr_t>(page_size()));

include/simdjson.h

@@ -35,7 +35,6 @@
  */
 
 #include "simdjson/common_defs.h"
-#include "simdjson/feature_macros.h"
 
 // This provides the public API for simdjson.
 // DOM and ondemand are amalgamated separately, in simdjson.h
@@ -46,29 +45,19 @@
 #include "simdjson/error.h"
 #include "simdjson/error-inl.h"
 #include "simdjson/implementation.h"
-#include "simdjson/builtin.h"
 #include "simdjson/minify.h"
 #include "simdjson/padded_string.h"
 #include "simdjson/padded_string-inl.h"
 #include "simdjson/padded_string_view.h"
 #include "simdjson/padded_string_view-inl.h"
 
-#if SIMDJSON_FEATURE_DOM_API
 #include "simdjson/dom.h"
-#if SIMDJSON_FEATURE_BUILDER_API
 #include "simdjson/builder.h"
-#endif // SIMDJSON_FEATURE_BUILDER_API
-#endif // SIMDJSON_FEATURE_DOM_API
-
-#if SIMDJSON_FEATURE_ONDEMAND_API
 #include "simdjson/ondemand.h"
-#endif // SIMDJSON_FEATURE_ONDEMAND_API
-
-#if SIMDJSON_FEATURE_DOM_API && SIMDJSON_FEATURE_ONDEMAND_API
 #include "simdjson/convert.h"
 #include "simdjson/convert-inl.h"
-#endif // SIMDJSON_FEATURE_DOM_API && SIMDJSON_FEATURE_ONDEMAND_API
 
+// Compile-time JSON parsing (C++26 P2996 reflection)
 #include "simdjson/compile_time_json.h"
 #include "simdjson/compile_time_json-inl.h"
 

include/simdjson/compile_time_json-inl.h

@@ -266,12 +266,6 @@ consteval std::pair<double, size_t> parse_double(const char *src,
 }
 } // namespace number_parsing
 
-consteval auto make_data_member_options(auto&& name_str) {
-  std::meta::data_member_options options{};
-  options.name = std::forward<decltype(name_str)>(name_str);
-  return options;
-}
-
 // JSON string may contain embedded nulls, and C++26 reflection does not yet
 // support std::string_view as a data member type. As a workaround, we define
 // a custom type that holds a const char* and a size.
@@ -326,8 +320,7 @@ using class_type = type_builder<meta_info...>::constructed_type;
 /**
  * @brief Variable template for constructing instances with values
  */
-template <typename T, auto... Vs> constexpr T construct_from = T{Vs...};
+template <typename T, auto... Vs> constexpr auto construct_from = T{Vs...};
-
 
 // in JSON, there are only a few whitespace characters that are allowed
 // outside of objects, arrays, strings, and numbers.
@@ -417,7 +410,7 @@ parse_number(std::string_view json,
         std::from_chars(json.data(), json.data() + json.size(), int_value);
     if (res.ec == std::errc()) {
       out = int_value;
-      if (static_cast<std::size_t>(res.ptr - json.data()) != scope) {
+      if ((res.ptr - json.data()) != scope) {
         simdjson_consteval_error(
             "Internal error: cannot agree on the character range of the float");
       }
@@ -431,7 +424,7 @@ parse_number(std::string_view json,
         std::from_chars(json.data(), json.data() + json.size(), uint_value);
     if (res.ec == std::errc()) {
       out = uint_value;
-      if (static_cast<std::size_t>(res.ptr - json.data()) != scope) {
+      if ((res.ptr - json.data()) != scope) {
         simdjson_consteval_error(
             "Internal error: cannot agree on the character range of the float");
       }
@@ -540,7 +533,7 @@ parse_string(std::string_view json) {
       // present, we have an error (isolated high surrogate), which we
       // tolerate by substituting the substitution_code_point.
       if (end - cursor < 6 || *cursor != '\\' ||
-          *(cursor + 1) != 'u') {
+          *(cursor + 1) != 'u' > 0xFFFF) {
         code_point = substitution_code_point;
       } else {       // we have \u following the high surrogate
         cursor += 2; // skip \u
@@ -894,19 +887,10 @@ parse_json_array_impl(const std::string_view json) {
   std::size_t count = values.size() - 1;
   // We assume all elements have the same type as the first element.
   // However, if the array is heterogeneous, we should use std::variant.
-  auto elem_type = std::meta::type_of(values[1]);
-  // String literals reflected via reflect_constant_string have type const
-  // char[N], but when passed as template auto parameters they decay to
-  // const char*.  Use const char* as the element type so that
-  // construct_from can aggregate-initialize the array.
-  if (std::meta::is_array_type(elem_type) &&
-      std::meta::remove_all_extents(elem_type) == ^^const char) {
-    elem_type = ^^const char *;
-  }
   auto array_type = std::meta::substitute(
       ^^std::array,
       {
-          elem_type, std::meta::reflect_constant(count)});
+          std::meta::type_of(values[1]), std::meta::reflect_constant(count)});
 
   // Create array instance with values
   values[0] = array_type;
@@ -973,7 +957,8 @@ parse_json_object_impl(std::string_view json) {
         simdjson_consteval_error("Expected '}'");
       }
       cursor += object_size;
-      auto dms = std::meta::data_member_spec(std::meta::type_of(parsed), make_data_member_options(field_name));
+      auto dms = std::meta::data_member_spec(std::meta::type_of(parsed),
+                                             {.name = field_name});
       members.push_back(std::meta::reflect_constant(dms));
       values.push_back(parsed);
 
@@ -982,7 +967,8 @@ parse_json_object_impl(std::string_view json) {
     case '[': {
       std::string_view value(cursor, end);
       auto [parsed, array_size] = parse_json_array_impl(value);
-      auto dms = std::meta::data_member_spec(std::meta::type_of(parsed), make_data_member_options(field_name));
+      auto dms = std::meta::data_member_spec(std::meta::type_of(parsed),
+                                             {.name = field_name});
       members.push_back(std::meta::reflect_constant(dms));
       values.push_back(parsed);
       if (*(cursor + array_size - 1) != ']') {
@@ -1003,7 +989,8 @@ parse_json_object_impl(std::string_view json) {
         }
       }
       auto dms =
-          std::meta::data_member_spec(^^const char *, make_data_member_options(field_name));
+          std::meta::data_member_spec(^^const char *, {
+                                                          .name = field_name});
       members.push_back(std::meta::reflect_constant(dms));
       values.push_back(std::meta::reflect_constant_string(value));
       break;
@@ -1014,7 +1001,8 @@ parse_json_object_impl(std::string_view json) {
       }
       cursor += 4;
 
-      auto dms = std::meta::data_member_spec(^^bool, make_data_member_options(field_name));
+      auto dms = std::meta::data_member_spec(^^bool, {
+                                                         .name = field_name});
       members.push_back(std::meta::reflect_constant(dms));
       values.push_back(std::meta::reflect_constant(true));
       break;
@@ -1025,7 +1013,8 @@ parse_json_object_impl(std::string_view json) {
       }
       cursor += 5;
 
-      auto dms = std::meta::data_member_spec(^^bool, make_data_member_options(field_name));
+      auto dms = std::meta::data_member_spec(^^bool, {
+                                                         .name = field_name});
       members.push_back(std::meta::reflect_constant(dms));
       values.push_back(std::meta::reflect_constant(false));
       break;
@@ -1036,7 +1025,9 @@ parse_json_object_impl(std::string_view json) {
       }
       cursor += 4;
 
-      auto dms = std::meta::data_member_spec(^^std::nullptr_t, make_data_member_options(field_name));
+      auto dms = std::meta::data_member_spec(^^std::nullptr_t,
+                                             {
+                                                 .name = field_name});
       members.push_back(std::meta::reflect_constant(dms));
       values.push_back(std::meta::reflect_constant(nullptr));
       break;
@@ -1060,19 +1051,22 @@ parse_json_object_impl(std::string_view json) {
       if (std::holds_alternative<int64_t>(out)) {
         int64_t int_value = std::get<int64_t>(out);
         auto dms =
-            std::meta::data_member_spec(^^int64_t, make_data_member_options(field_name));
+            std::meta::data_member_spec(^^int64_t, {
+                                                       .name = field_name});
         members.push_back(std::meta::reflect_constant(dms));
         values.push_back(std::meta::reflect_constant(int_value));
       } else if (std::holds_alternative<uint64_t>(out)) {
         uint64_t uint_value = std::get<uint64_t>(out);
         auto dms =
-            std::meta::data_member_spec(^^uint64_t, make_data_member_options(field_name));
+            std::meta::data_member_spec(^^uint64_t, {
+                                                        .name = field_name});
         members.push_back(std::meta::reflect_constant(dms));
         values.push_back(std::meta::reflect_constant(uint_value));
       } else {
         double float_value = std::get<double>(out);
         auto dms =
-            std::meta::data_member_spec(^^double, make_data_member_options(field_name));
+            std::meta::data_member_spec(^^double, {
+                                                      .name = field_name});
         members.push_back(std::meta::reflect_constant(dms));
         values.push_back(std::meta::reflect_constant(float_value));
       }
@@ -1117,11 +1111,16 @@ template <constevalutil::fixed_string json_str> consteval auto parse_json() {
                 "Only JSON objects and arrays are supported at the top level, this "
                 "limitation will be lifted in the future.");*/
 
-  if constexpr (json.front() == '[') {
+  constexpr auto result = json.front() == '['
-    return [: parse_json_array_impl(json).first :];
+                              ? parse_json_array_impl(json)
-  } else {
+                              : parse_json_object_impl(json);
-    return [: parse_json_object_impl(json).first :];
+  return [: result.first :];
-  }
+  /*
+  if(json.front() == '[') {
+      return [:parse_json_array_impl(json).first:];
+  } else if(json.front() == '{') {
+   //   return [:parse_json_object_impl(json).first:];
+  }*/
 }
 
 } // namespace compile_time

include/simdjson/compile_time_json.h

@@ -63,16 +63,13 @@ namespace compile_time {
 template <constevalutil::fixed_string json_str> consteval auto parse_json();
 
 } // namespace compile_time
+} // namespace simdjson
 
-inline namespace literals {
 
 template <simdjson::constevalutil::fixed_string str>
 consteval auto operator ""_json() {
   return simdjson::compile_time::parse_json<str>();
 }
 
-} // namespace literals
-} // namespace simdjson
-
 #endif // SIMDJSON_STATIC_REFLECTION
 #endif // SIMDJSON_GENERIC_COMPILE_TIME_JSON_H

include/simdjson/constevalutil.h

@@ -58,11 +58,6 @@ struct fixed_string {
             data[i] = str[i];
         }
     }
-    constexpr fixed_string(const unsigned char (&str)[N])  {
-        for (std::size_t i = 0; i < N; ++i) {
-            data[i] = static_cast<char>(str[i]);
-        }
-    }
     char data[N];
     constexpr std::string_view view() const { return {data, N - 1}; }
     constexpr size_t size() const { return N ; }

include/simdjson/feature_macros.h

@@ -1,17 +0,0 @@
-#pragma once
-
-#if !defined(SIMDJSON_FEATURE_DOM_API)
-#define SIMDJSON_FEATURE_DOM_API 1
-#endif
-
-#if !defined(SIMDJSON_FEATURE_ONDEMAND_API)
-#define SIMDJSON_FEATURE_ONDEMAND_API 1
-#endif
-
-#if !defined(SIMDJSON_FEATURE_BUILDER_API)
-#define SIMDJSON_FEATURE_BUILDER_API 1
-#endif
-
-#if !SIMDJSON_FEATURE_DOM_API && !SIMDJSON_FEATURE_ONDEMAND_API
-#error "simdjson: at least one of SIMDJSON_FEATURE_DOM_API or SIMDJSON_FEATURE_ONDEMAND_API must be enabled."
-#endif

include/simdjson/generic/builder/json_builder.h

@@ -22,7 +22,7 @@ namespace SIMDJSON_IMPLEMENTATION {
 namespace builder {
 
 template <class T>
-  requires(concepts::container_but_not_string<T> && ! concepts::optional_type<T> && !require_custom_serialization<T>)
+  requires(concepts::container_but_not_string<T> && !require_custom_serialization<T>)
 constexpr void atom(string_builder &b, const T &t) {
   auto it = t.begin();
   auto end = t.end();
@@ -130,7 +130,7 @@ template <typename T>
   requires(std::is_enum_v<T> && !require_custom_serialization<T>)
 void atom(string_builder &b, const T &e) {
 #if SIMDJSON_STATIC_REFLECTION
-  static constexpr auto enumerators = std::define_static_array(std::meta::enumerators_of(^^T));
+  constexpr auto enumerators = std::define_static_array(std::meta::enumerators_of(^^T));
   template for (constexpr auto enum_val : enumerators) {
     constexpr auto enum_str = std::define_static_string(constevalutil::consteval_to_quoted_escaped(std::meta::identifier_of(enum_val)));
     if (e == [:enum_val:]) {
@@ -294,23 +294,30 @@ string_builder& operator<<(string_builder& b, const Z& z) {
 template<constevalutil::fixed_string... FieldNames, typename T>
   requires(std::is_class_v<T> && (sizeof...(FieldNames) > 0))
 void extract_from(string_builder &b, const T &obj) {
+  // Helper to check if a field name matches any of the requested fields
+  auto should_extract = [](std::string_view field_name) constexpr -> bool {
+    return ((FieldNames.view() == field_name) || ...);
+  };
+
   b.append('{');
   bool first = true;
+
   // Iterate through all members of T using reflection
-  static constexpr auto members = std::define_static_array(std::meta::nonstatic_data_members_of(^^T, std::meta::access_context::unchecked()));
+  template for (constexpr auto mem : std::define_static_array(
-  template for (constexpr auto mem : members) {
+      std::meta::nonstatic_data_members_of(^^T, std::meta::access_context::unchecked()))) {
+
     if constexpr (std::meta::is_public(mem)) {
-      static constexpr std::string_view key = std::define_static_string(std::meta::identifier_of(mem));
+      constexpr std::string_view key = std::define_static_string(std::meta::identifier_of(mem));
 
       // Only serialize this field if it's in our list of requested fields
-      if constexpr (((FieldNames.view() == key) || ...)) {
+      if constexpr (should_extract(key)) {
         if (!first) {
           b.append(',');
         }
         first = false;
 
         // Serialize the key
-        static constexpr auto quoted_key = std::define_static_string(constevalutil::consteval_to_quoted_escaped(std::meta::identifier_of(mem)));
+        constexpr auto quoted_key = std::define_static_string(constevalutil::consteval_to_quoted_escaped(std::meta::identifier_of(mem)));
         b.append_raw(quoted_key);
         b.append(':');
 

include/simdjson/generic/builder/json_string_builder-inl.h

@@ -1,5 +1,6 @@
 #include <array>
 #include <cstring>
+#include <limits>
 #include <type_traits>
 #ifndef SIMDJSON_GENERIC_STRING_BUILDER_INL_H
 
@@ -505,7 +506,7 @@ simdjson_inline bool string_builder::capacity_check(size_t upcoming_bytes) {
   return is_valid;
 }
 
-inline void string_builder::grow_buffer(size_t desired_capacity) {
+simdjson_inline void string_builder::grow_buffer(size_t desired_capacity) {
   if (!is_valid) {
     return;
   }
@@ -755,6 +756,11 @@ simdjson_inline void string_builder::append(number_type v) noexcept {
 simdjson_inline void
 string_builder::escape_and_append(std::string_view input) noexcept {
   // escaping might turn a control character into \x00xx so 6 characters.
+  // Guard against size_t overflow in the multiplication below.
+  if (input.size() > (std::numeric_limits<size_t>::max)() / 6) {
+    set_valid(false);
+    return;
+  }
   if (capacity_check(6 * input.size())) {
     position += write_string_escaped(input, buffer.get() + position);
   }
@@ -763,6 +769,11 @@ string_builder::escape_and_append(std::string_view input) noexcept {
 simdjson_inline void
 string_builder::escape_and_append_with_quotes(std::string_view input) noexcept {
   // escaping might turn a control character into \x00xx so 6 characters.
+  // Guard against size_t overflow in the arithmetic below.
+  if (input.size() > ((std::numeric_limits<size_t>::max)() - 2) / 6) {
+    set_valid(false);
+    return;
+  }
   if (capacity_check(2 + 6 * input.size())) {
     buffer.get()[position++] = '"';
     position += write_string_escaped(input, buffer.get() + position);
@@ -842,7 +853,7 @@ simdjson_inline void string_builder::append(const T &value) {
 #if SIMDJSON_SUPPORTS_RANGES && SIMDJSON_SUPPORTS_CONCEPTS
 // Support for range-based appending (std::ranges::view, etc.)
 template <std::ranges::range R>
-  requires(!std::is_convertible<R, std::string_view>::value && !concepts::optional_type<R> && !require_custom_serialization<R>)
+  requires(!std::is_convertible<R, std::string_view>::value && !require_custom_serialization<R>)
 simdjson_inline void string_builder::append(const R &range) noexcept {
   auto it = std::ranges::begin(range);
   auto end = std::ranges::end(range);

include/simdjson/generic/builder/json_string_builder.h

@@ -171,7 +171,7 @@ public:
 #if SIMDJSON_SUPPORTS_RANGES && SIMDJSON_SUPPORTS_CONCEPTS
   // Support for range-based appending (std::ranges::view, etc.)
   template <std::ranges::range R>
-requires (!std::is_convertible<R, std::string_view>::value && !concepts::optional_type<R> && !require_custom_serialization<R>)
+requires (!std::is_convertible<R, std::string_view>::value && !require_custom_serialization<R>)
   simdjson_inline void append(const R &range) noexcept;
 #endif
   /**
@@ -249,7 +249,7 @@ private:
    * If the allocation fails, is_valid is set to false. We expect
    * that this function would not be repeatedly called.
    */
-  inline void grow_buffer(size_t desired_capacity);
+  simdjson_inline void grow_buffer(size_t desired_capacity);
 
   /**
    * We use this helper function to make sure that is_valid is kept consistent.

include/simdjson/generic/ondemand/amalgamated.h

@@ -1,10 +1,4 @@
-#ifndef SIMDJSON_CONDITIONAL_INCLUDE
+#if defined(SIMDJSON_CONDITIONAL_INCLUDE) && !defined(SIMDJSON_GENERIC_BUILDER_DEPENDENCIES_H)
-#include "simdjson/feature_macros.h"
-#endif // SIMDJSON_CONDITIONAL_INCLUDE
-
-#if SIMDJSON_FEATURE_ONDEMAND_API
-
-#if defined(SIMDJSON_CONDITIONAL_INCLUDE) && !defined(SIMDJSON_GENERIC_ONDEMAND_DEPENDENCIES_H)
 #error simdjson/generic/ondemand/dependencies.h must be included before simdjson/generic/ondemand/amalgamated.h!
 #endif
 
@@ -54,5 +48,3 @@
 // JSON path accessor (compile-time) - must be after inline definitions
 #include "simdjson/generic/ondemand/compile_time_accessors.h"
 
-#endif // SIMDJSON_FEATURE_ONDEMAND_API
-

include/simdjson/generic/ondemand/array-inl.h

@@ -170,46 +170,34 @@ inline simdjson_result<value> array::at_path(std::string_view json_path) noexcep
   return at_pointer(json_pointer);
 }
 
-inline simdjson_result<std::vector<value>> array::at_path_with_wildcard(std::string_view json_path) noexcept {
+#if SIMDJSON_SUPPORTS_CONCEPTS
-  std::vector<value> result;
+template <typename Func>
-
+  requires std::invocable<Func, value>
+#else
+template <typename Func>
+#endif
+inline error_code array::for_each_at_path_with_wildcard(std::string_view json_path, Func&& callback) noexcept {
   auto result_pair = get_next_key_and_json_path(json_path);
   std::string_view key = result_pair.first;
   std::string_view remaining_path = result_pair.second;
   // Wildcard case
-  if(key=="*"){
+  if (key=="*"){
-    for(auto element: *this){
+    for(auto element: *this) {
-
+      value val;
-      if(element.error()){
+        SIMDJSON_TRY(element.get(val));
-        return element.error();
+      if (remaining_path.empty()) {
-      }
+        callback(val);
-
+      } else {
-      if(remaining_path.empty()){
+        error_code err = element.for_each_at_path_with_wildcard(remaining_path, callback);
-        // Use value_unsafe() because we've already checked for errors above.
+        if(err) { return err; }
-        // The 'element' is a simdjson_result<value> wrapper, and we need to extract
-        // the underlying value. value_unsafe() is safe here because error() returned false.
-        result.push_back(std::move(element).value_unsafe());
-
-      }else{
-        auto nested_result = element.at_path_with_wildcard(remaining_path);
-
-        if(nested_result.error()){
-          return nested_result.error();
-        }
-        // Same logic as above.
-        std::vector<value> nested_matches = std::move(nested_result).value_unsafe();
-
-        result.insert(result.end(),
-                      std::make_move_iterator(nested_matches.begin()),
-                      std::make_move_iterator(nested_matches.end()));
       }
     }
-    return result;
+    return SUCCESS;
-  }else{
+  } else {
     // Specific index case in which we access the element at the given index
-    size_t idx=0;
+    size_t idx = 0;
 
-    for(char c:key){
+    for (char c : key) {
       if(c < '0' || c > '9'){
         return INVALID_JSON_POINTER;
       }
@@ -217,16 +205,13 @@ inline simdjson_result<std::vector<value>> array::at_path_with_wildcard(std::str
     }
 
     auto element = at(idx);
-
+    value val;
-    if(element.error()){
+    SIMDJSON_TRY(element.get(val));
-      return element.error();
+    if (remaining_path.empty()){
-    }
+      callback(val);
-
+      return SUCCESS;
-    if(remaining_path.empty()){
+    } else {
-      result.push_back(std::move(element).value_unsafe());
+      return element.for_each_at_path_with_wildcard(remaining_path, callback);
-      return result;
-    }else{
-      return element.at_path_with_wildcard(remaining_path);
     }
   }
 }
@@ -289,9 +274,15 @@ simdjson_inline  simdjson_result<SIMDJSON_IMPLEMENTATION::ondemand::value> simdj
   if (error()) { return error(); }
   return first.at_path(json_path);
 }
-simdjson_inline simdjson_result<std::vector<SIMDJSON_IMPLEMENTATION::ondemand::value>> simdjson_result<SIMDJSON_IMPLEMENTATION::ondemand::array>::at_path_with_wildcard(std::string_view json_path) noexcept {
+#if SIMDJSON_SUPPORTS_CONCEPTS
+template <typename Func>
+  requires std::invocable<Func, SIMDJSON_IMPLEMENTATION::ondemand::value>
+#else
+template <typename Func>
+#endif
+simdjson_inline error_code simdjson_result<SIMDJSON_IMPLEMENTATION::ondemand::array>::for_each_at_path_with_wildcard(std::string_view json_path, Func&& callback) noexcept {
   if (error()) { return error(); }
-  return first.at_path_with_wildcard(json_path);
+  return first.for_each_at_path_with_wildcard(json_path, std::forward<Func>(callback));
 }
 simdjson_inline  simdjson_result<std::string_view> simdjson_result<SIMDJSON_IMPLEMENTATION::ondemand::array>::raw_json() noexcept {
   if (error()) { return error(); }

include/simdjson/generic/ondemand/array.h

@@ -119,13 +119,21 @@ public:
   inline simdjson_result<value> at_path(std::string_view json_path) noexcept;
 
   /**
-   * Get all values matching the given JSONPath expression with wildcard support.
+   * Call the provided callback for each value matching the given JSONPath
+   * expression with wildcard support.
    * Supports wildcard patterns like "[*]" to match all array elements.
    *
    * @param json_path JSONPath expression with wildcards
-   * @return Vector of values matching the wildcard pattern
+   * @param callback Function called for each matching value
+   * @return error_code indicating success or failure
   */
-  inline simdjson_result<std::vector<value>> at_path_with_wildcard(std::string_view json_path) noexcept;
+#if SIMDJSON_SUPPORTS_CONCEPTS
+  template <typename Func>
+    requires std::invocable<Func, value>
+#else
+  template <typename Func>
+#endif
+  inline error_code for_each_at_path_with_wildcard(std::string_view json_path, Func&& callback) noexcept;
 
   /**
    * Consumes the array and returns a string_view instance corresponding to the
@@ -249,7 +257,13 @@ public:
   simdjson_inline simdjson_result<SIMDJSON_IMPLEMENTATION::ondemand::value> at(size_t index) noexcept;
   simdjson_inline simdjson_result<SIMDJSON_IMPLEMENTATION::ondemand::value> at_pointer(std::string_view json_pointer) noexcept;
   simdjson_inline simdjson_result<SIMDJSON_IMPLEMENTATION::ondemand::value> at_path(std::string_view json_path) noexcept;
-  simdjson_inline simdjson_result<std::vector<SIMDJSON_IMPLEMENTATION::ondemand::value>> at_path_with_wildcard(std::string_view json_path) noexcept;
+#if SIMDJSON_SUPPORTS_CONCEPTS
+  template <typename Func>
+    requires std::invocable<Func, SIMDJSON_IMPLEMENTATION::ondemand::value>
+#else
+  template <typename Func>
+#endif
+  simdjson_inline error_code for_each_at_path_with_wildcard(std::string_view json_path, Func&& callback) noexcept;
   simdjson_inline simdjson_result<std::string_view> raw_json() noexcept;
 #if SIMDJSON_SUPPORTS_CONCEPTS
   // TODO: move this code into object-inl.h

include/simdjson/generic/ondemand/dependencies.h

@@ -8,7 +8,6 @@
 // Internal headers needed for ondemand generics.
 // All includes not under simdjson/generic/ondemand must be here!
 // Otherwise, amalgamation will fail.
-#include "simdjson/feature_macros.h"
 #include "simdjson/dom/base.h" // for MINIMAL_DOCUMENT_CAPACITY
 #include "simdjson/implementation.h"
 #include "simdjson/padded_string.h"

include/simdjson/generic/ondemand/document-inl.h

@@ -365,8 +365,14 @@ simdjson_inline simdjson_result<value> document::at_path(std::string_view json_p
   }
 }
 
-simdjson_inline simdjson_result<std::vector<value>> document::at_path_with_wildcard(std::string_view json_path) noexcept {
+#if SIMDJSON_SUPPORTS_CONCEPTS
-  rewind(); // Rewind the document each time at_path_with_wildcard is called
+template <typename Func>
+  requires std::invocable<Func, value>
+#else
+template <typename Func>
+#endif
+simdjson_inline error_code document::for_each_at_path_with_wildcard(std::string_view json_path, Func&& callback) noexcept {
+  rewind(); // Rewind the document each time for_each_at_path_with_wildcard is called
   if (json_path.empty()) {
       return INVALID_JSON_POINTER;
   }
@@ -374,9 +380,9 @@ simdjson_inline simdjson_result<std::vector<value>> document::at_path_with_wildc
   SIMDJSON_TRY(type().get(t));
   switch (t) {
   case json_type::array:
-      return (*this).get_array().at_path_with_wildcard(json_path);
+      return (*this).get_array().for_each_at_path_with_wildcard(json_path, std::forward<Func>(callback));
   case json_type::object:
-      return (*this).get_object().at_path_with_wildcard(json_path);
+      return (*this).get_object().for_each_at_path_with_wildcard(json_path, std::forward<Func>(callback));
   default:
       return INVALID_JSON_POINTER;
   }
@@ -653,27 +659,27 @@ simdjson_inline simdjson_result<SIMDJSON_IMPLEMENTATION::ondemand::document>::op
 }
 simdjson_inline simdjson_result<SIMDJSON_IMPLEMENTATION::ondemand::document>::operator uint64_t() noexcept(false) {
   if (error()) { throw simdjson_error(error()); }
-  return first.get_uint64();
+  return first;
 }
 simdjson_inline simdjson_result<SIMDJSON_IMPLEMENTATION::ondemand::document>::operator int64_t() noexcept(false) {
   if (error()) { throw simdjson_error(error()); }
-  return first.get_int64();
+  return first;
 }
 simdjson_inline simdjson_result<SIMDJSON_IMPLEMENTATION::ondemand::document>::operator double() noexcept(false) {
   if (error()) { throw simdjson_error(error()); }
-  return first.get_double();
+  return first;
 }
 simdjson_inline simdjson_result<SIMDJSON_IMPLEMENTATION::ondemand::document>::operator std::string_view() noexcept(false) {
   if (error()) { throw simdjson_error(error()); }
-  return first.get_string();
+  return first;
 }
 simdjson_inline simdjson_result<SIMDJSON_IMPLEMENTATION::ondemand::document>::operator SIMDJSON_IMPLEMENTATION::ondemand::raw_json_string() noexcept(false) {
   if (error()) { throw simdjson_error(error()); }
-  return first.get_raw_json_string();
+  return first;
 }
 simdjson_inline simdjson_result<SIMDJSON_IMPLEMENTATION::ondemand::document>::operator bool() noexcept(false) {
   if (error()) { throw simdjson_error(error()); }
-  return first.get_bool();
+  return first;
 }
 simdjson_inline simdjson_result<SIMDJSON_IMPLEMENTATION::ondemand::document>::operator SIMDJSON_IMPLEMENTATION::ondemand::value() noexcept(false) {
   if (error()) { throw simdjson_error(error()); }
@@ -713,9 +719,15 @@ simdjson_inline simdjson_result<SIMDJSON_IMPLEMENTATION::ondemand::value> simdjs
   return first.at_path(json_path);
 }
 
-simdjson_inline simdjson_result<std::vector<SIMDJSON_IMPLEMENTATION::ondemand::value>> simdjson_result<SIMDJSON_IMPLEMENTATION::ondemand::document>::at_path_with_wildcard(std::string_view json_path) noexcept {
+#if SIMDJSON_SUPPORTS_CONCEPTS
+template <typename Func>
+  requires std::invocable<Func, SIMDJSON_IMPLEMENTATION::ondemand::value>
+#else
+template <typename Func>
+#endif
+simdjson_inline error_code simdjson_result<SIMDJSON_IMPLEMENTATION::ondemand::document>::for_each_at_path_with_wildcard(std::string_view json_path, Func&& callback) noexcept {
   if (error()) { return error(); }
-  return first.at_path_with_wildcard(json_path);
+  return first.for_each_at_path_with_wildcard(json_path, std::forward<Func>(callback));
 }
 
 #if SIMDJSON_STATIC_REFLECTION
@@ -826,7 +838,13 @@ simdjson_inline simdjson_result<number> document_reference::get_number() noexcep
 simdjson_inline simdjson_result<std::string_view> document_reference::raw_json_token() noexcept { return doc->raw_json_token(); }
 simdjson_inline simdjson_result<value> document_reference::at_pointer(std::string_view json_pointer) noexcept { return doc->at_pointer(json_pointer); }
 simdjson_inline simdjson_result<value> document_reference::at_path(std::string_view json_path) noexcept { return doc->at_path(json_path); }
-simdjson_inline simdjson_result<std::vector<value>> document_reference::at_path_with_wildcard(std::string_view json_path) noexcept { return doc->at_path_with_wildcard(json_path); }
+#if SIMDJSON_SUPPORTS_CONCEPTS
+template <typename Func>
+  requires std::invocable<Func, value>
+#else
+template <typename Func>
+#endif
+simdjson_inline error_code document_reference::for_each_at_path_with_wildcard(std::string_view json_path, Func&& callback) noexcept { return doc->for_each_at_path_with_wildcard(json_path, std::forward<Func>(callback)); }
 simdjson_inline simdjson_result<std::string_view> document_reference::raw_json() noexcept { return doc->raw_json();}
 simdjson_inline document_reference::operator document&() const noexcept { return *doc; }
 #if SIMDJSON_SUPPORTS_CONCEPTS && SIMDJSON_STATIC_REFLECTION
@@ -1042,27 +1060,27 @@ simdjson_inline simdjson_result<SIMDJSON_IMPLEMENTATION::ondemand::document_refe
 }
 simdjson_inline simdjson_result<SIMDJSON_IMPLEMENTATION::ondemand::document_reference>::operator uint64_t() noexcept(false) {
   if (error()) { throw simdjson_error(error()); }
-  return first.get_uint64();
+  return first;
 }
 simdjson_inline simdjson_result<SIMDJSON_IMPLEMENTATION::ondemand::document_reference>::operator int64_t() noexcept(false) {
   if (error()) { throw simdjson_error(error()); }
-  return first.get_int64();
+  return first;
 }
 simdjson_inline simdjson_result<SIMDJSON_IMPLEMENTATION::ondemand::document_reference>::operator double() noexcept(false) {
   if (error()) { throw simdjson_error(error()); }
-  return first.get_double();
+  return first;
 }
 simdjson_inline simdjson_result<SIMDJSON_IMPLEMENTATION::ondemand::document_reference>::operator std::string_view() noexcept(false) {
   if (error()) { throw simdjson_error(error()); }
-  return first.get_string();
+  return first;
 }
 simdjson_inline simdjson_result<SIMDJSON_IMPLEMENTATION::ondemand::document_reference>::operator SIMDJSON_IMPLEMENTATION::ondemand::raw_json_string() noexcept(false) {
   if (error()) { throw simdjson_error(error()); }
-  return first.get_raw_json_string();
+  return first;
 }
 simdjson_inline simdjson_result<SIMDJSON_IMPLEMENTATION::ondemand::document_reference>::operator bool() noexcept(false) {
   if (error()) { throw simdjson_error(error()); }
-  return first.get_bool();
+  return first;
 }
 simdjson_inline simdjson_result<SIMDJSON_IMPLEMENTATION::ondemand::document_reference>::operator SIMDJSON_IMPLEMENTATION::ondemand::value() noexcept(false) {
   if (error()) { throw simdjson_error(error()); }
@@ -1091,11 +1109,17 @@ simdjson_inline simdjson_result<SIMDJSON_IMPLEMENTATION::ondemand::value> simdjs
   }
   return first.at_path(json_path);
 }
-simdjson_inline simdjson_result<std::vector<SIMDJSON_IMPLEMENTATION::ondemand::value>> simdjson_result<SIMDJSON_IMPLEMENTATION::ondemand::document_reference>::at_path_with_wildcard(std::string_view json_path) noexcept {
+#if SIMDJSON_SUPPORTS_CONCEPTS
+template <typename Func>
+  requires std::invocable<Func, SIMDJSON_IMPLEMENTATION::ondemand::value>
+#else
+template <typename Func>
+#endif
+simdjson_inline error_code simdjson_result<SIMDJSON_IMPLEMENTATION::ondemand::document_reference>::for_each_at_path_with_wildcard(std::string_view json_path, Func&& callback) noexcept {
   if (error()) {
       return error();
   }
-  return first.at_path_with_wildcard(json_path);
+  return first.for_each_at_path_with_wildcard(json_path, std::forward<Func>(callback));
 }
 #if SIMDJSON_STATIC_REFLECTION
 template<constevalutil::fixed_string... FieldNames, typename T>

include/simdjson/generic/ondemand/document.h

@@ -319,21 +319,21 @@ public:
    * @returns A signed 64-bit integer.
    * @exception simdjson_error(INCORRECT_TYPE) If the JSON value is not a 64-bit unsigned integer.
    */
-  explicit simdjson_inline operator uint64_t() noexcept(false);
+  simdjson_inline operator uint64_t() noexcept(false);
   /**
    * Cast this JSON value to a signed integer.
    *
    * @returns A signed 64-bit integer.
    * @exception simdjson_error(INCORRECT_TYPE) If the JSON value is not a 64-bit integer.
    */
-  explicit simdjson_inline operator int64_t() noexcept(false);
+  simdjson_inline operator int64_t() noexcept(false);
   /**
    * Cast this JSON value to a double.
    *
    * @returns A double.
    * @exception simdjson_error(INCORRECT_TYPE) If the JSON value is not a valid floating-point number.
    */
-  explicit simdjson_inline operator double() noexcept(false);
+  simdjson_inline operator double() noexcept(false);
   /**
    * Cast this JSON value to a string.
    *
@@ -343,7 +343,7 @@ public:
    *          time it parses a document or when it is destroyed.
    * @exception simdjson_error(INCORRECT_TYPE) if the JSON value is not a string.
    */
-  explicit simdjson_inline operator std::string_view() noexcept(false) simdjson_lifetime_bound;
+  simdjson_inline operator std::string_view() noexcept(false) simdjson_lifetime_bound;
   /**
    * Cast this JSON value to a raw_json_string.
    *
@@ -352,14 +352,14 @@ public:
    * @returns A pointer to the raw JSON for the given string.
    * @exception simdjson_error(INCORRECT_TYPE) if the JSON value is not a string.
    */
-  explicit simdjson_inline operator raw_json_string() noexcept(false) simdjson_lifetime_bound;
+  simdjson_inline operator raw_json_string() noexcept(false) simdjson_lifetime_bound;
   /**
    * Cast this JSON value to a bool.
    *
    * @returns A bool value.
    * @exception simdjson_error(INCORRECT_TYPE) if the JSON value is not true or false.
    */
-  explicit simdjson_inline operator bool() noexcept(false);
+  simdjson_inline operator bool() noexcept(false);
   /**
    * Cast this JSON value to a value when the document is an object or an array.
    *
@@ -744,21 +744,24 @@ public:
   simdjson_inline simdjson_result<value> at_path(std::string_view json_path) noexcept;
 
   /**
-   * Get all values matching the given JSONPath expression with wildcard support.
+   * Call the provided callback for each value matching the given JSONPath
+   * expression with wildcard support.
    *
    * Supports wildcard patterns like "$.array[*]" or "$.object.*" to match multiple elements.
    *
-   * This method materializes all matching values into a vector.
    * The document will be consumed after this call.
    *
    * @param json_path JSONPath expression with wildcards
-   * @return Vector of values matching the wildcard pattern, or:
+   * @param callback Function called for each matching value
-   *         - INVALID_JSON_POINTER if the JSONPath cannot be parsed
+   * @return error_code indicating success or failure
-   *         - NO_SUCH_FIELD if a field does not exist
-   *         - INDEX_OUT_OF_BOUNDS if an array index is out of bounds
-   *         - INCORRECT_TYPE if path traversal encounters wrong type
    */
-  simdjson_inline simdjson_result<std::vector<value>> at_path_with_wildcard(std::string_view json_path) noexcept;
+#if SIMDJSON_SUPPORTS_CONCEPTS
+  template <typename Func>
+    requires std::invocable<Func, value>
+#else
+  template <typename Func>
+#endif
+  simdjson_inline error_code for_each_at_path_with_wildcard(std::string_view json_path, Func&& callback) noexcept;
 
   /**
    * Consumes the document and returns a string_view instance corresponding to the
@@ -945,12 +948,12 @@ public:
   explicit simdjson_inline operator T() noexcept(false);
   simdjson_inline operator array() & noexcept(false);
   simdjson_inline operator object() & noexcept(false);
-  explicit simdjson_inline operator uint64_t() noexcept(false);
+  simdjson_inline operator uint64_t() noexcept(false);
-  explicit simdjson_inline operator int64_t() noexcept(false);
+  simdjson_inline operator int64_t() noexcept(false);
-  explicit simdjson_inline operator double() noexcept(false);
+  simdjson_inline operator double() noexcept(false);
-  explicit simdjson_inline operator std::string_view() noexcept(false);
+  simdjson_inline operator std::string_view() noexcept(false);
-  explicit simdjson_inline operator raw_json_string() noexcept(false);
+  simdjson_inline operator raw_json_string() noexcept(false);
-  explicit simdjson_inline operator bool() noexcept(false);
+  simdjson_inline operator bool() noexcept(false);
   simdjson_inline operator value() noexcept(false);
 #endif
   simdjson_inline simdjson_result<size_t> count_elements() & noexcept;
@@ -979,7 +982,13 @@ public:
   simdjson_inline simdjson_result<std::string_view> raw_json_token() noexcept;
   simdjson_inline simdjson_result<value> at_pointer(std::string_view json_pointer) noexcept;
   simdjson_inline simdjson_result<value> at_path(std::string_view json_path) noexcept;
-  simdjson_inline simdjson_result<std::vector<value>> at_path_with_wildcard(std::string_view json_path) noexcept;
+#if SIMDJSON_SUPPORTS_CONCEPTS
+  template <typename Func>
+    requires std::invocable<Func, value>
+#else
+  template <typename Func>
+#endif
+  simdjson_inline error_code for_each_at_path_with_wildcard(std::string_view json_path, Func&& callback) noexcept;
 
 private:
   document *doc{nullptr};
@@ -1030,12 +1039,12 @@ public:
   explicit simdjson_inline operator T() noexcept(false);
   simdjson_inline operator SIMDJSON_IMPLEMENTATION::ondemand::array() & noexcept(false);
   simdjson_inline operator SIMDJSON_IMPLEMENTATION::ondemand::object() & noexcept(false);
-  explicit simdjson_inline operator uint64_t() noexcept(false);
+  simdjson_inline operator uint64_t() noexcept(false);
-  explicit simdjson_inline operator int64_t() noexcept(false);
+  simdjson_inline operator int64_t() noexcept(false);
-  explicit simdjson_inline operator double() noexcept(false);
+  simdjson_inline operator double() noexcept(false);
-  explicit simdjson_inline operator std::string_view() noexcept(false);
+  simdjson_inline operator std::string_view() noexcept(false);
-  explicit simdjson_inline operator SIMDJSON_IMPLEMENTATION::ondemand::raw_json_string() noexcept(false);
+  simdjson_inline operator SIMDJSON_IMPLEMENTATION::ondemand::raw_json_string() noexcept(false);
-  explicit simdjson_inline operator bool() noexcept(false);
+  simdjson_inline operator bool() noexcept(false);
   simdjson_inline operator SIMDJSON_IMPLEMENTATION::ondemand::value() noexcept(false);
 #endif
   simdjson_inline simdjson_result<size_t> count_elements() & noexcept;
@@ -1065,7 +1074,13 @@ public:
 
   simdjson_inline simdjson_result<SIMDJSON_IMPLEMENTATION::ondemand::value> at_pointer(std::string_view json_pointer) noexcept;
   simdjson_inline simdjson_result<SIMDJSON_IMPLEMENTATION::ondemand::value> at_path(std::string_view json_path) noexcept;
-  simdjson_inline simdjson_result<std::vector<SIMDJSON_IMPLEMENTATION::ondemand::value>> at_path_with_wildcard(std::string_view json_path) noexcept;
+#if SIMDJSON_SUPPORTS_CONCEPTS
+  template <typename Func>
+    requires std::invocable<Func, SIMDJSON_IMPLEMENTATION::ondemand::value>
+#else
+  template <typename Func>
+#endif
+  simdjson_inline error_code for_each_at_path_with_wildcard(std::string_view json_path, Func&& callback) noexcept;
 #if SIMDJSON_STATIC_REFLECTION
   template<constevalutil::fixed_string... FieldNames, typename T>
     requires(std::is_class_v<T> && (sizeof...(FieldNames) > 0))
@@ -1116,12 +1131,12 @@ public:
   explicit simdjson_inline operator T() noexcept(false);
   simdjson_inline operator SIMDJSON_IMPLEMENTATION::ondemand::array() & noexcept(false);
   simdjson_inline operator SIMDJSON_IMPLEMENTATION::ondemand::object() & noexcept(false);
-  explicit simdjson_inline operator uint64_t() noexcept(false);
+  simdjson_inline operator uint64_t() noexcept(false);
-  explicit simdjson_inline operator int64_t() noexcept(false);
+  simdjson_inline operator int64_t() noexcept(false);
-  explicit simdjson_inline operator double() noexcept(false);
+  simdjson_inline operator double() noexcept(false);
-  explicit simdjson_inline operator std::string_view() noexcept(false);
+  simdjson_inline operator std::string_view() noexcept(false);
-  explicit simdjson_inline operator SIMDJSON_IMPLEMENTATION::ondemand::raw_json_string() noexcept(false);
+  simdjson_inline operator SIMDJSON_IMPLEMENTATION::ondemand::raw_json_string() noexcept(false);
-  explicit simdjson_inline operator bool() noexcept(false);
+  simdjson_inline operator bool() noexcept(false);
   simdjson_inline operator SIMDJSON_IMPLEMENTATION::ondemand::value() noexcept(false);
 #endif
   simdjson_inline simdjson_result<size_t> count_elements() & noexcept;
@@ -1150,7 +1165,13 @@ public:
 
   simdjson_inline simdjson_result<SIMDJSON_IMPLEMENTATION::ondemand::value> at_pointer(std::string_view json_pointer) noexcept;
   simdjson_inline simdjson_result<SIMDJSON_IMPLEMENTATION::ondemand::value> at_path(std::string_view json_path) noexcept;
-  simdjson_inline simdjson_result<std::vector<SIMDJSON_IMPLEMENTATION::ondemand::value>> at_path_with_wildcard(std::string_view json_path) noexcept;
+#if SIMDJSON_SUPPORTS_CONCEPTS
+  template <typename Func>
+    requires std::invocable<Func, SIMDJSON_IMPLEMENTATION::ondemand::value>
+#else
+  template <typename Func>
+#endif
+  simdjson_inline error_code for_each_at_path_with_wildcard(std::string_view json_path, Func&& callback) noexcept;
 #if SIMDJSON_STATIC_REFLECTION
   template<constevalutil::fixed_string... FieldNames, typename T>
     requires(std::is_class_v<T> && (sizeof...(FieldNames) > 0))

include/simdjson/generic/ondemand/object-inl.h

@@ -177,9 +177,13 @@ inline simdjson_result<value> object::at_path(std::string_view json_path) noexce
   return at_pointer(json_pointer);
 }
 
-inline simdjson_result<std::vector<value>> object::at_path_with_wildcard(std::string_view json_path) noexcept {
+#if SIMDJSON_SUPPORTS_CONCEPTS
-  std::vector<value> result;
+template <typename Func>
-
+  requires std::invocable<Func, value>
+#else
+template <typename Func>
+#endif
+inline error_code object::for_each_at_path_with_wildcard(std::string_view json_path, Func&& callback) noexcept {
   auto result_pair = get_next_key_and_json_path(json_path);
   std::string_view key = result_pair.first;
   std::string_view remaining_path = result_pair.second;
@@ -189,34 +193,22 @@ inline simdjson_result<std::vector<value>> object::at_path_with_wildcard(std::st
     for (auto field : *this) {
       value val;
       SIMDJSON_TRY(field.value().get(val));
-
       if (remaining_path.empty()) {
-        result.push_back(std::move(val));
+        callback(val);
       } else {
-        auto nested_result = val.at_path_with_wildcard(remaining_path);
+        SIMDJSON_TRY(val.for_each_at_path_with_wildcard(remaining_path, callback));
-
-        if (nested_result.error()) {
-          return nested_result.error();
-        }
-        // Extract and append all nested matches to our result
-        std::vector<value> nested_vec;
-        SIMDJSON_TRY(std::move(nested_result).get(nested_vec));
-
-        result.insert(result.end(),
-                     std::make_move_iterator(nested_vec.begin()),
-                     std::make_move_iterator(nested_vec.end()));
       }
     }
-    return result;
+    return SUCCESS;
   } else {
     value val;
     SIMDJSON_TRY(find_field(key).get(val));
 
     if (remaining_path.empty()) {
-      result.push_back(std::move(val));
+      callback(val);
-      return result;
+      return SUCCESS;
     } else {
-      return val.at_path_with_wildcard(remaining_path);
+      return val.for_each_at_path_with_wildcard(remaining_path, callback);
     }
   }
 }
@@ -347,9 +339,15 @@ simdjson_inline simdjson_result<SIMDJSON_IMPLEMENTATION::ondemand::value> simdjs
   return first.at_path(json_path);
 }
 
-simdjson_inline simdjson_result<std::vector<SIMDJSON_IMPLEMENTATION::ondemand::value>> simdjson_result<SIMDJSON_IMPLEMENTATION::ondemand::object>::at_path_with_wildcard(std::string_view json_path) noexcept {
+#if SIMDJSON_SUPPORTS_CONCEPTS
+template <typename Func>
+  requires std::invocable<Func, SIMDJSON_IMPLEMENTATION::ondemand::value>
+#else
+template <typename Func>
+#endif
+simdjson_inline error_code simdjson_result<SIMDJSON_IMPLEMENTATION::ondemand::object>::for_each_at_path_with_wildcard(std::string_view json_path, Func&& callback) noexcept {
   if (error()) { return error(); }
-  return first.at_path_with_wildcard(json_path);
+  return first.for_each_at_path_with_wildcard(json_path, std::forward<Func>(callback));
 }
 
 inline simdjson_result<bool> simdjson_result<SIMDJSON_IMPLEMENTATION::ondemand::object>::reset() noexcept {

include/simdjson/generic/ondemand/object.h

@@ -172,13 +172,21 @@ public:
   inline simdjson_result<value> at_path(std::string_view json_path) noexcept;
 
   /**
-   * Get all values matching the given JSONPath expression with wildcard support.
+   * Call the provided callback for each value matching the given JSONPath
+   * expression with wildcard support.
    * Supports wildcard patterns like ".*" to match all object fields.
    *
    * @param json_path JSONPath expression with wildcards
-   * @return Vector of values matching the wildcard pattern
+   * @param callback Function called for each matching value
+   * @return error_code indicating success or failure
   */
-  inline simdjson_result<std::vector<value>> at_path_with_wildcard(std::string_view json_path) noexcept;
+#if SIMDJSON_SUPPORTS_CONCEPTS
+  template <typename Func>
+    requires std::invocable<Func, value>
+#else
+  template <typename Func>
+#endif
+  inline error_code for_each_at_path_with_wildcard(std::string_view json_path, Func&& callback) noexcept;
 
   /**
    * Reset the iterator so that we are pointing back at the
@@ -328,7 +336,13 @@ public:
   simdjson_inline simdjson_result<SIMDJSON_IMPLEMENTATION::ondemand::value> operator[](std::string_view key) && noexcept;
   simdjson_inline simdjson_result<SIMDJSON_IMPLEMENTATION::ondemand::value> at_pointer(std::string_view json_pointer) noexcept;
   simdjson_inline simdjson_result<SIMDJSON_IMPLEMENTATION::ondemand::value> at_path(std::string_view json_path) noexcept;
-  simdjson_inline simdjson_result<std::vector<SIMDJSON_IMPLEMENTATION::ondemand::value>> at_path_with_wildcard(std::string_view json_path) noexcept;
+#if SIMDJSON_SUPPORTS_CONCEPTS
+  template <typename Func>
+    requires std::invocable<Func, SIMDJSON_IMPLEMENTATION::ondemand::value>
+#else
+  template <typename Func>
+#endif
+  simdjson_inline error_code for_each_at_path_with_wildcard(std::string_view json_path, Func&& callback) noexcept;
   inline simdjson_result<bool> reset() noexcept;
   inline simdjson_result<bool> is_empty() noexcept;
   inline simdjson_result<size_t> count_fields() & noexcept;

include/simdjson/generic/ondemand/parser-inl.h

@@ -199,7 +199,7 @@ simdjson_inline simdjson_warn_unused ondemand::parser& parser::get_parser() {
   return *parser::get_parser_instance();
 }
 
-simdjson_inline bool release_parser() {
+simdjson_inline bool parser::release_parser() {
   auto &parser_instance = parser::get_threadlocal_parser_if_exists();
   if (parser_instance) {
     parser_instance.reset();

include/simdjson/generic/ondemand/parser.h

@@ -388,8 +388,6 @@ public:
   static simdjson_inline bool release_parser();
 
 private:
-  friend bool release_parser();
-  friend ondemand::parser& get_parser();
   /** Get the thread-local parser instance, allocates it if needed */
   static simdjson_inline simdjson_warn_unused std::unique_ptr<ondemand::parser>& get_parser_instance();
   /** Get the thread-local parser instance, it might be null */

include/simdjson/generic/ondemand/std_deserialize.h

@@ -305,7 +305,7 @@ error_code tag_invoke(deserialize_tag, ValT &val, T &out) noexcept {
 #if SIMDJSON_STATIC_REFLECTION
   std::string_view str;
   SIMDJSON_TRY(val.get_string().get(str));
-  static constexpr auto enumerators = std::define_static_array(std::meta::enumerators_of(^^T));
+  constexpr auto enumerators = std::define_static_array(std::meta::enumerators_of(^^T));
   template for (constexpr auto enum_val : enumerators) {
     if (str == std::meta::identifier_of(enum_val)) {
       out = [:enum_val:];

include/simdjson/generic/ondemand/value-inl.h

@@ -314,14 +314,20 @@ simdjson_inline simdjson_result<value> value::at_path(std::string_view json_path
   }
 }
 
-inline simdjson_result<std::vector<value>> value::at_path_with_wildcard(std::string_view json_path) noexcept {
+#if SIMDJSON_SUPPORTS_CONCEPTS
+template <typename Func>
+  requires std::invocable<Func, value>
+#else
+template <typename Func>
+#endif
+inline error_code value::for_each_at_path_with_wildcard(std::string_view json_path, Func&& callback) noexcept {
   json_type t;
   SIMDJSON_TRY(type().get(t));
   switch (t) {
   case json_type::array:
-      return (*this).get_array().at_path_with_wildcard(json_path);
+      return (*this).get_array().for_each_at_path_with_wildcard(json_path, std::forward<Func>(callback));
   case json_type::object:
-      return (*this).get_object().at_path_with_wildcard(json_path);
+      return (*this).get_object().for_each_at_path_with_wildcard(json_path, std::forward<Func>(callback));
   default:
       return INVALID_JSON_POINTER;
   }
@@ -585,12 +591,18 @@ simdjson_inline simdjson_result<SIMDJSON_IMPLEMENTATION::ondemand::value> simdjs
   return first.at_path(json_path);
 }
 
-inline simdjson_result<std::vector<SIMDJSON_IMPLEMENTATION::ondemand::value>> simdjson_result<SIMDJSON_IMPLEMENTATION::ondemand::value>::at_path_with_wildcard(
+#if SIMDJSON_SUPPORTS_CONCEPTS
-      std::string_view json_path) noexcept {
+template <typename Func>
+  requires std::invocable<Func, SIMDJSON_IMPLEMENTATION::ondemand::value>
+#else
+template <typename Func>
+#endif
+inline error_code simdjson_result<SIMDJSON_IMPLEMENTATION::ondemand::value>::for_each_at_path_with_wildcard(
+      std::string_view json_path, Func&& callback) noexcept {
   if (error()) {
     return error();
   }
-  return first.at_path_with_wildcard(json_path);
+  return first.for_each_at_path_with_wildcard(json_path, std::forward<Func>(callback));
 }
 
 } // namespace simdjson

include/simdjson/generic/ondemand/value.h

@@ -698,13 +698,21 @@ public:
   simdjson_inline simdjson_result<value> at_path(std::string_view at_path) noexcept;
 
   /**
-   * Get all values matching the given JSONPath expression with wildcard support.
+   * Call the provided callback for each value matching the given JSONPath
+   * expression with wildcard support.
    * Supports wildcard character (*) for arrays or ".*" for objects.
    *
    * @param json_path JSONPath expression with wildcards
-   * @return Vector of values matching the wildcard pattern
+   * @param callback Function called for each matching value
+   * @return error_code indicating success or failure
    */
-  simdjson_inline simdjson_result<std::vector<value>> at_path_with_wildcard(std::string_view json_path) noexcept;
+#if SIMDJSON_SUPPORTS_CONCEPTS
+  template <typename Func>
+    requires std::invocable<Func, value>
+#else
+  template <typename Func>
+#endif
+  simdjson_inline error_code for_each_at_path_with_wildcard(std::string_view json_path, Func&& callback) noexcept;
 
 protected:
   /**
@@ -897,9 +905,23 @@ public:
   simdjson_inline simdjson_result<int32_t> current_depth() const noexcept;
   simdjson_inline simdjson_result<SIMDJSON_IMPLEMENTATION::ondemand::value> at_pointer(std::string_view json_pointer) noexcept;
   simdjson_inline simdjson_result<SIMDJSON_IMPLEMENTATION::ondemand::value> at_path(std::string_view json_path) noexcept;
-  simdjson_inline simdjson_result<std::vector<SIMDJSON_IMPLEMENTATION::ondemand::value>> at_path_with_wildcard(std::string_view json_path) noexcept;
+#if SIMDJSON_SUPPORTS_CONCEPTS
+  template <typename Func>
+    requires std::invocable<Func, SIMDJSON_IMPLEMENTATION::ondemand::value>
+#else
+  template <typename Func>
+#endif
+  simdjson_inline error_code for_each_at_path_with_wildcard(std::string_view json_path, Func&& callback) noexcept;
 };
 
+// Forward-declare explicit specializations so MSVC /permissive- sees them before
+// any template instantiation that would resolve element.get(val) to the primary.
+template<> simdjson_inline error_code
+simdjson_result<SIMDJSON_IMPLEMENTATION::ondemand::value>::get<SIMDJSON_IMPLEMENTATION::ondemand::value>(
+    SIMDJSON_IMPLEMENTATION::ondemand::value &out) noexcept;
+template<> simdjson_inline simdjson_result<SIMDJSON_IMPLEMENTATION::ondemand::value>
+simdjson_result<SIMDJSON_IMPLEMENTATION::ondemand::value>::get<SIMDJSON_IMPLEMENTATION::ondemand::value>() noexcept;
+
 } // namespace simdjson
 
 #endif // SIMDJSON_GENERIC_ONDEMAND_VALUE_H

include/simdjson/ondemand.h

@@ -8,14 +8,12 @@ namespace simdjson {
    * @copydoc simdjson::builtin::ondemand
    */
   namespace ondemand = builtin::ondemand;
-#if SIMDJSON_FEATURE_BUILDER_API
   /**
    * @copydoc simdjson::builtin::builder
    */
   namespace builder = builtin::builder;
-#endif // SIMDJSON_FEATURE_BUILDER_API
 
-#if SIMDJSON_STATIC_REFLECTION && SIMDJSON_FEATURE_BUILDER_API
+#if SIMDJSON_STATIC_REFLECTION
   /**
    * Create a JSON string from any user-defined type using static reflection.
    * Only available when SIMDJSON_STATIC_REFLECTION is enabled.

include/simdjson/padded_string_view-inl.h

@@ -6,15 +6,6 @@
 
 #include <cstring> /* memcmp */
 
-// for page size computation.
-#if defined(__unix__) || defined(__APPLE__) || defined(__linux__)
-  #include <unistd.h>
-  #if defined(__APPLE__)
-    #include <sys/sysctl.h>
-  #endif
-#endif
-
-
 namespace simdjson {
 
 inline padded_string_view::padded_string_view(const char* s, size_t len, size_t capacity) noexcept
@@ -104,83 +95,7 @@ inline padded_string_view pad_with_reserve(std::string& s) noexcept {
   return padded_string_view(s.data(), s.size(), s.capacity());
 }
 
-inline uint32_t get_page_size() noexcept {
-#if defined(_WINDOWS_) // if and only if someone loaded Windows.h, we can get the page size from there.
-// Otherwise, we assume 4096.
-    static const uint32_t cached = []() -> uint32_t {
-      SYSTEM_INFO si;
-      GetSystemInfo(&si);
-      return static_cast<std::uint32_t>(si.dwPageSize);
-    }();
-    return cached;
-#elif defined(__unix__) || defined(__APPLE__) || defined(__linux__)
-    static const uint32_t cached = []() -> uint32_t {
-      long page_size = sysconf(_SC_PAGESIZE);
-      if (page_size > 0) {
-          return static_cast<uint32_t>(page_size);
-      }
-      return 4096; // fallback
-    }();
-    return cached;
-#else
-    return 4096; // fallback
-#endif
-}
-#if SIMDJSON_CPLUSPLUS17
 
-inline padded_input::padded_input(std::string_view sv)
-    : storage(simdjson::padded_string_view{}) {
-  if (needs_allocation(sv.data(), sv.size())) {
-      storage = simdjson::padded_string(sv);
-  } else {
-      storage = simdjson::padded_string_view(
-          sv.data(), sv.size(), sv.size() + simdjson::SIMDJSON_PADDING);
-  }
-}
-
-inline padded_input::padded_input(const char *data, size_t length)
-    : storage(simdjson::padded_string_view{}) {
-  if (needs_allocation(data, length)) {
-      storage = simdjson::padded_string(data, length);
-  } else {
-      storage = simdjson::padded_string_view(
-          data, length, length + simdjson::SIMDJSON_PADDING);
-  }
-}
-
-inline padded_input::padded_input(const std::string &s)
-    : storage(simdjson::padded_string_view{}) {
-  const size_t len = s.size();
-  const size_t cap = s.capacity();
-  // Here we have the string content from data() to data() + size(),
-  // but the memory is accessible from data() to data() + capacity().
-  const size_t needed_padding = (cap - len) < simdjson::SIMDJSON_PADDING
-    ? simdjson::SIMDJSON_PADDING - (cap - len) : 0;
-  if (needed_padding > 0 && needs_allocation(s.data(), cap, needed_padding)) {
-      storage = simdjson::padded_string(s);
-  } else {
-      storage = simdjson::padded_string_view(
-          s.data(), len, len + simdjson::SIMDJSON_PADDING);
-  }
-}
-
-inline bool padded_input::is_view() const noexcept {
-  return std::holds_alternative<simdjson::padded_string_view>(storage);
-}
-
-inline padded_input::operator simdjson::padded_string_view() const noexcept {
-  return std::visit([](const auto& p) -> simdjson::padded_string_view {
-      return p;
-  }, storage);
-}
-
-inline bool padded_input::needs_allocation(const char* buf, size_t len, size_t padding) noexcept {
-  if(len == 0) { return false; }
-  const auto page_size = get_page_size();
-  return ((reinterpret_cast<uintptr_t>(buf + len - 1) % page_size)
-          + padding >= static_cast<uintptr_t>(page_size));
-}
-#endif // SIMDJSON_CPLUSPLUS17
 
 } // namespace simdjson
 

include/simdjson/padded_string_view.h

@@ -9,9 +9,6 @@
 #include <memory>
 #include <string>
 #include <ostream>
-#if SIMDJSON_CPLUSPLUS17
-#include <variant>
-#endif
 
 namespace simdjson {
 
@@ -76,68 +73,6 @@ public:
 
 }; // padded_string_view
 
-/**
- * Get the system's memory page size. By default, we return
- * 4096 bytes, which is the most common page size. On systems
- * where the page size is not a multiple of 4096 bytes, and not
- * a unix-like system, nor Windows, this function may return an
- * incorrect value.
- *
- * @return The page size in bytes.
- */
-inline uint32_t get_page_size() noexcept;
-
-#if SIMDJSON_CPLUSPLUS17
-/**
- * A padded_input is a wrapper around either a padded_string_view or a padded_string.
- * It will automatically pad a string_view if it does not have sufficient padding
- * up to the end of the memory page. Note that a requirement for this method to
- * make sense is to be on a system with a page size of at least 4096 (which is
- * universal except on some embedded systems).
- */
-struct padded_input {
-    /**
-     * Construct a padded_input from a string_view. If the string_view does not have sufficient padding,
-     * the data will be copied into a padded_string and the padded_string_view will point to the
-     * padded_string's data. Otherwise, the padded_string_view will point to the original string_view's data.
-     */
-     inline explicit padded_input(std::string_view sv);
-    /**
-     * Construct a padded_input from a C-style string (length specified). If the string does not have sufficient padding,
-     * the data will be copied into a padded_string and the padded_string_view will point to the
-     * padded_string's data. Otherwise, the padded_string_view will point to the original string's data.
-     */
-     inline explicit padded_input(const char *data, size_t length);
-    /**
-     * Construct a padded_input from a std::string. If the string does not have sufficient padding
-     * (considering its capacity), the data will be copied into a padded_string and the padded_string_view
-     * will point to the padded_string's data. Otherwise, the padded_string_view will point to the
-     * original string's data.
-     */
-     inline explicit padded_input(const std::string &s);
-
-    /**
-     * Check if the padded_input is a view.
-     *
-     * @return true if the padded_input is a view, false otherwise.
-     */
-     inline bool is_view() const noexcept;
-
-    /**
-     * Convert the padded_input to a padded_string_view.
-     *
-     * @return The padded_string_view.
-     */
-     inline operator simdjson::padded_string_view() const noexcept;
-
-private:
-    std::variant<simdjson::padded_string_view, simdjson::padded_string> storage;
-    // whether we cross a page boundary and need to allocate a new padded string.
-    static inline bool needs_allocation(const char* buf, size_t len, size_t padding = SIMDJSON_PADDING) noexcept;
-};
-
-#endif // SIMDJSON_CPLUSPLUS17
-
 #if SIMDJSON_EXCEPTIONS
 /**
  * Send padded_string instance to an output stream.
@@ -170,7 +105,6 @@ inline padded_string_view pad(std::string& s) noexcept;
  * @return The padded string.
  */
 inline padded_string_view pad_with_reserve(std::string& s) noexcept;
-
 } // namespace simdjson
 
 #endif // SIMDJSON_PADDED_STRING_VIEW_H

include/simdjson/simdjson_version.h

@@ -4,7 +4,7 @@
 #define SIMDJSON_SIMDJSON_VERSION_H
 
 /** The version of simdjson being used (major.minor.revision) */
-#define SIMDJSON_VERSION "4.6.1"
+#define SIMDJSON_VERSION "4.6.4"
 
 namespace simdjson {
 enum {
@@ -19,7 +19,7 @@ enum {
   /**
    * The revision (major.minor.REVISION) of simdjson being used.
    */
-  SIMDJSON_VERSION_REVISION = 1
+  SIMDJSON_VERSION_REVISION = 4
 };
 } // namespace simdjson
 

jsonexamples/example_config.json

@@ -1,11 +0,0 @@
-{
-  "app_name": "MyApp",
-  "version": "1.0.0",
-  "port": 8080,
-  "debug": true,
-  "features": ["logging", "caching"],
-  "database": {
-    "host": "localhost",
-    "port": 5432
-  }
-}

singleheader/all_features_test.py

@@ -1,226 +0,0 @@
-#!/usr/bin/env python3
-"""
-Amalgamates simdjson into temporary files, then builds and runs 7 feature-flag
-test programs.  Reports compile time and binary size for each configuration.
-"""
-
-import os
-import sys
-import subprocess
-import tempfile
-import time
-import shutil
-
-SCRIPTPATH = os.path.dirname(os.path.abspath(__file__))
-PROJECTPATH = os.path.dirname(SCRIPTPATH)
-TESTSRC = os.path.join(PROJECTPATH, "tests", "feature_flag_tests")
-
-# ── feature-flag configurations ──────────────────────────────────────────────
-CONFIGS = [
-    {
-        "name": "dom_only",
-        "flags": {"SIMDJSON_FEATURE_DOM_API": 1,
-                  "SIMDJSON_FEATURE_ONDEMAND_API": 0,
-                  "SIMDJSON_FEATURE_BUILDER_API": 0},
-    },
-    {
-        "name": "ondemand_only",
-        "flags": {"SIMDJSON_FEATURE_DOM_API": 1,
-                  "SIMDJSON_FEATURE_ONDEMAND_API": 1,
-                  "SIMDJSON_FEATURE_BUILDER_API": 0},
-    },
-    {
-        "name": "dom_and_ondemand",
-        "flags": {"SIMDJSON_FEATURE_DOM_API": 1,
-                  "SIMDJSON_FEATURE_ONDEMAND_API": 1,
-                  "SIMDJSON_FEATURE_BUILDER_API": 0},
-    },
-    {
-        "name": "builder_and_dom",
-        "flags": {"SIMDJSON_FEATURE_DOM_API": 1,
-                  "SIMDJSON_FEATURE_ONDEMAND_API": 0,
-                  "SIMDJSON_FEATURE_BUILDER_API": 1},
-    },
-    {
-        "name": "builder_and_ondemand",
-        "flags": {"SIMDJSON_FEATURE_DOM_API": 1,
-                  "SIMDJSON_FEATURE_ONDEMAND_API": 1,
-                  "SIMDJSON_FEATURE_BUILDER_API": 1},
-    },
-    {
-        "name": "builder_dom_and_ondemand",
-        "flags": {"SIMDJSON_FEATURE_DOM_API": 1,
-                  "SIMDJSON_FEATURE_ONDEMAND_API": 1,
-                  "SIMDJSON_FEATURE_BUILDER_API": 1},
-    },
-    {
-        "name": "builder_only",
-        "flags": {"SIMDJSON_FEATURE_DOM_API": 1,
-                  "SIMDJSON_FEATURE_ONDEMAND_API": 0,
-                  "SIMDJSON_FEATURE_BUILDER_API": 1},
-    },
-]
-
-CXX = os.environ.get("CXX", "c++")
-CXXSTD = os.environ.get("CXXSTD", "-std=c++17")
-OPT = os.environ.get("OPT", "-O2")
-
-
-def amalgamate(output_dir):
-    """Run amalgamate.py, writing simdjson.h / simdjson.cpp into *output_dir*."""
-    env = os.environ.copy()
-    env["AMALGAMATE_OUTPUT_PATH"] = output_dir
-    cmd = [sys.executable, os.path.join(SCRIPTPATH, "amalgamate.py")]
-    result = subprocess.run(cmd, env=env, capture_output=True, text=True)
-    if result.returncode != 0:
-        print("amalgamate.py failed:")
-        print(result.stdout)
-        print(result.stderr)
-        sys.exit(1)
-    header = os.path.join(output_dir, "simdjson.h")
-    source = os.path.join(output_dir, "simdjson.cpp")
-    assert os.path.isfile(header), f"missing {header}"
-    assert os.path.isfile(source), f"missing {source}"
-    return header, source
-
-
-def compile_and_run(name, flags, amal_dir, build_dir):
-    """
-    1. Compile simdjson.cpp -> simdjson.o  (timed, size reported)
-    2. Compile test .cpp -> test.o         (timed, size reported)
-    3. Link and run the test program
-
-    Returns (lib_time, lib_size, test_time, test_size) or Nones on failure.
-    """
-    src = os.path.join(TESTSRC, f"{name}.cpp")
-    simdjson_cpp = os.path.join(amal_dir, "simdjson.cpp")
-    simdjson_o = os.path.join(build_dir, f"{name}_simdjson.o")
-    test_o = os.path.join(build_dir, f"{name}.o")
-    binary = os.path.join(build_dir, name)
-
-    defs = [f"-D{k}={v}" for k, v in flags.items()]
-
-    # ── compile simdjson.o (timed) ────────────────────────────────────────
-    cmd_lib = [CXX, CXXSTD, OPT, "-c"] + defs + [
-        f"-I{amal_dir}", "-o", simdjson_o, simdjson_cpp,
-    ]
-    t0 = time.monotonic()
-    result = subprocess.run(cmd_lib, capture_output=True, text=True)
-    lib_time = time.monotonic() - t0
-
-    if result.returncode != 0:
-        print(f"  COMPILE FAILED (simdjson.o): {name}")
-        print(f"  command: {' '.join(cmd_lib)}")
-        print(result.stderr)
-        return None, None, None, None
-
-    lib_size = os.path.getsize(simdjson_o)
-
-    # ── compile test source (timed) ───────────────────────────────────────
-    cmd_test = [CXX, CXXSTD, OPT, "-c"] + defs + [
-        f"-I{amal_dir}", "-o", test_o, src,
-    ]
-    t0 = time.monotonic()
-    result = subprocess.run(cmd_test, capture_output=True, text=True)
-    test_time = time.monotonic() - t0
-
-    if result.returncode != 0:
-        print(f"  COMPILE FAILED (test): {name}")
-        print(f"  command: {' '.join(cmd_test)}")
-        print(result.stderr)
-        return None, None, None, None
-
-    test_size = os.path.getsize(test_o)
-
-    # ── link ──────────────────────────────────────────────────────────────
-    cmd_link = [CXX, "-o", binary, test_o, simdjson_o]
-    result = subprocess.run(cmd_link, capture_output=True, text=True)
-    if result.returncode != 0:
-        print(f"  LINK FAILED: {name}")
-        print(f"  command: {' '.join(cmd_link)}")
-        print(result.stderr)
-        return None, None, None, None
-
-    # ── run ───────────────────────────────────────────────────────────────
-    result = subprocess.run([binary], capture_output=True, text=True)
-    if result.returncode != 0:
-        print(f"  RUN FAILED: {name}")
-        print(result.stdout)
-        print(result.stderr)
-        return lib_time, lib_size, test_time, test_size
-
-    print(f"  {result.stdout.strip()}")
-    return lib_time, lib_size, test_time, test_size
-
-
-def human_size(n):
-    """Return e.g. '1.23 MB' or '456 KB'."""
-    if n is None:
-        return "N/A"
-    if n >= 1_000_000:
-        return f"{n / 1_000_000:.2f} MB"
-    if n >= 1_000:
-        return f"{n / 1_000:.1f} KB"
-    return f"{n} B"
-
-
-def main():
-    tmpdir = tempfile.mkdtemp(prefix="simdjson_features_")
-    amal_dir = os.path.join(tmpdir, "amalgamated")
-    build_dir = os.path.join(tmpdir, "build")
-    os.makedirs(amal_dir, exist_ok=True)
-    os.makedirs(build_dir, exist_ok=True)
-
-    print(f"Working directory: {tmpdir}")
-    print(f"Compiler: {CXX}  flags: {CXXSTD} {OPT}")
-    print()
-
-    # ── amalgamate ────────────────────────────────────────────────────────
-    print("Amalgamating...")
-    amalgamate(amal_dir)
-    print("Amalgamation done.\n")
-
-    # ── build & run each configuration ────────────────────────────────────
-    results = []
-    for cfg in CONFIGS:
-        name = cfg["name"]
-        flags = cfg["flags"]
-        enabled = [k.replace("SIMDJSON_FEATURE_", "").replace("_API", "")
-                   for k, v in flags.items() if v]
-        label = " + ".join(enabled) if enabled else "none"
-        print(f"[{name}] ({label})")
-        lib_time, lib_size, test_time, test_size = \
-            compile_and_run(name, flags, amal_dir, build_dir)
-        results.append((name, label, lib_time, lib_size, test_time, test_size))
-
-    print()
-
-    # ── summary table ─────────────────────────────────────────────────────
-    name_w = max(len(r[0]) for r in results)
-    label_w = max(len(r[1]) for r in results)
-    hdr = (f"{'Test':<{name_w}}  {'APIs':<{label_w}}"
-           f"  {'lib time':>9}  {'simdjson.o':>11}"
-           f"  {'test time':>10}  {'test .o':>11}")
-    print(hdr)
-    print("-" * len(hdr))
-    for name, label, lt, ls, tt, ts in results:
-        lt_s = f"{lt:.2f} s" if lt is not None else "FAIL"
-        ls_s = human_size(ls)
-        tt_s = f"{tt:.2f} s" if tt is not None else "FAIL"
-        ts_s = human_size(ts)
-        print(f"{name:<{name_w}}  {label:<{label_w}}"
-              f"  {lt_s:>9}  {ls_s:>11}"
-              f"  {tt_s:>10}  {ts_s:>11}")
-
-    # ── cleanup ───────────────────────────────────────────────────────────
-    shutil.rmtree(tmpdir, ignore_errors=True)
-
-    # exit non-zero if anything failed
-    if any(lt is None for _, _, lt, _, _, _ in results):
-        print("\nSome tests FAILED.")
-        sys.exit(1)
-    print("\nAll tests passed.")
-
-
-if __name__ == "__main__":
-    main()

singleheader/amalgamate.py

@@ -268,21 +268,7 @@ class SimdjsonFile:
         print(f"    Adding include: {self} includes {include}")
         if self.is_conditional_include:
             # If I have a dependency file, I can only include something that has a dependency file.
-            if not include.is_conditional_include:
+            assert include.is_conditional_include, f"Error: Amalgamated file '{self}' is trying to include '{include}', but '{include}' is not an amalgamated file. Amalgamated files can only include other amalgamated files to maintain conditional inclusion structure. Check the inclusion rules in the script's 'rules' variable. {rules}"
-                dep = self.dependency_file
-                dep_hint = f" and add it to the dependency file '{dep}'" if dep else ""
-                raise AssertionError(
-                    f"Error: Amalgamated file '{self}' is trying to include '{include}', "
-                    f"but '{include}' is not an amalgamated file.\n\n"
-                    f"FIX: Wrap the #include \"{include}\" in a conditional block:\n\n"
-                    f"    #ifndef SIMDJSON_CONDITIONAL_INCLUDE\n"
-                    f"    #include \"{include}\"\n"
-                    f"    #endif // SIMDJSON_CONDITIONAL_INCLUDE\n\n"
-                    f"This makes the include editor-only (skipped during amalgamation){dep_hint}.\n\n"
-                    f"During amalgamation, '{include}' is already included earlier in the "
-                    f"amalgamated output, so it does not need to be included again.\n\n"
-                    f"{rules}"
-                )
             # TODO make sure we only include amalgamated files that are guaranteed to be included with us (or before us)
             # if include.amalgamator_file:
             #     assert include.amalgamator_file == self, f"{self} cannot include {include}: it should be included from {include.amalgamator_file} instead."
@@ -439,10 +425,8 @@ class Amalgamator:
             self.implementation = "SIMDJSON_BUILTIN_IMPLEMENTATION"
 
         assert not self.editor_only_region, f"Error: Already in an editor-only region when starting to write '{file}'. Ensure proper nesting of conditional blocks."
-        editor_only_start_line = None
-        bare_endif_lines = []
         with open(file.absolute_path, 'r') as fid2:
-            for line_number, line in enumerate(fid2, 1):
+            for line in fid2:
                 line = line.rstrip('\n')
 
                 # Ignore #pragma once, it causes warnings if it ends up in a .cpp file
@@ -455,7 +439,6 @@ class Amalgamator:
                     assert self.in_conditional_include_block, f"Error: File '{file}' uses '#ifndef SIMDJSON_CONDITIONAL_INCLUDE' without a prior '#define SIMDJSON_CONDITIONAL_INCLUDE'. Ensure the define comes first. Stack: {self.include_stack}. {rules}"
                     assert not self.editor_only_region, f"Error: File '{file}' uses '#ifndef SIMDJSON_CONDITIONAL_INCLUDE' twice in a row. Ensure conditional blocks are properly nested and closed. {rules}"
                     self.editor_only_region = True
-                    editor_only_start_line = line_number
 
                 # Handle ignored lines (and ending ignore blocks)
                 end_ignore = endif_conditional_re.search(line)
@@ -470,12 +453,6 @@ class Amalgamator:
                             file.add_editor_only_include(included_file)
                     if end_ignore:
                         self.editor_only_region = False
-                        editor_only_start_line = None
-                    else:
-                        # Track bare #endif lines that might be the intended closer
-                        stripped = line.strip()
-                        if stripped == '#endif' or (stripped.startswith('#endif') and 'SIMDJSON_CONDITIONAL_INCLUDE' not in stripped):
-                            bare_endif_lines.append((line_number, line.strip()))
                     continue
 
                 assert not end_ignore, f"Error: File '{file}' has '#endif // SIMDJSON_CONDITIONAL_INCLUDE' without a matching '#ifndef'. Ensure proper conditional block structure. {rules}"
@@ -524,35 +501,7 @@ class Amalgamator:
 
                 self.write(line)
 
-            if self.editor_only_region:
+            assert not self.editor_only_region, f"Error: File '{file}' ended without closing the '#endif // SIMDJSON_CONDITIONAL_INCLUDE'. Ensure all conditional blocks are properly closed. {rules}"
-                msg = (
-                    f"Error: File '{file}' ended without closing the "
-                    f"'#endif // SIMDJSON_CONDITIONAL_INCLUDE' block "
-                    f"(opened at line {editor_only_start_line}).\n\n"
-                )
-                if bare_endif_lines:
-                    msg += (
-                        f"HINT: Found #endif line(s) inside the block that are missing "
-                        f"the required comment. The amalgamation script looks for exactly:\n\n"
-                        f"    #endif // SIMDJSON_CONDITIONAL_INCLUDE\n\n"
-                        f"but found:\n"
-                    )
-                    for ln, text in bare_endif_lines:
-                        msg += f"    line {ln}: {text}\n"
-                    msg += (
-                        f"\nFIX: Change the #endif to:\n\n"
-                        f"    #endif // SIMDJSON_CONDITIONAL_INCLUDE\n\n"
-                        f"The '// SIMDJSON_CONDITIONAL_INCLUDE' comment is required "
-                        f"for the amalgamation script to recognize it as the closing "
-                        f"of the conditional block.\n"
-                    )
-                else:
-                    msg += (
-                        f"FIX: Add '#endif // SIMDJSON_CONDITIONAL_INCLUDE' to close "
-                        f"the '#ifndef SIMDJSON_CONDITIONAL_INCLUDE' block.\n"
-                    )
-                msg += f"\n{rules}"
-                raise AssertionError(msg)
 
         self.write(f"/* end file {self.file_to_str(file)} */")
 

src/arm64.cpp

@@ -2,7 +2,6 @@
 #define SIMDJSON_SRC_ARM64_CPP
 
 #ifndef SIMDJSON_CONDITIONAL_INCLUDE
-#include "simdjson/feature_macros.h"
 #include <base.h>
 #endif // SIMDJSON_CONDITIONAL_INCLUDE
 
@@ -143,7 +142,6 @@ simdjson_warn_unused bool implementation::validate_utf8(const char *buf, size_t
   return arm64::stage1::generic_validate_utf8(buf,len);
 }
 
-#if SIMDJSON_FEATURE_DOM_API
 simdjson_warn_unused error_code dom_parser_implementation::stage2(dom::document &_doc) noexcept {
   return stage2::tape_builder::parse_document<false>(*this, _doc);
 }
@@ -151,7 +149,6 @@ simdjson_warn_unused error_code dom_parser_implementation::stage2(dom::document
 simdjson_warn_unused error_code dom_parser_implementation::stage2_next(dom::document &_doc) noexcept {
   return stage2::tape_builder::parse_document<true>(*this, _doc);
 }
-#endif // SIMDJSON_FEATURE_DOM_API
 
 SIMDJSON_NO_SANITIZE_MEMORY
 simdjson_warn_unused uint8_t *dom_parser_implementation::parse_string(const uint8_t *src, uint8_t *dst, bool allow_replacement) const noexcept {
@@ -162,13 +159,11 @@ simdjson_warn_unused uint8_t *dom_parser_implementation::parse_wobbly_string(con
   return arm64::stringparsing::parse_wobbly_string(src, dst);
 }
 
-#if SIMDJSON_FEATURE_DOM_API
 simdjson_warn_unused error_code dom_parser_implementation::parse(const uint8_t *_buf, size_t _len, dom::document &_doc) noexcept {
   auto error = stage1(_buf, _len, stage1_mode::regular);
   if (error) { return error; }
   return stage2(_doc);
 }
-#endif // SIMDJSON_FEATURE_DOM_API
 
 } // namespace arm64
 } // namespace simdjson

src/fallback.cpp

@@ -2,7 +2,6 @@
 #define SIMDJSON_SRC_FALLBACK_CPP
 
 #ifndef SIMDJSON_CONDITIONAL_INCLUDE
-#include "simdjson/feature_macros.h"
 #include <base.h>
 #endif // SIMDJSON_CONDITIONAL_INCLUDE
 
@@ -12,13 +11,10 @@
 #include <simdjson/fallback/begin.h>
 #include <generic/stage1/find_next_document_index.h>
 #include <generic/stage2/stringparsing.h>
-
-#if SIMDJSON_FEATURE_DOM_API
 #include <generic/stage2/logger.h>
 #include <generic/stage2/json_iterator.h>
 #include <generic/stage2/tape_writer.h>
 #include <generic/stage2/tape_builder.h>
-#endif // SIMDJSON_FEATURE_DOM_API
 
 //
 // Stage 1
@@ -440,7 +436,6 @@ simdjson_warn_unused bool implementation::validate_utf8(const char *buf, size_t
 namespace simdjson {
 namespace fallback {
 
-#if SIMDJSON_FEATURE_DOM_API
 simdjson_warn_unused error_code dom_parser_implementation::stage2(dom::document &_doc) noexcept {
   return stage2::tape_builder::parse_document<false>(*this, _doc);
 }
@@ -448,7 +443,6 @@ simdjson_warn_unused error_code dom_parser_implementation::stage2(dom::document
 simdjson_warn_unused error_code dom_parser_implementation::stage2_next(dom::document &_doc) noexcept {
   return stage2::tape_builder::parse_document<true>(*this, _doc);
 }
-#endif // SIMDJSON_FEATURE_DOM_API
 
 SIMDJSON_NO_SANITIZE_MEMORY
 simdjson_warn_unused uint8_t *dom_parser_implementation::parse_string(const uint8_t *src, uint8_t *dst, bool replacement_char) const noexcept {
@@ -459,13 +453,11 @@ simdjson_warn_unused uint8_t *dom_parser_implementation::parse_wobbly_string(con
   return fallback::stringparsing::parse_wobbly_string(src, dst);
 }
 
-#if SIMDJSON_FEATURE_DOM_API
 simdjson_warn_unused error_code dom_parser_implementation::parse(const uint8_t *_buf, size_t _len, dom::document &_doc) noexcept {
   auto error = stage1(_buf, _len, stage1_mode::regular);
   if (error) { return error; }
   return stage2(_doc);
 }
-#endif // SIMDJSON_FEATURE_DOM_API
 
 } // namespace fallback
 } // namespace simdjson

src/generic/dependencies.h

@@ -5,7 +5,6 @@
 #ifndef SIMDJSON_SRC_GENERIC_DEPENDENCIES_H
 #define SIMDJSON_SRC_GENERIC_DEPENDENCIES_H
 
-#include "simdjson/feature_macros.h"
 #include <base.h>
 
 #endif // SIMDJSON_SRC_GENERIC_DEPENDENCIES_H

src/generic/stage2/amalgamated.h

@@ -1,7 +1,3 @@
-#include <generic/stage2/stringparsing.h>
-
-#if SIMDJSON_FEATURE_DOM_API
-
 // Stuff other things depend on
 #include <generic/stage2/base.h>
 #include <generic/stage2/tape_writer.h>
@@ -9,7 +5,6 @@
 
 // All other declarations
 #include <generic/stage2/json_iterator.h>
+#include <generic/stage2/stringparsing.h>
 #include <generic/stage2/structural_iterator.h>
 #include <generic/stage2/tape_builder.h>
-
-#endif // SIMDJSON_FEATURE_DOM_API

src/haswell.cpp

@@ -2,7 +2,6 @@
 #define SIMDJSON_SRC_HASWELL_CPP
 
 #ifndef SIMDJSON_CONDITIONAL_INCLUDE
-#include "simdjson/feature_macros.h"
 #include <base.h>
 #endif // SIMDJSON_CONDITIONAL_INCLUDE
 
@@ -140,7 +139,6 @@ simdjson_warn_unused bool implementation::validate_utf8(const char *buf, size_t
   return haswell::stage1::generic_validate_utf8(buf,len);
 }
 
-#if SIMDJSON_FEATURE_DOM_API
 simdjson_warn_unused error_code dom_parser_implementation::stage2(dom::document &_doc) noexcept {
   return stage2::tape_builder::parse_document<false>(*this, _doc);
 }
@@ -148,7 +146,6 @@ simdjson_warn_unused error_code dom_parser_implementation::stage2(dom::document
 simdjson_warn_unused error_code dom_parser_implementation::stage2_next(dom::document &_doc) noexcept {
   return stage2::tape_builder::parse_document<true>(*this, _doc);
 }
-#endif // SIMDJSON_FEATURE_DOM_API
 
 SIMDJSON_NO_SANITIZE_MEMORY
 simdjson_warn_unused uint8_t *dom_parser_implementation::parse_string(const uint8_t *src, uint8_t *dst, bool replacement_char) const noexcept {
@@ -159,17 +156,15 @@ simdjson_warn_unused uint8_t *dom_parser_implementation::parse_wobbly_string(con
   return haswell::stringparsing::parse_wobbly_string(src, dst);
 }
 
-#if SIMDJSON_FEATURE_DOM_API
 simdjson_warn_unused error_code dom_parser_implementation::parse(const uint8_t *_buf, size_t _len, dom::document &_doc) noexcept {
   auto error = stage1(_buf, _len, stage1_mode::regular);
   if (error) { return error; }
   return stage2(_doc);
 }
-#endif // SIMDJSON_FEATURE_DOM_API
 
 } // namespace SIMDJSON_IMPLEMENTATION
 } // namespace simdjson
 
 #include <simdjson/haswell/end.h>
 
-#endif // SIMDJSON_SRC_HASWELL_CPP
+#endif // SIMDJSON_SRC_HASWELL_CPP

src/icelake.cpp

@@ -2,7 +2,6 @@
 #define SIMDJSON_SRC_ICELAKE_CPP
 
 #ifndef SIMDJSON_CONDITIONAL_INCLUDE
-#include "simdjson/feature_macros.h"
 #include <base.h>
 #endif // SIMDJSON_CONDITIONAL_INCLUDE
 
@@ -186,7 +185,6 @@ simdjson_warn_unused bool implementation::validate_utf8(const char *buf, size_t
   return icelake::stage1::generic_validate_utf8(buf,len);
 }
 
-#if SIMDJSON_FEATURE_DOM_API
 simdjson_warn_unused error_code dom_parser_implementation::stage2(dom::document &_doc) noexcept {
   return stage2::tape_builder::parse_document<false>(*this, _doc);
 }
@@ -194,7 +192,6 @@ simdjson_warn_unused error_code dom_parser_implementation::stage2(dom::document
 simdjson_warn_unused error_code dom_parser_implementation::stage2_next(dom::document &_doc) noexcept {
   return stage2::tape_builder::parse_document<true>(*this, _doc);
 }
-#endif // SIMDJSON_FEATURE_DOM_API
 
 SIMDJSON_NO_SANITIZE_MEMORY
 simdjson_warn_unused uint8_t *dom_parser_implementation::parse_string(const uint8_t *src, uint8_t *dst, bool replacement_char) const noexcept {
@@ -205,13 +202,11 @@ simdjson_warn_unused uint8_t *dom_parser_implementation::parse_wobbly_string(con
   return icelake::stringparsing::parse_wobbly_string(src, dst);
 }
 
-#if SIMDJSON_FEATURE_DOM_API
 simdjson_warn_unused error_code dom_parser_implementation::parse(const uint8_t *_buf, size_t _len, dom::document &_doc) noexcept {
   auto error = stage1(_buf, _len, stage1_mode::regular);
   if (error) { return error; }
   return stage2(_doc);
 }
-#endif // SIMDJSON_FEATURE_DOM_API
 
 } // namespace icelake
 } // namespace simdjson

src/lasx.cpp

@@ -2,7 +2,6 @@
 #define SIMDJSON_SRC_LASX_CPP
 
 #ifndef SIMDJSON_CONDITIONAL_INCLUDE
-#include "simdjson/feature_macros.h"
 #include <base.h>
 #endif // SIMDJSON_CONDITIONAL_INCLUDE
 
@@ -103,7 +102,6 @@ simdjson_warn_unused bool implementation::validate_utf8(const char *buf, size_t
   return lasx::stage1::generic_validate_utf8(buf,len);
 }
 
-#if SIMDJSON_FEATURE_DOM_API
 simdjson_warn_unused error_code dom_parser_implementation::stage2(dom::document &_doc) noexcept {
   return stage2::tape_builder::parse_document<false>(*this, _doc);
 }
@@ -111,7 +109,6 @@ simdjson_warn_unused error_code dom_parser_implementation::stage2(dom::document
 simdjson_warn_unused error_code dom_parser_implementation::stage2_next(dom::document &_doc) noexcept {
   return stage2::tape_builder::parse_document<true>(*this, _doc);
 }
-#endif // SIMDJSON_FEATURE_DOM_API
 
 SIMDJSON_NO_SANITIZE_MEMORY
 simdjson_warn_unused uint8_t *dom_parser_implementation::parse_string(const uint8_t *src, uint8_t *dst, bool allow_replacement) const noexcept {
@@ -122,13 +119,11 @@ simdjson_warn_unused uint8_t *dom_parser_implementation::parse_wobbly_string(con
   return lasx::stringparsing::parse_wobbly_string(src, dst);
 }
 
-#if SIMDJSON_FEATURE_DOM_API
 simdjson_warn_unused error_code dom_parser_implementation::parse(const uint8_t *_buf, size_t _len, dom::document &_doc) noexcept {
   auto error = stage1(_buf, _len, stage1_mode::regular);
   if (error) { return error; }
   return stage2(_doc);
 }
-#endif // SIMDJSON_FEATURE_DOM_API
 
 } // namespace lasx
 } // namespace simdjson

src/lsx.cpp

@@ -2,7 +2,6 @@
 #define SIMDJSON_SRC_LSX_CPP
 
 #ifndef SIMDJSON_CONDITIONAL_INCLUDE
-#include "simdjson/feature_macros.h"
 #include <base.h>
 #endif // SIMDJSON_CONDITIONAL_INCLUDE
 
@@ -107,7 +106,6 @@ simdjson_warn_unused bool implementation::validate_utf8(const char *buf, size_t
   return lsx::stage1::generic_validate_utf8(buf,len);
 }
 
-#if SIMDJSON_FEATURE_DOM_API
 simdjson_warn_unused error_code dom_parser_implementation::stage2(dom::document &_doc) noexcept {
   return stage2::tape_builder::parse_document<false>(*this, _doc);
 }
@@ -115,7 +113,6 @@ simdjson_warn_unused error_code dom_parser_implementation::stage2(dom::document
 simdjson_warn_unused error_code dom_parser_implementation::stage2_next(dom::document &_doc) noexcept {
   return stage2::tape_builder::parse_document<true>(*this, _doc);
 }
-#endif // SIMDJSON_FEATURE_DOM_API
 
 SIMDJSON_NO_SANITIZE_MEMORY
 simdjson_warn_unused uint8_t *dom_parser_implementation::parse_string(const uint8_t *src, uint8_t *dst, bool allow_replacement) const noexcept {
@@ -126,13 +123,11 @@ simdjson_warn_unused uint8_t *dom_parser_implementation::parse_wobbly_string(con
   return lsx::stringparsing::parse_wobbly_string(src, dst);
 }
 
-#if SIMDJSON_FEATURE_DOM_API
 simdjson_warn_unused error_code dom_parser_implementation::parse(const uint8_t *_buf, size_t _len, dom::document &_doc) noexcept {
   auto error = stage1(_buf, _len, stage1_mode::regular);
   if (error) { return error; }
   return stage2(_doc);
 }
-#endif // SIMDJSON_FEATURE_DOM_API
 
 } // namespace lsx
 } // namespace simdjson

src/ppc64.cpp

@@ -2,7 +2,6 @@
 #define SIMDJSON_SRC_PPC64_CPP
 
 #ifndef SIMDJSON_CONDITIONAL_INCLUDE
-#include "simdjson/feature_macros.h"
 #include <base.h>
 #endif // SIMDJSON_CONDITIONAL_INCLUDE
 
@@ -113,7 +112,6 @@ simdjson_warn_unused bool implementation::validate_utf8(const char *buf, size_t
   return ppc64::stage1::generic_validate_utf8(buf,len);
 }
 
-#if SIMDJSON_FEATURE_DOM_API
 simdjson_warn_unused error_code dom_parser_implementation::stage2(dom::document &_doc) noexcept {
   return stage2::tape_builder::parse_document<false>(*this, _doc);
 }
@@ -121,7 +119,6 @@ simdjson_warn_unused error_code dom_parser_implementation::stage2(dom::document
 simdjson_warn_unused error_code dom_parser_implementation::stage2_next(dom::document &_doc) noexcept {
   return stage2::tape_builder::parse_document<true>(*this, _doc);
 }
-#endif // SIMDJSON_FEATURE_DOM_API
 
 SIMDJSON_NO_SANITIZE_MEMORY
 simdjson_warn_unused uint8_t *dom_parser_implementation::parse_string(const uint8_t *src, uint8_t *dst, bool replacement_char) const noexcept {
@@ -132,13 +129,11 @@ simdjson_warn_unused uint8_t *dom_parser_implementation::parse_wobbly_string(con
   return ppc64::stringparsing::parse_wobbly_string(src, dst);
 }
 
-#if SIMDJSON_FEATURE_DOM_API
 simdjson_warn_unused error_code dom_parser_implementation::parse(const uint8_t *_buf, size_t _len, dom::document &_doc) noexcept {
   auto error = stage1(_buf, _len, stage1_mode::regular);
   if (error) { return error; }
   return stage2(_doc);
 }
-#endif // SIMDJSON_FEATURE_DOM_API
 
 } // namespace ppc64
 } // namespace simdjson

src/rvv-vls.cpp

@@ -2,7 +2,6 @@
 #define SIMDJSON_SRC_RVV_VLS_CPP
 
 #ifndef SIMDJSON_CONDITIONAL_INCLUDE
-#include "simdjson/feature_macros.h"
 #include <base.h>
 #endif // SIMDJSON_CONDITIONAL_INCLUDE
 
@@ -102,7 +101,6 @@ simdjson_warn_unused bool implementation::validate_utf8(const char *buf, size_t
   return rvv_vls::stage1::generic_validate_utf8(buf,len);
 }
 
-#if SIMDJSON_FEATURE_DOM_API
 simdjson_warn_unused error_code dom_parser_implementation::stage2(dom::document &_doc) noexcept {
   return stage2::tape_builder::parse_document<false>(*this, _doc);
 }
@@ -110,7 +108,6 @@ simdjson_warn_unused error_code dom_parser_implementation::stage2(dom::document
 simdjson_warn_unused error_code dom_parser_implementation::stage2_next(dom::document &_doc) noexcept {
   return stage2::tape_builder::parse_document<true>(*this, _doc);
 }
-#endif // SIMDJSON_FEATURE_DOM_API
 
 SIMDJSON_NO_SANITIZE_MEMORY
 simdjson_warn_unused uint8_t *dom_parser_implementation::parse_string(const uint8_t *src, uint8_t *dst, bool allow_replacement) const noexcept {
@@ -121,13 +118,11 @@ simdjson_warn_unused uint8_t *dom_parser_implementation::parse_wobbly_string(con
   return rvv_vls::stringparsing::parse_wobbly_string(src, dst);
 }
 
-#if SIMDJSON_FEATURE_DOM_API
 simdjson_warn_unused error_code dom_parser_implementation::parse(const uint8_t *_buf, size_t _len, dom::document &_doc) noexcept {
   auto error = stage1(_buf, _len, stage1_mode::regular);
   if (error) { return error; }
   return stage2(_doc);
 }
-#endif // SIMDJSON_FEATURE_DOM_API
 
 } // namespace rvv_vls
 } // namespace simdjson

src/simdjson.cpp

@@ -1,7 +1,5 @@
 #define SIMDJSON_SRC_SIMDJSON_CPP
 
-#include "simdjson/feature_macros.h"
-
 #include <base.h>
 
 SIMDJSON_PUSH_DISABLE_UNUSED_WARNINGS
@@ -15,11 +13,8 @@ SIMDJSON_PUSH_DISABLE_UNUSED_WARNINGS
 
 #include <simdjson/generic/dependencies.h>
 #include <generic/dependencies.h>
-
-#if SIMDJSON_FEATURE_DOM_API
 #include <generic/stage1/dependencies.h>
 #include <generic/stage2/dependencies.h>
-#endif
 
 #include <implementation.cpp>
 
@@ -55,3 +50,4 @@ SIMDJSON_PUSH_DISABLE_UNUSED_WARNINGS
 #undef SIMDJSON_CONDITIONAL_INCLUDE
 
 SIMDJSON_POP_DISABLE_UNUSED_WARNINGS
+

src/westmere.cpp

@@ -2,7 +2,6 @@
 #define SIMDJSON_SRC_WESTMERE_CPP
 
 #ifndef SIMDJSON_CONDITIONAL_INCLUDE
-#include "simdjson/feature_macros.h"
 #include <base.h>
 #endif // SIMDJSON_CONDITIONAL_INCLUDE
 
@@ -145,7 +144,6 @@ simdjson_warn_unused bool implementation::validate_utf8(const char *buf, size_t
   return westmere::stage1::generic_validate_utf8(buf,len);
 }
 
-#if SIMDJSON_FEATURE_DOM_API
 simdjson_warn_unused error_code dom_parser_implementation::stage2(dom::document &_doc) noexcept {
   return stage2::tape_builder::parse_document<false>(*this, _doc);
 }
@@ -153,7 +151,6 @@ simdjson_warn_unused error_code dom_parser_implementation::stage2(dom::document
 simdjson_warn_unused error_code dom_parser_implementation::stage2_next(dom::document &_doc) noexcept {
   return stage2::tape_builder::parse_document<true>(*this, _doc);
 }
-#endif // SIMDJSON_FEATURE_DOM_API
 
 SIMDJSON_NO_SANITIZE_MEMORY
 simdjson_warn_unused uint8_t *dom_parser_implementation::parse_string(const uint8_t *src, uint8_t *dst, bool replacement_char) const noexcept {
@@ -164,16 +161,14 @@ simdjson_warn_unused uint8_t *dom_parser_implementation::parse_wobbly_string(con
   return westmere::stringparsing::parse_wobbly_string(src, dst);
 }
 
-#if SIMDJSON_FEATURE_DOM_API
 simdjson_warn_unused error_code dom_parser_implementation::parse(const uint8_t *_buf, size_t _len, dom::document &_doc) noexcept {
   auto error = stage1(_buf, _len, stage1_mode::regular);
   if (error) { return error; }
   return stage2(_doc);
 }
-#endif // SIMDJSON_FEATURE_DOM_API
 } // namespace westmere
 } // namespace simdjson
 
 #include <simdjson/westmere/end.h>
 
-#endif // SIMDJSON_SRC_WESTMERE_CPP
+#endif // SIMDJSON_SRC_WESTMERE_CPP

tests/CMakeLists.txt

@@ -29,5 +29,4 @@ add_cpp_test(checkimplementation LABELS other per_implementation)
 
 add_subdirectory(compilation_failure_tests)
 add_subdirectory(builder)
-add_subdirectory(compile_time)
+add_subdirectory(compile_time)
-add_subdirectory(feature_flag_tests)

tests/builder/CMakeLists.txt

@@ -1,8 +1,5 @@
 # All remaining tests link with simdjson proper
 include_directories(..)
-if(NOT SIMDJSON_FEATURE_BUILDER_API)
-  return()
-endif()
 add_cpp_test(builder_string_builder_tests                LABELS ondemand acceptance per_implementation)
 if(SIMDJSON_STATIC_REFLECTION)
   add_cpp_test(static_reflection_custom_tests            LABELS ondemand acceptance per_implementation)

tests/builder/static_reflection_builder_tests.cpp

@@ -6,40 +6,40 @@
 
 using namespace simdjson;
 struct Car {
-  std::string make{};
+  std::string make;
-  std::string model{};
+  std::string model;
-  int64_t year{};
+  int64_t year;
-  std::vector<double> tire_pressure{};
+  std::vector<double> tire_pressure;
 };
 
 struct kid {
-  int age{};
+  int age;
-  std::string name{};
+  std::string name;
-  std::vector<std::string> toys{};
+  std::vector<std::string> toys;
   bool operator<=> (const kid&) const = default;
 };
 
 struct Z {
-  int x{};
+  int x;
   bool operator<=> (const Z&) const = default;
 };
 
 struct Y {
-  int g{};
+  int g;
-  std::string h{};
+  std::string h;
-  std::vector<int> i{};
+  std::vector<int> i;
-  Z z{};
+  Z z;
   bool operator<=> (const Y&) const = default;
 };
 
 struct X {
-  char a{};
+  char a;
-  int b{};
+  int b;
-  int c{};
+  int c;
-  std::string d{};
+  std::string d;
-  std::vector<int> e{};
+  std::vector<int> e;
-  std::vector<std::string> f{};
+  std::vector<std::string> f;
-  Y y{};
+  Y y;
   bool operator<=> (const X&) const = default;
 };
 

tests/builder/static_reflection_comprehensive_tests.cpp

@@ -16,8 +16,8 @@ namespace builder_tests {
 #if SIMDJSON_STATIC_REFLECTION
   // Custom type for testing tag_invoke with extract_into
   struct Price {
-    double amount{};
+    double amount;
-    std::string currency{};
+    std::string currency;
 
     // Custom deserializer that applies currency conversion
     friend error_code tag_invoke(deserialize_tag,
@@ -46,37 +46,17 @@ namespace builder_tests {
       return SUCCESS;
     }
   };
-  struct Car {
+
-    std::string make{};
-    std::string model{};
-    int year{};
-    double price{};
-    bool electric{};
-  };
-  struct CarOpt {
-    std::string make;
-    std::string model;
-    int year;
-    double price;
-    std::optional<std::string> color;
-  };
-  struct CarColor {
-    std::string make;
-    std::string model;
-    int year;
-    double price;
-    std::string color;
-  };
   struct Product {
-    std::string name{};
+    std::string name;
-    Price price{};  // Custom deserializable type
+    Price price;  // Custom deserializable type
-    int stock{};
+    int stock;
   };
 
   // Another custom type for testing
   struct Dimensions {
-    double value{};
+    double value;
-    std::string unit{};
+    std::string unit;
 
     // Custom deserializer that converts to metric
     friend error_code tag_invoke(deserialize_tag,
@@ -109,13 +89,6 @@ namespace builder_tests {
     Dimensions weight;
     Dimensions length;
   };
-
-  struct Person {
-    std::string name;
-    int age;
-    std::optional<std::string> email;
-    std::optional<std::string> phone;
-  };
 #endif
 
   bool test_primitive_types() {
@@ -159,8 +132,8 @@ namespace builder_tests {
     TEST_START();
 #if SIMDJSON_STATIC_REFLECTION
     struct StringTypes {
-      std::string string_val{};
+      std::string string_val;
-      std::string_view string_view_val{};
+      std::string_view string_view_val;
     };
 
     StringTypes test{"hello world", "test_view"};
@@ -186,10 +159,10 @@ namespace builder_tests {
     TEST_START();
 #if SIMDJSON_STATIC_REFLECTION
     struct OptionalTypes {
-      std::optional<int> opt_int_with_value{};
+      std::optional<int> opt_int_with_value;
-      std::optional<std::string> opt_string_with_value{};
+      std::optional<std::string> opt_string_with_value;
-      std::optional<int> opt_int_null{};
+      std::optional<int> opt_int_null;
-      std::optional<std::string> opt_string_null{};
+      std::optional<std::string> opt_string_null;
     };
 
     OptionalTypes test;
@@ -227,11 +200,11 @@ namespace builder_tests {
     TEST_START();
 #if SIMDJSON_STATIC_REFLECTION
     struct SmartPointerTypes {
-      std::unique_ptr<int> unique_int_with_value{};
+      std::unique_ptr<int> unique_int_with_value;
-      std::shared_ptr<std::string> shared_string_with_value{};
+      std::shared_ptr<std::string> shared_string_with_value;
-      std::unique_ptr<bool> unique_bool_with_value{};
+      std::unique_ptr<bool> unique_bool_with_value;
-      std::unique_ptr<int> unique_int_null{};
+      std::unique_ptr<int> unique_int_null;
-      std::shared_ptr<std::string> shared_string_null{};
+      std::shared_ptr<std::string> shared_string_null;
     };
 
     SmartPointerTypes test;
@@ -272,9 +245,9 @@ namespace builder_tests {
 #if SIMDJSON_STATIC_REFLECTION
     // Test basic container types
     struct ContainerTypes {
-      std::vector<int> int_vector{};
+      std::vector<int> int_vector;
-      std::set<std::string> string_set{};
+      std::set<std::string> string_set;
-      std::map<std::string, int> string_map{};
+      std::map<std::string, int> string_map;
     };
 
     ContainerTypes test;
@@ -305,8 +278,8 @@ namespace builder_tests {
 
     // Test std::list with iterator-based serialization
     struct ListContainer {
-      std::list<int> int_list{};
+      std::list<int> int_list;
-      std::list<std::string> string_list{};
+      std::list<std::string> string_list;
     };
 
     ListContainer list_test;
@@ -346,7 +319,13 @@ namespace builder_tests {
   bool test_extract_into() {
     TEST_START();
 #if SIMDJSON_STATIC_REFLECTION
-
+    struct Car {
+      std::string make;
+      std::string model;
+      int year;
+      double price;
+      std::optional<std::string> color;
+    };
 
     ondemand::parser parser;
 
@@ -362,7 +341,7 @@ namespace builder_tests {
         "transmission": "Automatic"
       })"_padded;
 
-      CarOpt car{};
+      Car car{};
       ondemand::document doc;
       ASSERT_SUCCESS( parser.iterate(padded).get(doc) );
 
@@ -398,7 +377,7 @@ namespace builder_tests {
         "color": "Red"
       })"_padded;
 
-      CarOpt car{};
+      Car car{};
       ondemand::document doc;
       ASSERT_SUCCESS(parser.iterate(padded).get(doc));
 
@@ -423,7 +402,7 @@ namespace builder_tests {
         "price": 35999.99
       })"_padded;
 
-      CarOpt car{};
+      Car car{};
       ondemand::document doc;
       ASSERT_SUCCESS(parser.iterate(padded).get(doc));
 
@@ -516,6 +495,13 @@ namespace builder_tests {
 #if SIMDJSON_STATIC_REFLECTION
     // Test 1: Extract specific fields from Car struct
     {
+      struct Car {
+        std::string make;
+        std::string model;
+        int year;
+        double price;
+        bool electric;
+      };
 
       Car car{"Tesla", "Model 3", 2023, 42000.0, true};
 
@@ -547,7 +533,13 @@ namespace builder_tests {
 
     // Test 2: Extract different field combination
     {
-
+      struct Car {
+        std::string make;
+        std::string model;
+        int year;
+        double price;
+        bool electric;
+      };
 
       Car car{"Ford", "F-150", 2024, 55000.0, false};
 
@@ -574,6 +566,13 @@ namespace builder_tests {
 
     // Test 3: Extract from struct with optional fields
     {
+      struct Person {
+        std::string name;
+        int age;
+        std::optional<std::string> email;
+        std::optional<std::string> phone;
+      };
+
       Person person{"John Doe", 30, "john@example.com", std::nullopt};
 
       // Extract name and email
@@ -595,6 +594,13 @@ namespace builder_tests {
 
     // Test 4: Extract with optional that has value
     {
+      struct Person {
+        std::string name;
+        int age;
+        std::optional<std::string> email;
+        std::optional<std::string> phone;
+      };
+
       Person person{"Jane Smith", 25, "jane@example.com", "555-1234"};
 
       // Extract name, age, and phone
@@ -623,21 +629,21 @@ namespace builder_tests {
 
     // Test 5: Round-trip test - serialize with extract_from, deserialize with extract_into
     {
-      struct MyProduct {
+      struct Product {
-        std::string id{};
+        std::string id;
-        std::string name{};
+        std::string name;
-        double price{};
+        double price;
-        int stock{};
+        int stock;
       };
 
-      MyProduct original{"P123", "Widget", 19.99, 100};
+      Product original{"P123", "Widget", 19.99, 100};
 
       // Extract specific fields to JSON
       std::string json;
       ASSERT_SUCCESS((extract_from<"id", "name", "price">(original).get(json)));
 
       // Parse and extract back
-      MyProduct restored{"", "", 0.0, 0};
+      Product restored{"", "", 0.0, 0};
       auto padded = pad(json);
       ondemand::parser parser;
       auto doc = parser.iterate(padded);

tests/builder/static_reflection_custom_tests.cpp

@@ -11,10 +11,10 @@ using namespace simdjson;
 // Suppose that we want to serialize/deserialize Car using
 // strings for the year
 struct Car {
-  std::string make{};
+  std::string make;
-  std::string model{};
+  std::string model;
-  int64_t year{};
+  int64_t year;
-  std::vector<float> tire_pressure{};
+  std::vector<float> tire_pressure;
 };
 
 

tests/builder/static_reflection_edge_cases_tests.cpp

@@ -14,11 +14,11 @@ namespace builder_tests {
     TEST_START();
 #if SIMDJSON_STATIC_REFLECTION
     struct EmptyValues {
-      std::string empty_string{};
+      std::string empty_string;
-      std::vector<int> empty_vector{};
+      std::vector<int> empty_vector;
-      std::optional<int> null_optional{};
+      std::optional<int> null_optional;
-      std::unique_ptr<int> null_unique_ptr{};
+      std::unique_ptr<int> null_unique_ptr;
-      std::shared_ptr<std::string> null_shared_ptr{};
+      std::shared_ptr<std::string> null_shared_ptr;
     };
 
     EmptyValues test;
@@ -56,18 +56,18 @@ namespace builder_tests {
     TEST_START();
 #if SIMDJSON_STATIC_REFLECTION
     struct SpecialChars {
-      std::string quotes{};
+      std::string quotes;
-      std::string backslashes{};
+      std::string backslashes;
-      std::string newlines{};
+      std::string newlines;
-      std::string unicode{};
+      std::string unicode;
-      char null_char{};
+      char null_char;
     };
 
     SpecialChars test;
     test.quotes = "He said \"Hello\"";
     test.backslashes = "Path\\to\\file";
     test.newlines = "Line1\nLine2\tTabbed";
-    test.unicode = "Caf\xc3\xa9 r\xc3\xa9sum\xc3\xa9";
+    test.unicode = "Café résumé";
     test.null_char = '\0';
 
     std::string json;
@@ -82,10 +82,10 @@ namespace builder_tests {
 
     // Test round-trip (excluding null char which has special handling)
     struct SpecialCharsNoNull {
-      std::string quotes{};
+      std::string quotes;
-      std::string backslashes{};
+      std::string backslashes;
-      std::string newlines{};
+      std::string newlines;
-      std::string unicode{};
+      std::string unicode;
     };
 
     SpecialCharsNoNull test_no_null;
@@ -157,15 +157,15 @@ namespace builder_tests {
     TEST_START();
 #if SIMDJSON_STATIC_REFLECTION
     struct Inner {
-      int value{};
+      int value;
-      std::string name{};
+      std::string name;
     };
 
     struct Outer {
-      Inner inner_obj{};
+      Inner inner_obj;
-      std::vector<Inner> inner_vector{};
+      std::vector<Inner> inner_vector;
-      std::optional<Inner> optional_inner{};
+      std::optional<Inner> optional_inner;
-      std::unique_ptr<Inner> unique_inner{};
+      std::unique_ptr<Inner> unique_inner;
     };
 
     Outer test;
@@ -213,4 +213,4 @@ namespace builder_tests {
 
 int main(int argc, char *argv[]) {
   return test_main(argc, argv, builder_tests::run);
-}
+}

tests/builder/static_reflection_enum_tests.cpp

@@ -51,8 +51,8 @@ namespace builder_tests {
     };
 
     struct StatusStruct {
-      Status status{};
+      Status status;
-      std::string name{};
+      std::string name;
     };
 
     // Test deserialization of different enum values with string representation
@@ -104,9 +104,9 @@ namespace builder_tests {
     };
 
     struct Task {
-      Priority priority{};
+      Priority priority;
-      std::string description{};
+      std::string description;
-      int id{};
+      int id;
     };
 
     Task original{Priority::High, "Important task", 123};
@@ -144,8 +144,8 @@ namespace builder_tests {
     };
 
     struct Response {
-      ErrorCode error{};
+      ErrorCode error;
-      std::string message{};
+      std::string message;
     };
 
     Response test{ErrorCode::NotFound, "Resource not found"};

tests/builder/static_reflection_fractured_json_tests.cpp

@@ -8,26 +8,26 @@ using namespace simdjson;
 
 // Test structures for FracturedJson builder integration
 struct SimpleUser {
-  int id{};
+  int id;
-  std::string name{};
+  std::string name;
-  bool active{};
+  bool active;
 };
 
 struct UserWithEmail {
-  int id{};
+  int id;
-  std::string name{};
+  std::string name;
-  std::string email{};
+  std::string email;
-  bool active{};
+  bool active;
 };
 
 struct NestedData {
-  std::string title{};
+  std::string title;
-  std::vector<SimpleUser> users{};
+  std::vector<SimpleUser> users;
-  int count{};
+  int count;
 };
 
 struct TableTestData {
-  std::vector<SimpleUser> records{};
+  std::vector<SimpleUser> records;
 };
 
 namespace fractured_json_builder_tests {

tests/compile_time/compile_time_json_tests.cpp

@@ -10,7 +10,6 @@
 
 using namespace std::string_view_literals;
 using namespace simdjson;
-using namespace simdjson::literals;
 
 namespace compile_time_json_tests {
 /**
@@ -667,27 +666,27 @@ bool test_array_of_objects_with_concept() {
 /**
  * Test: #embed support for external JSON files (C++26)
  */
-bool test_embed_example_config_json() {
+bool test_embed_twitter_json() {
     TEST_START();
 
     // C++26 #embed allows embedding files directly into the binary at compile time
     // This creates a const char array with the file contents plus null terminator
-    constexpr const unsigned char example_config_json[] = {
+    constexpr const char twitter_json[] = {
-        #embed "../../jsonexamples/example_config.json"
+        #embed TWITTER_JSON
         , 0
     };
 
     // Parse the embedded JSON at compile time
-    constexpr auto parsed_example_config = simdjson::compile_time::parse_json<example_config_json>();
+    constexpr auto parsed_twitter = simdjson::compile_time::parse_json<twitter_json>();
 
-    // Verify the structure - example_config.json should have an "app_name" field
+    // Verify the structure - twitter.json should have a "statuses" array
-    static_assert(std::string_view(parsed_example_config.app_name) == "MyApp");
+    static_assert(parsed_twitter.statuses.size() > 0);
 
     // Runtime verification
-    ASSERT_TRUE(std::string_view(parsed_example_config.app_name) == "MyApp");
+    ASSERT_TRUE(parsed_twitter.statuses.size() > 0);
 
-    std::cout << "Successfully parsed embedded example_config.json with "
+    std::cout << "Successfully parsed embedded twitter.json with "
-              << parsed_example_config.app_name << " as app_name" << std::endl;
+              << parsed_twitter.statuses.size() << " statuses" << std::endl;
 
     TEST_SUCCEED();
 }
@@ -719,10 +718,11 @@ bool run() {
            test_top_level_array_example() &&
            test_array_of_objects_with_concept()
 #ifdef TEST_EMBED_SUPPORTED
-           && test_embed_example_config_json()
+           && test_embed_twitter_json()
 #endif
 ;
 }
+
 } // namespace compile_time_json_tests
 
 int main(int argc, char *argv[]) {

tests/dom/big_integer_tests.cpp

@@ -79,7 +79,7 @@ namespace big_integer_tests {
     std::string output = simdjson::to_string(doc);
     // Raw digits should appear
     ASSERT_TRUE(output.find("123456789012345678901") != std::string::npos);
-    // Must not be quoted - it's a number, not a string
+    // Must not be quoted — it's a number, not a string
     ASSERT_EQUAL(output.find("\"123456789012345678901\""), std::string::npos);
     TEST_SUCCEED();
   }

tests/dom/readme_examples.cpp

@@ -1,6 +1,5 @@
 #include <iostream>
 #include "simdjson.h"
-#include "simdjson/padded_string_view.h"
 
 using namespace std;
 using namespace simdjson;
@@ -532,35 +531,6 @@ void simplepad() {
   if(error) { exit(-1); }
 }
 
-#if SIMDJSON_CPLUSPLUS17
-void simpleinputpad_dom1() {
-  std::string_view json = "[1,2,3]";
-  simdjson::padded_input input(json);
-  dom::parser parser;
-  dom::element doc;
-  auto error = parser.parse(input).get(doc);
-  if(error) { exit(-1); }
-}
-
-void simpleinputpad_dom2() {
-  const char *jsonpointer = R"(
-        {
-            "key": "value"
-        }
-    )";
-  size_t len = strlen(jsonpointer);
-  simdjson::padded_input input(jsonpointer, len);
-  dom::parser parser;
-  dom::element doc;
-  auto error = parser.parse(input).get(doc);
-  if(error) { exit(-1); }
-  std::string_view val;
-  error = doc["key"].get(val);
-  if(error) { exit(-1); }
-  if(val != "value") { exit(-1); }
-}
-#endif // SIMDJSON_CPLUSPLUS17
-
 void jsondollar() {
   dom::parser parser;
   auto json = R"( { "c" :{ "foo": { "a": [ 10, 20, 30 ] }}, "d": { "foo2": { "a": [ 10, 20, 30 ] }} , "e": 120 })"_padded;

tests/feature_flag_tests/CMakeLists.txt

@@ -1,36 +0,0 @@
-# Feature flag tests: compile and run against the amalgamated single-header file.
-# Each test uses target_compile_definitions to set its own feature macros,
-# independent of the project-wide settings.
-
-set(SINGLEHEADER_DIR ${PROJECT_SOURCE_DIR}/singleheader)
-
-function(add_feature_flag_test TEST_NAME)
-  cmake_parse_arguments(PARSE_ARGV 1 ARG "" "" "DEFS")
-  add_executable(${TEST_NAME} ${TEST_NAME}.cpp ${SINGLEHEADER_DIR}/simdjson.cpp)
-  target_include_directories(${TEST_NAME} PRIVATE ${SINGLEHEADER_DIR})
-  target_compile_features(${TEST_NAME} PRIVATE cxx_std_17)
-  # Override any inherited feature flag definitions with our own.
-  target_compile_definitions(${TEST_NAME} PRIVATE ${ARG_DEFS})
-  # Remove inherited link libraries (simdjson-internal-flags brings -Werror
-  # which conflicts with the amalgamated header's warning profile).
-  set_target_properties(${TEST_NAME} PROPERTIES LINK_LIBRARIES "")
-  add_test(NAME ${TEST_NAME} COMMAND ${TEST_NAME})
-  set_property(TEST ${TEST_NAME} APPEND PROPERTY LABELS feature_flags acceptance)
-endfunction()
-
-add_feature_flag_test(dom_only DEFS
-  SIMDJSON_FEATURE_DOM_API=1 SIMDJSON_FEATURE_ONDEMAND_API=0 SIMDJSON_FEATURE_BUILDER_API=0)
-# Note: OnDemand tests also enable DOM because the builtin infrastructure
-# is currently included via the DOM/builtin path in the amalgamated header.
-add_feature_flag_test(ondemand_only DEFS
-  SIMDJSON_FEATURE_DOM_API=1 SIMDJSON_FEATURE_ONDEMAND_API=1 SIMDJSON_FEATURE_BUILDER_API=0)
-add_feature_flag_test(dom_and_ondemand DEFS
-  SIMDJSON_FEATURE_DOM_API=1 SIMDJSON_FEATURE_ONDEMAND_API=1 SIMDJSON_FEATURE_BUILDER_API=0)
-add_feature_flag_test(builder_and_dom DEFS
-  SIMDJSON_FEATURE_DOM_API=1 SIMDJSON_FEATURE_ONDEMAND_API=0 SIMDJSON_FEATURE_BUILDER_API=1)
-add_feature_flag_test(builder_and_ondemand DEFS
-  SIMDJSON_FEATURE_DOM_API=1 SIMDJSON_FEATURE_ONDEMAND_API=1 SIMDJSON_FEATURE_BUILDER_API=1)
-add_feature_flag_test(builder_dom_and_ondemand DEFS
-  SIMDJSON_FEATURE_DOM_API=1 SIMDJSON_FEATURE_ONDEMAND_API=1 SIMDJSON_FEATURE_BUILDER_API=1)
-add_feature_flag_test(builder_only DEFS
-  SIMDJSON_FEATURE_DOM_API=1 SIMDJSON_FEATURE_ONDEMAND_API=0 SIMDJSON_FEATURE_BUILDER_API=1)

tests/feature_flag_tests/builder_and_dom.cpp

@@ -1,42 +0,0 @@
-// Test: Builder + DOM APIs (OnDemand disabled)
-// Feature flags set via target_compile_definitions in CMakeLists.txt
-#include "simdjson.h"
-#include <iostream>
-
-int main() {
-  auto json = R"({"key": "value"})"_padded;
-
-  // Use DOM API
-  simdjson::dom::parser parser;
-  simdjson::dom::element doc;
-  auto error = parser.parse(json).get(doc);
-  if (error) {
-    std::cerr << "DOM parse error: " << error << std::endl;
-    return EXIT_FAILURE;
-  }
-  std::string_view val;
-  error = doc["key"].get_string().get(val);
-  if (error || val != "value") {
-    std::cerr << "DOM key lookup failed" << std::endl;
-    return EXIT_FAILURE;
-  }
-
-  // Use Builder API
-  simdjson::builder::string_builder sb;
-  sb.start_object();
-  sb.append_key_value("greeting", "hello");
-  sb.end_object();
-  std::string_view result;
-  error = sb.view().get(result);
-  if (error) {
-    std::cerr << "Builder error: " << error << std::endl;
-    return EXIT_FAILURE;
-  }
-  if (result != R"({"greeting":"hello"})") {
-    std::cerr << "Builder output mismatch: " << result << std::endl;
-    return EXIT_FAILURE;
-  }
-
-  std::cout << "Builder+DOM test passed." << std::endl;
-  return EXIT_SUCCESS;
-}

tests/feature_flag_tests/builder_and_ondemand.cpp

@@ -1,45 +0,0 @@
-// Test: Builder + OnDemand APIs (DOM also enabled since Builder depends on it)
-// Feature flags set via target_compile_definitions in CMakeLists.txt
-#include "simdjson.h"
-#include <iostream>
-
-int main() {
-  // Use OnDemand API
-  auto json = R"({"key": "value"})"_padded;
-  simdjson::ondemand::parser parser;
-  simdjson::ondemand::document doc;
-  auto error = parser.iterate(json).get(doc);
-  if (error) {
-    std::cerr << "OnDemand parse error: " << error << std::endl;
-    return EXIT_FAILURE;
-  }
-  std::string_view val;
-  error = doc["key"].get_string().get(val);
-  if (error || val != "value") {
-    std::cerr << "OnDemand key lookup failed" << std::endl;
-    return EXIT_FAILURE;
-  }
-
-  // Use Builder API
-  simdjson::builder::string_builder sb;
-  sb.start_array();
-  sb.append(1);
-  sb.append_comma();
-  sb.append(2);
-  sb.append_comma();
-  sb.append(3);
-  sb.end_array();
-  std::string_view result;
-  error = sb.view().get(result);
-  if (error) {
-    std::cerr << "Builder error: " << error << std::endl;
-    return EXIT_FAILURE;
-  }
-  if (result != "[1,2,3]") {
-    std::cerr << "Builder output mismatch: " << result << std::endl;
-    return EXIT_FAILURE;
-  }
-
-  std::cout << "Builder+OnDemand test passed." << std::endl;
-  return EXIT_SUCCESS;
-}

tests/feature_flag_tests/builder_dom_and_ondemand.cpp

@@ -1,59 +0,0 @@
-// Test: All three APIs enabled (Builder + DOM + OnDemand)
-// Feature flags set via target_compile_definitions in CMakeLists.txt
-#include "simdjson.h"
-#include <iostream>
-
-int main() {
-  auto json = R"({"name": "simdjson", "version": 5})"_padded;
-
-  // Use DOM API
-  simdjson::dom::parser dom_parser;
-  simdjson::dom::element dom_doc;
-  auto error = dom_parser.parse(json).get(dom_doc);
-  if (error) {
-    std::cerr << "DOM parse error: " << error << std::endl;
-    return EXIT_FAILURE;
-  }
-  std::string_view name;
-  error = dom_doc["name"].get_string().get(name);
-  if (error || name != "simdjson") {
-    std::cerr << "DOM name lookup failed" << std::endl;
-    return EXIT_FAILURE;
-  }
-
-  // Use OnDemand API
-  simdjson::ondemand::parser od_parser;
-  simdjson::ondemand::document od_doc;
-  error = od_parser.iterate(json).get(od_doc);
-  if (error) {
-    std::cerr << "OnDemand parse error: " << error << std::endl;
-    return EXIT_FAILURE;
-  }
-  std::string_view od_name;
-  error = od_doc["name"].get_string().get(od_name);
-  if (error || od_name != "simdjson") {
-    std::cerr << "OnDemand name lookup failed" << std::endl;
-    return EXIT_FAILURE;
-  }
-
-  // Use Builder API
-  simdjson::builder::string_builder sb;
-  sb.start_object();
-  sb.append_key_value("name", "simdjson");
-  sb.append_comma();
-  sb.append_key_value("version", 5);
-  sb.end_object();
-  std::string_view result;
-  error = sb.view().get(result);
-  if (error) {
-    std::cerr << "Builder error: " << error << std::endl;
-    return EXIT_FAILURE;
-  }
-  if (result != R"({"name":"simdjson","version":5})") {
-    std::cerr << "Builder output mismatch: " << result << std::endl;
-    return EXIT_FAILURE;
-  }
-
-  std::cout << "Builder+DOM+OnDemand test passed." << std::endl;
-  return EXIT_SUCCESS;
-}

tests/feature_flag_tests/builder_only.cpp

@@ -1,27 +0,0 @@
-// Test: Builder API only (OnDemand disabled, DOM enabled since Builder depends on it)
-// Feature flags set via target_compile_definitions in CMakeLists.txt
-#include "simdjson.h"
-#include <iostream>
-
-int main() {
-  // Use Builder API
-  simdjson::builder::string_builder sb;
-  sb.start_object();
-  sb.append_key_value("count", 2);
-  sb.append_comma();
-  sb.append_key_value("name", "test");
-  sb.end_object();
-  std::string_view result;
-  auto error = sb.view().get(result);
-  if (error) {
-    std::cerr << "Builder error: " << error << std::endl;
-    return EXIT_FAILURE;
-  }
-  if (result != R"({"count":2,"name":"test"})") {
-    std::cerr << "Builder output mismatch: " << result << std::endl;
-    return EXIT_FAILURE;
-  }
-
-  std::cout << "Builder-only test passed." << std::endl;
-  return EXIT_SUCCESS;
-}

tests/feature_flag_tests/dom_and_ondemand.cpp

@@ -1,41 +0,0 @@
-// Test: Both DOM and OnDemand APIs (Builder disabled)
-// Feature flags set via target_compile_definitions in CMakeLists.txt
-#include "simdjson.h"
-#include <iostream>
-
-int main() {
-  auto json = R"({"key": "value", "number": 42})"_padded;
-
-  // Use DOM API
-  simdjson::dom::parser dom_parser;
-  simdjson::dom::element dom_doc;
-  auto error = dom_parser.parse(json).get(dom_doc);
-  if (error) {
-    std::cerr << "DOM parse error: " << error << std::endl;
-    return EXIT_FAILURE;
-  }
-  std::string_view dom_val;
-  error = dom_doc["key"].get_string().get(dom_val);
-  if (error || dom_val != "value") {
-    std::cerr << "DOM key lookup failed" << std::endl;
-    return EXIT_FAILURE;
-  }
-
-  // Use OnDemand API
-  simdjson::ondemand::parser od_parser;
-  simdjson::ondemand::document od_doc;
-  error = od_parser.iterate(json).get(od_doc);
-  if (error) {
-    std::cerr << "OnDemand parse error: " << error << std::endl;
-    return EXIT_FAILURE;
-  }
-  std::string_view od_val;
-  error = od_doc["key"].get_string().get(od_val);
-  if (error || od_val != "value") {
-    std::cerr << "OnDemand key lookup failed" << std::endl;
-    return EXIT_FAILURE;
-  }
-
-  std::cout << "DOM+OnDemand test passed." << std::endl;
-  return EXIT_SUCCESS;
-}

tests/feature_flag_tests/dom_only.cpp

@@ -1,29 +0,0 @@
-// Test: DOM API only (OnDemand and Builder disabled)
-// Feature flags set via target_compile_definitions in CMakeLists.txt
-#include "simdjson.h"
-#include <iostream>
-
-int main() {
-  simdjson::dom::parser parser;
-  auto json = R"({"key": "value", "number": 42})"_padded;
-  simdjson::dom::element doc;
-  auto error = parser.parse(json).get(doc);
-  if (error) {
-    std::cerr << "DOM parse error: " << error << std::endl;
-    return EXIT_FAILURE;
-  }
-  std::string_view val;
-  error = doc["key"].get_string().get(val);
-  if (error || val != "value") {
-    std::cerr << "DOM key lookup failed" << std::endl;
-    return EXIT_FAILURE;
-  }
-  int64_t num;
-  error = doc["number"].get_int64().get(num);
-  if (error || num != 42) {
-    std::cerr << "DOM number lookup failed" << std::endl;
-    return EXIT_FAILURE;
-  }
-  std::cout << "DOM-only test passed." << std::endl;
-  return EXIT_SUCCESS;
-}

tests/feature_flag_tests/ondemand_only.cpp

@@ -1,25 +0,0 @@
-// Test: OnDemand API only (Builder disabled)
-// Note: DOM must remain enabled because the builtin infrastructure
-// (SIMDJSON_BUILTIN_IMPLEMENTATION_IS) is currently included via the DOM path.
-// Feature flags set via target_compile_definitions in CMakeLists.txt
-#include "simdjson.h"
-#include <iostream>
-
-int main() {
-  simdjson::ondemand::parser parser;
-  auto json = R"({"key": "value", "number": 42})"_padded;
-  simdjson::ondemand::document doc;
-  auto error = parser.iterate(json).get(doc);
-  if (error) {
-    std::cerr << "OnDemand parse error: " << error << std::endl;
-    return EXIT_FAILURE;
-  }
-  std::string_view val;
-  error = doc["key"].get_string().get(val);
-  if (error || val != "value") {
-    std::cerr << "OnDemand key lookup failed" << std::endl;
-    return EXIT_FAILURE;
-  }
-  std::cout << "OnDemand-only test passed." << std::endl;
-  return EXIT_SUCCESS;
-}

tests/fractured_json_tests.cpp

@@ -475,11 +475,11 @@ bool unicode_test() {
   std::cout << "Running " << __func__ << std::endl;
 
   const char* json = R"({
-    "greeting": "Hello, \u4e16\u754c!",
+    "greeting": "Hello, 世界!",
-    "emoji": "\ud83c\udf89\ud83d\ude80\u2728",
+    "emoji": "🎉🚀✨",
-    "arabic": "\u0645\u0631\u062d\u0628\u0627",
+    "arabic": "مرحبا",
-    "russian": "\u041f\u0440\u0438\u0432\u0435\u0442",
+    "russian": "Привет",
-    "mixed": "caf\u00e9 r\u00e9sum\u00e9 na\u00efve"
+    "mixed": "café résumé naïve"
   })";
 
   simdjson::dom::parser parser;

tests/ondemand/CMakeLists.txt

@@ -40,7 +40,6 @@ add_cpp_test(ondemand_convert_tests                  LABELS ondemand acceptance
 add_cpp_test(ondemand_unknown_tests                  LABELS ondemand acceptance per_implementation)
 add_cpp_test(ondemand_wildcard_tests                 LABELS ondemand acceptance per_implementation)
 if(NOT SIMDJSON_SANITIZE)
-  add_cpp_test(ondemand_padded_input              LABELS ondemand acceptance per_implementation)
   add_cpp_test(ondemand_cacheline              LABELS ondemand acceptance per_implementation)
 endif()
 

tests/ondemand/ondemand_cacheline.cpp

@@ -20,7 +20,7 @@ long page_size() {
 }
 
 // Returns true if the buffer + len + simdjson::SIMDJSON_PADDING crosses the
-// page boundary. Assumes len != 0.
+// page boundary.
 bool need_allocation(const char *buf, size_t len) {
   return ((reinterpret_cast<uintptr_t>(buf + len - 1) % page_size())
     + simdjson::SIMDJSON_PADDING >= static_cast<uintptr_t>(page_size()));

tests/ondemand/ondemand_convert_tests.cpp

@@ -19,7 +19,7 @@ public:
         return date_str;
     }
 private:
-    std::string date_str{};
+    std::string date_str;
 };
 
 
@@ -52,8 +52,8 @@ auto tag_invoke(deserialize_tag, simdjson_value &val, MyDate& date) {
 } // namespace simdjson
 
 struct complicated_weather_data {
-    std::vector<MyDate> time{};
+    std::vector<MyDate> time;
-    std::vector<float> temperature{};
+    std::vector<float> temperature;
 };
 
 
@@ -152,19 +152,19 @@ simdjson::padded_string json_cars =
     TEST_SUCCEED();
   }
   struct Player {
-      std::string username{};
+      std::string username;
-      int level{};
+      int level;
-      double health{};
+      double health;
   };
   struct BadPlayer {
-      int username{};  // Oops, should be string!
+      int username;  // Oops, should be string!
-      int level{};
+      int level;
-      double health{};
+      double health;
   };
   struct OptionalPlayer {
-      std::string username{};
+      std::string username;
-      std::optional<int> level{};
+      std::optional<int> level;
-      double health{};
+      double health;
   };
 #if SIMDJSON_STATIC_REFLECTION
   bool missing_key_player() {

tests/ondemand/ondemand_padded_input.cpp

@@ -1,197 +0,0 @@
-#include "simdjson.h"
-#include "simdjson/padded_string_view.h"
-#include <cstdio>
-#include <cstring>
-#include <cstdlib>
-#include <string>
-#include <string_view>
-
-#if SIMDJSON_CPLUSPLUS17
-
-bool test_padded_input_from_string_view() {
-  std::string_view json = "[1,2,3]";
-  simdjson::padded_input input(json);
-  simdjson::ondemand::parser parser;
-  simdjson::ondemand::document doc;
-  auto error = parser.iterate(input).get(doc);
-  if (error) {
-    printf("FAILED: test_padded_input_from_string_view (iterate error: %s)\n",
-           simdjson::error_message(error));
-    return false;
-  }
-  size_t count = 0;
-  for (auto val : doc) {
-    int64_t v;
-    error = val.get_int64().get(v);
-    if (error) {
-      printf("FAILED: test_padded_input_from_string_view (get_int64 error)\n");
-      return false;
-    }
-    count++;
-  }
-  if (count != 3) {
-    printf("FAILED: test_padded_input_from_string_view (expected 3 elements, got %zu)\n", count);
-    return false;
-  }
-  printf("OK: test_padded_input_from_string_view\n");
-  return true;
-}
-
-bool test_padded_input_from_cstring() {
-  const char *json = R"({"key": "value"})";
-  size_t len = std::strlen(json);
-  simdjson::padded_input input(json, len);
-  simdjson::ondemand::parser parser;
-  simdjson::ondemand::document doc;
-  auto error = parser.iterate(input).get(doc);
-  if (error) {
-    printf("FAILED: test_padded_input_from_cstring (iterate error: %s)\n",
-           simdjson::error_message(error));
-    return false;
-  }
-  std::string_view val;
-  error = doc["key"].get_string().get(val);
-  if (error) {
-    printf("FAILED: test_padded_input_from_cstring (get_string error)\n");
-    return false;
-  }
-  if (val != "value") {
-    printf("FAILED: test_padded_input_from_cstring (expected 'value', got '%.*s')\n",
-           (int)val.size(), val.data());
-    return false;
-  }
-  printf("OK: test_padded_input_from_cstring\n");
-  return true;
-}
-
-bool test_padded_input_is_view() {
-  // A short string at a "safe" position should typically be a view (no copy).
-  // We can't guarantee this in all environments, but we can at least test
-  // that is_view() returns a valid boolean and parsing works either way.
-  std::string_view json = "[1]";
-  simdjson::padded_input input(json);
-  bool view = input.is_view();
-  printf("  is_view() = %s\n", view ? "true" : "false");
-  simdjson::ondemand::parser parser;
-  simdjson::ondemand::document doc;
-  auto error = parser.iterate(input).get(doc);
-  if (error) {
-    printf("FAILED: test_padded_input_is_view (iterate error: %s)\n",
-           simdjson::error_message(error));
-    return false;
-  }
-  printf("OK: test_padded_input_is_view\n");
-  return true;
-}
-
-bool test_padded_input_nested_json() {
-  std::string_view json = R"({"a":{"b":[1,2,{"c":true}]}})";
-  simdjson::padded_input input(json);
-  simdjson::ondemand::parser parser;
-  simdjson::ondemand::document doc;
-  auto error = parser.iterate(input).get(doc);
-  if (error) {
-    printf("FAILED: test_padded_input_nested_json (iterate error: %s)\n",
-           simdjson::error_message(error));
-    return false;
-  }
-  bool c_val;
-  error = doc["a"]["b"].at(2)["c"].get_bool().get(c_val);
-  if (error) {
-    printf("FAILED: test_padded_input_nested_json (get_bool error)\n");
-    return false;
-  }
-  if (!c_val) {
-    printf("FAILED: test_padded_input_nested_json (expected true)\n");
-    return false;
-  }
-  printf("OK: test_padded_input_nested_json\n");
-  return true;
-}
-
-bool test_padded_input_dom() {
-  std::string_view json = "[1,2,3]";
-  simdjson::padded_input input(json);
-  simdjson::dom::parser parser;
-  simdjson::dom::element doc;
-  auto error = parser.parse(input).get(doc);
-  if (error) {
-    printf("FAILED: test_padded_input_dom (parse error: %s)\n",
-           simdjson::error_message(error));
-    return false;
-  }
-  printf("OK: test_padded_input_dom\n");
-  return true;
-}
-
-bool test_padded_input_dom_object() {
-  const char *json = R"({"name":"simdjson","version":42})";
-  size_t len = std::strlen(json);
-  simdjson::padded_input input(json, len);
-  simdjson::dom::parser parser;
-  simdjson::dom::element doc;
-  auto error = parser.parse(input).get(doc);
-  if (error) {
-    printf("FAILED: test_padded_input_dom_object (parse error: %s)\n",
-           simdjson::error_message(error));
-    return false;
-  }
-  std::string_view name;
-  error = doc["name"].get(name);
-  if (error || name != "simdjson") {
-    printf("FAILED: test_padded_input_dom_object (name mismatch)\n");
-    return false;
-  }
-  printf("OK: test_padded_input_dom_object\n");
-  return true;
-}
-
-bool test_padded_input_from_std_string() {
-  std::string json = R"({"key": "value"})";
-  // Reserve extra space to test capacity handling
-  json.reserve(json.size() + 100);
-  simdjson::padded_input input(json);
-  simdjson::ondemand::parser parser;
-  simdjson::ondemand::document doc;
-  auto error = parser.iterate(input).get(doc);
-  if (error) {
-    printf("FAILED: test_padded_input_from_std_string (iterate error: %s)\n",
-           simdjson::error_message(error));
-    return false;
-  }
-  std::string_view key;
-  error = doc["key"].get(key);
-  if (error || key != "value") {
-    printf("FAILED: test_padded_input_from_std_string (key/value mismatch)\n");
-    return false;
-  }
-  printf("OK: test_padded_input_from_std_string\n");
-  return true;
-}
-
-int main() {
-  bool ok = true;
-  ok = test_padded_input_from_string_view() && ok;
-  ok = test_padded_input_from_cstring() && ok;
-  ok = test_padded_input_from_std_string() && ok;
-  ok = test_padded_input_is_view() && ok;
-  ok = test_padded_input_nested_json() && ok;
-  ok = test_padded_input_dom() && ok;
-  ok = test_padded_input_dom_object() && ok;
-  if (ok) {
-    printf("\nAll padded_input tests passed.\n");
-    return EXIT_SUCCESS;
-  } else {
-    printf("\nSome padded_input tests FAILED.\n");
-    return EXIT_FAILURE;
-  }
-}
-
-#else // !SIMDJSON_CPLUSPLUS17
-
-int main() {
-  printf("padded_input requires C++17 or better. Skipping.\n");
-  return EXIT_SUCCESS;
-}
-
-#endif // SIMDJSON_CPLUSPLUS17

tests/ondemand/ondemand_readme_examples.cpp

@@ -1,5 +1,4 @@
 #include "simdjson.h"
-#include "simdjson/padded_string_view.h"
 #include "test_ondemand.h"
 #if __cpp_lib_optional >= 201606L
 #include <optional>
@@ -50,33 +49,6 @@ bool simplepad() {
   return error == SUCCESS;
 }
 
-
-#if SIMDJSON_CPLUSPLUS17
-bool simpleinputpad1() {
-  std::string json = "[1]";
-  simdjson::padded_input padded_json(json);
-  ondemand::parser parser;
-  ondemand::document doc;
-  auto error = parser.iterate(padded_json).get(doc);
-  return error == SUCCESS;
-}
-
-bool simpleinputpad2() {
-  const char *jsonpointer = R"(
-        {
-            "key": "value"
-        }
-    )";
-  size_t len = strlen(jsonpointer);
-
-  simdjson::padded_input padded_json(jsonpointer, len);
-  ondemand::parser parser;
-  ondemand::document doc;
-  auto error = parser.iterate(padded_json).get(doc);
-  return error == SUCCESS;
-}
-#endif // SIMDJSON_CPLUSPLUS17
-
 bool string1() {
   const char * data = "my data"; // 7 bytes
   simdjson::padded_string my_padded_data(data, 7); // copies to a padded buffer
@@ -205,6 +177,68 @@ simdjson_inline simdjson_result<Car> simdjson::ondemand::document::get() & noexc
 
 #if SIMDJSON_EXCEPTIONS
 
+// Test matching the doc example in doc/basics.md
+// "Using for_each_at_path_with_wildcard for JSONPath Queries (On-Demand)"
+bool wildcard_basics_example() {
+  TEST_START();
+  simdjson::padded_string json_string = R"(
+{
+  "firstName": "John",
+  "lastName": "doe",
+  "age": 26,
+  "address": {
+    "streetAddress": "naist street",
+    "city": "Nara",
+    "postalCode": "630-0192"
+  },
+  "phoneNumbers": [
+    {
+      "type": "iPhone",
+      "numbers": ["0123-4567-8888", "0123-4567-8788"]
+    },
+    {
+      "type": "home",
+      "numbers": ["0123-4567-8910"]
+    }
+  ]
+})"_padded;
+
+  ondemand::parser parser;
+  ondemand::document doc = parser.iterate(json_string);
+
+  // Fetch all fields in the address object
+  std::vector<std::string_view> fields;
+  auto error = doc.for_each_at_path_with_wildcard("$.address.*",
+      [&](ondemand::value value) {
+        std::string_view field;
+        if (value.get(field) == SUCCESS) {
+          fields.push_back(field);
+        }
+      });
+  ASSERT_SUCCESS(error);
+  ASSERT_EQUAL(fields.size(), 3);
+  ASSERT_EQUAL(fields[0], "naist street");
+  ASSERT_EQUAL(fields[1], "Nara");
+  ASSERT_EQUAL(fields[2], "630-0192");
+
+  // Fetch all phone numbers
+  std::vector<std::string_view> numbers;
+  error = doc.for_each_at_path_with_wildcard("$.phoneNumbers[*].numbers[*]",
+      [&](ondemand::value value) {
+        std::string_view number;
+        if (value.get(number) == SUCCESS) {
+          numbers.push_back(number);
+        }
+      });
+  ASSERT_SUCCESS(error);
+  ASSERT_EQUAL(numbers.size(), 3);
+  ASSERT_EQUAL(numbers[0], "0123-4567-8888");
+  ASSERT_EQUAL(numbers[1], "0123-4567-8788");
+  ASSERT_EQUAL(numbers[2], "0123-4567-8910");
+
+  TEST_SUCCEED();
+}
+
 void main_capture() {
   padded_string json_padded = "{\"a\":[1,2,3], \"b\": 2, \"c\": \"hello\"}"_padded;
   std::vector<std::string_view> fields;
@@ -2044,6 +2078,7 @@ bool value_raw_json_object() {
 }
 
 #endif
+
 bool run() {
   return true
     && fatal_error()
@@ -2103,6 +2138,7 @@ bool run() {
     && current_location_no_error()
     && to_string_example_no_except()
   #if SIMDJSON_EXCEPTIONS
+    && wildcard_basics_example()
     && issue2215()
     && to_string_example()
     && raw_string()

tests/ondemand/ondemand_wildcard_tests.cpp

@@ -21,18 +21,16 @@ namespace wildcard_tests {
     ondemand::parser parser;
     auto doc = parser.iterate(json);
 
-    std::vector<ondemand::value> titles;
+    std::vector<std::string_view> titles;
-    ASSERT_SUCCESS(doc.at_path_with_wildcard("$.books[*].title").get(titles));
+    ASSERT_SUCCESS(doc.for_each_at_path_with_wildcard("$.books[*].title", [&](ondemand::value v) {
+      std::string_view sv;
+      if (v.get_string().get(sv) == SUCCESS) { titles.push_back(sv); }
+    }));
 
     ASSERT_EQUAL(titles.size(), 3);
-
+    ASSERT_EQUAL(titles[0], "Book A");
-    std::string_view title;
+    ASSERT_EQUAL(titles[1], "Book B");
-    ASSERT_SUCCESS(titles[0].get_string().get(title));
+    ASSERT_EQUAL(titles[2], "Book C");
-    ASSERT_EQUAL(title, "Book A");
-    ASSERT_SUCCESS(titles[1].get_string().get(title));
-    ASSERT_EQUAL(title, "Book B");
-    ASSERT_SUCCESS(titles[2].get_string().get(title));
-    ASSERT_EQUAL(title, "Book C");
 
     TEST_SUCCEED();
   }
@@ -46,18 +44,16 @@ namespace wildcard_tests {
     ondemand::parser parser;
     auto doc = parser.iterate(json);
 
-    std::vector<ondemand::value> prices;
+    std::vector<uint64_t> prices;
-    ASSERT_SUCCESS(doc.at_path_with_wildcard("$.prices[*]").get(prices));
+    ASSERT_SUCCESS(doc.for_each_at_path_with_wildcard("$.prices[*]", [&](ondemand::value v) {
+      uint64_t p;
+      if (v.get_uint64().get(p) == SUCCESS) { prices.push_back(p); }
+    }));
 
     ASSERT_EQUAL(prices.size(), 5);
-
+    ASSERT_EQUAL(prices[0], 10);
-    uint64_t price;
+    ASSERT_EQUAL(prices[2], 30);
-    ASSERT_SUCCESS(prices[0].get_uint64().get(price));
+    ASSERT_EQUAL(prices[4], 50);
-    ASSERT_EQUAL(price, 10);
-    ASSERT_SUCCESS(prices[2].get_uint64().get(price));
-    ASSERT_EQUAL(price, 30);
-    ASSERT_SUCCESS(prices[4].get_uint64().get(price));
-    ASSERT_EQUAL(price, 50);
 
     TEST_SUCCEED();
   }
@@ -75,19 +71,14 @@ namespace wildcard_tests {
     ondemand::parser parser;
     auto doc = parser.iterate(json);
 
-    std::vector<ondemand::value> names;
+    std::set<std::string_view> name_set;
-    auto error = doc.at_path_with_wildcard("$.users.*.name").get(names);
+    auto error = doc.for_each_at_path_with_wildcard("$.users.*.name", [&](ondemand::value v) {
+      std::string_view sv;
+      if (v.get_string().get(sv) == SUCCESS) { name_set.insert(sv); }
+    });
     ASSERT_SUCCESS(error);
 
-    ASSERT_EQUAL(names.size(), 3);
+    ASSERT_EQUAL(name_set.size(), 3);
-
-    // Verify we got all three names (order may vary)
-    std::set<std::string_view> name_set;
-    for (auto& name : names) {
-      std::string_view view;
-      ASSERT_SUCCESS(name.get_string().get(view));
-      name_set.insert(view);
-    }
     ASSERT_TRUE(name_set.count("Alice") > 0);
     ASSERT_TRUE(name_set.count("Bob") > 0);
     ASSERT_TRUE(name_set.count("Charlie") > 0);
@@ -117,19 +108,15 @@ namespace wildcard_tests {
     ondemand::parser parser;
     auto doc = parser.iterate(json);
 
-    std::vector<ondemand::value> salaries;
+    uint64_t total = 0;
-    auto error = doc.at_path_with_wildcard("$.departments.*.employees[*].salary").get(salaries);
+    size_t count = 0;
+    auto error = doc.for_each_at_path_with_wildcard("$.departments.*.employees[*].salary", [&](ondemand::value v) {
+      uint64_t s;
+      if (v.get_uint64().get(s) == SUCCESS) { total += s; count++; }
+    });
     ASSERT_SUCCESS(error);
 
-    ASSERT_EQUAL(salaries.size(), 4);
+    ASSERT_EQUAL(count, 4);
-
-    // Check sum of all salaries
-    uint64_t total = 0;
-    for (auto& salary : salaries) {
-      uint64_t value;
-      ASSERT_SUCCESS(salary.get_uint64().get(value));
-      total += value;
-    }
     ASSERT_EQUAL(total, 360000);
 
     TEST_SUCCEED();
@@ -142,11 +129,12 @@ namespace wildcard_tests {
     ondemand::parser parser;
     auto doc = parser.iterate(json);
 
-    std::vector<ondemand::value> items;
+    size_t count = 0;
-    auto error = doc.at_path_with_wildcard("$.items[*].name").get(items);
+    auto error = doc.for_each_at_path_with_wildcard("$.items[*].name", [&](ondemand::value) {
+      count++;
+    });
     ASSERT_SUCCESS(error);
-
+    ASSERT_EQUAL(count, 0);
-    ASSERT_EQUAL(items.size(), 0);
 
     TEST_SUCCEED();
   }
@@ -158,11 +146,12 @@ namespace wildcard_tests {
     ondemand::parser parser;
     auto doc = parser.iterate(json);
 
-    std::vector<ondemand::value> names;
+    size_t count = 0;
-    auto error = doc.at_path_with_wildcard("$.users.*.name").get(names);
+    auto error = doc.for_each_at_path_with_wildcard("$.users.*.name", [&](ondemand::value) {
+      count++;
+    });
     ASSERT_SUCCESS(error);
-
+    ASSERT_EQUAL(count, 0);
-    ASSERT_EQUAL(names.size(), 0);
 
     TEST_SUCCEED();
   }
@@ -175,8 +164,7 @@ namespace wildcard_tests {
     auto doc = parser.iterate(json);
 
     // Can't use array wildcard on scalar
-    std::vector<ondemand::value> values;
+    auto error = doc.for_each_at_path_with_wildcard("$.data[*]", [](ondemand::value) {});
-    auto error = doc.at_path_with_wildcard("$.data[*]").get(values);
     ASSERT_ERROR(error, INVALID_JSON_POINTER);
 
     TEST_SUCCEED();
@@ -195,12 +183,12 @@ namespace wildcard_tests {
     ondemand::parser parser;
     auto doc = parser.iterate(json);
 
-    // Get all nested arrays
+    size_t count = 0;
-    std::vector<ondemand::value> arrays;
+    ASSERT_SUCCESS(doc.for_each_at_path_with_wildcard("$.matrix[*]", [&](ondemand::value) {
-    ASSERT_SUCCESS(doc.at_path_with_wildcard("$.matrix[*]").get(arrays));
+      count++;
+    }));
 
-    // Verify we got 3 arrays
+    ASSERT_EQUAL(count, 3);
-    ASSERT_EQUAL(arrays.size(), 3);
 
     TEST_SUCCEED();
   }
@@ -218,18 +206,16 @@ namespace wildcard_tests {
     ondemand::parser parser;
     auto doc = parser.iterate(json);
 
-    std::vector<ondemand::value> statuses;
+    std::vector<std::string_view> statuses;
-    ASSERT_SUCCESS(doc.at_path_with_wildcard("$.data[*].info.status").get(statuses));
+    ASSERT_SUCCESS(doc.for_each_at_path_with_wildcard("$.data[*].info.status", [&](ondemand::value v) {
+      std::string_view sv;
+      if (v.get_string().get(sv) == SUCCESS) { statuses.push_back(sv); }
+    }));
 
     ASSERT_EQUAL(statuses.size(), 3);
-
+    ASSERT_EQUAL(statuses[0], "active");
-    std::string_view status;
+    ASSERT_EQUAL(statuses[1], "inactive");
-    ASSERT_SUCCESS(statuses[0].get_string().get(status));
+    ASSERT_EQUAL(statuses[2], "active");
-    ASSERT_EQUAL(status, "active");
-    ASSERT_SUCCESS(statuses[1].get_string().get(status));
-    ASSERT_EQUAL(status, "inactive");
-    ASSERT_SUCCESS(statuses[2].get_string().get(status));
-    ASSERT_EQUAL(status, "active");
 
     TEST_SUCCEED();
   }
@@ -250,13 +236,12 @@ namespace wildcard_tests {
     ondemand::parser parser;
     auto doc = parser.iterate(json);
 
-    std::vector<ondemand::value> values;
+    size_t count = 0;
-    ASSERT_SUCCESS(doc.at_path_with_wildcard("$.mixed[*]").get(values));
+    ASSERT_SUCCESS(doc.for_each_at_path_with_wildcard("$.mixed[*]", [&](ondemand::value) {
+      count++;
+    }));
 
-    // Just verify we got all 6 elements
+    ASSERT_EQUAL(count, 6);
-    ASSERT_EQUAL(values.size(), 6);
-
-    // Don't try to access the values - they've been consumed by the OnDemand API
 
     TEST_SUCCEED();
   }
@@ -275,8 +260,11 @@ namespace wildcard_tests {
     auto doc = parser.iterate(json);
 
     // Third element doesn't have "name" field
-    std::vector<ondemand::value> names;
+    std::vector<std::string_view> names;
-    auto error = doc.at_path_with_wildcard("$.data[*].name").get(names);
+    auto error = doc.for_each_at_path_with_wildcard("$.data[*].name", [&](ondemand::value v) {
+      std::string_view sv;
+      if (v.get_string().get(sv) == SUCCESS) { names.push_back(sv); }
+    });
 
     // This might error or return partial results
     if (error) {
@@ -301,18 +289,47 @@ namespace wildcard_tests {
     ondemand::parser parser;
     auto doc = parser.iterate(json);
 
-    std::vector<ondemand::value> names;
+    std::vector<std::string_view> names;
-    ASSERT_SUCCESS(doc.at_path_with_wildcard("$[*].name").get(names));
+    ASSERT_SUCCESS(doc.for_each_at_path_with_wildcard("$[*].name", [&](ondemand::value v) {
+      std::string_view sv;
+      if (v.get_string().get(sv) == SUCCESS) { names.push_back(sv); }
+    }));
 
     ASSERT_EQUAL(names.size(), 3);
+    ASSERT_EQUAL(names[0], "Item 1");
+    ASSERT_EQUAL(names[1], "Item 2");
+    ASSERT_EQUAL(names[2], "Item 3");
 
-    std::string_view name;
+    TEST_SUCCEED();
-    ASSERT_SUCCESS(names[0].get_string().get(name));
+  }
-    ASSERT_EQUAL(name, "Item 1");
+
-    ASSERT_SUCCESS(names[1].get_string().get(name));
+  // https://github.com/simdjson/simdjson/issues/2684
-    ASSERT_EQUAL(name, "Item 2");
+  bool wildcard_raw_json_issue_2684() {
-    ASSERT_SUCCESS(names[2].get_string().get(name));
+    TEST_START();
-    ASSERT_EQUAL(name, "Item 3");
+    auto json = R"([{"tag_meta":{"meta_code":2000211,"meta_value":""},"tag_value":""}])"_padded;
+
+    ondemand::parser parser;
+    auto doc = parser.iterate(json);
+
+    size_t count = 0;
+    bool raw_json_ok = true;
+    ASSERT_SUCCESS(doc.for_each_at_path_with_wildcard("$[*].tag_meta", [&](ondemand::value v) {
+      count++;
+      std::string_view raw;
+      if (v.raw_json().get(raw) != SUCCESS) {
+        raw_json_ok = false;
+        return;
+      }
+      // raw_json() must not leak sibling fields or outer array delimiters
+      std::string_view expected = R"({"meta_code":2000211,"meta_value":""})";
+      if (raw != expected || raw.find("tag_value") != std::string_view::npos) {
+        std::cerr << "  raw_json() returned: " << raw << std::endl;
+        raw_json_ok = false;
+      }
+    }));
+
+    ASSERT_EQUAL(count, 1);
+    ASSERT_TRUE(raw_json_ok);
 
     TEST_SUCCEED();
   }
@@ -329,10 +346,11 @@ namespace wildcard_tests {
            wildcard_with_nested_objects() &&
            mixed_types_in_array() &&
            wildcard_nonexistent_field() &&
-           root_array_wildcard();
+           root_array_wildcard() &&
+           wildcard_raw_json_issue_2684();
   }
 }
 
 int main(int argc, char *argv[]) {
   return test_main(argc, argv, wildcard_tests::run);
-}
+}

tests/ondemand/ondemand_wrong_type_error_tests.cpp

@@ -15,9 +15,9 @@ namespace wrong_type_error_tests {
     return false; \
   } \
   { \
-    std::string a_json(R"({ "a": )"); a_json += JSON; a_json += " }"; \
+    padded_string a_json(std::string(R"({ "a": )") + JSON + " }"); \
     std::cout << R"(- Subtest: get_)" << (#TYPE) << "() - JSON: " << a_json << std::endl; \
-    if (!test_ondemand_doc(simdjson::pad(a_json), [&](auto doc_result) { \
+    if (!test_ondemand_doc(a_json, [&](auto doc_result) { \
       ASSERT_ERROR( doc_result["a"].get_##TYPE(), (ERROR) ); \
       return true; \
     })) { \