template for

add static reflection benchmark to 'large random' benchmark and allows (#2349 )
deserialization (with static reflection) from objects and arrays. Co-authored-by: Daniel Lemire <dlemire@lemire.me>
2026-06-08 17:27:07 +00:00 · 2025-03-17 20:40:56 -04:00 · 2025-03-17 18:02:41 -04:00 · 2025-03-13 09:37:46 -04:00 · 2025-03-07 20:46:43 -05:00 · 2025-03-07 16:41:19 -05:00
90 changed files with 13107 additions and 895 deletions
@@ -13,7 +13,7 @@ jobs:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
-      - uses: uraimo/run-on-arch-action@v2
+      - uses: uraimo/run-on-arch-action@v3
        name: Test
        id: runcmd
        with:
@@ -1,9 +1,8 @@
 name: Doxygen GitHub Pages

 on:
-  push:
-    branches:
-      - master
+  release:
+    types: [created]
  # Allows you to run this workflow manually from the Actions tab
  workflow_dispatch:

@@ -24,7 +24,7 @@ jobs:
      implementations: haswell westmere fallback
      UBSAN_OPTIONS: halt_on_error=1
      MAXLEN: -max_len=4000
-      CLANGVERSION: 15
+      CLANGVERSION: 19
      # which optimization level to use for the sanitizer build (see build_fuzzer.variants.sh)
      OPTLEVEL: -O3

@@ -125,7 +125,7 @@ jobs:
        done

    - name: Save the corpus as a github artifact
-      uses: actions/upload-artifact@v3
+      uses: actions/upload-artifact@v4
      with:
        name: corpus
        path: corpus.tar
@@ -148,7 +148,7 @@ jobs:
      run: tar cf valgrind.tar valgrind-*.txt

    - name: Save valgrind output as a github artifact
-      uses: actions/upload-artifact@v3
+      uses: actions/upload-artifact@v4
      if: always()
      with:
        name: valgrindresults
@@ -156,7 +156,7 @@ jobs:
        if-no-files-found: ignore

    - name: Archive any crashes as an artifact
-      uses: actions/upload-artifact@v3
+      uses: actions/upload-artifact@v4
      if: always()
      with:
        name: crashes
@@ -20,7 +20,7 @@ jobs:
          - msystem: "MINGW64"
            install: mingw-w64-x86_64-libxml2 mingw-w64-x86_64-cmake mingw-w64-x86_64-ninja mingw-w64-x86_64-clang
            type: Debug
-            - msystem: "MINGW64"
+          - msystem: "MINGW64"
            install: mingw-w64-x86_64-libxml2 mingw-w64-x86_64-cmake mingw-w64-x86_64-ninja mingw-w64-x86_64-clang
            type: RelWithDebInfo
    env:
@@ -13,7 +13,7 @@ jobs:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
-      - uses: uraimo/run-on-arch-action@v2
+      - uses: uraimo/run-on-arch-action@v3
        name: Test
        id: runcmd
        with:
@@ -13,7 +13,7 @@ jobs:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
-      - uses: uraimo/run-on-arch-action@v2
+      - uses: uraimo/run-on-arch-action@v3
        name: Test
        id: runcmd
        with:
@@ -13,7 +13,7 @@ jobs:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
-      - uses: uraimo/run-on-arch-action@v2
+      - uses: uraimo/run-on-arch-action@v3
        name: Test
        id: runcmd
        with:
@@ -18,4 +18,4 @@ jobs:
       - name: Use cmake
         run: |
           cmake -A ${{ matrix.arch }} -DCMAKE_SYSTEM_VERSION="10.0.22621.0" -DCMAKE_CROSSCOMPILING=1 -DSIMDJSON_DEVELOPER_MODE=ON -D SIMDJSON_GOOGLE_BENCHMARKS=OFF -DSIMDJSON_EXCEPTIONS=OFF -B build  &&
-           cmake --build build --verbose
+           cmake --build build --verbose
@@ -3,7 +3,7 @@ cmake_minimum_required(VERSION 3.14)
 project(
    simdjson
    # The version number is modified by tools/release.py
-    VERSION 3.10.1
+    VERSION 3.12.2
    DESCRIPTION "Parsing gigabytes of JSON per second"
    HOMEPAGE_URL "https://simdjson.org/"
    LANGUAGES CXX C
@@ -20,8 +20,8 @@ string(
 # ---- Options, variables ----

 # These version numbers are modified by tools/release.py
-set(SIMDJSON_LIB_VERSION "23.0.0" CACHE STRING "simdjson library version")
-set(SIMDJSON_LIB_SOVERSION "23" CACHE STRING "simdjson library soversion")
+set(SIMDJSON_LIB_VERSION "25.0.0" CACHE STRING "simdjson library version")
+set(SIMDJSON_LIB_SOVERSION "25" CACHE STRING "simdjson library soversion")

 option(SIMDJSON_BUILD_STATIC_LIB "Build simdjson_static library along with simdjson (only makes sense if BUILD_SHARED_LIBS=ON)" OFF)
 if(SIMDJSON_BUILD_STATIC_LIB AND NOT BUILD_SHARED_LIBS)
@@ -43,6 +43,20 @@ if(SIMDJSON_DISABLE_DEPRECATED_API)
  )
 endif()

+if(${CMAKE_VERSION} VERSION_GREATER_EQUAL "3.25.0")
+    option(SIMDJSON_STATIC_REFLECTION "Enables static reflection (experimental), requires C++26" OFF)
+else()
+    set(SIMDJSON_STATIC_REFLECTION OFF CACHE BOOL "Enables static reflection (experimental)" FORCE)
+    message(WARNING "SIMDJSON_STATIC_REFLECTION is disabled because your CMake version is below 3.25")
+endif()
+
+if(SIMDJSON_STATIC_REFLECTION)
+  simdjson_add_props(
+      target_compile_definitions PUBLIC
+      SIMDJSON_STATIC_REFLECTION=1
+  )
+endif()
+
 option(SIMDJSON_DEVELOPMENT_CHECKS "Enable development-time aids, such as \
 checks for incorrect API usage. Enabled by default in DEBUG." OFF)
 if(SIMDJSON_DEVELOPMENT_CHECKS)
@@ -98,7 +112,16 @@ simdjson_add_props(
    PRIVATE "$<BUILD_INTERFACE:${PROJECT_SOURCE_DIR}/src>"
 )

-simdjson_add_props(target_compile_features PUBLIC cxx_std_11)
+if(SIMDJSON_STATIC_REFLECTION)
+  # We would like to require C++26, but no compiler supports that!
+  # This is a hack:
+  simdjson_add_props(
+      target_compile_options PUBLIC
+      -freflection -fexpansion-statements -stdlib=libc++ -std=c++26
+  )
+else()
+  simdjson_add_props(target_compile_features PUBLIC cxx_std_11)
+endif()

 # workaround for GNU GCC poor AVX load/store code generation
 if(
@@ -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         = "3.10.1"
+PROJECT_NUMBER         = "3.12.2"

 # 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
@@ -186,7 +186,7 @@
      same "printed page" as the copyright notice for easier
      identification within third-party archives.

-   Copyright 2018-2023 The simdjson authors
+   Copyright 2018-2025 The simdjson authors

   Licensed under the Apache License, Version 2.0 (the "License");
   you may not use this file except in compliance with the License.
@@ -0,0 +1,18 @@
+Copyright 2018-2025 The simdjson authors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of
+this software and associated documentation files (the "Software"), to deal in
+the Software without restriction, including without limitation the rights to
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+the Software, and to permit persons to whom the Software is furnished to do so,
+subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
@@ -1,7 +1,7 @@

-[![Ubuntu 20.04 CI](https://github.com/simdjson/simdjson/workflows/Ubuntu%2020.04%20CI%20(GCC%209)/badge.svg)](https://simdjson.org/plots.html)
 [![Fuzzing Status](https://oss-fuzz-build-logs.storage.googleapis.com/badges/simdjson.svg)](https://bugs.chromium.org/p/oss-fuzz/issues/list?sort=-opened&can=1&q=proj:simdjson)
-[![][license img]][license]
+[![][license img]][license] [![][licensemit img]][licensemit]
+

 [![Doxygen Documentation](https://img.shields.io/badge/docs-doxygen-green.svg)](https://simdjson.github.io/simdjson/)

@@ -31,6 +31,7 @@ Table of Contents
 * [Documentation](#documentation)
 * [Godbolt](#godbolt)
 * [Performance results](#performance-results)
+* [Packages](#packages)
 * [Bindings and Ports of simdjson](#bindings-and-ports-of-simdjson)
 * [About simdjson](#about-simdjson)
 * [Funding](#funding)
@@ -61,6 +62,8 @@ Real-world usage
 - [ada-url](https://github.com/ada-url/ada)
 - [fastgron](https://github.com/adamritter/fastgron)
 - [WasmEdge](https://wasmedge.org)
+- [RonDB](https://github.com/logicalclocks/rondb)
+

 If you are planning to use simdjson in a product, please work from one of our releases.

@@ -105,6 +108,7 @@ Documentation
 Usage documentation is available:

 * [Basics](doc/basics.md) is an overview of how to use simdjson and its APIs.
+* [Builder](doc/builder.md) is an overview of how to efficiently write JSON strings using simdjson.
 * [Performance](doc/performance.md) shows some more advanced scenarios and how to tune for them.
 * [Implementation Selection](doc/implementation-selection.md) describes runtime CPU detection and
  how you can work with it.
@@ -143,6 +147,9 @@ speed for [synthetic files over various sizes generated with a script](https://g
 For NDJSON files, we can exceed 3 GB/s with [our  multithreaded parsing functions](https://github.com/simdjson/simdjson/blob/master/doc/parse_many.md).


+Packages
+------------------------------
+[![Packaging status](https://repology.org/badge/vertical-allrepos/simdjson.svg)](https://repology.org/project/simdjson/versions)


 Bindings and Ports of simdjson
@@ -207,6 +214,11 @@ RGPIN-2017-03910 and RGPIN-2024-03787.
 [license]: LICENSE
 [license img]: https://img.shields.io/badge/License-Apache%202-blue.svg

+
+[licensemit]: LICENSE-MIT
+[licensemit img]: https://img.shields.io/badge/License-MIT-blue.svg
+
+
 Contributing to simdjson
 ------------------------

@@ -216,7 +228,7 @@ Head over to [CONTRIBUTING.md](CONTRIBUTING.md) for information on contributing
 License
 -------

-This code is made available under the [Apache License 2.0](https://www.apache.org/licenses/LICENSE-2.0.html).
+This code is made available under the [Apache License 2.0](https://www.apache.org/licenses/LICENSE-2.0.html) as well as under the MIT License. As a user, you can pick the license you prefer.

 Under Windows, we build some tools using the windows/dirent_portable.h file (which is outside our library code): it is under the liberal (business-friendly) MIT license.

@@ -4,6 +4,9 @@ add_subdirectory(dom)
 include_directories( . linux )
 link_libraries(simdjson-windows-headers test-data)
 link_libraries(simdjson)
+if(SIMDJSON_STATIC_REFLECTION)
+  add_compile_definitions(SIMDJSON_STATIC_REFLECTION=1)
+endif(SIMDJSON_STATIC_REFLECTION)

 add_executable(benchfeatures benchfeatures.cpp)
 add_executable(get_corpus_benchmark get_corpus_benchmark.cpp)
@@ -32,3 +35,6 @@ if (TARGET benchmark::benchmark)
  endif()
 endif()

+if(SIMDJSON_STATIC_REFLECTION)
+  add_subdirectory(static_reflect)
+endif(SIMDJSON_STATIC_REFLECTION)
@@ -122,6 +122,7 @@ struct event_aggregate {
  }

  double elapsed_sec() const { return total.elapsed_sec() / iterations; }
+  double total_elapsed_ns() const { return total.elapsed_ns(); }
  double elapsed_ns() const { return total.elapsed_ns() / iterations; }
  double cycles() const { return total.cycles() / iterations; }
  double instructions() const { return total.instructions() / iterations; }
@@ -23,7 +23,30 @@ struct simdjson_ondemand {
 };

 BENCHMARK_TEMPLATE(large_random, simdjson_ondemand)->UseManualTime();
+#if SIMDJSON_STATIC_REFLECTION

+struct simdjson_ondemand_static_reflect {
+  static constexpr diff_flags DiffFlags = diff_flags::NONE;
+
+  ondemand::parser parser{};
+
+  bool run(simdjson::padded_string &json, std::vector<point> &result) {
+    auto doc = parser.iterate(json);
+    //ondemand::array arr = doc.get_array();
+    //arr.get<std::vector<point>>(result);
+    // We can also do it like so:
+    for (ondemand::object coord : doc) {
+      result.emplace_back(coord.get<point>());
+    }
+    // It seems that doing the reflection is slower than doing the manual lookup.
+    // E.g., it is faster if we do result.emplace_back(coord["x"], coord["y"], coord["z"]);
+    return true;
+  }
+};
+BENCHMARK_TEMPLATE(large_random, simdjson_ondemand_static_reflect)->UseManualTime();
+
+
+#endif
 } // namespace large_random

 #endif // SIMDJSON_EXCEPTIONS
@@ -0,0 +1,44 @@
+# Include reflect-cpp
+CPMAddPackage(
+  NAME reflect-cpp
+  GITHUB_REPOSITORY getml/reflect-cpp
+  GIT_TAG v0.17.0
+  EXCLUDE_FROM_ALL YES
+)
+
+
+
+if(NOT WIN32)
+# We want the check whether Rust is available before trying to build a crate.
+CPMAddPackage(
+  NAME corrosion
+  GITHUB_REPOSITORY corrosion-rs/corrosion
+  VERSION 0.4.4
+  DOWNLOAD_ONLY ON
+  OPTIONS "Rust_FIND_QUIETLY OFF"
+)
+include("${corrosion_SOURCE_DIR}/cmake/FindRust.cmake")
+endif()
+
+if(RUST_FOUND)
+  message(STATUS "Rust found: " ${Rust_VERSION} )
+  add_subdirectory("${corrosion_SOURCE_DIR}" "${PROJECT_BINARY_DIR}/_deps/corrosion" EXCLUDE_FROM_ALL)
+  # Important: we want to build in release mode!
+  corrosion_import_crate(MANIFEST_PATH "serde-benchmark/Cargo.toml" NO_LINKER_OVERRIDE PROFILE release)
+else()
+  message(STATUS "Rust/Cargo is unavailable." )
+  message(STATUS "We will not benchmark serde-benchmark." )
+  if (${CMAKE_SYSTEM_NAME} MATCHES "Darwin")
+    message(STATUS "Under macOS, you may be able to install rust with")
+    message(STATUS "curl https://sh.rustup.rs -sSf | sh")
+  elseif(CMAKE_SYSTEM_NAME STREQUAL "Linux")
+    message(STATUS "Under Linux, you may be able to install rust with a command such as")
+    message(STATUS "apt-get install cargo" )
+    message(STATUS "or" )
+    message(STATUS "curl https://sh.rustup.rs -sSf | sh")
+  endif()
+endif()
+
+
+
+add_subdirectory(twitter_data)
@@ -0,0 +1,103 @@
+# This file is automatically @generated by Cargo.
+# It is not intended for manual editing.
+version = 3
+
+[[package]]
+name = "itoa"
+version = "1.0.11"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "49f1f14873335454500d59611f1cf4a4b0f786f9ac11f4312a78e4cf2566695b"
+
+[[package]]
+name = "libc"
+version = "0.2.158"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d8adc4bb1803a324070e64a98ae98f38934d91957a99cfb3a43dcbc01bc56439"
+
+[[package]]
+name = "memchr"
+version = "2.7.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "78ca9ab1a0babb1e7d5695e3530886289c18cf2f87ec19a575a0abdce112e3a3"
+
+[[package]]
+name = "proc-macro2"
+version = "1.0.86"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5e719e8df665df0d1c8fbfd238015744736151d4445ec0836b8e628aae103b77"
+dependencies = [
+ "unicode-ident",
+]
+
+[[package]]
+name = "quote"
+version = "1.0.37"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b5b9d34b8991d19d98081b46eacdd8eb58c6f2b201139f7c5f643cc155a633af"
+dependencies = [
+ "proc-macro2",
+]
+
+[[package]]
+name = "ryu"
+version = "1.0.18"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f3cb5ba0dc43242ce17de99c180e96db90b235b8a9fdc9543c96d2209116bd9f"
+
+[[package]]
+name = "serde"
+version = "1.0.209"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "99fce0ffe7310761ca6bf9faf5115afbc19688edd00171d81b1bb1b116c63e09"
+dependencies = [
+ "serde_derive",
+]
+
+[[package]]
+name = "serde-benchmark"
+version = "0.1.0"
+dependencies = [
+ "libc",
+ "serde",
+ "serde_json",
+]
+
+[[package]]
+name = "serde_derive"
+version = "1.0.209"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a5831b979fd7b5439637af1752d535ff49f4860c0f341d1baeb6faf0f4242170"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "serde_json"
+version = "1.0.127"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8043c06d9f82bd7271361ed64f415fe5e12a77fdb52e573e7f06a516dea329ad"
+dependencies = [
+ "itoa",
+ "memchr",
+ "ryu",
+ "serde",
+]
+
+[[package]]
+name = "syn"
+version = "2.0.76"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "578e081a14e0cefc3279b0472138c513f37b41a08d5a3cca9b6e4e8ceb6cd525"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "unicode-ident",
+]
+
+[[package]]
+name = "unicode-ident"
+version = "1.0.12"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3354b9ac3fae1ff6755cb6db53683adb661634f67557942dea4facebec0fee4b"
@@ -0,0 +1,17 @@
+[package]
+name = "serde-benchmark"
+version = "0.1.0"
+
+[lib]
+path = "lib.rs"
+crate-type = ["cdylib"]
+
+[dependencies]
+serde = { version = "1.0", features = ["derive"] }
+libc = "0.2"
+serde_json = "1.0"
+
+[profile.release]
+opt-level = 3
+debug = false
+lto = true
@@ -0,0 +1,18 @@
+## Rust Serde FFI
+
+This folder includes FFI bindings for rust/serde.
+
+### Links
+
+- https://github.com/eqrion/cbindgen/blob/master/docs.md
+- https://gist.github.com/zbraniecki/b251714d77ffebbc73c03447f2b2c69f
+- https://michael-f-bryan.github.io/rust-ffi-guide/setting_up.html
+
+### Building
+
+- Generating cbindgen output
+  - Install dependencies with `brew install cbindgen` or `apt-get install cbindgen` or `cargo install cbindgen` or the equivalent: we used `cargo install --version 0.23.0 cbindgen`.
+  - Go to the directory where this README.md file is located
+  - Generate with `cbindgen --config cbindgen.toml --crate serde-benchmark --output serde_benchmark.h`
+- Building
+  - Run with `cargo build --release`
@@ -0,0 +1,12 @@
+autogen_warning = "/* Warning, this file is autogenerated by cbindgen. Don't modify this manually. */"
+include_version = true
+braces = "SameLine"
+line_length = 100
+tab_width = 2
+language = "C++"
+namespaces = ["serde_benchmark"]
+include_guard = "serde_benchmark_ffi_h"
+
+[parse]
+parse_deps = true
+include = ["serde_json", "serde"]
@@ -0,0 +1,170 @@
+extern crate serde;
+extern crate serde_json;
+extern crate libc;
+use std::slice;
+
+use libc::{c_char, size_t};
+use serde::{Serialize, Deserialize};
+
+/******************************************************/
+/******************************************************/
+/**
+ * Warning: the C++ code may not generate the same JSON.
+ */
+ /******************************************************/
+ /******************************************************/
+
+// This has no equivalent in C++:
+#[derive(Serialize, Deserialize)]
+pub struct Metadata {
+    result_type: String,
+    iso_language_code: String,
+}
+
+#[derive(Serialize, Deserialize)]
+pub struct User {
+    id: i64,
+    id_str: String,
+    name: String,
+    screen_name: String,
+    location: String,
+    description: String,
+    // C++ does not have those:
+    // url: Option<String>,
+    //protected: bool,
+    //listed_count: i64,
+    //created_at: String,
+    //favourites_count: i64,
+    //utc_offset: Option<i64>,
+    //time_zone: Option<String>,
+    //geo_enabled: bool,
+    verified: bool,
+    followers_count: i64,
+    friends_count: i64,
+    statuses_count: i64,
+    // C++ does not have those:
+    //lang: String,
+    //profile_background_color: String,
+    //profile_background_image_url: String,
+    //profile_background_image_url_https: String,
+    //profile_background_tile: bool,
+    //profile_image_url: String,
+    //profile_image_url_https: String,
+    //profile_banner_url: Option<String>,
+    //profile_link_color: String,
+    //profile_sidebar_border_color: String,
+    //profile_sidebar_fill_color: String,
+    //profile_text_color: String,
+    //profile_use_background_image: bool,
+    //default_profile: bool,
+    //default_profile_image: bool,
+    //following: bool,
+    //follow_request_sent: bool,
+    //notifications: bool,
+}
+
+#[derive(Serialize, Deserialize)]
+pub struct Hashtag {
+    text: String,
+
+    // C++ has those but D. Lemire does not know what they are, they don't appear in the JSON:
+    // int64_t indices_start;
+    // int64_t indices_end;
+}
+
+#[derive(Serialize, Deserialize)]
+pub struct Url {
+    url: String,
+    expanded_url: String,
+    display_url: String,
+    // C++ has those but D. Lemire does not know what they are, they don't appear in the JSON:
+    // int64_t indices_start;
+    // int64_t indices_end;
+}
+
+#[derive(Serialize, Deserialize)]
+pub struct UserMention {
+    id: i64,
+    name: String,
+    screen_name: String,
+    // Not in the C++ equivalent:
+    //id_str: String,
+    //indices: Vec<i64>,
+    // C++ has those but D. Lemire does not know what they are, they don't appear in the JSON:
+    // int64_t indices_start;
+    // int64_t indices_end;
+}
+
+#[derive(Serialize, Deserialize)]
+pub struct Entities {
+    hashtags: Vec<Hashtag>,
+    urls: Vec<Url>,
+    user_mentions: Vec<UserMention>,
+}
+
+#[derive(Serialize, Deserialize)]
+pub struct Status {
+    created_at: String,
+    id: i64,
+    text: String,
+    user: User,
+    entities: Entities,
+    retweet_count: i64,
+    favorite_count: i64,
+    favorited: bool,
+    retweeted: bool,
+    // None of these are in the C++ equivalent:
+    /*
+    metadata: Metadata,
+    id_str: String,
+    source: String,
+    truncated: bool,
+    in_reply_to_status_id: Option<i64>,
+    in_reply_to_status_id_str: Option<String>,
+    in_reply_to_user_id: Option<i64>,
+    in_reply_to_user_id_str: Option<String>,
+    in_reply_to_screen_name: Option<String>,
+    geo: Option<String>,
+    coordinates: Option<String>,
+    place: Option<String>,
+    contributors: Option<String>,
+    lang: String,
+    */
+}
+
+#[derive(Serialize, Deserialize)]
+pub struct TwitterData {
+    statuses: Vec<Status>,
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn  twitter_from_str(raw_input: *const c_char, raw_input_length: size_t) -> *mut TwitterData {
+  let input = std::str::from_utf8_unchecked(slice::from_raw_parts(raw_input as *const u8, raw_input_length));
+  match serde_json::from_str(&input) {
+    Ok(result) => Box::into_raw(Box::new(result)),
+    Err(_) => std::ptr::null_mut(),
+  }
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn str_from_twitter(raw: *mut TwitterData) -> *const c_char {
+  let twitter_thing = { &*raw };
+  let serialized = serde_json::to_string(&twitter_thing).unwrap();
+  return std::ffi::CString::new(serialized.as_str()).unwrap().into_raw()
+}
+
+
+#[no_mangle]
+pub unsafe extern "C" fn free_twitter(raw: *mut TwitterData) {
+  if raw.is_null() {
+    return;
+  }
+
+  drop(Box::from_raw(raw))
+}
+
+
+#[no_mangle]
+pub unsafe extern fn free_string(ptr: *const c_char) {
+    let _ = std::ffi::CString::from_raw(ptr as *mut _);
+}
@@ -0,0 +1,32 @@
+#ifndef serde_benchmark_ffi_h
+#define serde_benchmark_ffi_h
+
+/* Generated with cbindgen:0.24.3 */
+
+/* Warning, this file is autogenerated by cbindgen. Don't modify this manually. */
+
+#include <cstdarg>
+#include <cstdint>
+#include <cstdlib>
+#include <ostream>
+#include <new>
+
+namespace serde_benchmark {
+
+struct TwitterData;
+
+extern "C" {
+
+TwitterData *twitter_from_str(const char *raw_input, size_t raw_input_length);
+
+const char *str_from_twitter(TwitterData *raw);
+
+void free_twitter(TwitterData *raw);
+
+void free_string(const char *ptr);
+
+} // extern "C"
+
+} // namespace serde_benchmark
+
+#endif // serde_benchmark_ffi_h
@@ -0,0 +1,15 @@
+
+# Add executable targets
+add_executable(benchmark_serialization_twitter benchmark_serialization_twitter.cpp)
+
+ if(TARGET serde-benchmark)
+    message(STATUS "serde-benchmark target was created. Linking benchmarks and serde-benchmark.")
+    target_link_libraries(benchmark_serialization_twitter PRIVATE serde-benchmark)
+    target_compile_definitions(benchmark_serialization_twitter PRIVATE SIMDJSON_RUST_VERSION="${Rust_VERSION}")
+endif()
+target_link_libraries(benchmark_serialization_twitter PRIVATE simdjson::simdjson nlohmann_json)
+
+target_link_libraries(benchmark_serialization_twitter PRIVATE reflectcpp)
+target_compile_definitions(benchmark_serialization_twitter PRIVATE SIMDJSON_BENCH_CPP_REFLECT=1)
+
+target_compile_definitions(benchmark_serialization_twitter PRIVATE JSON_FILE="${EXAMPLE_JSON}")
@@ -0,0 +1,52 @@
+#ifndef BENCHMARK_HELPER_HPP
+#define BENCHMARK_HELPER_HPP
+#include "event_counter.h"
+#include <atomic>
+
+inline event_collector &get_collector() {
+  static event_collector collector;
+  return collector;
+}
+
+template <class function_type>
+event_aggregate bench(const function_type &function, size_t min_repeat = 10,
+                      size_t min_time_ns = 1000000000,
+                      size_t max_repeat = 100000) {
+  event_collector &collector = get_collector();
+  event_aggregate aggregate{};
+  size_t N = min_repeat;
+  if (N == 0) {
+    N = 1;
+  }
+  for (size_t i = 0; i < N; i++) {
+    std::atomic_thread_fence(std::memory_order_acquire);
+    collector.start();
+    function();
+    std::atomic_thread_fence(std::memory_order_release);
+    event_count allocate_count = collector.end();
+    aggregate << allocate_count;
+    if ((i + 1 == N) && (aggregate.total_elapsed_ns() < min_time_ns) &&
+        (N < max_repeat)) {
+      N *= 10;
+    }
+  }
+  return aggregate;
+}
+
+// Source of the 2 functions below:
+// https://github.com/simdutf/simdutf/blob/master/benchmarks/base64/benchmark_base64.cpp
+inline void pretty_print(size_t strings, size_t bytes, std::string name,
+                         event_aggregate agg) {
+  event_collector &collector = get_collector();
+  printf("%-60s : ", name.c_str());
+  printf(" %5.2f MB/s ", bytes * 1000 / agg.elapsed_ns());
+  printf(" %5.2f Ms/s ", strings * 1000 / agg.elapsed_ns());
+  if (collector.has_events()) {
+    printf(" %5.2f GHz ", agg.cycles() / agg.elapsed_ns());
+    printf(" %5.2f c/b ", agg.cycles() / bytes);
+    printf(" %5.2f i/b ", agg.instructions() / bytes);
+    printf(" %5.2f i/c ", agg.instructions() / agg.cycles());
+  }
+  printf("\n");
+}
+#endif
@@ -0,0 +1,142 @@
+#include <cassert>
+#include <cstdlib>
+#include <ctime>
+#include <format>
+#include <fstream>
+#include <iostream>
+#include <nlohmann/json.hpp>
+#include <simdjson.h>
+#include <string>
+#include "twitter_data.h"
+#include "nlohmann_twitter_data.h"
+#include "benchmark_helper.h"
+#if SIMDJSON_BENCH_CPP_REFLECT
+#include <rfl.hpp>
+#include <rfl/json.hpp>
+void bench_reflect_cpp(TwitterData &data) {
+  std::string output = rfl::json::write(data);
+  size_t output_volume = output.size();
+  printf("# output volume: %zu bytes\n", output_volume);
+
+  volatile size_t measured_volume = 0;
+  pretty_print(1, output_volume, "bench_reflect_cpp",
+               bench([&data, &measured_volume, &output_volume]() {
+                 std::string output = rfl::json::write(data);
+                 measured_volume = output.size();
+                 if (measured_volume != output_volume) {
+                   printf("mismatch\n");
+                 }
+               }));
+}
+#endif // SIMDJSON_BENCH_CPP_REFLECT
+
+#ifdef SIMDJSON_RUST_VERSION
+#include "../serde-benchmark/serde_benchmark.h"
+
+
+void bench_rust(serde_benchmark::TwitterData *data) {
+  const char * output = serde_benchmark::str_from_twitter(data);
+  size_t output_volume = strlen(output);
+  printf("# output volume: %zu bytes\n", output_volume);
+  volatile size_t measured_volume = 0;
+  pretty_print(1, output_volume, "bench_rust",
+               bench([&data, &measured_volume, &output_volume]() {
+                 const char * output = serde_benchmark::str_from_twitter(data);
+                 serde_benchmark::free_string(output);
+               }));
+}
+#endif
+
+template <class T> void bench_simdjson_static_reflection(T &data) {
+  simdjson::builder::string_builder sb;
+  simdjson::builder::append(sb, data);
+  std::string_view p;
+  if(sb.view().get(p)) {
+    std::cerr << "Error!" << std::endl;
+  }
+  size_t output_volume = p.size();
+  sb.clear();
+  printf("# output volume: %zu bytes\n", output_volume);
+
+  volatile size_t measured_volume = 0;
+  pretty_print(sizeof(data), output_volume, "bench_simdjson_static_reflection",
+               bench([&data, &measured_volume, &output_volume, &sb]() {
+                 sb.clear();
+                 simdjson::builder::append(sb, data);
+                 std::string_view p;
+                 if(sb.view().get(p)) {
+                   std::cerr << "Error!" << std::endl;
+                 }
+                 measured_volume = sb.size();
+                 if (measured_volume != output_volume) {
+                   printf("mismatch\n");
+                 }
+               }));
+}
+
+void bench_nlohmann(TwitterData &data) {
+  std::string output = nlohmann_serialize(data);
+  size_t output_volume = output.size();
+  printf("# output volume: %zu bytes\n", output_volume);
+
+  volatile size_t measured_volume = 0;
+  pretty_print(1, output_volume, "bench_nlohmann",
+               bench([&data, &measured_volume, &output_volume]() {
+                 std::string output = nlohmann_serialize(data);
+                 measured_volume = output.size();
+                 if (measured_volume != output_volume) {
+                   printf("mismatch\n");
+                 }
+               }));
+}
+
+size_t WriteCallback(void *contents, size_t size, size_t nmemb, void *userp) {
+  ((std::string *)userp)->append((char *)contents, size * nmemb);
+  return size * nmemb;
+}
+
+std::string read_file(std::string filename) {
+  printf("# Reading file %s\n", filename.c_str());
+  constexpr size_t read_size = 4096;
+  auto stream = std::ifstream(filename.c_str());
+  stream.exceptions(std::ios_base::badbit);
+  std::string out;
+  std::string buf(read_size, '\0');
+  while (stream.read(&buf[0], read_size)) {
+    out.append(buf, 0, size_t(stream.gcount()));
+  }
+  out.append(buf, 0, size_t(stream.gcount()));
+  return out;
+}
+
+int main() {
+  // Testing correctness of round-trip (serialization + deserialization)
+  std::string json_str = read_file(JSON_FILE);
+
+  // Loading up the data into a structure.
+  simdjson::ondemand::parser parser;
+  simdjson::ondemand::document doc;
+  if(parser.iterate(simdjson::pad(json_str)).get(doc)) {
+    std::cerr << "Error loading the document!" << std::endl;
+    return EXIT_FAILURE;
+  }
+  TwitterData my_struct;
+  if(doc.get<TwitterData>().get(my_struct)) {
+    std::cerr << "Error loading TwitterData!" << std::endl;
+    return EXIT_FAILURE;
+  }
+
+  // Benchmarking the serialization
+  bench_nlohmann(my_struct);
+  bench_simdjson_static_reflection(my_struct);
+#ifdef SIMDJSON_RUST_VERSION
+  printf("# WARNING: The Rust benchmark may not be directly comparable since it does not use an equivalent data structure.\n");
+  serde_benchmark::TwitterData * td = serde_benchmark::twitter_from_str(json_str.c_str(), json_str.size());
+  bench_rust(td);
+  serde_benchmark::free_twitter(td);
+#endif
+#if SIMDJSON_BENCH_CPP_REFLECT
+  bench_reflect_cpp(my_struct);
+#endif
+  return EXIT_SUCCESS;
+}
@@ -0,0 +1,117 @@
+#ifndef NLOHMANN_TWITTER_DATA_H
+#define NLOHMANN_TWITTER_DATA_H
+
+#include "twitter_data.h"
+#include <nlohmann/json.hpp>
+
+void to_json(nlohmann::json &j, const User &u) {
+  j = nlohmann::json{{"id", u.id},
+                     {"name", u.name},
+                     {"screen_name", u.screen_name},
+                     {"location", u.location},
+                     {"description", u.description},
+                     {"verified", u.verified},
+                     {"followers_count", u.followers_count},
+                     {"friends_count", u.friends_count},
+                     {"statuses_count", u.statuses_count}};
+}
+
+void to_json(nlohmann::json &j, const Hashtag &h) {
+  j = nlohmann::json{{"text", h.text},
+                     {"indices_start", h.indices_start},
+                     {"indices_end", h.indices_end}};
+}
+
+void to_json(nlohmann::json &j, const Url &u) {
+  j = nlohmann::json{{"url", u.url},
+                     {"expanded_url", u.expanded_url},
+                     {"display_url", u.display_url},
+                     {"indices_start", u.indices_start},
+                     {"indices_end", u.indices_end}};
+}
+
+void to_json(nlohmann::json &j, const UserMention &um) {
+  j = nlohmann::json{{"id", um.id},
+                     {"name", um.name},
+                     {"screen_name", um.screen_name},
+                     {"indices_start", um.indices_start},
+                     {"indices_end", um.indices_end}};
+}
+
+void to_json(nlohmann::json &j, const Entities &e) {
+  j = nlohmann::json{{"hashtags", e.hashtags},
+                     {"urls", e.urls},
+                     {"user_mentions", e.user_mentions}};
+}
+
+void to_json(nlohmann::json &j, const Status &s) {
+  j = nlohmann::json{{"created_at", s.created_at},
+                     {"id", s.id},
+                     {"text", s.text},
+                     {"user", s.user},
+                     {"entities", s.entities},
+                     {"retweet_count", s.retweet_count},
+                     {"favorite_count", s.favorite_count},
+                     {"favorited", s.favorited},
+                     {"retweeted", s.retweeted}};
+}
+
+
+std::string nlohmann_serialize(const std::vector<Hashtag>& v) {
+  nlohmann::json a = nlohmann::json::array();
+  for(const Hashtag & h : v) {
+    a.push_back(nlohmann::json{{"text", h.text},
+                     {"indices_start", h.indices_start},
+                     {"indices_end", h.indices_end}});
+  }
+  return a.dump();
+}
+std::string nlohmann_serialize(const std::vector<Url>& v) {
+  nlohmann::json a = nlohmann::json::array();
+  for(const Url & u : v) {
+    a.push_back(nlohmann::json{{"url", u.url},
+                     {"expanded_url", u.expanded_url},
+                     {"display_url", u.display_url},
+                     {"indices_start", u.indices_start},
+                     {"indices_end", u.indices_end}});
+  }
+  return a.dump();
+}
+std::string nlohmann_serialize(const std::vector<UserMention>& v) {
+  nlohmann::json a = nlohmann::json::array();
+  for(const UserMention & um : v) {
+    a.push_back(nlohmann::json{{"id", um.id},
+                     {"name", um.name},
+                     {"screen_name", um.screen_name},
+                     {"indices_start", um.indices_start},
+                     {"indices_end", um.indices_end}});
+  }
+  return a.dump();
+}
+
+std::string nlohmann_serialize(const std::vector<Status>& v) {
+  nlohmann::json a = nlohmann::json::array();
+  for(const Status & s : v) {
+    a.push_back(nlohmann::json{{"created_at", s.created_at},
+                     {"id", s.id},
+                     {"text", s.text},
+                     {"user", s.user},
+                     {"entities", s.entities},
+                     {"retweet_count", s.retweet_count},
+                     {"favorite_count", s.favorite_count},
+                     {"favorited", s.favorited},
+                     {"retweeted", s.retweeted}});
+  }
+  return a.dump();
+}
+
+
+void to_json(nlohmann::json &j, const TwitterData &t) {
+  j = nlohmann::json{{"statuses", t.statuses}};
+}
+
+std::string nlohmann_serialize(const TwitterData &data) {
+  return nlohmann_serialize(data.statuses);
+}
+
+#endif // NLOHMANN_TWITTER_DATA_H
@@ -0,0 +1,71 @@
+#ifndef TWITTER_DATA_H
+#define TWITTER_DATA_H
+
+#include <string>
+#include <vector>
+
+struct User {
+  int64_t id;
+  std::string id_str;
+  std::string name;
+  std::string screen_name;
+  std::string location;
+  std::string description;
+  bool verified;
+  int64_t followers_count;
+  int64_t friends_count;
+  int64_t statuses_count;
+  bool operator<=>(const User &other) const = default;
+};
+
+struct Hashtag {
+  std::string text;
+  int64_t indices_start;
+  int64_t indices_end;
+  bool operator<=>(const Hashtag &other) const = default;
+};
+
+struct Url {
+  std::string url;
+  std::string expanded_url;
+  std::string display_url;
+  int64_t indices_start;
+  int64_t indices_end;
+  bool operator<=>(const Url &other) const = default;
+};
+
+struct UserMention {
+  int64_t id;
+  std::string name;
+  std::string screen_name;
+  int64_t indices_start;
+  int64_t indices_end;
+  bool operator<=>(const UserMention &other) const = default;
+};
+
+struct Entities {
+  std::vector<Hashtag> hashtags;
+  std::vector<Url> urls;
+  std::vector<UserMention> user_mentions;
+  bool operator==(const Entities &other) const = default;
+};
+
+struct Status {
+  std::string created_at;
+  int64_t id;
+  std::string text;
+  User user;
+  Entities entities;
+  int64_t retweet_count;
+  int64_t favorite_count;
+  bool favorited;
+  bool retweeted;
+  bool operator==(const Status &other) const = default;
+};
+
+struct TwitterData {
+  std::vector<Status> statuses;
+  bool operator==(const TwitterData &other) const = default;
+};
+
+#endif
@@ -110,8 +110,14 @@ endif()

 # We compile tools, tests, etc. with C++ 17. Override yourself if you need on a
 # target.
-set(SIMDJSON_CXX_STANDARD 17 CACHE STRING "the C++ standard to use for simdjson")
-set(CMAKE_CXX_STANDARD ${SIMDJSON_CXX_STANDARD})
+if(SIMDJSON_STATIC_REFLECTION)
+  # This is temporary.
+  set(SIMDJSON_CXX_STANDARD 26 CACHE STRING "the C++ standard to use for simdjson")
+  #set(CMAKE_CXX_STANDARD ${SIMDJSON_CXX_STANDARD})
+else()
+  set(SIMDJSON_CXX_STANDARD 17 CACHE STRING "the C++ standard to use for simdjson")
+  set(CMAKE_CXX_STANDARD ${SIMDJSON_CXX_STANDARD})
+endif()
 set(CMAKE_CXX_STANDARD_REQUIRED ON)
 set(CMAKE_CXX_EXTENSIONS OFF)
 set(CMAKE_THREAD_PREFER_PTHREAD ON)
@@ -114,7 +114,7 @@ int main() {}

  CPMAddPackage(
      NAME rapidjson
-      URL https://github.com/Tencent/rapidjson/archive/f54b0e47a08782a6131cc3d60f94d038fa6e0a51.zip
+      URL https://github.com/Tencent/rapidjson/archive/805d7ed5dfe97a39b8b0816fd5eeed8731dc4936.zip
      DOWNLOAD_ONLY YES
  )
  add_library(rapidjson INTERFACE)
@@ -48,7 +48,7 @@ Requirements
 ------------------

 - A recent compiler (LLVM clang 6 or better, GNU GCC 7.4 or better, Xcode 11 or better) on a 64-bit (PPC, ARM or x64 Intel/AMD) POSIX systems such as macOS, freeBSD or Linux. We require that the compiler supports the C++11 standard or better.
- Visual Studio 2017 or better under 64-bit Windows. Users should target a 64-bit build (x64 or ARM64) instead of a 32-bit build (x86). We support the LLVM clang compiler under Visual Studio (clangcl) as well as as the regular Visual Studio compiler. We also support MinGW 64-bit under Windows.
+- Visual Studio 2017 or better under 64-bit Windows. Users should target a 64-bit build (x64 or ARM64) instead of a 32-bit build (x86). We support the LLVM clang compiler under Visual Studio (clang-cl) as well as as the regular Visual Studio compiler. For better release performance (both compile time and execution time), we recommend Visual Studio users adopt LLVM (clang-cl). We also support MinGW 64-bit under Windows.


 Support for AVX-512 require a processor with AVX512-VBMI2 support (Ice Lake or better, AMD Zen 4 or better) under a 64-bit system and a recent compiler (LLVM clang 6 or better, GCC 8 or better, Visual Studio 2019 or better). You need a correspondingly recent assembler such as gas (2.30+) or nasm (2.14+): recent compilers usually come with recent assemblers. If you mix a recent compiler with an incompatible/old assembler (e.g., when using a recent compiler with an old Linux distribution), you may get errors at build time because the compiler produces instructions that the assembler does not recognize: you should update your assembler to match your compiler (e.g., upgrade binutils to version 2.30 or better under Linux) or use an older compiler matching the capabilities of your assembler.
@@ -209,6 +209,25 @@ std::string data = "my data";
 simdjson::padded_string my_padded_data(data); // copies to a padded buffer
 ```

+You can then parse the JSON data from the `simdjson::padded_string` instance:
+
+
+```c++
+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()`).
+If you are using a sanitizer that checks for reading uninitialized bytes or `std::string`'s
+container-overflow checks, you may encounter sanitizer warnings.
+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:
+
+```c++
+std::string json = "[1]";
+ondemand::document doc = parser.iterate(simdjson::pad(json));
+```

 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.
@@ -403,9 +422,13 @@ support for users who avoid exceptions. See [the simdjson error handling documen
  of the object: to warn you, an OUT_OF_ORDER_ITERATION error is generated [when development checks](#avoiding-pitfalls-enable-development-checks) are active. If you need to access an object more
  than once, you may call `reset()` on it although we discourage this practice. Keep in mind that
  you should consume each value at most once.
+
+  When you are iterating through an object, you are advancing through its keys and values. You should not also access the object or other objects. E.g. within a loop over `myobject`, you should not be accessing `myobject`. The following is an anti-pattern: `for(auto value: myobject) {myobject["mykey"]}`.
+
+  You should never reset an object as you are iterating through it. The following is an anti-pattern: `for(auto value: myobject) {myobject.reset()}`.
 * **Array Index:** Because it is forward-only, you cannot look up an array element by index by index. Instead,
  you should iterate through the array and keep an index yourself. Exceptionally, if need a single value
-  out of the array, you may use an array access (e.g., `array[1]`).
+  out of the array, you may use an array access (e.g., `array[1]`). You should never reset an array as you are iterating through it. The following is an anti-pattern: `for(auto value: myarray) {myarray.reset()}`.
 * **Field Access:** To get the value of the "foo" field in an object, use `object["foo"]`. This will
  scan through the object looking for the field with the matching string, doing a character-by-character
  comparison. It may generate the error `simdjson::NO_SUCH_FIELD` if there is no such key in the object, it may throw an exception (see [Error handling](#error-handling)). For efficiency reason, you should avoid looking up the same field repeatedly: e.g., do
@@ -538,7 +561,7 @@ support for users who avoid exceptions. See [the simdjson error handling documen
  For this purpose, `array` instances have a `count_elements` method. Users should be
  aware that the `count_elements` method can be costly since it requires scanning the
  whole array. You should only call `count_elements` as a last resort as it may
-  require scanning the document twice or more. You may use it as follows if your document is itself an array:
+  require scanning the document twice or more. You should never use the `count_elements` as part of an attempt to iterate through the array: use a `for` loop to iterate through arrays. In the spirit of On-Demand, the `count_elements` function does not validate the values in the array: they are validated when they are consumed. You may use it as follows if your document is itself an array:

  ```C++
  auto cars_json = R"( [ 40.1, 39.9, 37.7, 40.4 ] )"_padded;
@@ -790,15 +813,17 @@ for (ondemand::object points : parser.iterate(points_json)) {
 Adding support for custom types
 ----------------------

-There are 2 main ways provided by simdjson to deserialize a value into a custom type:
+There are 3 main ways provided by simdjson to deserialize a value into a custom type:

 1. Provide a [**template specialization** for member functions](https://en.cppreference.com/w/cpp/language/template_specialization#Members_of_specializations)
   1. Specialize `simdjson::ondemand::document::get` for the whole document
   2. Specialize `simdjson::ondemand::value::get` for each value
 2. Using `tag_invoke` *(the recommended way if your system supports C++20 or better)*
+3. Using static reflectioin (requires C++26 or better)

-We describe both of them in the following sections. Most users who have systems compatible with
+We describe all of them in the following sections. Most users who have systems compatible with
 C++20 or better should skip ahead to [using `tag_invoke` for custom types (C++20)](#2-use-tag_invoke-for-custom-types-c20) as it is more powerful and simpler.
+The C++26 approach is even simpler.

 ### 1. Specialize `simdjson::ondemand::value::get` to get custom types (pre-C++20)

@@ -1269,6 +1294,29 @@ auto tag_invoke(deserialize_tag, simdjson_value &val, std::list<Car>& car) {
 With this code, deserializing an `std::list<Car>` instance would capture only the cars
 that are not made by Toyota.

+### 3. Using static reflection (C++26)
+
+If you have a C++26 compatible compiler, you can compile
+your code with the `SIMDJSON_STATIC_REFLECTION` macro set:
+
+```cpp
+#define SIMDJSON_STATIC_REFLECTION 1
+//...
+#include "simdjson.h"
+```
+
+Then you can deserialize a type such as `Car` automatically:
+```cpp
+std::string json =  R"( { "make": "Toyota", "model": "Camry",  "year": 2018,
+       "tire_pressure": [ 40.1, 39.9 ] } )";
+simdjson::ondemand::parser parser;
+simdjson::ondemand::document doc = parser.iterate(simdjson::pad(json)).get(doc);
+Car c = doc.get<Car>();
+```
+
+You can also automatically serialize the `Car` instance to a JSON string, see
+our [Builder documentation](builder.md).
+

 Minifying JSON strings without parsing
 ----------------------
@@ -1606,7 +1654,7 @@ The following is a similar example where one wants to get the id of the first tw
 triggering exceptions. To do this, we use `["statuses"].at(0)["id"]`. We break that expression down:

 - Get the list of tweets (the `"statuses"` key of the document) using `["statuses"]`). The result is expected to be an array.
- Get the first tweet using `.at(0)`. The result is expected to be an object.
+- Get the first tweet using `.at(0)`. The result is expected to be an object. Observe that the `at` method can only be called once on an array (it cannot be used for iteration).
 - Get the id of the tweet using ["id"]. We expect the value to be a non-negative integer.

 Observe how we use the `at` method when querying an index into an array, and not the bracket operator.
@@ -1631,8 +1679,8 @@ int main(void) {
 }
 ```

-The `at` method can only be called once on an array. It cannot be used
-to iterate through the values of an array.
+*Important remark*: The `at` method can only be called once on an array. It cannot be used
+to iterate through the values of an array. We deliberately forbid this usage to avoid performance antipatterns. If you need to iterate through the values of an array, you should use a `for` loop.

 ### Error handling examples without exceptions

@@ -1951,6 +1999,7 @@ to the document `rewind()` method, except that it does not rewind the
 internal string buffer. Thus you should consume values only once
 even if you can iterate through the array or object more than once.
 If you unescape a string within an array more than once, you have unsafe code.
+You must not call `reset()` on an object or an array as you are iterating through it.


 Newline-Delimited JSON (ndjson) and JSON lines
@@ -1962,7 +2011,7 @@ serialize data into streams of multiple JSON documents. That is, instead of one
 write out multiple records as independent JSON documents, to be read one-by-one.

 The simdjson library also supports multithreaded JSON streaming through a large file
-containing many smaller JSON documents in either [ndjson](http://ndjson.org)
+containing many smaller JSON documents in either [ndjson](https://github.com/ndjson/ndjson-spec)
 or [JSON lines](http://jsonlines.org) format. If your JSON documents all contain arrays
 or objects, we even support direct file concatenation without whitespace. However, if there
 is content between your JSON documents, it should be exclusively ASCII white-space characters.
@@ -0,0 +1,141 @@
+Builder
+==========
+
+Sometimes you want to generate JSON string outputs efficiently.
+The simdjson library provides high-performance low-level facilities.
+When using these low-level functionalities, you are responsible to
+define the structure of your JSON document. However, string escaping
+and UTF-8 validation is automated.
+
+Overview: string_builder
+---------------------------
+
+The string_builder class is a low-level utility for constructing JSON strings representing documents. It is optimized for performance, potentially leveraging kernel-specific features like SIMD instructions for tasks such as string escaping. This class supports atomic types (e.g., booleans, numbers, strings) but does not handle composed types directly (like arrays or objects).
+
+An `string_builder` is created with an initial buffer capacity (e.g., 1kB). The memory
+is reallocated when needed. It has the following methods to add content to the string:
+
+
+- `append(number_type v)`: Appends a number (including booleans) to the JSON buffer. Booleans are converted to the strings "false" or "true". Numbers are formatted according to the JSON standard, with floating-point numbers using the shortest representation that accurately reflects the value.
+- `append(char c)`: Appends a single character to the JSON buffer.
+- `append_null()`: Appends the string "null" to the JSON buffer.
+- `clear()`: Clears the contents of the JSON buffer, resetting the position to 0 while retaining the allocated capacity.
+- `escape_and_append(std::string_view input)`: Appends a string view to the JSON buffer after escaping special characters (e.g., quotes, backslashes) as required by JSON.
+- `escape_and_append_with_quotes(std::string_view input)` Appends a string view surrounded by double quotes (e.g., "input") to the JSON buffer after escaping special characters.
+Parameters:
+- `escape_and_append_with_quotes(char input)`: Appends a single character surrounded by double quotes (e.g., "c") to the JSON buffer after escaping it if necessary.
+- `append_raw(const char *c)`: Appends a null-terminated C string directly to the JSON buffer without escaping.
+- `append_raw(std::string_view input)`: Appends a string view directly to the JSON buffer without escaping.
+- `append_raw(const char *str, size_t len)`: Appends a specified number of characters from a C string directly to the JSON
+
+After writting the content, if you have reasons to believe that the content might violate UTF-8 conventions, you can check it as follows:
+
+- `validate_unicode()`: Checks if the content in the JSON buffer is valid UTF-8. Returns: true if the content is valid UTF-8, false otherwise.
+
+Once you are satisfied, you can recover the string as follows:
+
+- `operator std::string()`: Converts the JSON buffer to an std::string. (Might throw if an error occurred.)
+- `operator std::string_view()`: Converts the JSON buffer to an std::string_view.  (Might throw if an error occurred.)
+- `view()`: Returns a view of the written JSON buffer as a `simdjson_result<std::string_view>`.
+
+The later method (`view()`) is recommended.
+
+Example: string_builder
+---------------------------
+
+```C++
+
+    void serialize_car(const Car& car, simdjson::builder::string_builder& builder) {
+        // start of JSON
+        builder.append_raw("{");
+
+        // "make"
+        builder.escape_and_append_with_quotes("make");
+        builder.append_raw(":");
+        builder.escape_and_append_with_quotes(car.make);
+
+        // "model"
+        builder.append_raw(",");
+        builder.escape_and_append_with_quotes("model");
+        builder.append_raw(":");
+        builder.escape_and_append_with_quotes(car.model);
+
+        // "year"
+        builder.append_raw(",");
+        builder.escape_and_append_with_quotes("year");
+        builder.append_raw(":");
+        builder.append(car.year);
+
+        // "tire_pressure"
+        builder.append_raw(",");
+        builder.escape_and_append_with_quotes("tire_pressure");
+        builder.append_raw(":[");
+
+        // vector tire_pressure
+        for (size_t i = 0; i < car.tire_pressure.size(); ++i) {
+            builder.append(car.tire_pressure[i]);
+            if (i < car.tire_pressure.size() - 1) {
+                builder.append_raw(",");
+            }
+        }
+        // end of array
+        builder.append_raw("]");
+
+        // end of object
+        builder.append_raw("}");
+    }
+
+    bool car_test() {
+        simdjson::builder::string_builder sb;
+        Car c = {"Toyota", "Corolla", 2017, {30.0,30.2,30.513,30.79}};
+        serialize_car(c, sb);
+        std::string_view p;
+        if(sb.view().get(p)) {
+            return false; // there was an error
+        }
+        // p holds the JSON:
+        // "{\"make\":\"Toyota\",\"model\":\"Corolla\",\"year\":2017,\"tire_pressure\":[30.0,30.2,30.513,30.79]}"
+        return true;
+    }
+```
+
+C++26 static reflection
+------------------------
+
+If you have a compiler with support C++26 static reflection, you can compile
+your code with the `SIMDJSON_STATIC_REFLECTION` macro set:
+
+```cpp
+#define SIMDJSON_STATIC_REFLECTION 1
+//...
+#include "simdjson.h"
+```
+
+And then you can append your data structures to a `string_builder` instance
+automatically. In most cases, it should work automatically:
+
+```cpp
+    bool car_test() {
+        simdjson::builder::string_builder sb;
+        Car c = {"Toyota", "Corolla", 2017, {30.0,30.2,30.513,30.79}};
+        append(sb, c);
+        std::string_view p;
+        if(sb.view().get(p)) {
+            return false; // there was an error
+        }
+        // p holds the JSON:
+        // "{\"make\":\"Toyota\",\"model\":\"Corolla\",\"year\":2017,\"tire_pressure\":[30.0,30.2,30.513,30.79]}"
+        return true;
+    }
+```
+
+If you prefer, you can also create a string directly:
+
+```cpp
+  std::string json;
+  if(simdjson::builder::to_json_string(c).get(json)) {
+    // there was an error
+  } else {
+    // json contain the serialized JSON
+  }
+```
@@ -60,6 +60,26 @@ std::string data = "my data";
 simdjson::padded_string my_padded_data(data); // copies to a padded buffer
 ```

+You can then parse the JSON document from the `simdjson::padded_string` instance:
+
+```cpp
+simdjson::dom::parser parser;
+simdjson::dom::element doc = parser.parse(my_padded_data);
+```
+
+Whenever you pass an `std::string` reference to `parser::parse`,
+the parser will access the bytes beyond the end of
+the string but before the end of the allocated memory (`std::string::capacity()`).
+If you are using a sanitizer that checks for reading uninitialized bytes or `std::string`'s
+container-overflow checks, you may encounter sanitizer warnings.
+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:
+
+```c++
+std::string json = "[1]";
+dom::element doc = parser.parse(simdjson::pad(json));
+```
+
 The parsed document resulting from the `parser.load` and `parser.parse` calls depends on the `parser` instance. Thus the `parser` instance must remain in scope. Furthermore, you must have at most one parsed document in play per `parser` instance.
 You cannot copy a `parser` instance, you may only move it.

@@ -130,7 +130,7 @@ If your documents are all objects or arrays, then you may even have nothing betw
 E.g., `[1,2]{"32":1}` is recognized as two documents.

 Some official formats **(non-exhaustive list)**:
- [Newline-Delimited JSON (NDJSON)](http://ndjson.org/)
+- [Newline-Delimited JSON (NDJSON)](https://github.com/ndjson/ndjson-spec/)
 - [JSON lines (JSONL)](http://jsonlines.org/)
 - [Record separator-delimited JSON (RFC 7464)](https://tools.ietf.org/html/rfc7464) <- Not supported by JsonStream!
 - [More on Wikipedia...](https://en.wikipedia.org/wiki/JSON_streaming)
@@ -102,7 +102,7 @@ or indexing (`object["key"]`). In some cases, the values are even deserialized d
 maps.

 The DOM approach is conceptually simple and "programmer friendly". Using the
-DOM tree is often easy enough that many users use the DOM as-is instead of creating
+DOM tree is often easy enough that many users process the DOM as-is instead of creating
 their own custom data structures.

 The DOM approach was the only way to parse JSON documents up to version 0.6 of the simdjson library.
@@ -158,7 +158,9 @@ On Intel and AMD Windows platforms, Microsoft Visual Studio enables programmers

 When compiling with Visual Studio, we recommend the flags `/Ob2 /O2` or better. We do not recommend that you compile simdjson with architecture-specific flags such as  `arch:AVX2`. The simdjson library automatically selects the best execution kernel at runtime.

-Recent versions of Microsoft Visual Studio on Windows provides support for the LLVM Clang compiler. You  only need to install the "Clang compiler" optional component (ClangCL). You may also get a copy of the 64-bit LLVM CLang compiler for [Windows directly from LLVM](https://releases.llvm.org/download.html). The simdjson library fully supports the LLVM Clang compiler under Windows. In fact, you may get better performance out of simdjson with the LLVM Clang compiler than with the regular Visual Studio compiler. Meanwhile the [LLVM CLang compiler is binary compatible with Visual Studio](https://clang.llvm.org/docs/MSVCCompatibility.html) which means that you can combine their binaries (executables and libraries).
+Recent versions of Microsoft Visual Studio on Windows provides support for the LLVM Clang compiler. You  only need to install the "Clang compiler" optional component (clang-cl). You may also get a copy of the 64-bit LLVM CLang compiler for [Windows directly from LLVM](https://releases.llvm.org/download.html). The simdjson library fully supports the LLVM Clang compiler under Windows. In fact, you may get better performance out of simdjson with the LLVM Clang compiler than with the regular Visual Studio compiler. Meanwhile the [LLVM CLang compiler is binary compatible with Visual Studio](https://clang.llvm.org/docs/MSVCCompatibility.html) which means that you can combine their binaries (executables and libraries).
+
+We recommend Visual Studio users prefer LLVM (clang-cl). It compiles to faster release binaries. Furthermore, it compilers faster in release mode.

 Under Windows, we also support the GNU GCC compiler via MSYS2. The performance of 64-bit MSYS2 under Windows is excellent (on par with Linux).

@@ -20,10 +20,14 @@ IF(${CMAKE_SYSTEM_NAME} MATCHES "Linux")
  endif()

  add_quickstart_test(quickstart_noexceptions   quickstart_noexceptions.cpp NO_EXCEPTIONS LABELS acceptance)
-  add_quickstart_test(quickstart_noexceptions11 quickstart_noexceptions.cpp NO_EXCEPTIONS CXX_STANDARD c++11)
+  if(NOT SIMDJSON_STATIC_REFLECTION)
+    add_quickstart_test(quickstart_noexceptions11 quickstart_noexceptions.cpp NO_EXCEPTIONS CXX_STANDARD c++11)
+  endif(NOT SIMDJSON_STATIC_REFLECTION)

  add_quickstart_test(quickstart2_noexceptions   quickstart2_noexceptions.cpp NO_EXCEPTIONS LABELS acceptance)
-  add_quickstart_test(quickstart2_noexceptions11 quickstart2_noexceptions.cpp NO_EXCEPTIONS CXX_STANDARD c++11)
+  if(NOT SIMDJSON_STATIC_REFLECTION)
+    add_quickstart_test(quickstart2_noexceptions11 quickstart2_noexceptions.cpp NO_EXCEPTIONS CXX_STANDARD c++11)
+  endif(NOT SIMDJSON_STATIC_REFLECTION)

  # On-Demand Quick Start
  if (SIMDJSON_EXCEPTIONS)
@@ -33,6 +37,8 @@ IF(${CMAKE_SYSTEM_NAME} MATCHES "Linux")
  endif()

  add_quickstart_test(quickstart_ondemand_noexceptions   quickstart_ondemand_noexceptions.cpp NO_EXCEPTIONS LABELS quickstart_ondemand acceptance)
-  add_quickstart_test(quickstart_ondemand_noexceptions11 quickstart_ondemand_noexceptions.cpp NO_EXCEPTIONS CXX_STANDARD c++11 LABELS quickstart_ondemand)
+  if(NOT SIMDJSON_STATIC_REFLECTION)
+    add_quickstart_test(quickstart_ondemand_noexceptions11 quickstart_ondemand_noexceptions.cpp NO_EXCEPTIONS CXX_STANDARD c++11 LABELS quickstart_ondemand)
+  endif(NOT SIMDJSON_STATIC_REFLECTION)

 endif()
@@ -72,7 +72,7 @@ extern "C" int LLVMFuzzerTestOneInput(const uint8_t *Data, size_t Size) {

    // make this dynamic, so it works regardless of how it was compiled
    // or what hardware it runs on
-    constexpr std::size_t Nimplementations_max=3;
+    constexpr std::size_t Nimplementations_max=4;
    const std::size_t Nimplementations = supported_implementations.size();

    if(Nimplementations>Nimplementations_max) {
@@ -19,7 +19,7 @@ SIMDJSON_NO_SANITIZE_UNDEFINED
 // See issue https://github.com/simdjson/simdjson/issues/1965
 SIMDJSON_NO_SANITIZE_MEMORY
 simdjson_inline int trailing_zeroes(uint64_t input_num) {
-#ifdef SIMDJSON_REGULAR_VISUAL_STUDIO
+#if SIMDJSON_REGULAR_VISUAL_STUDIO
  unsigned long ret;
  // Search the mask data from least significant bit (LSB)
  // to the most significant bit (MSB) for a set bit (1).
@@ -43,7 +43,7 @@ simdjson_inline uint64_t clear_lowest_bit(uint64_t input_num) {
 SIMDJSON_NO_SANITIZE_UNDEFINED
 /* result might be undefined when input_num is zero */
 simdjson_inline int leading_zeroes(uint64_t input_num) {
-#ifdef SIMDJSON_REGULAR_VISUAL_STUDIO
+#if SIMDJSON_REGULAR_VISUAL_STUDIO
  unsigned long leading_zero = 0;
  // Search the mask data from most significant bit (MSB)
  // to least significant bit (LSB) for a set bit (1).
@@ -96,7 +96,7 @@ simdjson_inline uint64_t zero_leading_bit(uint64_t rev_bits, int leading_zeroes)
 #endif

 simdjson_inline bool add_overflow(uint64_t value1, uint64_t value2, uint64_t *result) {
-#ifdef SIMDJSON_REGULAR_VISUAL_STUDIO
+#if SIMDJSON_REGULAR_VISUAL_STUDIO
  *result = value1 + value2;
  return *result < value1;
 #else
@@ -12,7 +12,7 @@ namespace arm64 {
 namespace {
 namespace simd {

-#ifdef SIMDJSON_REGULAR_VISUAL_STUDIO
+#if SIMDJSON_REGULAR_VISUAL_STUDIO
 namespace {
 // Start of private section with Visual Studio workaround

@@ -121,7 +121,7 @@ namespace {
    // We return uint32_t instead of uint16_t because that seems to be more efficient for most
    // purposes (cutting it down to uint16_t costs performance in some compilers).
    simdjson_inline uint32_t to_bitmask() const {
-#ifdef SIMDJSON_REGULAR_VISUAL_STUDIO
+#if SIMDJSON_REGULAR_VISUAL_STUDIO
      const uint8x16_t bit_mask =  simdjson_make_uint8x16_t(0x01, 0x02, 0x4, 0x8, 0x10, 0x20, 0x40, 0x80,
                                                   0x01, 0x02, 0x4, 0x8, 0x10, 0x20, 0x40, 0x80);
 #else
@@ -158,7 +158,7 @@ namespace {
    // Splat constructor
    simdjson_inline simd8(uint8_t _value) : simd8(splat(_value)) {}
    // Member-by-member initialization
-#ifdef SIMDJSON_REGULAR_VISUAL_STUDIO
+#if SIMDJSON_REGULAR_VISUAL_STUDIO
    simdjson_inline simd8(
      uint8_t v0,  uint8_t v1,  uint8_t v2,  uint8_t v3,  uint8_t v4,  uint8_t v5,  uint8_t v6,  uint8_t v7,
      uint8_t v8,  uint8_t v9,  uint8_t v10, uint8_t v11, uint8_t v12, uint8_t v13, uint8_t v14, uint8_t v15
@@ -257,7 +257,7 @@ namespace {
      uint64x2_t shufmask64 = {thintable_epi8[mask1], thintable_epi8[mask2]};
      uint8x16_t shufmask = vreinterpretq_u8_u64(shufmask64);
      // we increment by 0x08 the second half of the mask
-#ifdef SIMDJSON_REGULAR_VISUAL_STUDIO
+#if SIMDJSON_REGULAR_VISUAL_STUDIO
      uint8x16_t inc = simdjson_make_uint8x16_t(0, 0, 0, 0, 0, 0, 0, 0, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08);
 #else
      uint8x16_t inc = {0, 0, 0, 0, 0, 0, 0, 0, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08};
@@ -287,7 +287,7 @@ namespace {
      uint8x8_t compactmask1 = vcreate_u8(thintable_epi8[mask1]);
      uint8x8_t compactmask2 = vcreate_u8(thintable_epi8[mask2]);
      // we increment by 0x08 the second half of the mask
-#ifdef SIMDJSON_REGULAR_VISUAL_STUDIO
+#if SIMDJSON_REGULAR_VISUAL_STUDIO
      uint8x8_t inc = simdjson_make_uint8x8_t(0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08);
 #else
      uint8x8_t inc = {0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08};
@@ -339,7 +339,7 @@ namespace {
    // Array constructor
    simdjson_inline simd8(const int8_t* values) : simd8(load(values)) {}
    // Member-by-member initialization
-#ifdef SIMDJSON_REGULAR_VISUAL_STUDIO
+#if SIMDJSON_REGULAR_VISUAL_STUDIO
    simdjson_inline simd8(
      int8_t v0,  int8_t v1,  int8_t v2,  int8_t v3, int8_t v4,  int8_t v5,  int8_t v6,  int8_t v7,
      int8_t v8,  int8_t v9,  int8_t v10, int8_t v11, int8_t v12, int8_t v13, int8_t v14, int8_t v15
@@ -460,7 +460,7 @@ namespace {
    }

    simdjson_inline uint64_t to_bitmask() const {
-#ifdef SIMDJSON_REGULAR_VISUAL_STUDIO
+#if SIMDJSON_REGULAR_VISUAL_STUDIO
      const uint8x16_t bit_mask = simdjson_make_uint8x16_t(
        0x01, 0x02, 0x4, 0x8, 0x10, 0x20, 0x40, 0x80,
        0x01, 0x02, 0x4, 0x8, 0x10, 0x20, 0x40, 0x80
@@ -50,16 +50,55 @@
 #endif
 #endif

+#ifndef SIMDJSON_CONSTEXPR_LAMBDA
+#if SIMDJSON_CPLUSPLUS17
+#define SIMDJSON_CONSTEXPR_LAMBDA constexpr
+#else
+#define SIMDJSON_CONSTEXPR_LAMBDA
+#endif
+#endif
+
+
+
 #ifdef __has_include
 #if __has_include(<version>)
 #include <version>
 #endif
 #endif

-#ifdef __cpp_concepts
+// The current specification is unclear on how we detect
+// static reflection, both __cpp_lib_reflection and
+// __cpp_impl_reflection are proposed in the draft specification.
+// For now, we disable static reflect by default. It must be
+// specified at compiler time.
+#ifndef SIMDJSON_STATIC_REFLECTION
+#define SIMDJSON_STATIC_REFLECTION 0 // disabled by default.
+#endif
+
+#if defined(__apple_build_version__)
+#if __apple_build_version__ < 14000000
+#define SIMDJSON_CONCEPT_DISABLED 1 // apple-clang/13 doesn't support std::convertible_to
+#endif
+#endif
+
+
+#if defined(__cpp_concepts) && !defined(SIMDJSON_CONCEPT_DISABLED)
+#if __cpp_concepts >= 201907L
 #include <utility>
 #define SIMDJSON_SUPPORTS_DESERIALIZATION 1
-#else // __cpp_concepts
+#else
 #define SIMDJSON_SUPPORTS_DESERIALIZATION 0
 #endif
+#else // defined(__cpp_concepts) && !defined(SIMDJSON_CONCEPT_DISABLED)
+#define SIMDJSON_SUPPORTS_DESERIALIZATION 0
+#endif // defined(__cpp_concepts) && !defined(SIMDJSON_CONCEPT_DISABLED)
+
+#if !defined(SIMDJSON_CONSTEVAL)
+#if defined(__cpp_consteval) && __cpp_consteval >= 201811L
+#define SIMDJSON_CONSTEVAL 1
+#else
+#define SIMDJSON_CONSTEVAL 0
+#endif // defined(__cpp_consteval) && __cpp_consteval >= 201811L
+#endif // !defined(SIMDJSON_CONSTEVAL)
+
 #endif // SIMDJSON_COMPILER_CHECK_H
@@ -20,14 +20,14 @@ namespace details {
    };                                                                         \
  };

-SIMDJSON_IMPL_CONCEPT(emplace_back, emplace_back);
-SIMDJSON_IMPL_CONCEPT(emplace, emplace);
-SIMDJSON_IMPL_CONCEPT(push_back, push_back);
-SIMDJSON_IMPL_CONCEPT(add, add);
-SIMDJSON_IMPL_CONCEPT(push, push);
-SIMDJSON_IMPL_CONCEPT(append, append);
-SIMDJSON_IMPL_CONCEPT(insert, insert);
-SIMDJSON_IMPL_CONCEPT(op_append, operator+=);
+SIMDJSON_IMPL_CONCEPT(emplace_back, emplace_back)
+SIMDJSON_IMPL_CONCEPT(emplace, emplace)
+SIMDJSON_IMPL_CONCEPT(push_back, push_back)
+SIMDJSON_IMPL_CONCEPT(add, add)
+SIMDJSON_IMPL_CONCEPT(push, push)
+SIMDJSON_IMPL_CONCEPT(append, append)
+SIMDJSON_IMPL_CONCEPT(insert, insert)
+SIMDJSON_IMPL_CONCEPT(op_append, operator+=)

 #undef SIMDJSON_IMPL_CONCEPT
 } // namespace details
@@ -107,6 +107,7 @@ concept optional_type = requires(std::remove_cvref_t<T> obj) {
  { static_cast<bool>(obj) } -> std::same_as<bool>; // convertible to bool
 };

+
 } // namespace concepts
 } // namespace simdjson
 #endif // SIMDJSON_SUPPORTS_DESERIALIZATION
@@ -372,6 +372,8 @@ public:
   *         - INCORRECT_TYPE if this is not an object
   */
  inline simdjson_result<element> operator[](const char *key) const noexcept;
+  simdjson_result<element> operator[](int) const noexcept = delete;
+

  /**
   * Get the value associated with the given JSON pointer.  We use the RFC 6901
@@ -540,6 +542,7 @@ public:

  simdjson_inline simdjson_result<dom::element> operator[](std::string_view key) const noexcept;
  simdjson_inline simdjson_result<dom::element> operator[](const char *key) const noexcept;
+  simdjson_result<dom::element> operator[](int) const noexcept = delete;
  simdjson_inline simdjson_result<dom::element> at_pointer(const std::string_view json_pointer) const noexcept;
  simdjson_inline simdjson_result<dom::element> at_path(const std::string_view json_path) const noexcept;
  [[deprecated("For standard compliance, use at_pointer instead, and prefix your pointers with a slash '/', see RFC6901 ")]]
@@ -145,6 +145,7 @@ public:
   *         - INCORRECT_TYPE if this is not an object
   */
  inline simdjson_result<element> operator[](const char *key) const noexcept;
+  simdjson_result<element> operator[](int) const noexcept = delete;

  /**
   * Get the value associated with the given JSON pointer. We use the RFC 6901
@@ -258,6 +259,7 @@ public:

  inline simdjson_result<dom::element> operator[](std::string_view key) const noexcept;
  inline simdjson_result<dom::element> operator[](const char *key) const noexcept;
+  simdjson_result<dom::element> operator[](int) const noexcept = delete;
  inline simdjson_result<dom::element> at_pointer(std::string_view json_pointer) const noexcept;
  inline simdjson_result<dom::element> at_path(std::string_view json_path) const noexcept;
  inline simdjson_result<dom::element> at_key(std::string_view key) const noexcept;
@@ -202,6 +202,22 @@ public:
   *   simdjson::dom::parser parser;
   *   simdjson::dom::element element = parser.parse(padded_json_copy.get(), json_len, false);
   *
+   * ### std::string references
+   *
+   * If you pass a mutable std::string reference (std::string&), the parser will seek to extend
+   * its capacity to SIMDJSON_PADDING bytes beyond the end of the string.
+   *
+   * Whenever you pass an std::string reference, the parser will access the bytes beyond the end of
+   * the string but before the end of the allocated memory (std::string::capacity()).
+   * If you are using a sanitizer that checks for reading uninitialized bytes or std::string's
+   * container-overflow checks, you may encounter sanitizer warnings.
+   * 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 parse function:
+   *
+   *    std::string json = R"({ "foo": 1 } { "foo": 2 } { "foo": 3 } )";
+   *    element doc = parser.parse(simdjson::pad(json));
+   *
   * ### Parser Capacity
   *
   * If the parser's current capacity is less than len, it will allocate enough capacity
@@ -87,7 +87,7 @@ struct simdjson_error : public std::exception {
   */
  simdjson_error(error_code error) noexcept : _error{error} { }
  /** The error message */
-  const char *what() const noexcept { return error_message(error()); }
+  const char *what() const noexcept override { return error_message(error()); }
  /** The error code */
  error_code error() const noexcept { return _error; }
 private:
@@ -49,4 +49,5 @@
 // but it is convenient for now to have them here.
 #include "simdjson/generic/ondemand/json_string_builder.h"
 #include "simdjson/generic/ondemand/json_string_builder-inl.h"
+#include "simdjson/generic/ondemand/json_builder.h"

@@ -44,7 +44,8 @@ public:
   * calling this function, if successful, the array is 'rewinded' at its
   * beginning as if it had never been accessed. If the JSON is malformed (e.g.,
   * there is a missing comma), then an error is returned and it is no longer
-   * safe to continue.
+   * safe to continue. Note that count_elements() does not validate the JSON values,
+   * only the structure of the array.
   *
   * To check that an array is empty, it is more performant to use
   * the is_empty() method.
@@ -130,6 +131,37 @@ public:
   *         - INDEX_OUT_OF_BOUNDS if the array index is larger than an array length
   */
  simdjson_inline simdjson_result<value> at(size_t index) noexcept;
+
+#if SIMDJSON_SUPPORTS_DESERIALIZATION
+  /**
+   * Get this array as the given type.
+   *
+   * @param out This is set to a value of the given type, parsed from the JSON. If there is an error, this may not be initialized.
+   * @returns INCORRECT_TYPE If the JSON array is not of the given type.
+   * @returns SUCCESS If the parse succeeded and the out parameter was set to the value.
+   */
+  template <typename T>
+  simdjson_inline error_code get(T &out)
+     noexcept(custom_deserializable<T, array> ? nothrow_custom_deserializable<T, array> : true) {
+    static_assert(custom_deserializable<T, array>);
+    return deserialize(*this, out);
+  }
+  /**
+   * Get this array as the given type.
+   *
+   * @returns A value of the given type, parsed from the JSON.
+   * @returns INCORRECT_TYPE If the JSON value is not the given type.
+   */
+  template <typename T>
+  simdjson_inline simdjson_result<T> get()
+    noexcept(custom_deserializable<T, value> ? nothrow_custom_deserializable<T, value> : true)
+  {
+    static_assert(std::is_default_constructible<T>::value, "The specified type is not default constructible.");
+    T out{};
+    SIMDJSON_TRY(get<T>(out));
+    return out;
+  }
+#endif // SIMDJSON_SUPPORTS_DESERIALIZATION
 protected:
  /**
   * Go to the end of the array, no matter where you are right now.
@@ -208,7 +240,28 @@ 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::string_view> raw_json() noexcept;
+#if SIMDJSON_SUPPORTS_DESERIALIZATION
+  // TODO: move this code into object-inl.h

+  template<typename T>
+  simdjson_inline simdjson_result<T> get() noexcept {
+    if (error()) { return error(); }
+    if constexpr (std::is_same_v<T, SIMDJSON_IMPLEMENTATION::ondemand::array>) {
+      return first;
+    }
+    return first.get<T>();
+  }
+  template<typename T>
+  simdjson_inline error_code get(T& out) noexcept {
+    if (error()) { return error(); }
+    if constexpr (std::is_same_v<T, SIMDJSON_IMPLEMENTATION::ondemand::array>) {
+      out = first;
+    } else {
+      SIMDJSON_TRY( first.get<T>(out) );
+    }
+    return SUCCESS;
+  }
+#endif // SIMDJSON_SUPPORTS_DESERIALIZATION
 };

 } // namespace simdjson
@@ -88,10 +88,26 @@ concept nothrow_deserializable = nothrow_custom_deserializable<T, ValT> || is_bu

 /// Deserialize Tag
 inline constexpr struct deserialize_tag {
+  using array_type = SIMDJSON_IMPLEMENTATION::ondemand::array;
+  using object_type = SIMDJSON_IMPLEMENTATION::ondemand::object;
  using value_type = SIMDJSON_IMPLEMENTATION::ondemand::value;
  using document_type = SIMDJSON_IMPLEMENTATION::ondemand::document;
  using document_reference_type = SIMDJSON_IMPLEMENTATION::ondemand::document_reference;

+  // Customization Point for array
+  template <typename T>
+    requires custom_deserializable<T, value_type>
+  [[nodiscard]] constexpr /* error_code */ auto operator()(array_type &object, T& output) const noexcept(nothrow_custom_deserializable<T, value_type>) {
+    return tag_invoke(*this, object, output);
+  }
+
+  // Customization Point for object
+  template <typename T>
+    requires custom_deserializable<T, value_type>
+  [[nodiscard]] constexpr /* error_code */ auto operator()(object_type &object, T& output) const noexcept(nothrow_custom_deserializable<T, value_type>) {
+    return tag_invoke(*this, object, output);
+  }
+
  // Customization Point for value
  template <typename T>
    requires custom_deserializable<T, value_type>
@@ -246,7 +246,14 @@ simdjson_inline simdjson_result<value> document::operator[](const char *key) & n
 }

 simdjson_inline error_code document::consume() noexcept {
-  auto error = iter.skip_child(0);
+  bool scalar = false;
+  auto error = is_scalar().get(scalar);
+  if(error) { return error; }
+  if(scalar) {
+    iter.return_current_and_advance();
+    return SUCCESS;
+  }
+  error = iter.skip_child(0);
  if(error) { iter.abandon(); }
  return error;
 }
@@ -268,6 +275,8 @@ simdjson_inline simdjson_result<json_type> document::type() noexcept {
 }

 simdjson_inline simdjson_result<bool> document::is_scalar() noexcept {
+  // For more speed, we could do:
+  // return iter.is_single_token();
  json_type this_type;
  auto error = type().get(this_type);
  if(error) { return error; }
@@ -224,7 +224,7 @@ public:
   * Be mindful that the document instance must remain in scope while you are accessing object, array and value instances.
   *
   * @param out This is set to a value of the given type, parsed from the JSON. If there is an error, this may not be initialized.
-   * @returns INCORRECT_TYPE If the JSON value is not an object.
+   * @returns INCORRECT_TYPE If the JSON value is of the given type.
   * @returns SUCCESS If the parse succeeded and the out parameter was set to the value.
   */
  template<typename T>
@@ -354,7 +354,8 @@ public:
   * calling this function, if successful, the array is 'rewinded' at its
   * beginning as if it had never been accessed. If the JSON is malformed (e.g.,
   * there is a missing comma), then an error is returned and it is no longer
-   * safe to continue.
+   * safe to continue. Note that count_elements() does not validate the JSON values,
+   * only the structure of the array.
   */
  simdjson_inline simdjson_result<size_t> count_elements() & noexcept;
   /**
@@ -466,6 +467,7 @@ public:
  simdjson_inline simdjson_result<value> operator[](std::string_view key) & noexcept;
  /** @overload simdjson_inline simdjson_result<value> find_field_unordered(std::string_view key) & noexcept; */
  simdjson_inline simdjson_result<value> operator[](const char *key) & noexcept;
+ simdjson_result<value> operator[](int) & noexcept = delete;

  /**
   * Get the type of this JSON value. It does not validate or consume the value.
@@ -852,6 +854,7 @@ public:
  simdjson_inline simdjson_result<value> find_field(const char *key) & noexcept;
  simdjson_inline simdjson_result<value> operator[](std::string_view key) & noexcept;
  simdjson_inline simdjson_result<value> operator[](const char *key) & noexcept;
+  simdjson_result<value> operator[](int) & noexcept = delete;
  simdjson_inline simdjson_result<value> find_field_unordered(std::string_view key) & noexcept;
  simdjson_inline simdjson_result<value> find_field_unordered(const char *key) & noexcept;

@@ -930,6 +933,7 @@ public:
  simdjson_inline simdjson_result<SIMDJSON_IMPLEMENTATION::ondemand::value> find_field(const char *key) & noexcept;
  simdjson_inline simdjson_result<SIMDJSON_IMPLEMENTATION::ondemand::value> operator[](std::string_view key) & noexcept;
  simdjson_inline simdjson_result<SIMDJSON_IMPLEMENTATION::ondemand::value> operator[](const char *key) & noexcept;
+  simdjson_result<SIMDJSON_IMPLEMENTATION::ondemand::value> operator[](int) & noexcept = delete;
  simdjson_inline simdjson_result<SIMDJSON_IMPLEMENTATION::ondemand::value> find_field_unordered(std::string_view key) & noexcept;
  simdjson_inline simdjson_result<SIMDJSON_IMPLEMENTATION::ondemand::value> find_field_unordered(const char *key) & noexcept;
  simdjson_inline simdjson_result<SIMDJSON_IMPLEMENTATION::ondemand::json_type> type() noexcept;
@@ -1007,6 +1011,7 @@ public:
  simdjson_inline simdjson_result<SIMDJSON_IMPLEMENTATION::ondemand::value> find_field(const char *key) & noexcept;
  simdjson_inline simdjson_result<SIMDJSON_IMPLEMENTATION::ondemand::value> operator[](std::string_view key) & noexcept;
  simdjson_inline simdjson_result<SIMDJSON_IMPLEMENTATION::ondemand::value> operator[](const char *key) & noexcept;
+  simdjson_result<SIMDJSON_IMPLEMENTATION::ondemand::value> operator[](int) & noexcept = delete;
  simdjson_inline simdjson_result<SIMDJSON_IMPLEMENTATION::ondemand::value> find_field_unordered(std::string_view key) & noexcept;
  simdjson_inline simdjson_result<SIMDJSON_IMPLEMENTATION::ondemand::value> find_field_unordered(const char *key) & noexcept;
  simdjson_inline simdjson_result<SIMDJSON_IMPLEMENTATION::ondemand::json_type> type() noexcept;
@@ -0,0 +1,156 @@
+/**
+ * This file is part of the builder API. It is temporarily in the ondemand directory
+ * but we will move it to a builder directory later.
+ */
+#ifndef SIMDJSON_GENERIC_BUILDER_H
+
+#ifndef SIMDJSON_CONDITIONAL_INCLUDE
+#define SIMDJSON_GENERIC_STRING_BUILDER_H
+#include "simdjson/generic/builder/json_string_builder.h"
+#endif // SIMDJSON_CONDITIONAL_INCLUDE
+#if SIMDJSON_STATIC_REFLECTION
+
+#include <charconv>
+#include <cstring>
+#include <experimental/meta>
+#include <string_view>
+#include <type_traits>
+#include <utility>
+
+namespace simdjson {
+namespace SIMDJSON_IMPLEMENTATION {
+namespace builder {
+
+// Concept that checks if a type is a container but not a string (because
+// strings handling must be handled differently)
+template <typename T>
+concept container_but_not_string =
+    requires(T a) {
+      { a.size() } -> std::convertible_to<std::size_t>;
+      {
+        a[std::declval<std::size_t>()]
+      }; // check if elements are accessible for the subscript operator
+    } && !std::is_same_v<T, std::string> &&
+    !std::is_same_v<T, std::string_view> && !std::is_same_v<T, const char *>;
+
+template <class T>
+  requires(container_but_not_string<T>)
+constexpr void atom(string_builder &b, const T &t) {
+  if (t.size() == 0) {
+    b.append_raw("[]");
+    return;
+  }
+  b.append('[');
+  atom(b, t[0]);
+  for (size_t i = 1; i < t.size(); ++i) {
+    b.append(',');
+    atom(b, t[i]);
+  }
+  b.append(']');
+}
+
+template <class T>
+  requires(std::is_same_v<T, std::string> ||
+           std::is_same_v<T, std::string_view> ||
+           std::is_same_v<T, const char *> ||
+           std::is_same_v<T, char>)
+constexpr void atom(string_builder &b, const T &t) {
+  b.escape_and_append_with_quotes(t);
+}
+
+
+template<typename number_type,
+         typename = typename std::enable_if<std::is_arithmetic<number_type>::value && !std::is_same_v<number_type, char>>::type>
+constexpr void atom(string_builder &b, const number_type t) {
+  b.append(t);
+}
+#if SIMDJSON_CONSTEVAL
+consteval std::string consteval_to_quoted_escaped(std::string_view input);
+#endif
+
+template <class T>
+  requires(std::is_class_v<T> && !container_but_not_string<T> &&
+           !std::is_same_v<T, std::string> &&
+           !std::is_same_v<T, std::string_view>)
+constexpr void atom(string_builder &b, const T &t) {
+  int i = 0;
+  b.append('{');
+  template for (constexpr auto mem : std::meta::nonstatic_data_members_of(^^T)) {
+    constexpr std::string_view key = std::string_view(std::meta::identifier_of(mem));
+    if (i != 0)
+      b.append(',');
+    b.append_raw(consteval_to_quoted_escaped(key));
+    b.append(':');
+    atom(b, t.*mem);
+    i++;
+  }
+  b.append('}');
+  /*[:expand(std::meta::nonstatic_data_members_of(^T)):] >> [&]<auto dm> {
+    if (i != 0)
+      b.append(',');
+    constexpr auto key = consteval_to_quoted_escaped(std::meta::identifier_of(dm));
+    b.append_raw(key);
+    b.append(':');
+    atom(b, t.[:dm:]);
+    i++;
+  };
+  b.append('}');*/
+}
+
+// works for struct
+template <class Z> void append(string_builder &b, const Z &z) {
+  int i = 0;
+  b.append('{');
+  template for (constexpr auto dm : std::meta::nonstatic_data_members_of(^^Z)) {
+    if (i != 0)
+      b.append(',');
+    constexpr auto key = consteval_to_quoted_escaped(std::meta::identifier_of(dm));
+    b.append_raw(key);
+    b.append(':');
+    atom(b, z.[:dm:]);
+    i++;
+  }
+  b.append('}');
+}
+
+// works for container
+template <class Z>
+  requires(container_but_not_string<Z>)
+void append(string_builder &b, const Z &z) {
+  if (z.size() == 0) {
+    b.append_raw("[]");
+    return;
+  }
+  b.append('[');
+  atom(b, z[0]);
+  for (size_t i = 1; i < z.size(); ++i) {
+    b.append(',');
+    atom(b, z[i]);
+  }
+  b.append(']');
+}
+
+template <class Z>
+simdjson_result<std::string> to_json_string(const Z &z) {
+  string_builder b;
+  append(b, z);
+  std::string_view s;
+  if(auto e = b.view().get(s); e) { return e; }
+  return std::string(s);
+}
+
+template <class Z>
+simdjson_error to_json(const Z &z, std::string &s) {
+  string_builder b;
+  append(b, z);
+  std::string_view view;
+  if(auto e = b.view().get(view); e) { return e; }
+  s.assign(view);
+  return SUCCESS;
+}
+} // namespace json_builder
+} // namespace SIMDJSON_IMPLEMENTATION
+} // namespace simdjson
+#endif // SIMDJSON_STATIC_REFLECTION
+
+#endif
@@ -1,31 +1,226 @@
 /**
- * This file is part of the builder API. It is temporarily in the ondemand directory
- * but we will move it to a builder directory later.
+ * This file is part of the builder API. It is temporarily in the ondemand
+ * directory but we will move it to a builder directory later.
 */
+#include <array>
+#include <cstring>
 #include <type_traits>
-#ifndef SIMDJSON_GENERIC_BUILDER_INL_H
+#ifndef SIMDJSON_GENERIC_STRING_BUILDER_INL_H

 #ifndef SIMDJSON_CONDITIONAL_INCLUDE
-#define SIMDJSON_GENERIC_BUILDER_INL_H
+#define SIMDJSON_GENERIC_STRING_BUILDER_INL_H
 #include "simdjson/generic/builder/json_string_builder.h"
 #endif // SIMDJSON_CONDITIONAL_INCLUDE

+/*
+ * Empirically, we have found that an inlined optimization is important for
+ * performance. The following macros are not ideal. We should find a better
+ * way to inline the code.
+ */
+
+#if defined(__SSE2__) || defined(__x86_64__) || defined(__x86_64) ||           \
+    (defined(_M_AMD64) || defined(_M_X64) ||                                   \
+     (defined(_M_IX86_FP) && _M_IX86_FP == 2))
+#ifndef SIMDJSON_EXPERIMENTAL_HAS_SSE2
+#define SIMDJSON_EXPERIMENTAL_HAS_SSE2 1
+#endif
+#endif
+
+#if defined(__aarch64__) || defined(_M_ARM64)
+#ifndef SIMDJSON_EXPERIMENTAL_HAS_NEON
+#define SIMDJSON_EXPERIMENTAL_HAS_NEON 1
+#endif
+#endif
+#if SIMDJSON_EXPERIMENTAL_HAS_NEON
+#include <arm_neon.h>
+#endif
+#if SIMDJSON_EXPERIMENTAL_HAS_SSE2
+#include <emmintrin.h>
+#endif
+
 namespace simdjson {
 namespace SIMDJSON_IMPLEMENTATION {
 namespace builder {

-simdjson_inline string_builder::string_builder(size_t initial_capacity) :
-  buffer(new (std::nothrow) char[initial_capacity]),
-  position(0), capacity(buffer.get() != nullptr ? initial_capacity : 0),
-  is_valid(buffer.get() != nullptr) {}
+SIMDJSON_CONSTEXPR_LAMBDA simdjson_inline bool
+simple_needs_escaping(std::string_view v) {
+  for (char c : v) {
+    if ((uint8_t(c) < 32) | (c == '"') | (c == '\\')) {
+      return true;
+    }
+  }
+  return false;
+}
+
+#if SIMDJSON_EXPERIMENTAL_HAS_NEON
+simdjson_inline bool fast_needs_escaping(std::string_view view) {
+  if (view.size() < 16) {
+    return simple_needs_escaping(view);
+  }
+  size_t i = 0;
+  uint8x16_t running = vdupq_n_u8(0);
+  uint8x16_t v34 = vdupq_n_u8(34);
+  uint8x16_t v92 = vdupq_n_u8(92);
+
+  for (; i + 15 < view.size(); i += 16) {
+    uint8x16_t word = vld1q_u8((const uint8_t *)view.data() + i);
+    running = vorrq_u8(running, vceqq_u8(word, v34));
+    running = vorrq_u8(running, vceqq_u8(word, v92));
+    running = vorrq_u8(running, vcltq_u8(word, vdupq_n_u8(32)));
+  }
+  if (i < view.size()) {
+    uint8x16_t word =
+        vld1q_u8((const uint8_t *)view.data() + view.length() - 16);
+    running = vorrq_u8(running, vceqq_u8(word, v34));
+    running = vorrq_u8(running, vceqq_u8(word, v92));
+    running = vorrq_u8(running, vcltq_u8(word, vdupq_n_u8(32)));
+  }
+  return vmaxvq_u32(vreinterpretq_u32_u8(running)) != 0;
+}
+#elif SIMDJSON_EXPERIMENTAL_HAS_SSE2
+simdjson_inline bool fast_needs_escaping(std::string_view view) {
+  if (view.size() < 16) {
+    return simple_needs_escaping(view);
+  }
+  size_t i = 0;
+  __m128i running = _mm_setzero_si128();
+  for (; i + 15 < view.size(); i += 16) {
+
+    __m128i word = _mm_loadu_si128(reinterpret_cast<const __m128i *>(view.data() + i));
+    running = _mm_or_si128(running, _mm_cmpeq_epi8(word, _mm_set1_epi8(34)));
+    running = _mm_or_si128(running, _mm_cmpeq_epi8(word, _mm_set1_epi8(92)));
+    running = _mm_or_si128(
+        running, _mm_cmpeq_epi8(_mm_subs_epu8(word, _mm_set1_epi8(31)),
+                                _mm_setzero_si128()));
+  }
+  if (i < view.size()) {
+    __m128i word =
+        _mm_loadu_si128(reinterpret_cast<const __m128i *>(view.data() + view.length() - 16));
+    running = _mm_or_si128(running, _mm_cmpeq_epi8(word, _mm_set1_epi8(34)));
+    running = _mm_or_si128(running, _mm_cmpeq_epi8(word, _mm_set1_epi8(92)));
+    running = _mm_or_si128(
+        running, _mm_cmpeq_epi8(_mm_subs_epu8(word, _mm_set1_epi8(31)),
+                                _mm_setzero_si128()));
+  }
+  return _mm_movemask_epi8(running) != 0;
+}
+#else
+simdjson_inline bool fast_needs_escaping(std::string_view view) {
+  return simple_needs_escaping(view);
+}
+#endif
+
+static SIMDJSON_CONSTEXPR_LAMBDA std::array<uint8_t, 256> json_quotable_character = {
+    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
+    1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
+
+SIMDJSON_CONSTEXPR_LAMBDA inline size_t
+find_next_json_quotable_character(const std::string_view view,
+                                  size_t location) noexcept {
+
+  for (auto pos = view.begin() + location; pos != view.end(); ++pos) {
+    if (json_quotable_character[static_cast<uint8_t>(*pos)]) {
+      return pos - view.begin();
+    }
+  }
+  return size_t(view.size());
+}
+
+SIMDJSON_CONSTEXPR_LAMBDA static std::string_view control_chars[] = {
+    "\\x0000", "\\x0001", "\\x0002", "\\x0003", "\\x0004", "\\x0005", "\\x0006",
+    "\\x0007", "\\x0008", "\\t",     "\\n",     "\\x000b", "\\f",     "\\r",
+    "\\x000e", "\\x000f", "\\x0010", "\\x0011", "\\x0012", "\\x0013", "\\x0014",
+    "\\x0015", "\\x0016", "\\x0017", "\\x0018", "\\x0019", "\\x001a", "\\x001b",
+    "\\x001c", "\\x001d", "\\x001e", "\\x001f"};
+
+SIMDJSON_CONSTEXPR_LAMBDA void escape_json_char(char c, char *&out) {
+  if (c == '"') {
+    memcpy(out, "\\\"", 2);
+    out += 2;
+  } else if (c == '\\') {
+    memcpy(out, "\\\\", 2);
+    out += 2;
+  } else {
+    std::string_view v = control_chars[uint8_t(c)];
+    memcpy(out, v.data(), v.size());
+    out += v.size();
+  }
+}
+
+inline size_t write_string_escaped(const std::string_view input, char *out) {
+  size_t mysize = input.size();
+  if (!fast_needs_escaping(input)) { // fast path!
+    memcpy(out, input.data(), input.size());
+    return input.size();
+  }
+  const char *const initout = out;
+  size_t location = find_next_json_quotable_character(input, 0);
+  memcpy(out, input.data(), location);
+  out += location;
+  escape_json_char(input[location], out);
+  location += 1;
+  while (location < mysize) {
+    size_t newlocation = find_next_json_quotable_character(input, location);
+    memcpy(out, input.data() + location, newlocation - location);
+    out += newlocation - location;
+    location = newlocation;
+    if (location == mysize) {
+      break;
+    }
+    escape_json_char(input[location], out);
+    location += 1;
+  }
+  return out - initout;
+}
+
+#if SIMDJSON_CONSTEVAL
+// unoptimized, meant for compile-time execution
+consteval std::string consteval_to_quoted_escaped(std::string_view input) {
+  std::string out = "\"";
+  for (char c : input) {
+    if (json_quotable_character[uint8_t(c)]) {
+      if (c == '"') {
+        out.append("\\\"");
+      } else if (c == '\\') {
+        out.append("\\\\");
+      } else {
+        std::string_view v = control_chars[uint8_t(c)];
+        out.append(v);
+      }
+    } else {
+      out.push_back(c);
+    }
+  }
+  out.push_back('"');
+  return out;
+}
+#endif // SIMDJSON_CONSTEVAL
+
+simdjson_inline string_builder::string_builder(size_t initial_capacity)
+    : buffer(new(std::nothrow) char[initial_capacity]), position(0),
+      capacity(buffer.get() != nullptr ? initial_capacity : 0),
+      is_valid(buffer.get() != nullptr) {}

 simdjson_inline bool string_builder::capacity_check(size_t upcoming_bytes) {
  // We use the convention that when is_valid is false, then the capacity and
  // the position are 0.
  // Most of the time, this function will return true.
-  if (simdjson_likely(upcoming_bytes <= capacity - position)) { return true; }
+  if (simdjson_likely(upcoming_bytes <= capacity - position)) {
+    return true;
+  }
  // check for overflow, most of the time there is no overflow
-  if (simdjson_likely(position + upcoming_bytes < position)) { return false; }
+  if (simdjson_likely(position + upcoming_bytes < position)) {
+    return false;
+  }
  // We will rarely get here.
  grow_buffer((std::max)(capacity * 2, position + upcoming_bytes));
  // If the buffer allocation failed, we set is_valid to false.
@@ -33,7 +228,9 @@ simdjson_inline bool string_builder::capacity_check(size_t upcoming_bytes) {
 }

 simdjson_inline void string_builder::grow_buffer(size_t desired_capacity) {
-  if (!is_valid) { return; }
+  if (!is_valid) {
+    return;
+  }
  std::unique_ptr<char[]> new_buffer(new (std::nothrow) char[desired_capacity]);
  if (new_buffer.get() == nullptr) {
    set_valid(false);
@@ -45,7 +242,7 @@ simdjson_inline void string_builder::grow_buffer(size_t desired_capacity) {
 }

 simdjson_inline void string_builder::set_valid(bool valid) noexcept {
-  if(!valid) {
+  if (!valid) {
    is_valid = false;
    capacity = 0;
    position = 0;
@@ -59,27 +256,25 @@ simdjson_inline size_t string_builder::size() const noexcept {
  return position;
 }

-
 simdjson_inline void string_builder::append(char c) noexcept {
-    if(capacity_check(1)) {
-      buffer.get()[position++] = c;
-    }
+  if (capacity_check(1)) {
+    buffer.get()[position++] = c;
+  }
 }

-
 simdjson_inline void string_builder::append_null() noexcept {
  constexpr char null_literal[] = "null";
  constexpr size_t null_len = sizeof(null_literal) - 1;
-  if(capacity_check(null_len)) {
+  if (capacity_check(null_len)) {
    std::memcpy(buffer.get() + position, null_literal, null_len);
    position += null_len;
  }
 }

-simdjson_inline void string_builder::clear()  noexcept {
+simdjson_inline void string_builder::clear() noexcept {
  position = 0;
  // if it was invalid, we should try to repair it
-  if(!is_valid) {
+  if (!is_valid) {
    capacity = 0;
    buffer.reset();
    is_valid = true;
@@ -91,7 +286,7 @@ namespace internal {
 // We could specialize further for 32-bit integers.
 int int_log2(uint32_t x) { return (63 - leading_zeroes(x | 1)); }

-int fast_digit_count_32(uint32_t x) {
+int fast_digit_count(uint32_t x) {
  static uint64_t table[] = {
      4294967296,  8589934582,  8589934582,  8589934582,  12884901788,
      12884901788, 12884901788, 17179868184, 17179868184, 17179868184,
@@ -105,7 +300,7 @@ int fast_digit_count_32(uint32_t x) {

 int int_log2(uint64_t x) { return 63 - leading_zeroes(x | 1); }

-int digit_count_64(uint64_t x) {
+int fast_digit_count(uint64_t x) {
  static uint64_t table[] = {9,
                             99,
                             999,
@@ -130,118 +325,133 @@ int digit_count_64(uint64_t x) {
  return y + 1;
 }

-template<typename number_type,
-         typename = typename std::enable_if<std::is_unsigned<number_type>::value>::type>
+template <typename number_type, typename = typename std::enable_if<
+                                    std::is_unsigned<number_type>::value>::type>
 simdjson_inline size_t digit_count(number_type v) noexcept {
-  static_assert(sizeof(number_type) == 8
-   || sizeof(number_type) == 4
-   || sizeof(number_type) == 2
-   || sizeof(number_type) == 1, "We only support 8-bit, 16-bit, 32-bit and 64-bit numbers");
-  if (sizeof(number_type) <= 4) {
-    return fast_digit_count_32(v);
-  } else {
-    return digit_count_64(v);
-  }
+  static_assert(sizeof(number_type) == 8 || sizeof(number_type) == 4 ||
+                    sizeof(number_type) == 2 || sizeof(number_type) == 1,
+                "We only support 8-bit, 16-bit, 32-bit and 64-bit numbers");
+  return fast_digit_count(v);
 }

-} // internal
+} // namespace internal

-template<typename number_type, typename>
+template <typename number_type, typename>
 simdjson_inline void string_builder::append(number_type v) noexcept {
-  static_assert(std::is_same<number_type, bool>::value
-    || std::is_integral<number_type>::value || std::is_floating_point<number_type>::value, "Unsupported number type");
+  static_assert(std::is_same<number_type, bool>::value ||
+                    std::is_integral<number_type>::value ||
+                    std::is_floating_point<number_type>::value,
+                "Unsupported number type");
  // If C++17 is available, we can 'if constexpr' here.
-  if constexpr (std::is_same<number_type, bool>::value) {
+  SIMDJSON_IF_CONSTEXPR(std::is_same<number_type, bool>::value) {
    if (v) {
      constexpr char true_literal[] = "true";
      constexpr size_t true_len = sizeof(true_literal) - 1;
-      if(capacity_check(true_len)) {
+      if (capacity_check(true_len)) {
        std::memcpy(buffer.get() + position, true_literal, true_len);
        position += true_len;
      }
    } else {
      constexpr char false_literal[] = "false";
      constexpr size_t false_len = sizeof(false_literal) - 1;
-      if(capacity_check(false_len)) {
+      if (capacity_check(false_len)) {
        std::memcpy(buffer.get() + position, false_literal, false_len);
        position += false_len;
      }
    }
-  } else if constexpr (std::is_unsigned<number_type>::value) {
+  }
+  else SIMDJSON_IF_CONSTEXPR(std::is_unsigned<number_type>::value) {
    constexpr size_t max_number_size = 20;
-    if(capacity_check(max_number_size)) {
+    if (capacity_check(max_number_size)) {
      using unsigned_type = typename std::make_unsigned<number_type>::type;
      unsigned_type pv = static_cast<unsigned_type>(v);
      size_t dc = internal::digit_count(pv);
      char *write_pointer = buffer.get() + position + dc - 1;
      // optimization opportunity: if v is large, we can do better.
-      while(pv >= 10) {
+      while (pv >= 10) {
        *write_pointer-- = char('0' + (pv % 10));
        pv /= 10;
      }
      *write_pointer = char('0' + pv);
      position += dc;
    }
-  } else if constexpr (std::is_integral<number_type>::value) {
+  }
+  else SIMDJSON_IF_CONSTEXPR(std::is_integral<number_type>::value) {
    constexpr size_t max_number_size = 20;
-    if(capacity_check(max_number_size)) {
+    if (capacity_check(max_number_size)) {
      using unsigned_type = typename std::make_unsigned<number_type>::type;
      bool negative = v < 0;
      unsigned_type pv = static_cast<unsigned_type>(negative ? -v : v);
      size_t dc = internal::digit_count(pv);
-      if(negative) {
+      if (negative) {
        buffer.get()[position++] = '-';
      }
      char *write_pointer = buffer.get() + position + dc - 1;
      // optimization opportunity: if v is large, we can do better.
-      while(pv >= 10) {
+      while (pv >= 10) {
        *write_pointer-- = char('0' + (pv % 10));
        pv /= 10;
      }
      *write_pointer = char('0' + pv);
      position += dc;
    }
-  } else if constexpr (std::is_floating_point<number_type>::value) {
+  }
+  else SIMDJSON_IF_CONSTEXPR(std::is_floating_point<number_type>::value) {
    constexpr size_t max_number_size = 24;
-    if(capacity_check(max_number_size)) {
+    if (capacity_check(max_number_size)) {
      // We could specialize for float.
-      char *end = simdjson::internal::to_chars(buffer.get() + position, nullptr, double(v));
+      char *end = simdjson::internal::to_chars(buffer.get() + position, nullptr,
+                                               double(v));
      position = end - buffer.get();
    }
  }
 }

-simdjson_inline void string_builder::escape_and_append(std::string_view input)  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.
-  if(capacity_check(6 * input.size())) {
-    position += simdjson::write_string_escaped(input, buffer.get() + position);
+  if (capacity_check(6 * input.size())) {
+    position += write_string_escaped(input, buffer.get() + position);
  }
 }

-simdjson_inline void string_builder::escape_and_append_with_quotes(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.
-  if(capacity_check(2 + 6 * input.size())) {
+  if (capacity_check(2 + 6 * input.size())) {
    buffer.get()[position++] = '"';
-    position += simdjson::write_string_escaped(input, buffer.get() + position);
+    position += write_string_escaped(input, buffer.get() + position);
    buffer.get()[position++] = '"';
  }
 }

-simdjson_inline void string_builder::append_raw(const char *c)  noexcept {
-  if(capacity_check(1)) {
-    buffer.get()[position++] = *c;
+simdjson_inline void
+string_builder::escape_and_append_with_quotes(char input) noexcept {
+  // escaping might turn a control character into \x00xx so 6 characters.
+  if (capacity_check(2 + 6 * 1)) {
+    buffer.get()[position++] = '"';
+    std::string_view cinput(&input, 1);
+    position += write_string_escaped(cinput, buffer.get() + position);
+    buffer.get()[position++] = '"';
  }
 }

-simdjson_inline void string_builder::append_raw(std::string_view input)  noexcept {
-  if(capacity_check(input.size())) {
+simdjson_inline void string_builder::append_raw(const char *c) noexcept {
+  size_t len = std::strlen(c);
+  append_raw(c, len);
+}
+
+simdjson_inline void
+string_builder::append_raw(std::string_view input) noexcept {
+  if (capacity_check(input.size())) {
    std::memcpy(buffer.get() + position, input.data(), input.size());
    position += input.size();
  }
 }

-simdjson_inline void string_builder::append_raw(const char *str, size_t len)  noexcept {
-  if(capacity_check(len)) {
+simdjson_inline void string_builder::append_raw(const char *str,
+                                                size_t len) noexcept {
+  if (capacity_check(len)) {
    std::memcpy(buffer.get() + position, str, len);
    position += len;
  }
@@ -252,18 +462,22 @@ simdjson_inline string_builder::operator std::string() const noexcept(false) {
  return std::string(std::string_view());
 }

-simdjson_inline string_builder::operator std::string_view() const noexcept(false) {
+simdjson_inline string_builder::operator std::string_view() const
+    noexcept(false) {
  return view();
 }
 #endif

-simdjson_inline simdjson_result<std::string_view> string_builder::view() const noexcept {
-  if (!is_valid) { return simdjson::OUT_OF_CAPACITY; }
+simdjson_inline simdjson_result<std::string_view>
+string_builder::view() const noexcept {
+  if (!is_valid) {
+    return simdjson::OUT_OF_CAPACITY;
+  }
  return std::string_view(buffer.get(), position);
 }

 simdjson_inline simdjson_result<const char *> string_builder::c_str() noexcept {
-  if(capacity_check(1)) {
+  if (capacity_check(1)) {
    buffer.get()[position] = '\0';
    return buffer.get();
  }
@@ -278,4 +492,4 @@ simdjson_inline bool string_builder::validate_unicode() const noexcept {
 } // namespace SIMDJSON_IMPLEMENTATION
 } // namespace simdjson

-#endif // SIMDJSON_GENERIC_BUILDER_INL_H
+#endif // SIMDJSON_GENERIC_STRING_BUILDER_INL_H
@@ -2,10 +2,10 @@
 * This file is part of the builder API. It is temporarily in the ondemand directory
 * but we will move it to a builder directory later.
 */
-#ifndef SIMDJSON_GENERIC_BUILDER_H
+#ifndef SIMDJSON_GENERIC_STRING_BUILDER_H

 #ifndef SIMDJSON_CONDITIONAL_INCLUDE
-#define SIMDJSON_GENERIC_BUILDER_H
+#define SIMDJSON_GENERIC_STRING_BUILDER_H
 #include "simdjson/generic/implementation_simdjson_result_base.h"
 #endif // SIMDJSON_CONDITIONAL_INCLUDE

@@ -63,6 +63,11 @@ public:
   */
  simdjson_inline void escape_and_append_with_quotes(std::string_view input)  noexcept;

+  /**
+   * Append the character surrounded by double quotes, after escaping it.
+   * There is no UTF-8 validation.
+   */
+  simdjson_inline void escape_and_append_with_quotes(char input)  noexcept;
  /**
   * Append the C string directly, without escaping.
   * There is no UTF-8 validation.
@@ -164,4 +169,4 @@ private:
 }
 } // namespace simdjson

-#endif // SIMDJSON_GENERIC_BUILDER_H
+#endif // SIMDJSON_GENERIC_STRING_BUILDER_H
@@ -271,6 +271,7 @@ simdjson_inline  simdjson_result<std::string_view> simdjson_result<SIMDJSON_IMPL
  if (error()) { return error(); }
  return first.raw_json();
 }
+
 } // namespace simdjson

 #endif // SIMDJSON_GENERIC_ONDEMAND_OBJECT_INL_H
@@ -202,6 +202,36 @@ public:
   */
  simdjson_inline simdjson_result<std::string_view> raw_json() noexcept;

+#if SIMDJSON_SUPPORTS_DESERIALIZATION
+  /**
+   * Get this object as the given type.
+   *
+   * @param out This is set to a value of the given type, parsed from the JSON. If there is an error, this may not be initialized.
+   * @returns INCORRECT_TYPE If the JSON object is not of the given type.
+   * @returns SUCCESS If the parse succeeded and the out parameter was set to the value.
+   */
+  template <typename T>
+  simdjson_inline error_code get(T &out)
+     noexcept(custom_deserializable<T, object> ? nothrow_custom_deserializable<T, object> : true) {
+    static_assert(custom_deserializable<T, object>);
+    return deserialize(*this, out);
+  }
+  /**
+   * Get this array as the given type.
+   *
+   * @returns A value of the given type, parsed from the JSON.
+   * @returns INCORRECT_TYPE If the JSON value is not the given type.
+   */
+  template <typename T>
+  simdjson_inline simdjson_result<T> get()
+    noexcept(custom_deserializable<T, value> ? nothrow_custom_deserializable<T, value> : true)
+  {
+    static_assert(std::is_default_constructible<T>::value, "The specified type is not default constructible.");
+    T out{};
+    SIMDJSON_TRY(get<T>(out));
+    return out;
+  }
+#endif // SIMDJSON_SUPPORTS_DESERIALIZATION
 protected:
  /**
   * Go to the end of the object, no matter where you are right now.
@@ -245,12 +275,32 @@ 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;
-
  inline simdjson_result<bool> reset() noexcept;
  inline simdjson_result<bool> is_empty() noexcept;
  inline simdjson_result<size_t> count_fields() & noexcept;
  inline simdjson_result<std::string_view> raw_json() noexcept;
+  #if SIMDJSON_SUPPORTS_DESERIALIZATION
+  // TODO: move this code into object-inl.h

+  template<typename T>
+  simdjson_inline simdjson_result<T> get() noexcept {
+    if (error()) { return error(); }
+    if constexpr (std::is_same_v<T, SIMDJSON_IMPLEMENTATION::ondemand::object>) {
+      return first;
+    }
+    return first.get<T>();
+  }
+  template<typename T>
+  simdjson_inline error_code get(T& out) noexcept {
+    if (error()) { return error(); }
+    if constexpr (std::is_same_v<T, SIMDJSON_IMPLEMENTATION::ondemand::object>) {
+      out = first;
+    } else {
+      SIMDJSON_TRY( first.get<T>(out) );
+    }
+    return SUCCESS;
+  }
+#endif // SIMDJSON_SUPPORTS_DESERIALIZATION
 };

 } // namespace simdjson
@@ -84,6 +84,22 @@ public:
   * using a sanitizer that verifies that no uninitialized byte is read, then you should initialize the
   * SIMDJSON_PADDING bytes to avoid runtime warnings.
   *
+   * ### std::string references
+   *
+   * If you pass a mutable std::string reference (std::string&), the parser will seek to extend
+   * its capacity to SIMDJSON_PADDING bytes beyond the end of the string.
+   *
+   * Whenever you pass an std::string reference, the parser will access the bytes beyond the end of
+   * the string but before the end of the allocated memory (std::string::capacity()).
+   * If you are using a sanitizer that checks for reading uninitialized bytes or std::string's
+   * container-overflow checks, you may encounter sanitizer warnings.
+   * 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 iterate function:
+   *
+   *    std::string json = R"({ "foo": 1 } { "foo": 2 } { "foo": 3 } )";
+   *    document doc = parser.iterate(simdjson::pad(json));
+   *
   * @param json The JSON to parse.
   * @param len The length of the JSON.
   * @param capacity The number of bytes allocated in the JSON (must be at least len+SIMDJSON_PADDING).
@@ -20,36 +20,39 @@ simdjson_inline const char * raw_json_string::raw() const noexcept { return rein

 simdjson_inline bool raw_json_string::is_free_from_unescaped_quote(std::string_view target) noexcept {
  size_t pos{0};
-  // if the content has no escape character, just scan through it quickly!
-  for(;pos < target.size() && target[pos] != '\\';pos++) {}
-  // slow path may begin.
-  bool escaping{false};
-  for(;pos < target.size();pos++) {
-    if((target[pos] == '"') && !escaping) {
-      return false;
-    } else if(target[pos] == '\\') {
-      escaping = !escaping;
-    } else {
-      escaping = false;
+  while(pos < target.size()) {
+    pos = target.find('"', pos);
+    if(pos == std::string_view::npos) { return true; }
+    if(pos != 0 && target[pos-1] != '\\') { return false; }
+    if(pos > 1 && target[pos-2] == '\\') {
+      size_t backslash_count{2};
+      for(size_t i = 3; i <= pos; i++) {
+        if(target[pos-i] == '\\') { backslash_count++; }
+        else { break; }
+      }
+      if(backslash_count % 2 == 0) { return false; }
    }
+    pos++;
  }
  return true;
 }

 simdjson_inline bool raw_json_string::is_free_from_unescaped_quote(const char* target) noexcept {
  size_t pos{0};
-  // if the content has no escape character, just scan through it quickly!
-  for(;target[pos] && target[pos] != '\\';pos++) {}
-  // slow path may begin.
-  bool escaping{false};
-  for(;target[pos];pos++) {
-    if((target[pos] == '"') && !escaping) {
-      return false;
-    } else if(target[pos] == '\\') {
-      escaping = !escaping;
-    } else {
-      escaping = false;
+  while(target[pos]) {
+    const char * result = strchr(target+pos, '"');
+    if(result == nullptr) { return true; }
+    pos = result - target;
+    if(pos != 0 && target[pos-1] != '\\') { return false; }
+    if(pos > 1 && target[pos-2] == '\\') {
+      size_t backslash_count{2};
+      for(size_t i = 3; i <= pos; i++) {
+        if(target[pos-i] == '\\') { backslash_count++; }
+        else { break; }
+      }
+      if(backslash_count % 2 == 0) { return false; }
    }
+    pos++;
  }
  return true;
 }
@@ -61,7 +64,7 @@ simdjson_inline bool raw_json_string::unsafe_is_equal(size_t length, std::string
 }

 simdjson_inline bool raw_json_string::unsafe_is_equal(std::string_view target) const noexcept {
-  // Assumptions: does not contain unescaped quote characters, and
+  // Assumptions: does not contain unescaped quote characters("), and
  // the raw content is quote terminated within a valid JSON string.
  if(target.size() <= SIMDJSON_PADDING) {
    return (raw()[target.size()] == '"') && !memcmp(raw(), target.data(), target.size());
@@ -3,12 +3,16 @@
 #ifndef SIMDJSON_ONDEMAND_DESERIALIZE_H
 #ifndef SIMDJSON_CONDITIONAL_INCLUDE
 #define SIMDJSON_ONDEMAND_DESERIALIZE_H
+#include "simdjson/generic/ondemand/object.h"
 #include "simdjson/generic/ondemand/array.h"
 #include "simdjson/generic/ondemand/base.h"
 #endif // SIMDJSON_CONDITIONAL_INCLUDE

 #include <concepts>
 #include <limits>
+#if SIMDJSON_STATIC_REFLECTION
+#include <experimental/meta>
+#endif

 namespace simdjson {
 template <typename T>
@@ -55,6 +59,28 @@ error_code tag_invoke(deserialize_tag, auto &val, T &out) noexcept {
  return SUCCESS;
 }

+//////////////////////////////
+// String deserialization
+//////////////////////////////
+
+error_code tag_invoke(deserialize_tag, auto &val, char &out) noexcept {
+  std::string_view x;
+  SIMDJSON_TRY(val.get_string().get(x));
+  if(x.size() != 1) {
+    return INCORRECT_TYPE;
+  }
+  out = x[0];
+  return SUCCESS;
+}
+
+
+error_code tag_invoke(deserialize_tag, auto &val, std::string &out) noexcept {
+  std::string_view x;
+  SIMDJSON_TRY(val.get_string().get(x));
+  out.assign(x.data(), x.size());
+  return SUCCESS;
+}
+
 /**
 * STL containers have several constructors including one that takes a single
 * size argument. Thus, some compilers (Visual Studio) will not be able to
@@ -66,15 +92,20 @@ template <concepts::appendable_containers T, typename ValT>
  requires(!require_custom_serialization<T>)
 error_code tag_invoke(deserialize_tag, ValT &val, T &out) noexcept(false) {
  using value_type = typename std::remove_cvref_t<T>::value_type;
-  static_assert(
+  /*static_assert(
      deserializable<value_type, ValT>,
-      "The specified type inside the container must itself be deserializable");
+      "The specified type inside the container must itself be deserializable");*/
  static_assert(
      std::is_default_constructible_v<value_type>,
      "The specified type inside the container must default constructible.");

  SIMDJSON_IMPLEMENTATION::ondemand::array arr;
-  SIMDJSON_TRY(val.get_array().get(arr));
+  if constexpr (std::is_same_v<std::remove_cvref_t<ValT>, SIMDJSON_IMPLEMENTATION::ondemand::array>) {
+    arr = val;
+  } else {
+    SIMDJSON_TRY(val.get_array().get(arr));
+  }
+
  for (auto v : arr) {
    if constexpr (concepts::returns_reference<T>) {
      if (auto const err = v.get<value_type>().get(concepts::emplace_one(out));
@@ -160,6 +191,190 @@ error_code tag_invoke(deserialize_tag, ValT &val, T &out) noexcept(nothrow_deser
  return SUCCESS;
 }

+
+#if SIMDJSON_STATIC_REFLECTION
+
+
+template <typename T>
+constexpr bool user_defined_type = (std::is_class_v<T>
+&& !std::is_same_v<T, std::string> && !std::is_same_v<T, std::string_view> && !concepts::optional_type<T> &&
+!concepts::appendable_containers<T> && !require_custom_serialization<T>);
+
+
+// workaround from
+// https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2024/p2996r3.html#back-and-forth
+// for missing expansion statements
+/*namespace __impl {
+template <auto... vals> struct replicator_type {
+  template <typename F> constexpr void operator>>(F body) const {
+    (body.template operator()<vals>(), ...);
+  }
+};
+
+template <auto... vals> replicator_type<vals...> replicator = {};
+} // namespace __impl
+
+template <typename R> consteval auto expand(R range) {
+  std::vector<std::meta::info> args;
+  for (auto r : range) {
+    args.push_back(std::meta::reflect_value(r));
+  }
+  return substitute(^__impl::replicator, args);
+}*/
+// end of workaround
+
+template <typename T, typename ValT>
+  requires(user_defined_type<T> && std::is_class_v<T>)
+  constexpr error_code tag_invoke(deserialize_tag, ValT &val, T &out) noexcept {
+  SIMDJSON_IMPLEMENTATION::ondemand::object obj;
+  if constexpr (std::is_same_v<std::remove_cvref_t<ValT>, SIMDJSON_IMPLEMENTATION::ondemand::object>) {
+    obj = val;
+  } else {
+    SIMDJSON_TRY(val.get_object().get(obj));
+  }
+  template for (constexpr auto mem : std::meta::nonstatic_data_members_of(^^T)) {
+    if(std::meta::is_const(mem)) {
+      continue;
+    }
+    std::string_view key = std::string_view(std::meta::identifier_of(mem));
+    if(error_code e = obj[key].get(out.[:mem:]); e != simdjson::SUCCESS && e != simdjson::NO_SUCH_FIELD) {
+      return e;
+    }
+  }
+  return simdjson::SUCCESS;
+}
+template <typename simdjson_value, typename T>
+  requires(user_defined_type<std::remove_cvref_t<T>>)
+error_code tag_invoke(deserialize_tag, simdjson_value &val, std::unique_ptr<T> &out) noexcept {
+  if (!out) {
+    out = std::make_unique<T>();
+    if (!out) {
+      return MEMALLOC;
+    }
+  }
+  if (auto err = val.get(*out)) {
+    out.reset();
+    return err;
+  }
+  return SUCCESS;
+}
+
+template <typename simdjson_value, typename T>
+  requires(user_defined_type<std::remove_cvref_t<T>>)
+error_code tag_invoke(deserialize_tag, simdjson_value &val, std::shared_ptr<T> &out) noexcept {
+  if (!out) {
+    out = std::make_shared<T>();
+    if (!out) {
+      return MEMALLOC;
+    }
+  }
+  if (auto err = val.get(*out)) {
+    out.reset();
+    return err;
+  }
+  return SUCCESS;
+}
+
+#endif // SIMDJSON_STATIC_REFLECTION
+
+////////////////////////////////////////
+// Unique pointers
+////////////////////////////////////////
+error_code tag_invoke(deserialize_tag, auto &val, std::unique_ptr<bool> &out) noexcept {
+  if (!out) {
+    out = std::make_unique<bool>();
+    if (!out) { return MEMALLOC; }
+  }
+  SIMDJSON_TRY(val.get_bool().get(*out));
+  return SUCCESS;
+}
+
+error_code tag_invoke(deserialize_tag, auto &val, std::unique_ptr<int64_t> &out) noexcept {
+  if (!out) {
+    out = std::make_unique<int64_t>();
+    if (!out) { return MEMALLOC; }
+  }
+  SIMDJSON_TRY(val.get_int64().get(*out));
+  return SUCCESS;
+}
+
+error_code tag_invoke(deserialize_tag, auto &val, std::unique_ptr<uint64_t> &out) noexcept {
+  if (!out) {
+    out = std::make_unique<uint64_t>();
+    if (!out) { return MEMALLOC; }
+  }
+  SIMDJSON_TRY(val.get_uint64().get(*out));
+  return SUCCESS;
+}
+
+error_code tag_invoke(deserialize_tag, auto &val, std::unique_ptr<double> &out) noexcept {
+  if (!out) {
+    out = std::make_unique<double>();
+    if (!out) { return MEMALLOC; }
+  }
+  SIMDJSON_TRY(val.get_double().get(*out));
+  return SUCCESS;
+}
+
+error_code tag_invoke(deserialize_tag, auto &val, std::unique_ptr<std::string_view> &out) noexcept {
+  if (!out) {
+    out = std::make_unique<std::string_view>();
+    if (!out) { return MEMALLOC; }
+  }
+  SIMDJSON_TRY(val.get_string().get(*out));
+  return SUCCESS;
+}
+
+
+////////////////////////////////////////
+// Shared pointers
+////////////////////////////////////////
+error_code tag_invoke(deserialize_tag, auto &val, std::shared_ptr<bool> &out) noexcept {
+  if (!out) {
+    out = std::make_shared<bool>();
+    if (!out) { return MEMALLOC; }
+  }
+  SIMDJSON_TRY(val.get_bool().get(*out));
+  return SUCCESS;
+}
+
+error_code tag_invoke(deserialize_tag, auto &val, std::shared_ptr<int64_t> &out) noexcept {
+  if (!out) {
+    out = std::make_shared<int64_t>();
+    if (!out) { return MEMALLOC; }
+  }
+  SIMDJSON_TRY(val.get_int64().get(*out));
+  return SUCCESS;
+}
+
+error_code tag_invoke(deserialize_tag, auto &val, std::shared_ptr<uint64_t> &out) noexcept {
+  if (!out) {
+    out = std::make_shared<uint64_t>();
+    if (!out) { return MEMALLOC; }
+  }
+  SIMDJSON_TRY(val.get_uint64().get(*out));
+  return SUCCESS;
+}
+
+error_code tag_invoke(deserialize_tag, auto &val, std::shared_ptr<double> &out) noexcept {
+  if (!out) {
+    out = std::make_shared<double>();
+    if (!out) { return MEMALLOC; }
+  }
+  SIMDJSON_TRY(val.get_double().get(*out));
+  return SUCCESS;
+}
+
+error_code tag_invoke(deserialize_tag, auto &val, std::shared_ptr<std::string_view> &out) noexcept {
+  if (!out) {
+    out = std::make_shared<std::string_view>();
+    if (!out) { return MEMALLOC; }
+  }
+  SIMDJSON_TRY(val.get_string().get(*out));
+  return SUCCESS;
+}
+
+
 } // namespace simdjson

 #endif // SIMDJSON_ONDEMAND_DESERIALIZE_H
@@ -34,6 +34,7 @@ public:
   *
   * You may use get_double(), get_bool(), get_uint64(), get_int64(),
   * get_object(), get_array(), get_raw_json_string(), or get_string() instead.
+   * When SIMDJSON_SUPPORTS_DESERIALIZATION is set, custom types are also supported.
   *
   * @returns A value of the given type, parsed from the JSON.
   * @returns INCORRECT_TYPE If the JSON value is not the given type.
@@ -57,6 +58,7 @@ public:
   * Get this value as the given type.
   *
   * Supported types: object, array, raw_json_string, string_view, uint64_t, int64_t, double, bool
+   * If the macro SIMDJSON_SUPPORTS_DESERIALIZATION is set, then custom types are also supported.
   *
   * @param out This is set to a value of the given type, parsed from the JSON. If there is an error, this may not be initialized.
   * @returns INCORRECT_TYPE If the JSON value is not an object.
@@ -163,6 +165,17 @@ public:
   * Important: a value should be consumed once. Calling get_string() twice on the same value
   * is an error.
   *
+   * In some instances, you may want to allow replacement of invalid Unicode sequences.
+   * You may do so by passing the allow_replacement parameter as true. In the following
+   * example, the string "431924697b\udff0L\u0001Y" is not valid Unicode. By passing true
+   * to get_string, we allow the replacement of the invalid Unicode sequences with the Unicode
+   * replacement character (U+FFFD).
+   *
+   *   simdjson::ondemand::parser parser;
+   *   auto json = R"({"deviceId":"431924697b\udff0L\u0001Y"})"_padded;
+   *   simdjson::ondemand::document doc = parser.iterate(json);
+   *   auto view = doc["deviceId"].get_string(true);
+   *
   * @returns An UTF-8 string. The string is stored in the parser and will be invalidated the next
   *          time it parses a document or when it is destroyed.
   * @returns INCORRECT_TYPE if the JSON value is not a string.
@@ -414,6 +427,7 @@ public:
  simdjson_inline simdjson_result<value> operator[](std::string_view key) noexcept;
  /** @overload simdjson_inline simdjson_result<value> find_field_unordered(std::string_view key) noexcept; */
  simdjson_inline simdjson_result<value> operator[](const char *key) noexcept;
+  simdjson_result<value> operator[](int) noexcept = delete;

  /**
   * Get the type of this JSON value. It does not validate or consume the value.
@@ -781,6 +795,7 @@ public:
  simdjson_inline simdjson_result<SIMDJSON_IMPLEMENTATION::ondemand::value> operator[](std::string_view key) noexcept;
  /** @overload simdjson_inline simdjson_result<SIMDJSON_IMPLEMENTATION::ondemand::value> find_field_unordered(std::string_view key) noexcept; */
  simdjson_inline simdjson_result<SIMDJSON_IMPLEMENTATION::ondemand::value> operator[](const char *key) noexcept;
+  simdjson_result<SIMDJSON_IMPLEMENTATION::ondemand::value> operator[](int) noexcept = delete;

  /**
   * Get the type of this JSON value.
@@ -147,14 +147,18 @@ namespace simd {

    // Copies to 'output" all bytes corresponding to a 0 in the mask (interpreted as a bitset).
    // Passing a 0 value for mask would be equivalent to writing out every byte to output.
-    // Only the first 32 - count_ones(mask) bytes of the result are significant but 32 bytes
+    // Only the first 64 - count_ones(mask) bytes of the result are significant but 64 bytes
    // get written.
    // Design consideration: it seems like a function with the
    // signature simd8<L> compress(uint32_t mask) would be
    // sensible, but the AVX ISA makes this kind of approach difficult.
    template<typename L>
    simdjson_inline void compress(uint64_t mask, L * output) const {
-      _mm512_mask_compressstoreu_epi8 (output,~mask,*this);
+      // we deliberately avoid _mm512_mask_compressstoreu_epi8 for portability
+      // (AMD Zen4 has terrible performance with it, it is effectively broken)
+      // _mm512_mask_compressstoreu_epi8 (output,~mask,*this);
+      __m512i compressed = _mm512_maskz_compress_epi8(~mask, *this);
+      _mm512_storeu_si512(output, compressed); // could use a mask
    }

    template<typename L>
@@ -166,22 +166,22 @@ inline namespace literals {
 inline namespace string_view_literals {


-constexpr std::string_view operator "" _sv( const char* str, size_t len ) noexcept  // (1)
+constexpr std::string_view operator ""_sv( const char* str, size_t len ) noexcept  // (1)
 {
    return std::string_view{ str, len };
 }

-constexpr std::u16string_view operator "" _sv( const char16_t* str, size_t len ) noexcept  // (2)
+constexpr std::u16string_view operator ""_sv( const char16_t* str, size_t len ) noexcept  // (2)
 {
    return std::u16string_view{ str, len };
 }

-constexpr std::u32string_view operator "" _sv( const char32_t* str, size_t len ) noexcept  // (3)
+constexpr std::u32string_view operator ""_sv( const char32_t* str, size_t len ) noexcept  // (3)
 {
    return std::u32string_view{ str, len };
 }

-constexpr std::wstring_view operator "" _sv( const wchar_t* str, size_t len ) noexcept  // (4)
+constexpr std::wstring_view operator ""_sv( const wchar_t* str, size_t len ) noexcept  // (4)
 {
    return std::wstring_view{ str, len };
 }
@@ -1512,22 +1512,22 @@ nssv_inline_ns namespace string_view_literals {

 #if nssv_CONFIG_STD_SV_OPERATOR && nssv_HAVE_STD_DEFINED_LITERALS

-nssv_constexpr nonstd::sv_lite::string_view operator "" sv( const char* str, size_t len ) nssv_noexcept  // (1)
+nssv_constexpr nonstd::sv_lite::string_view operator ""sv( const char* str, size_t len ) nssv_noexcept  // (1)
 {
    return nonstd::sv_lite::string_view{ str, len };
 }

-nssv_constexpr nonstd::sv_lite::u16string_view operator "" sv( const char16_t* str, size_t len ) nssv_noexcept  // (2)
+nssv_constexpr nonstd::sv_lite::u16string_view operator ""sv( const char16_t* str, size_t len ) nssv_noexcept  // (2)
 {
    return nonstd::sv_lite::u16string_view{ str, len };
 }

-nssv_constexpr nonstd::sv_lite::u32string_view operator "" sv( const char32_t* str, size_t len ) nssv_noexcept  // (3)
+nssv_constexpr nonstd::sv_lite::u32string_view operator ""sv( const char32_t* str, size_t len ) nssv_noexcept  // (3)
 {
    return nonstd::sv_lite::u32string_view{ str, len };
 }

-nssv_constexpr nonstd::sv_lite::wstring_view operator "" sv( const wchar_t* str, size_t len ) nssv_noexcept  // (4)
+nssv_constexpr nonstd::sv_lite::wstring_view operator ""sv( const wchar_t* str, size_t len ) nssv_noexcept  // (4)
 {
    return nonstd::sv_lite::wstring_view{ str, len };
 }
@@ -1536,22 +1536,22 @@ nssv_constexpr nonstd::sv_lite::wstring_view operator "" sv( const wchar_t* str,

 #if nssv_CONFIG_USR_SV_OPERATOR

-nssv_constexpr nonstd::sv_lite::string_view operator "" _sv( const char* str, size_t len ) nssv_noexcept  // (1)
+nssv_constexpr nonstd::sv_lite::string_view operator ""_sv( const char* str, size_t len ) nssv_noexcept  // (1)
 {
    return nonstd::sv_lite::string_view{ str, len };
 }

-nssv_constexpr nonstd::sv_lite::u16string_view operator "" _sv( const char16_t* str, size_t len ) nssv_noexcept  // (2)
+nssv_constexpr nonstd::sv_lite::u16string_view operator ""_sv( const char16_t* str, size_t len ) nssv_noexcept  // (2)
 {
    return nonstd::sv_lite::u16string_view{ str, len };
 }

-nssv_constexpr nonstd::sv_lite::u32string_view operator "" _sv( const char32_t* str, size_t len ) nssv_noexcept  // (3)
+nssv_constexpr nonstd::sv_lite::u32string_view operator ""_sv( const char32_t* str, size_t len ) nssv_noexcept  // (3)
 {
    return nonstd::sv_lite::u32string_view{ str, len };
 }

-nssv_constexpr nonstd::sv_lite::wstring_view operator "" _sv( const wchar_t* str, size_t len ) nssv_noexcept  // (4)
+nssv_constexpr nonstd::sv_lite::wstring_view operator ""_sv( const wchar_t* str, size_t len ) nssv_noexcept  // (4)
 {
    return nonstd::sv_lite::wstring_view{ str, len };
 }
@@ -187,11 +187,11 @@ inline simdjson_result<padded_string> padded_string::load(std::string_view filen

 } // namespace simdjson

-inline simdjson::padded_string operator "" _padded(const char *str, size_t len) {
+inline simdjson::padded_string operator ""_padded(const char *str, size_t len) {
  return simdjson::padded_string(str, len);
 }
 #ifdef __cpp_char8_t
-inline simdjson::padded_string operator "" _padded(const char8_t *str, size_t len) {
+inline simdjson::padded_string operator ""_padded(const char8_t *str, size_t len) {
  return simdjson::padded_string(reinterpret_cast<const char8_t *>(str), len);
 }
 #endif
@@ -161,9 +161,9 @@ inline std::ostream& operator<<(std::ostream& out, simdjson_result<padded_string
 } // namespace simdjson

 // This is deliberately outside of simdjson so that people get it without having to use the namespace
-inline simdjson::padded_string operator "" _padded(const char *str, size_t len);
+inline simdjson::padded_string operator ""_padded(const char *str, size_t len);
 #ifdef __cpp_char8_t
-inline simdjson::padded_string operator "" _padded(const char8_t *str, size_t len);
+inline simdjson::padded_string operator ""_padded(const char8_t *str, size_t len);
 #endif

 namespace simdjson {
@@ -53,6 +53,11 @@ inline bool padded_string_view::remove_utf8_bom() noexcept {
 inline std::ostream& operator<<(std::ostream& out, simdjson_result<padded_string_view> &s) noexcept(false) { return out << s.value(); }
 #endif

+inline padded_string_view pad(std::string& s) noexcept {
+  const auto len = s.size();
+  s.append(SIMDJSON_PADDING, ' ');
+  return padded_string_view(s.data(), len, s.size());
+}
 } // namespace simdjson


@@ -83,6 +83,15 @@ public:
 inline std::ostream& operator<<(std::ostream& out, simdjson_result<padded_string_view> &s) noexcept(false);
 #endif

+/**
+ * Create a padded_string_view from a string. The string will be padded with SIMDJSON_PADDING
+ * space characters. The resulting padded_string_view will have a length equal to the original
+ * string.
+ *
+ * @param s The string.
+ * @return The padded string.
+ */
+inline padded_string_view pad(std::string& s) noexcept;
 } // namespace simdjson

 #endif // SIMDJSON_PADDED_STRING_VIEW_H
@@ -6,11 +6,15 @@
 #include <cstdlib>
 #include <cfloat>
 #include <cassert>
+#include <climits>
 #ifndef _WIN32
 // strcasecmp, strncasecmp
 #include <strings.h>
 #endif

+static_assert(CHAR_BIT == 8, "simdjson requires 8-bit bytes");
+
+
 // We are using size_t without namespace std:: throughout the project
 using std::size_t;

@@ -44,6 +48,7 @@ using std::size_t;
 #elif defined(__loongarch_lp64)
 #define SIMDJSON_IS_LOONGARCH64 1
 #elif defined(__PPC64__) || defined(_M_PPC64)
+#define SIMDJSON_IS_PPC64 1
 #if defined(__ALTIVEC__)
 #define SIMDJSON_IS_PPC64_VMX 1
 #endif // defined(__ALTIVEC__)
@@ -79,7 +79,8 @@ simdjson_inline escaping escaping::copy_and_find(const uint8_t *src, uint8_t *ds
  simd8<bool> is_backslash = (v == '\\');
  simd8<bool> is_control = (v < 32);
  return {
-    (is_backslash | is_quote | is_control).to_bitmask()
+    // We store it as a 64-bit bitmask even though we only need 16 bits.
+    uint64_t((is_backslash | is_quote | is_control).to_bitmask())
  };
 }

@@ -4,7 +4,7 @@
 #define SIMDJSON_SIMDJSON_VERSION_H

 /** The version of simdjson being used (major.minor.revision) */
-#define SIMDJSON_VERSION "3.10.1"
+#define SIMDJSON_VERSION "3.12.2"

 namespace simdjson {
 enum {
@@ -15,11 +15,11 @@ enum {
  /**
   * The minor version (major.MINOR.revision) of simdjson being used.
   */
-  SIMDJSON_VERSION_MINOR = 10,
+  SIMDJSON_VERSION_MINOR = 12,
  /**
   * The revision (major.minor.REVISION) of simdjson being used.
   */
-  SIMDJSON_VERSION_REVISION = 1
+  SIMDJSON_VERSION_REVISION = 2
 };
 } // namespace simdjson

@@ -488,6 +488,22 @@ if SCRIPTPATH != AMALGAMATE_OUTPUT_PATH:
  shutil.copy2(os.path.join(SCRIPTPATH,"amalgamate_demo.cpp"),AMALGAMATE_OUTPUT_PATH)
  shutil.copy2(os.path.join(SCRIPTPATH,"README.md"),AMALGAMATE_OUTPUT_PATH)

+
+
+
+def create_zip():
+    import zipfile
+    outdir = AMALGAMATE_OUTPUT_PATH
+
+    path = os.path.join(outdir, "singleheader.zip")
+    print(f"Creating {path}")
+    with zipfile.ZipFile(path, 'w') as zf:
+        for name in ["simdjson.cpp", "simdjson.h"]:
+            source = os.path.join(outdir, name)
+            print(f"Adding {source}")
+            zf.write(source, name)
+    print(f"Created {path}")
+create_zip()
 print("Done with all files generation.")

 print(f"Files have been written to directory: {AMALGAMATE_OUTPUT_PATH}/")
@@ -496,6 +512,8 @@ print(subprocess.run(['ls', '-la', AMAL_C, AMAL_H, DEMOCPP, README],
 print("Done with all files generation.")


+
+
 #
 # Instructions to create demo
 #
@@ -150,6 +150,7 @@ simdjson_warn_unused error_code dom_parser_implementation::stage2_next(dom::docu
  return stage2::tape_builder::parse_document<true>(*this, _doc);
 }

+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 {
  return arm64::stringparsing::parse_string(src, dst, allow_replacement);
 }
@@ -388,6 +388,7 @@ simdjson_warn_unused error_code dom_parser_implementation::stage2_next(dom::docu
  return stage2::tape_builder::parse_document<true>(*this, _doc);
 }

+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 {
  return fallback::stringparsing::parse_string(src, dst, replacement_char);
 }
@@ -1,3 +1,4 @@
+#include <cstdint>
 #ifndef SIMDJSON_SRC_GENERIC_STAGE2_STRINGPARSING_H

 #ifndef SIMDJSON_CONDITIONAL_INCLUDE
@@ -236,29 +237,32 @@ simdjson_warn_unused simdjson_inline uint8_t *parse_wobbly_string(const uint8_t
  }
 }

+/////////////
+/// TODO: This function is not used in the codebase. It is not clear if it is needed.
+/////////////
 simdjson_warn_unused size_t write_string_escaped(const std::string_view input, char *out) noexcept {
  // We are making the following assumption: most strings will either be very short or they will not
  // need escaping.
  size_t i = 0;
  size_t pos = 0;
-  if(input.size() >= escaping::BYTES_PROCESSED) {
+  /*if(input.size() >= escaping::BYTES_PROCESSED) {
    auto vec_processing = [input,out]() -> size_t {
-      size_t i = 0;
-      size_t pos = 0;
-      for(;input.size() - i >= escaping::BYTES_PROCESSED; i += escaping::BYTES_PROCESSED) {
-        escaping vinput = escaping::copy_and_find(reinterpret_cast<const uint8_t *>(input.data()) + i, reinterpret_cast<uint8_t *>(out) + pos);
+      size_t index = 0;
+      size_t position = 0;
+      for(;input.size() - index >= escaping::BYTES_PROCESSED; index += escaping::BYTES_PROCESSED) {
+        escaping vinput = escaping::copy_and_find(reinterpret_cast<const uint8_t *>(input.data()) + index, reinterpret_cast<uint8_t *>(out) + position);
        if(vinput.has_escape()) {
-          return i + vinput.escape_index(); // We have a character that needs escaping
+          return index + vinput.escape_index(); // We have a character that needs escaping
        }
-        pos += escaping::BYTES_PROCESSED;
+        position += escaping::BYTES_PROCESSED;
      }
-      if(i == input.size()) { return input.size(); }
+      if(index == input.size()) { return input.size(); }
      // We virtually backtrack so we can load a full vector register
-      i = input.size() - escaping::BYTES_PROCESSED;
-      pos = i;
-      escaping vinput = escaping::copy_and_find(reinterpret_cast<const uint8_t *>(input.data()) + i, reinterpret_cast<uint8_t *>(out) + pos);
+      index = input.size() - escaping::BYTES_PROCESSED;
+      position = index;
+      escaping vinput = escaping::copy_and_find(reinterpret_cast<const uint8_t *>(input.data()) + index, reinterpret_cast<uint8_t *>(out) + position);
      if(vinput.has_escape()) {
-        return i + vinput.escape_index(); // We have a character that needs escaping
+        return index + vinput.escape_index(); // We have a character that needs escaping
      }
      return input.size();
    };
@@ -266,7 +270,7 @@ simdjson_warn_unused size_t write_string_escaped(const std::string_view input, c
    pos = i;
    if(i == input.size()) { return pos; }
    // Here we only continue if there was a character that needed escaping.
-  }
+  }*/
  static std::string_view control_chars[] = {
    "\\x0000", "\\x0001", "\\x0002", "\\x0003", "\\x0004", "\\x0005", "\\x0006",
    "\\x0007", "\\x0008", "\\t",     "\\n",     "\\x000b", "\\f",     "\\r",
@@ -274,13 +278,13 @@ simdjson_warn_unused size_t write_string_escaped(const std::string_view input, c
    "\\x0015", "\\x0016", "\\x0017", "\\x0018", "\\x0019", "\\x001a", "\\x001b",
    "\\x001c", "\\x001d", "\\x001e", "\\x001f"};
  static std::array<uint8_t, 256> json_quotable_character =
-    []() constexpr {
+    []() SIMDJSON_CONSTEXPR_LAMBDA {
      std::array<uint8_t, 256> result{};
-      for (int i = 0; i < 32; i++) {
-        result[i] = 1;
+      for (int index = 0; index < 32; index++) {
+        result[index] = 1;
      }
-      for (int i : {'"', '\\'}) {
-        result[i] = 1;
+      for (int index : {'"', '\\'}) {
+        result[index] = 1;
      }
      return result;
    }();
@@ -332,6 +336,7 @@ simdjson_warn_unused size_t write_string_escaped(const std::string_view input, c


 } // namespace stringparsing
+
 } // unnamed namespace
 } // namespace SIMDJSON_IMPLEMENTATION
 } // namespace simdjson
@@ -147,6 +147,7 @@ simdjson_warn_unused error_code dom_parser_implementation::stage2_next(dom::docu
  return stage2::tape_builder::parse_document<true>(*this, _doc);
 }

+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 {
  return haswell::stringparsing::parse_string(src, dst, replacement_char);
 }
@@ -193,6 +193,7 @@ simdjson_warn_unused error_code dom_parser_implementation::stage2_next(dom::docu
  return stage2::tape_builder::parse_document<true>(*this, _doc);
 }

+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 {
  return icelake::stringparsing::parse_string(src, dst, replacement_char);
 }
@@ -239,8 +239,8 @@ public:
  simdjson_warn_unused error_code minify(const uint8_t *, size_t, uint8_t *, size_t &) const noexcept final override {
    return UNSUPPORTED_ARCHITECTURE;
  }
-  simdjson_warn_unused size_t write_string_escaped(const std::string_view input, char *out) const noexcept final {
-    return 0;
+  simdjson_warn_unused size_t write_string_escaped(const std::string_view, char *) const noexcept final override {
+    return 0; // TODO: Evaluate whether this is the right thing to do for unsupported architecture.
  }
  simdjson_warn_unused bool validate_utf8(const char *, size_t) const noexcept final override {
    return false; // Just refuse to validate. Given that we have a fallback implementation
@@ -110,6 +110,7 @@ simdjson_warn_unused error_code dom_parser_implementation::stage2_next(dom::docu
  return stage2::tape_builder::parse_document<true>(*this, _doc);
 }

+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 {
  return lasx::stringparsing::parse_string(src, dst, allow_replacement);
 }
@@ -114,6 +114,7 @@ simdjson_warn_unused error_code dom_parser_implementation::stage2_next(dom::docu
  return stage2::tape_builder::parse_document<true>(*this, _doc);
 }

+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 {
  return lsx::stringparsing::parse_string(src, dst, allow_replacement);
 }
@@ -120,6 +120,7 @@ simdjson_warn_unused error_code dom_parser_implementation::stage2_next(dom::docu
  return stage2::tape_builder::parse_document<true>(*this, _doc);
 }

+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 {
  return ppc64::stringparsing::parse_string(src, dst, replacement_char);
 }
@@ -152,6 +152,7 @@ simdjson_warn_unused error_code dom_parser_implementation::stage2_next(dom::docu
  return stage2::tape_builder::parse_document<true>(*this, _doc);
 }

+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 {
  return westmere::stringparsing::parse_string(src, dst, replacement_char);
 }
@@ -1,8 +1,9 @@
 # All remaining tests link with simdjson proper
-link_libraries(simdjson)
 include_directories(..)
 add_cpp_test(builder_string_builder_tests              LABELS ondemand acceptance per_implementation)
-
+if(SIMDJSON_STATIC_REFLECTION)
+  add_cpp_test(static_reflection_builder_tests           LABELS ondemand acceptance per_implementation)
+endif(SIMDJSON_STATIC_REFLECTION)
 # Copy the simdjson dll into the tests directory
 if(MSVC AND BUILD_SHARED_LIBS)
  add_custom_command(TARGET builder_string_builder_tests POST_BUILD        # Adds a post-build event
@@ -4,6 +4,13 @@

 using namespace simdjson;

+struct Car {
+    std::string make;
+    std::string model;
+    int64_t year;
+    std::vector<double> tire_pressure;
+}; // Car
+
 namespace builder_tests {
  using namespace std;

@@ -27,7 +34,7 @@ namespace builder_tests {
        ASSERT_EQUAL(sb.size(), 1);
        std::string_view p;
        auto result = sb.view().get(p);
-        ASSERT_EQUAL(result, SUCCESS);
+        ASSERT_SUCCESS(result);
        ASSERT_EQUAL(p, "a");
        TEST_SUCCEED();
    }
@@ -40,7 +47,7 @@ namespace builder_tests {
        ASSERT_EQUAL(sb.size(), 2);
        std::string_view p;
        auto result = sb.view().get(p);
-        ASSERT_EQUAL(result, SUCCESS);
+        ASSERT_SUCCESS(result);
        ASSERT_EQUAL(p, "42");
        TEST_SUCCEED();
    }
@@ -49,10 +56,10 @@ namespace builder_tests {
        TEST_START();
        simdjson::builder::string_builder sb;
        sb.append(1.1);
-        ASSERT_EQUAL(sb.size(), 2);
+        ASSERT_EQUAL(sb.size(), 3);
        std::string_view p;
        auto result = sb.view().get(p);
-        ASSERT_EQUAL(result, SUCCESS);
+        ASSERT_SUCCESS(result);
        ASSERT_EQUAL(p, "1.1");
        TEST_SUCCEED();
    }
@@ -64,7 +71,7 @@ namespace builder_tests {
        ASSERT_EQUAL(sb.size(), 4);
        std::string_view p;
        auto result = sb.view().get(p);
-        ASSERT_EQUAL(result, SUCCESS);
+        ASSERT_SUCCESS(result);
        ASSERT_EQUAL(p, "null");
        TEST_SUCCEED();
    }
@@ -84,8 +91,8 @@ namespace builder_tests {
        sb.escape_and_append("Hello, \"world\"!");
        std::string_view p;
        auto result = sb.view().get(p);
-        ASSERT_EQUAL(result, SUCCESS);
-        ASSERT_EQUAL(p, "Hello, \"world\"!");
+        ASSERT_SUCCESS(result);
+        ASSERT_EQUAL(p, "Hello, \\\"world\\\"!");
        TEST_SUCCEED();
    }

@@ -95,7 +102,7 @@ namespace builder_tests {
        sb.escape_and_append_with_quotes("Hello, \"world\"!");
        std::string_view p;
        auto result = sb.view().get(p);
-        ASSERT_EQUAL(result, SUCCESS);
+        ASSERT_SUCCESS(result);
        ASSERT_EQUAL(p, "\"Hello, \\\"world\\\"!\"");
        TEST_SUCCEED();
    }
@@ -106,7 +113,7 @@ namespace builder_tests {
        sb.append_raw("Test");
        std::string_view p;
        auto result = sb.view().get(p);
-        ASSERT_EQUAL(result, SUCCESS);
+        ASSERT_SUCCESS(result);
        ASSERT_EQUAL(p, "Test");
        TEST_SUCCEED();
    }
@@ -117,7 +124,7 @@ namespace builder_tests {
        sb.append_raw("Test String", 4);
        std::string_view p;
        auto result = sb.view().get(p);
-        ASSERT_EQUAL(result, SUCCESS);
+        ASSERT_SUCCESS(result);
        ASSERT_EQUAL(p, "Test");
        TEST_SUCCEED();
    }
@@ -128,7 +135,7 @@ namespace builder_tests {
        sb.append('a');
        std::string_view p;
        auto result = sb.view().get(p);
-        ASSERT_EQUAL(result, SUCCESS);
+        ASSERT_SUCCESS(result);
        ASSERT_EQUAL(p, "a");
        TEST_SUCCEED();
    }
@@ -151,8 +158,62 @@ namespace builder_tests {
        TEST_SUCCEED();
    }

+    void serialize_car(const Car& car, simdjson::builder::string_builder& builder) {
+        // start of JSON
+        builder.append_raw("{");
+
+        // "make"
+        builder.escape_and_append_with_quotes("make");
+        builder.append_raw(":");
+        builder.escape_and_append_with_quotes(car.make);
+
+        // "model"
+        builder.append_raw(",");
+        builder.escape_and_append_with_quotes("model");
+        builder.append_raw(":");
+        builder.escape_and_append_with_quotes(car.model);
+
+        // "year"
+        builder.append_raw(",");
+        builder.escape_and_append_with_quotes("year");
+        builder.append_raw(":");
+        builder.append(car.year);
+
+        // "tire_pressure"
+        builder.append_raw(",");
+        builder.escape_and_append_with_quotes("tire_pressure");
+        builder.append_raw(":[");
+
+        // vector tire_pressure
+        for (size_t i = 0; i < car.tire_pressure.size(); ++i) {
+            builder.append(car.tire_pressure[i]);
+            if (i < car.tire_pressure.size() - 1) {
+                builder.append_raw(",");
+            }
+        }
+        // end of array
+        builder.append_raw("]");
+
+        // end of object
+        builder.append_raw("}");
+    }
+
+    bool car_test() {
+        TEST_START();
+        simdjson::builder::string_builder sb;
+        Car c = {"Toyota", "Corolla", 2017, {30.0,30.2,30.513,30.79}};
+        serialize_car(c, sb);
+        std::string_view p;
+        auto result = sb.view().get(p);
+        ASSERT_SUCCESS(result);
+        ASSERT_EQUAL(p, "{\"make\":\"Toyota\",\"model\":\"Corolla\",\"year\":2017,\"tire_pressure\":[30.0,30.2,30.513,30.79]}");
+        TEST_SUCCEED();
+    }
+
+
    bool run() {
        return
+            car_test() &&
    #if SIMDJSON_EXCEPTIONS
            string_convertion_except() &&
    #endif
@@ -171,7 +232,7 @@ namespace builder_tests {
            true;
    }

-} // namespace twitter_tests
+} // namespace builder_tests

 int main(int argc, char *argv[]) {
  return test_main(argc, argv, builder_tests::run);
@@ -0,0 +1,143 @@
+#include "simdjson.h"
+#include "test_builder.h"
+#include <string>
+#include <string_view>
+#include <vector>
+
+using namespace simdjson;
+struct Car {
+  std::string make;
+  std::string model;
+  int64_t year;
+  std::vector<double> tire_pressure;
+};
+
+struct kid {
+  int age;
+  std::string name;
+  std::vector<std::string> toys;
+  bool operator<=> (const kid&) const = default;
+};
+
+struct Z {
+  int x;
+  bool operator<=> (const Z&) const = default;
+};
+
+struct Y {
+  int g;
+  std::string h;
+  std::vector<int> i;
+  Z z;
+  bool operator<=> (const Y&) const = default;
+};
+
+struct X {
+  char a;
+  int b;
+  int c;
+  std::string d;
+  std::vector<int> e;
+  std::vector<std::string> f;
+  Y y;
+  bool operator<=> (const X&) const = default;
+};
+
+namespace builder_tests {
+
+
+  bool car_test() {
+    TEST_START();
+    simdjson::builder::string_builder sb;
+    Car c = {"Toyota", "Corolla", 2017, {30.0,30.2,30.513,30.79}};
+    append(sb, c);
+    std::string_view p;
+    auto result = sb.view().get(p);
+    ASSERT_SUCCESS(result);
+    ASSERT_EQUAL(p, "{\"make\":\"Toyota\",\"model\":\"Corolla\",\"year\":2017,\"tire_pressure\":[30.0,30.2,30.513,30.79]}");
+    std::string pstr(p.begin(), p.end());
+    ASSERT_EQUAL(pstr, "{\"make\":\"Toyota\",\"model\":\"Corolla\",\"year\":2017,\"tire_pressure\":[30.0,30.2,30.513,30.79]}");
+    simdjson::ondemand::parser parser;
+    simdjson::ondemand::document doc;
+    ASSERT_SUCCESS(parser.iterate(simdjson::pad(pstr)).get(doc));
+    Car c2;
+    ASSERT_SUCCESS(doc.get<Car>().get(c2));
+    ASSERT_EQUAL(c2.make, "Toyota");
+    ASSERT_EQUAL(c2.model, "Corolla");
+    ASSERT_EQUAL(c2.year, 2017);
+    ASSERT_EQUAL(c2.tire_pressure.size(), 4);
+    ASSERT_EQUAL(c2.tire_pressure[0], 30.0);
+    ASSERT_EQUAL(c2.tire_pressure[1], 30.2);
+    ASSERT_EQUAL(c2.tire_pressure[2], 30.513);
+    ASSERT_EQUAL(c2.tire_pressure[3], 30.79);
+    TEST_SUCCEED();
+  }
+
+
+bool serialize_deserialize_kid() {
+  TEST_START();
+  simdjson::padded_string json_str =
+      R"({"age": 12, "name": "John", "toys": ["car", "ball"]})"_padded;
+  simdjson::ondemand::parser parser;
+  simdjson::ondemand::document doc;
+  ASSERT_SUCCESS(parser.iterate(json_str).get(doc));
+  kid k;
+  ASSERT_SUCCESS(doc.get<kid>().get(k));
+  ASSERT_EQUAL(k.age, 12);
+  ASSERT_EQUAL(k.name, "John");
+  ASSERT_EQUAL(k.toys.size(), 2);
+  ASSERT_EQUAL(k.toys[0], "car");
+  ASSERT_EQUAL(k.toys[1], "ball");
+  // Now, go the other direction:
+  std::string json;
+  ASSERT_SUCCESS(simdjson::builder::to_json_string(k).get(json));
+  std::cout << json << std::endl;
+  // Now we parse it back:
+  simdjson::ondemand::parser parser2;
+  simdjson::ondemand::document doc2;
+  ASSERT_SUCCESS(parser2.iterate(simdjson::pad(json)).get(doc2));
+  kid k2;
+  ASSERT_SUCCESS(doc2.get<kid>().get(k2));
+  ASSERT_EQUAL(k2.age, 12);
+  ASSERT_EQUAL(k2.name, "John");
+  ASSERT_EQUAL(k2.toys.size(), 2);
+  ASSERT_EQUAL(k2.toys[0], "car");
+  ASSERT_EQUAL(k2.toys[1], "ball");
+  TEST_SUCCEED();
+}
+
+bool serialize_deserialize_x_y_z() {
+  TEST_START();
+  X s1 = {.a = '1',
+          .b = 10,
+          .c = 0,
+          .d = "test string\n\r\"",
+          .e = {1, 2, 3},
+          .f = {"ab", "cd", "fg"},
+          .y = {.g = 100,
+                .h = "test string\n\r\"",
+                .i = {1, 2, 3},
+                .z = {.x = 1000}}};
+  std::string pstr;
+  ASSERT_SUCCESS(simdjson::builder::to_json_string(s1).get(pstr));
+  ASSERT_EQUAL(
+      pstr,
+      R"({"a":"1","b":10,"c":0,"d":"test string\n\r\"","e":[1,2,3],"f":["ab","cd","fg"],"y":{"g":100,"h":"test string\n\r\"","i":[1,2,3],"z":{"x":1000}}})");
+  simdjson::ondemand::parser parser;
+  simdjson::ondemand::document doc;
+  ASSERT_SUCCESS(parser.iterate(simdjson::pad(pstr)).get(doc));
+  X s2;
+  ASSERT_SUCCESS(doc.get<X>().get(s2));
+  ASSERT_TRUE(s1 == s2);
+  TEST_SUCCEED();
+}
+
+bool run() {
+  return car_test() && serialize_deserialize_kid() && serialize_deserialize_x_y_z() && true;
+}
+
+} // namespace builder_tests
+
+int main(int argc, char *argv[]) {
+  return test_main(argc, argv, builder_tests::run);
+}
@@ -99,14 +99,18 @@ endif()
 if(NOT (MSVC AND MSVC_VERSION LESS 1920))
  if(SIMDJSON_EXCEPTIONS)
    add_cpp_test(readme_examples COMPILE_ONLY LABELS acceptance)
-    add_cpp_test(readme_examples11 COMPILE_ONLY LABELS acceptance SOURCES readme_examples.cpp)
-    set_target_properties(readme_examples11 PROPERTIES CXX_STANDARD 11 CXX_STANDARD_REQUIRED ON CXX_EXTENSIONS OFF)
+    if(NOT SIMDJSON_STATIC_REFLECTION)
+      add_cpp_test(readme_examples11 COMPILE_ONLY LABELS acceptance SOURCES readme_examples.cpp)
+      set_target_properties(readme_examples11 PROPERTIES CXX_STANDARD 11 CXX_STANDARD_REQUIRED ON CXX_EXTENSIONS OFF)
+    endif(NOT SIMDJSON_STATIC_REFLECTION)
  endif()

  add_cpp_test(readme_examples_noexceptions COMPILE_ONLY LABELS acceptance)

-  add_cpp_test(readme_examples_noexceptions11 COMPILE_ONLY LABELS acceptance SOURCES readme_examples_noexceptions.cpp)
-  set_target_properties(readme_examples_noexceptions11 PROPERTIES CXX_STANDARD 11 CXX_STANDARD_REQUIRED ON CXX_EXTENSIONS OFF)
+  if(NOT SIMDJSON_STATIC_REFLECTION)
+    add_cpp_test(readme_examples_noexceptions11 COMPILE_ONLY LABELS acceptance SOURCES readme_examples_noexceptions.cpp)
+    set_target_properties(readme_examples_noexceptions11 PROPERTIES CXX_STANDARD 11 CXX_STANDARD_REQUIRED ON CXX_EXTENSIONS OFF)
+  endif(NOT SIMDJSON_STATIC_REFLECTION)

  # Compile tests that *should fail*
  add_cpp_test(readme_examples_will_fail_with_exceptions_off WILL_FAIL COMPILE_ONLY LABELS acceptance SOURCES readme_examples.cpp)
@@ -461,6 +461,13 @@ void parse_documentation_lowlevel() {
  (void)element;
 }

+void simplepad() {
+  std::string json = "[1]";
+  dom::parser parser;
+  dom::element doc;
+  auto error = parser.parse(simdjson::pad(json)).get(doc);
+  if(error) { exit(-1); }
+}

 void jsondollar() {
  dom::parser parser;
@@ -497,6 +504,7 @@ void jsonpath() {
 }

 int main() {
+  simplepad();
  jsonpath();
  jsondollar();
  basics_dom_1();
@@ -5,6 +5,23 @@ using namespace simdjson;

 namespace misc_tests {
  using namespace std;
+bool issue2322() {
+  TEST_START();
+  std::vector<std::pair<std::string, bool>> examples = {{R"("hello")", false},
+                                         {R"(\"hello)", true},
+                                         {R"("hello\")", true},
+                                         {R"("hel\"lo")", false},
+                                         {R"("hel\\lo")", false},
+                                         {R"(\"hel\\\"lo\")", true},
+                                         {R"(\\"hel\\\"lo\")", false}};
+  for (std::pair<std::string, bool> v : examples) {
+    ASSERT_EQUAL(ondemand::raw_json_string::is_free_from_unescaped_quote(v.first),
+                 v.second);
+    ASSERT_EQUAL(ondemand::raw_json_string::is_free_from_unescaped_quote(v.first.c_str()),
+                 v.second);
+  }
+  TEST_SUCCEED();
+}
 #if SIMDJSON_EXCEPTIONS
  // user reported an asan error:
  bool issue2199() {
@@ -537,6 +554,24 @@ namespace misc_tests {
    TEST_SUCCEED();
  }

+  simdjson_warn_unused bool issue2312() {
+    TEST_START();
+    std::string init_string = R"("abc":)";
+    init_string.resize(init_string.size() + simdjson::SIMDJSON_PADDING);
+    simdjson::padded_string_view padded_view{init_string.data(), 5, init_string.size()};
+    simdjson::ondemand::parser parser;
+    simdjson::ondemand::document doc;
+    ASSERT_SUCCESS(parser.iterate(padded_view).get(doc));
+    std::string_view abc;
+    ASSERT_SUCCESS(doc.get_string().get(abc));
+    ASSERT_EQUAL(abc, "abc");
+    ASSERT_SUCCESS(parser.iterate(padded_view).get(doc));
+    std::string_view raw;
+    ASSERT_SUCCESS(doc.raw_json().get(raw));
+    ASSERT_EQUAL(raw, "\"abc\"");
+    TEST_SUCCEED();
+  }
+
  simdjson_warn_unused bool big_integer() {
    TEST_START();
    simdjson::ondemand::parser parser;
@@ -620,6 +655,8 @@ namespace misc_tests {

  bool run() {
    return
+           issue2322() &&
+           issue2312() &&
 #if SIMDJSON_EXCEPTIONS
           issue2199() &&
 #endif
@@ -8,7 +8,15 @@
 #endif
 using namespace std;
 using namespace simdjson;
-using error_code=simdjson::error_code;
+using error_code = simdjson::error_code;
+
+bool simplepad() {
+  std::string json = "[1]";
+  ondemand::parser parser;
+  ondemand::document doc;
+  auto error = parser.iterate(simdjson::pad(json)).get(doc);
+  return error == SUCCESS;
+}

 bool string1() {
  const char * data = "my data"; // 7 bytes
@@ -1918,6 +1926,7 @@ bool run() {
    && using_the_parsed_json_4()
    && using_the_parsed_json_5()
 #endif
+    && simplepad()
    && using_the_parsed_json_6()
    && json_pointer_simple()
    && json_pointer_unicode()
@@ -184,8 +184,6 @@ else:
       if(detectedreadme != toversionstring(*newversion)):
           print(colored(255, 0, 0, "Consider updating the readme link to "+toversionstring(*newversion)))

-
-
 print("Please run the tests before issuing a release. \n")
 print("to issue release, enter \n git commit -a && git push  &&  git tag -a v"+toversionstring(*newversion)+" -m \"version "+toversionstring(*newversion)+"\" &&  git push --tags \n")
Author	SHA1	Message	Date
Daniel Lemire	5b51413c27	template for	2025-03-17 20:40:56 -04:00
Daniel Lemire	846ae99d2a	add static reflection benchmark to 'large random' benchmark and allows (#2349 ) deserialization (with static reflection) from objects and arrays. Co-authored-by: Daniel Lemire <dlemire@lemire.me>	2025-03-17 18:02:41 -04:00
Daniel Lemire	bb39fbbb44	removing dead code	2025-03-13 09:37:46 -04:00
Daniel Lemire	0fa65afcab	fancy casting	2025-03-07 20:46:43 -05:00
Daniel Lemire	22477f3471	update	2025-03-07 16:41:19 -05:00
Daniel Lemire	d6145d4669	adding a cast	2025-03-07 14:33:42 -05:00
Daniel Lemire	cbb6a0d02a	updating amal	2025-03-07 11:57:15 -05:00
Daniel Lemire	de312b5fbb	minor simplification	2025-03-07 09:54:50 -05:00
Daniel Lemire	5c644443ba	Merge branch 'master' into json_builder_init	2025-03-06 18:45:58 -05:00
Daniel Lemire	6f014f1ee5	Merge branch 'json_builder_init' of https://github.com/simdjson/simdjson into json_builder_init	2025-03-06 18:24:10 -05:00
Daniel Lemire	9222fb9f9a	minor tweak	2025-03-06 18:24:02 -05:00
Daniel Lemire	2ddf85de1f	various minor fixes	2025-03-06 16:34:11 -05:00
Daniel Lemire	9370abb17b	tuning	2025-03-06 16:18:10 -05:00
Dirk Eddelbuettel	f3b034ac38	Address 'whitespace in literal' decreation warning from clang++-20	2025-03-06 14:28:01 -06:00
Daniel Lemire	2c05f5b1b0	non-functional benchmarks (#2342 ) * non-functional benchmarks * Fix typo * various fixes * tweaking --------- Co-authored-by: Daniel Lemire <dlemire@lemire.me> Co-authored-by: Francisco Geiman Thiesen <franciscogthiesen@gmail.com>	2025-03-06 12:05:53 -05:00
Daniel Lemire	9c2e8a8f39	upgrading uraimo/run-on-arch-action	2025-03-01 14:32:13 -05:00
Daniel Lemire	7ef00629af	saving	2025-02-28 22:28:00 -05:00
Daniel Lemire	cd7e7c7fb7	rename to 'append'	2025-02-28 21:28:38 -05:00
Daniel Lemire	a30102ae8e	saving	2025-02-28 21:28:13 -05:00
Daniel Lemire	69a98fbede	adding documentation for string_builder	2025-02-28 15:25:21 -05:00
Daniel Lemire	7c58616a76	guarding the tests	2025-02-27 19:48:56 -05:00
Francisco Geiman Thiesen	054a2032cc	Referncing a later version of rapidjson that fixed the issue related with assignment attempt of a const variable for GenericStringRef class.	2025-02-25 05:43:55 +00:00
Francisco Geiman Thiesen	616faf6340	Adding specialization for smart pointers for basic types. I think it is highly likely that this can be done in a more generic way.	2025-02-21 23:26:28 +00:00
yun	dfa43f6cdd	doc: replace ndjson[dot]org with ndjson spec (#2340 ) the `ndjson[dot]org` expired, and point to incorrect website with malware. more in https://github.com/ndjson/ndjson.github.io/issues/24 follow up #2234	2025-02-21 09:07:39 +00:00
Francisco Geiman Thiesen	05415534fe	Adding support for smart pointers of user defined types.	2025-02-21 00:31:07 +00:00
Daniel Lemire	797e61742c	release bump	2025-02-14 16:12:28 -05:00
Daniel Lemire	f289412e0a	fixing performance issue under Zen 4 processors (#2335 ) * fixing performance issue under Zen 4 processors * trying something else --------- Co-authored-by: Daniel Lemire <dlemire@lemire.me>	2025-02-14 16:11:36 -05:00
Daniel Lemire	7bd79b4445	Update README.md	2025-02-14 16:03:01 -05:00
Daniel Lemire	497d2ce6f3	automated	2025-02-14 00:21:23 -05:00
Daniel Lemire	ac405de81a	patching the automated deserialization.	2025-02-13 23:35:59 -05:00
Francisco Geiman Thiesen	12bae04b00	Updating simdjson singleheader	2025-02-13 08:37:02 -08:00
Francisco Geiman Thiesen	c2b18fb28b	Adding draft of static reflection based deserialization	2025-02-13 08:35:33 -08:00
Daniel Lemire	29212b53cd	simplify	2025-02-12 10:49:08 -05:00
Daniel Lemire	8b77325a40	reordering.	2025-02-11 21:07:37 -05:00
Daniel Lemire	fc15add8f3	Sketch of builder	2025-02-11 18:19:36 -05:00
Daniel Lemire	078e2c9073	patch release 3.12.1	2025-02-11 13:46:03 -05:00
Daniel Lemire	d7b6b20511	creating zip files.	2025-02-11 13:43:34 -05:00
Daniel Lemire	4024d70596	various pedantic fixes	2025-02-10 14:26:40 -05:00
Francisco Geiman Thiesen	cbf08bda78	Fixing unused argument problem and updating the singleheader file	2025-02-09 20:25:08 -08:00
Francisco Geiman Thiesen	a7d4a4e373	Merge pull request #2330 from simdjson/json_builder_init_constexpr fix for pre C++17 if constexpr	2025-02-05 16:09:26 -08:00
Daniel Lemire	6a4e445960	fix for pre C++17 if constexpr	2025-02-05 18:45:58 -05:00
Daniel Lemire	b47cde21b2	updating single header	2025-02-04 17:43:28 -05:00
Daniel Lemire	98c37ac3d6	applying a couple of fixes	2025-02-04 17:42:04 -05:00
Francisco Geiman Thiesen	d7152b8759	Merging with master.	2025-02-02 18:00:57 -08:00
Francisco Geiman Thiesen	3dfa83ec2f	Merge branch 'master' into json_builder_init, since this branch was created more than 2 months ago.	2025-02-02 17:50:45 -08:00
Daniel Lemire	dbea3bbd62	Update README.md	2025-01-29 11:48:36 -05:00
Daniel Lemire	e422933414	release 3.12.0	2025-01-27 20:35:57 -05:00
Daniel Lemire	de4d69b367	Introducing dual licensing (#2328 ) * Introducing dual licensing * adding missing file	2025-01-27 20:34:35 -05:00
Paul Dreik	b8675a7f7b	fix fuzzing when running on icelake (#2327 )	2025-01-26 05:36:33 +01:00
Paul Dreik	5642bb93a4	fix fuzzer CI job (#2324 )	2025-01-16 13:33:53 -05:00
Daniel Lemire	1b23a77e03	3.11.6	2025-01-14 21:33:29 -05:00
Daniel Lemire	57699bfed8	release candidate (#2323 )	2025-01-09 11:01:48 -05:00
Daniel Lemire	648303b26a	typo	2025-01-08 21:29:11 -05:00
Daniel Lemire	9008960e36	fixed comment	2025-01-08 20:35:30 -05:00
Daniel Lemire	8a9e8a1792	fixing issue 2322	2025-01-08 20:28:25 -05:00
Daniel Lemire	ba33e9e78f	release	2025-01-06 19:33:53 -05:00
Daniel Lemire	d98b351eef	let us be more careful with concepts, we require __cpp_concepts >= 201907L and check for old versions of Apple clang (#2321 ) * let us be more careful with concepts, we require __cpp_concepts >= 202002L * checking Apple version * let us be more specific * removing extra endif	2025-01-06 19:23:09 -05:00
Daniel Lemire	5488dca126	Accidentally, it appears that PPC64 was always disabled by default. (#2320 )	2025-01-03 11:01:04 -05:00
Daniel Lemire	7712ecf164	adding char bit check (pedantic) (#2316 )	2024-12-31 14:34:13 -05:00
Paul Dreik	2803ca3093	use clang 19 in fuzzer job (#2315 ) * use clang 19 in fuzzer job * fix syntax error in msys2-clang.yml	2024-12-22 15:00:58 -05:00
Daniel Lemire	e7f2463920	some tweaks	2024-12-17 16:27:31 -05:00
Daniel Lemire	5bfa0b098c	patch release 3.11.3 (#2313 ) * preparing patch release 3.11.3	2024-12-12 13:38:22 -05:00
Daniel Lemire	f7ba9cb11b	Update basics.md	2024-12-10 11:47:21 -05:00
Daniel Lemire	d4bf0cc7ec	sync	2024-12-09 21:36:43 -05:00
Daniel Lemire	2fbbea0b15	Merge branch 'master' of github.com:simdjson/simdjson	2024-12-09 21:36:12 -05:00
Daniel Lemire	c16486f702	release candidate 3.11.2	2024-12-09 21:35:21 -05:00
zhanglistar	f615112093	Disabling memory sanitizer with parse_string (#2310 )	2024-12-09 10:20:33 -05:00
Daniel Lemire	6bbcbfbb95	version 3.11.1	2024-12-07 11:13:00 -05:00
Valery Mironov	e6578fea39	Fix missing override (#2305 )	2024-12-07 11:12:25 -05:00
Joyee Cheung	6fb050d04e	fix: fix deprecation from -Wdeprecated-literal-operator (#2307 ) Otherwise simdjson doesn't build with V8's Node.js fork, which uses -Werror,-Wdeprecated-literal-operator and latest version of clang.	2024-12-07 11:12:14 -05:00
Daniel Lemire	b4242d3b4f	release candidate (#2304 )	2024-12-05 22:05:39 -05:00
Daniel Lemire	cbfe2d4a21	Update vs17-arm-ci.yml	2024-12-02 20:24:24 -05:00
halx99	79126ca323	fix: processor checks inconsistently problem (#2299 )	2024-12-02 20:23:28 -05:00
Daniel Lemire	3f87f958d7	documentation	2024-12-02 00:06:20 -05:00
Daniel Lemire	cab383e1de	Update README.md	2024-11-30 20:43:20 -05:00
Francisco Geiman Thiesen	db25f5d8e9	Fixing appeand_float typo (#2294 )	2024-11-29 08:10:14 -05:00
Daniel Lemire	9b314922a1	additional documentation	2024-11-08 11:53:34 -05:00
Daniel Lemire	587beae307	prevent int to pointer implicit conversion for operator[](const char *) (#2286 )	2024-11-01 18:11:43 -04:00
Daniel Lemire	f53981d945	Update dom.md	2024-11-01 12:23:35 -04:00
Daniel Lemire	41b4ffd6aa	Update basics.md	2024-11-01 12:15:40 -04:00
Daniel Lemire	6cd8a6d776	adding pad function (#2283 )	2024-10-29 21:26:01 -04:00