added missing 'auto'

removing <optional>, use concepts
Removing trailing whitespace.
2026-06-08 17:27:07 +00:00 · 2025-07-18 13:02:52 -04:00 · 2025-07-18 08:54:02 -04:00 · 2025-07-18 10:49:47 +00:00 · 2025-07-18 05:12:21 +00:00 · 2025-07-18 05:01:40 +00:00
104 changed files with 56886 additions and 153 deletions
@@ -45,6 +45,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)
@@ -100,7 +114,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(
@@ -109,6 +109,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.
@@ -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)
@@ -0,0 +1,618 @@
 #!/bin/bash
 # JSON Parsing Compilation Benchmark: Reflection Usage vs Manual Parsing
 # Compares compilation times when ACTUALLY USING reflection for parsing vs manual parsing
 # This measures the compile-time cost of reflection-based automatic deserialization
 set -e
 echo "=== simdjson Reflection Usage Compilation Benchmark ==="
 echo "Measuring compilation impact of ACTUALLY USING reflection for parsing"
 echo "Starting at: $(date)"
 echo
 echo "╔════════════════════════════════════════════════════════════════════════════╗"
 echo "║                              METHODOLOGY                                   ║"
 echo "╠════════════════════════════════════════════════════════════════════════════╣"
 echo "║                                                                            ║"
 echo "║ FAIR COMPARISON STRATEGY:                                                  ║"
 echo "║ This benchmark compares two DIFFERENT approaches to parsing the same JSON: ║"
 echo "║                                                                            ║"
 echo "║ • MANUAL PARSING: Traditional simdjson with explicit .get() calls          ║"
 echo "║   - Uses doc[\"field\"].get(variable) for each field                         ║"
 echo "║   - No reflection involved                                                 ║"
 echo "║                                                                            ║"
 echo "║ • REFLECTION PARSING: Automatic deserialization with reflection            ║"
 echo "║   - Uses doc.get<MyStruct>() for automatic field mapping                   ║"
 echo "║   - Relies on compile-time reflection to generate parsing code             ║"
 echo "║                                                                            ║"
 echo "║ WHAT WE'RE MEASURING:                                                      ║"
 echo "║ • Compile-time cost of reflection-based automatic deserialization          ║"
 echo "║ • Template instantiation overhead for reflection parsing                   ║"
 echo "║ • Code generation complexity from using reflection features                ║"
 echo "║                                                                            ║"
 echo "║ TEST SCENARIOS:                                                            ║"
 echo "║                                                                            ║"
 echo "║ 1. SIMPLE STRUCT: Basic fields (string, int, bool)                         ║"
 echo "║    - Measures baseline reflection overhead                                 ║"
 echo "║                                                                            ║"
 echo "║ 2. NESTED STRUCT: Multiple levels of nested objects                        ║"
 echo "║    - Measures reflection complexity scaling                                ║"
 echo "║                                                                            ║"
 echo "║ 3. COMPLEX STRUCT: Arrays, optional fields, mixed types                    ║"
 echo "║    - Measures real-world reflection usage impact                           ║"
 echo "║                                                                            ║"
 echo "║ WHY THIS IS MEANINGFUL:                                                    ║"
 echo "║ • Shows actual cost of using reflection features                           ║"
 echo "║ • Measures compile-time code generation overhead                           ║"
 echo "║ • Helps developers understand reflection's compilation impact              ║"
 echo "║ • Compares equivalent functionality implemented two different ways         ║"
 echo "║                                                                            ║"
 echo "╚════════════════════════════════════════════════════════════════════════════╝"
 echo
 # Configuration
 ITERATIONS=10
 JOBS=4
 # ───────────────────────────── BOX-PRINT HELPER ────────────────────────────
 BOX_WIDTH=74                               # characters between the pipes
 print_box_line() {                         # usage: print_box_line "text"
  printf "║ %-*s ║\n" "${BOX_WIDTH}" "$1"
 }
 # Function to test if a compiler supports reflection with debug output
 test_reflection_support() {
    local compiler="$1"
    echo "  → Testing compiler: $compiler"
    if [ ! -x "$compiler" ] && ! command -v "$compiler" >/dev/null 2>&1; then
        echo "  → Compiler not found or not executable"
        return 1
    fi
    # Check compiler version first
    echo "  → Compiler version: $("$compiler" --version 2>/dev/null | head -n1 || echo "version check failed")"
    # Simple test: check if compiler accepts reflection flags
    local test_file=$(mktemp /tmp/reflection_test_XXXXXX.cpp)
    cat > "$test_file" << 'EOF'
 int main() {
    return 0;
 }
 EOF
    echo "  → Testing basic reflection flags..."
    local test_exe=$(mktemp /tmp/reflection_test_XXXXXX)
    local basic_result=$("$compiler" -freflection -fexpansion-statements -std=c++26 "$test_file" -o "$test_exe" 2>&1)
    local basic_exit_code=$?
    if [ $basic_exit_code -ne 0 ]; then
        echo "  → Basic flags FAILED with exit code $basic_exit_code"
        echo "  → Error output: $basic_result"
        rm -f "$test_file" "$test_exe"
        return 1
    fi
    echo "  → Basic flags: OK"
    rm -f "$test_exe"
    # Test reflection syntax
    echo "  → Testing reflection syntax..."
    cat > "$test_file" << 'EOF'
 struct Test {
    int x;
 };
 int main() {
    auto refl = ^^Test;
    return 0;
 }
 EOF
    local syntax_result=$("$compiler" -freflection -fexpansion-statements -std=c++26 "$test_file" -o "$test_exe" 2>&1)
    local syntax_exit_code=$?
    if [ $syntax_exit_code -eq 0 ]; then
        echo "  → Reflection syntax: OK"
        echo "  → ✓ REFLECTION SUPPORT CONFIRMED"
        rm -f "$test_file" "$test_exe"
        return 0
    else
        echo "  → Reflection syntax FAILED with exit code $syntax_exit_code"
        echo "  → Error output: $syntax_result"
        rm -f "$test_file" "$test_exe"
        return 1
    fi
 }
 # Find a compiler with reflection support
 echo "Searching for clang++ with reflection support..."
 REFLECTION_CXX=""
 REFLECTION_CC=""
 # List of potential clang++ locations to check
 POTENTIAL_COMPILERS=(
    "/usr/local/bin/clang++"
    "/opt/clang/bin/clang++"
    "/usr/bin/clang++"
    "clang++"
 )
 # If CXX is already set, test it first
 if [ -n "$CXX" ]; then
    echo "Testing user-specified compiler: $CXX"
    if test_reflection_support "$CXX"; then
        REFLECTION_CXX="$CXX"
        echo "✓ User-specified compiler supports reflection: $CXX"
    else
        echo "✗ User-specified compiler does not support reflection: $CXX"
        echo "Will search for alternative..."
    fi
 fi
 # If we don't have a working compiler yet, search for one
 if [ -z "$REFLECTION_CXX" ]; then
    for compiler in "${POTENTIAL_COMPILERS[@]}"; do
        echo "Testing: $compiler"
        if test_reflection_support "$compiler"; then
            REFLECTION_CXX="$compiler"
            echo "✓ Found reflection-enabled compiler: $compiler"
            break
        else
            echo "✗ No reflection support: $compiler"
        fi
    done
 fi
 # Check if we found a working compiler
 if [ -z "$REFLECTION_CXX" ]; then
    echo
    echo "╔════════════════════════════════════════════════════════════════════════════╗"
    echo "║                                 ERROR                                      ║"
    echo "╠════════════════════════════════════════════════════════════════════════════╣"
    echo "║                                                                            ║"
    echo "║ No clang++ compiler with reflection support found!                        ║"
    echo "║                                                                            ║"
    echo "║ This benchmark requires a compiler that supports C++26 reflection.        ║"
    echo "║                                                                            ║"
    echo "║ Options:                                                                   ║"
    echo "║ 1. Use the Docker container: ./p2996/run_docker.sh                        ║"
    echo "║ 2. Build clang with reflection from: https://github.com/bloomberg/clang-p2996 ║"
    echo "║ 3. Set CXX environment variable to point to reflection-enabled clang++    ║"
    echo "║                                                                            ║"
    echo "║ Example: CXX=/path/to/reflection-clang++ ./benchmark_script.sh            ║"
    echo "║                                                                            ║"
    echo "╚════════════════════════════════════════════════════════════════════════════╝"
    exit 1
 fi
 # Set the compilers
 export CXX="$REFLECTION_CXX"
 # Find corresponding C compiler
 if [ -n "$CC" ]; then
    REFLECTION_CC="$CC"
 elif [ "$REFLECTION_CXX" = "/usr/local/bin/clang++" ]; then
    REFLECTION_CC="/usr/local/bin/clang"
 elif [ "$REFLECTION_CXX" = "/opt/clang/bin/clang++" ]; then
    REFLECTION_CC="/opt/clang/bin/clang"
 elif [ "$REFLECTION_CXX" = "/usr/bin/clang++" ]; then
    REFLECTION_CC="/usr/bin/clang"
 else
    REFLECTION_CC="clang"
 fi
 export CC="$REFLECTION_CC"
 echo
 echo "Using reflection-enabled compiler: $($CXX --version | head -n1)"
 echo "Using C compiler: $($CC --version | head -n1)"
 echo
 # Function to create manual parsing test
 create_manual_parsing_test() {
    local test_name="$1"
    local struct_complexity="$2"
    cat > "${test_name}_manual.cpp" << 'EOF'
 #include <simdjson.h>
 #include <iostream>
 #include <string>
 #include <vector>
 #include <optional>
 // Test structures
 struct Person {
    std::string name;
    int age;
    bool active;
 };
 struct Address {
    std::string street;
    std::string city;
    int zipcode;
 };
 struct Employee {
    Person person;
    Address address;
    std::vector<std::string> skills;
    std::optional<std::string> department;
    double salary;
 };
 // Manual parsing functions
 bool parse_person_manual(simdjson::ondemand::value& val, Person& person) {
    auto obj = val.get_object();
    if (obj.error()) return false;
    for (auto field : obj) {
        std::string_view key = field.unescaped_key();
        if (key == "name") {
            std::string_view name_val;
            if (field.value().get(name_val)) return false;
            person.name = name_val;
        } else if (key == "age") {
            if (field.value().get(person.age)) return false;
        } else if (key == "active") {
            if (field.value().get(person.active)) return false;
        }
    }
    return true;
 }
 bool parse_address_manual(simdjson::ondemand::value& val, Address& address) {
    auto obj = val.get_object();
    if (obj.error()) return false;
    for (auto field : obj) {
        std::string_view key = field.unescaped_key();
        if (key == "street") {
            std::string_view street_val;
            if (field.value().get(street_val)) return false;
            address.street = street_val;
        } else if (key == "city") {
            std::string_view city_val;
            if (field.value().get(city_val)) return false;
            address.city = city_val;
        } else if (key == "zipcode") {
            if (field.value().get(address.zipcode)) return false;
        }
    }
    return true;
 }
 bool parse_employee_manual(simdjson::ondemand::document& doc, Employee& employee) {
    auto obj = doc.get_object();
    if (obj.error()) return false;
    for (auto field : obj) {
        std::string_view key = field.unescaped_key();
        if (key == "person") {
            auto person_val = field.value();
            if (!parse_person_manual(person_val, employee.person)) return false;
        } else if (key == "address") {
            auto addr_val = field.value();
            if (!parse_address_manual(addr_val, employee.address)) return false;
        } else if (key == "skills") {
            auto skills_array = field.value().get_array();
            if (skills_array.error()) return false;
            for (auto skill : skills_array) {
                std::string_view skill_val;
                if (skill.get(skill_val)) return false;
                employee.skills.emplace_back(skill_val);
            }
        } else if (key == "department") {
            std::string_view dept_val;
            if (!field.value().get(dept_val)) {
                employee.department = dept_val;
            }
        } else if (key == "salary") {
            if (field.value().get(employee.salary)) return false;
        }
    }
    return true;
 }
 int main() {
    simdjson::ondemand::parser parser;
    std::string json_str = R"({
        "person": {
            "name": "John Doe",
            "age": 30,
            "active": true
        },
        "address": {
            "street": "123 Main St",
            "city": "Anytown",
            "zipcode": 12345
        },
        "skills": ["C++", "JSON", "Programming"],
        "department": "Engineering",
        "salary": 85000.50
    })";
    simdjson::ondemand::document doc;
    auto error = parser.iterate(simdjson::pad(json_str)).get(doc);
    if (error) {
        std::cerr << "Parse error" << std::endl;
        return 1;
    }
    Employee employee;
    if (!parse_employee_manual(doc, employee)) {
        std::cerr << "Manual parsing failed" << std::endl;
        return 1;
    }
    std::cout << "Manual parsing successful: " << employee.person.name
              << ", age " << employee.person.age << std::endl;
    return 0;
 }
 EOF
 }
 # Function to create reflection parsing test
 create_reflection_parsing_test() {
    local test_name="$1"
    local struct_complexity="$2"
    cat > "${test_name}_reflection.cpp" << 'EOF'
 #include <simdjson.h>
 #include <iostream>
 #include <string>
 #include <vector>
 #include <optional>
 // Test structures (same as manual version)
 struct Person {
    std::string name;
    int age;
    bool active;
 };
 struct Address {
    std::string street;
    std::string city;
    int zipcode;
 };
 struct Employee {
    Person person;
    Address address;
    std::vector<std::string> skills;
    std::optional<std::string> department;
    double salary;
 };
 int main() {
    simdjson::ondemand::parser parser;
    std::string json_str = R"({
        "person": {
            "name": "John Doe",
            "age": 30,
            "active": true
        },
        "address": {
            "street": "123 Main St",
            "city": "Anytown",
            "zipcode": 12345
        },
        "skills": ["C++", "JSON", "Programming"],
        "department": "Engineering",
        "salary": 85000.50
    })";
    simdjson::ondemand::document doc;
    auto error = parser.iterate(simdjson::pad(json_str)).get(doc);
    if (error) {
        std::cerr << "Parse error" << std::endl;
        return 1;
    }
    // Use reflection-based automatic deserialization
    Employee employee;
    auto result = doc.get<Employee>();
    if (result.error()) {
        std::cerr << "Reflection parsing failed" << std::endl;
        return 1;
    }
    employee = result.value();
    std::cout << "Reflection parsing successful: " << employee.person.name
              << ", age " << employee.person.age << std::endl;
    return 0;
 }
 EOF
 }
 # Function to time compilation of parsing approach
 time_parsing_compilation() {
    local description="$1"
    local test_file="$2"
    local use_reflection="$3"
    local iteration="$4"
    echo "[$iteration] $description"
    # Clean build
    rm -rf build_parsing_test
    mkdir build_parsing_test
    cd build_parsing_test
    # Copy test file
    cp "../$test_file" .
    echo "  Configuring..."
    if [ "$use_reflection" = "true" ]; then
        cmake -DCMAKE_CXX_COMPILER="$CXX" \
              -DSIMDJSON_DEVELOPER_MODE=ON \
              -DSIMDJSON_STATIC_REFLECTION=ON \
              -DBUILD_SHARED_LIBS=OFF \
              ../.. >/dev/null 2>&1
    else
        cmake -DCMAKE_CXX_COMPILER="$CXX" \
              -DSIMDJSON_DEVELOPER_MODE=ON \
              -DSIMDJSON_STATIC_REFLECTION=OFF \
              -DBUILD_SHARED_LIBS=OFF \
              ../.. >/dev/null 2>&1
    fi
    echo "  Building simdjson..."
    cmake --build . --target simdjson >/dev/null 2>&1
    echo "  Compiling parsing test..."
    # Time just the test compilation
    start_time=$(date +%s.%N)
    "$CXX" -std=c++17 -I../../include "$test_file" -L. -lsimdjson -o parsing_test >/dev/null 2>&1
    end_time=$(date +%s.%N)
    # Calculate time duration
    time_taken=$(echo "$end_time $start_time" | awk '{printf "%.3f", $1 - $2}')
    echo "  Completed in: ${time_taken}s"
    cd ..
    rm -rf build_parsing_test
    echo "$time_taken"
 }
 # Create test files
 echo "Creating test files..."
 create_manual_parsing_test "complex" "complex"
 create_reflection_parsing_test "complex" "complex"
 # Arrays to store times
 times_manual=""
 times_reflection=""
 echo
 echo "=== MANUAL PARSING COMPILATION ==="
 echo "Testing traditional simdjson parsing with explicit .get() calls"
 echo
 for i in $(seq 1 $ITERATIONS); do
    time_result=$(time_parsing_compilation "Compiling manual parsing test" "complex_manual.cpp" "false" "$i" | tail -n1)
    times_manual="$times_manual $time_result"
 done
 echo
 echo "=== REFLECTION PARSING COMPILATION ==="
 echo "Testing automatic deserialization with doc.get<Struct>()"
 echo
 for i in $(seq 1 $ITERATIONS); do
    time_result=$(time_parsing_compilation "Compiling reflection parsing test" "complex_reflection.cpp" "true" "$i" | tail -n1)
    times_reflection="$times_reflection $time_result"
 done
 echo
 echo "╔════════════════════════════════════════════════════════════════════════════╗"
 echo "║           REFLECTION USAGE COMPILATION RESULTS                             ║"
 echo "╠════════════════════════════════════════════════════════════════════════════╣"
 echo "║                                                                            ║"
 echo "║ MANUAL PARSING (explicit .get() calls):                                    ║"
 count=1
 for t in $times_manual; do
    if [[ "$t" =~ ^[0-9]+\.?[0-9]*$ ]]; then
        line=$(printf "Run %2d: %7.3f seconds" "$count" "$t")
        print_box_line "$line"
        count=$((count + 1))
    fi
 done
 echo "║                                                                            ║"
 echo "║ REFLECTION PARSING (automatic doc.get<Struct>()):                          ║"
 count=1
 for t in $times_reflection; do
    if [[ "$t" =~ ^[0-9]+\.?[0-9]*$ ]]; then
        line=$(printf "Run %2d: %7.3f seconds" "$count" "$t")
        print_box_line "$line"
        count=$((count + 1))
    fi
 done
 echo "╚════════════════════════════════════════════════════════════════════════════╝"
 echo
 echo "╔════════════════════════════════════════════════════════════════════════════╗"
 echo "║                              ANALYSIS SUMMARY                              ║"
 echo "╠════════════════════════════════════════════════════════════════════════════╣"
 echo "║                                                                            ║"
 # Calculate averages and percentages - filter to only numeric values first
 manual_numbers=""
 reflection_numbers=""
 for t in $times_manual; do
    if [[ "$t" =~ ^[0-9]+\.?[0-9]*$ ]]; then
        manual_numbers="$manual_numbers $t"
    fi
 done
 for t in $times_reflection; do
    if [[ "$t" =~ ^[0-9]+\.?[0-9]*$ ]]; then
        reflection_numbers="$reflection_numbers $t"
    fi
 done
 if [ -n "$manual_numbers" ] && [ -n "$reflection_numbers" ]; then
    manual_avg=$(echo "$manual_numbers" | awk '{sum=0; for(i=1;i<=NF;i++) sum+=$i; print sum/NF}')
    reflection_avg=$(echo "$reflection_numbers" | awk '{sum=0; for(i=1;i<=NF;i++) sum+=$i; print sum/NF}')
    overhead=$(echo "$reflection_avg $manual_avg" | awk '{printf "%.3f", $1 - $2}')
    if [ $(echo "$manual_avg > 0" | awk '{print ($1 > 0)}') -eq 1 ]; then
        percent=$(echo "$reflection_avg $manual_avg" | awk '{printf "%.1f", ($1 - $2) / $2 * 100}')
    else
        percent="0"
    fi
    print_box_line "MANUAL PARSING RESULTS:"
    print_box_line "$(printf "Average compilation time: %.3fs" "$manual_avg")"
    print_box_line ""
    print_box_line "REFLECTION PARSING RESULTS:"
    print_box_line "$(printf "Average compilation time: %.3fs" "$reflection_avg")"
    print_box_line ""
    print_box_line "REFLECTION OVERHEAD:"
    print_box_line "$(printf "Additional time: %.3fs (%+.1f%%)" "$overhead" "$percent")"
    print_box_line ""
 else
    echo "║ ERROR: Could not extract valid timing data                                 ║"
    echo "║ Manual times: $times_manual"
    echo "║ Reflection times: $times_reflection"
    echo "║                                                                            ║"
 fi
 echo "╠════════════════════════════════════════════════════════════════════════════╣"
 echo "║                              INTERPRETATION                                ║"
 echo "╠════════════════════════════════════════════════════════════════════════════╣"
 echo "║                                                                            ║"
 echo "║ WHAT THESE RESULTS SHOW:                                                   ║"
 echo "║                                                                            ║"
 echo "║ • COMPILE-TIME COST: How much longer reflection parsing takes to compile   ║"
 echo "║   - Higher % = more expensive template instantiation and codegen           ║"
 echo "║                                                                            ║"
 echo "║ • CODE GENERATION OVERHEAD: Reflection creates parsing code at compile     ║"
 echo "║   time, which requires more template processing than manual parsing        ║"
 echo "║                                                                            ║"
 echo "║ • DEVELOPER TRADE-OFF: Reflection provides automatic deserialization       ║"
 echo "║   but at the cost of increased compilation time                            ║"
 echo "║                                                                            ║"
 echo "║ EVALUATION:                                                                ║"
 echo "║ • Low overhead (0-20%): Reflection is compile-time efficient               ║"
 echo "║ • Medium overhead (20-50%): Noticeable but potentially acceptable          ║"
 echo "║ • High overhead (50%+): Significant compilation cost for reflection        ║"
 echo "║                                                                            ║"
 echo "║ REAL-WORLD IMPACT:                                                         ║"
 echo "║ • Small projects: Absolute time matters more than percentage               ║"
 echo "║ • Large projects: Percentage overhead compounds across many files          ║"
 echo "║ • CI/CD pipelines: Longer builds affect development velocity               ║"
 echo "║                                                                            ║"
 echo "╚════════════════════════════════════════════════════════════════════════════╝"
 # Clean up test files
 rm -f complex_manual.cpp complex_reflection.cpp
 echo
 echo "Completed at: $(date)"
@@ -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,29 @@ 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);
    if(auto e = doc.get_array().get<std::vector<point>>(result); e) { return false; }
    // 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 the benchmark executable targets
 add_subdirectory(twitter_benchmark)
 add_subdirectory(citm_catalog_benchmark)
@@ -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,14 @@
 add_executable(benchmark_serialization_citm_catalog benchmark_serialization_citm_catalog.cpp)
 # Link with Rust benchmarking code if available
 if(TARGET serde-benchmark)
    message(STATUS "serde-benchmark target was created. Linking CITM catalog benchmark with serde-benchmark.")
    target_link_libraries(benchmark_serialization_citm_catalog PRIVATE serde-benchmark)
    target_compile_definitions(benchmark_serialization_citm_catalog PRIVATE SIMDJSON_RUST_VERSION="${Rust_VERSION}")
 endif()
 target_link_libraries(benchmark_serialization_citm_catalog PRIVATE simdjson::simdjson nlohmann_json)
 target_link_libraries(benchmark_serialization_citm_catalog PRIVATE reflectcpp)
 target_compile_definitions(benchmark_serialization_citm_catalog PRIVATE SIMDJSON_BENCH_CPP_REFLECT=1)
 target_compile_definitions(benchmark_serialization_citm_catalog PRIVATE JSON_FILE="${BENCH_CITM_JSON}")
@@ -0,0 +1,177 @@
 #include <cassert>
 #include <cstdlib>
 #include <ctime>
 #include <format>
 #include <fstream>
 #include <iostream>
 #include <nlohmann/json.hpp>
 #include <simdjson.h>
 #include <string>
 #include "citm_catalog_data.h"
 #include "nlohmann_citm_catalog_data.h"
 #include "../benchmark_utils/benchmark_helper.h"
 #if SIMDJSON_BENCH_CPP_REFLECT
 #include <rfl.hpp>
 #include <rfl/json.hpp>
 void bench_reflect_cpp(CitmCatalog &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::CitmCatalog *data) {
  const char * output = serde_benchmark::str_from_citm(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_citm(data);
                 measured_volume = strlen(output);
                 if (measured_volume != output_volume) {
                   printf("mismatch\n");
                 }
                 serde_benchmark::free_str(const_cast<char*>(output));
               }));
  serde_benchmark::free_str(const_cast<char*>(output));
 }
 #endif // SIMDJSON_RUST_VERSION
 void bench_nlohmann(CitmCatalog &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");
                 }
               }));
 }
 void bench_simdjson_static_reflection(CitmCatalog &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");
                 }
               }));
 }
 std::string read_file(const std::string &file_path, size_t read_size = 65536) {
  std::ifstream stream(file_path, std::ios::binary);
  if(!stream) {
    std::cerr << "Could not open file '" << file_path << "'" << std::endl;
    exit(EXIT_FAILURE);
  }
  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;
 }
 // Function to check if benchmark name contains filter substring
 bool matches_filter(const std::string& benchmark_name, const std::string& filter) {
  return filter.empty() || benchmark_name.find(filter) != std::string::npos;
 }
 int main(int argc, char* argv[]) {
  std::string filter;
  // Parse command-line arguments
  for (int i = 1; i < argc; ++i) {
      if (strcmp(argv[i], "-f") == 0 || strcmp(argv[i], "--filter") == 0) {
          if (i + 1 < argc) {
              filter = argv[++i];
          } else {
              std::cerr << "Error: -f/--filter requires an argument" << std::endl;
              return EXIT_FAILURE;
          }
      }
  }
  // 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;
  }
  CitmCatalog my_struct;
  if(doc.get<CitmCatalog>().get(my_struct)) {
    std::cerr << "Error loading CitmCatalog!" << std::endl;
    return EXIT_FAILURE;
  }
  // Benchmarking the serialization
  if (matches_filter("nlohmann", filter)) {
    bench_nlohmann(my_struct);
  }
  if (matches_filter("simdjson_static_reflection", filter)) {
    bench_simdjson_static_reflection(my_struct);
  }
 #ifdef SIMDJSON_RUST_VERSION
  if (matches_filter("rust", filter)) {
    printf("# WARNING: The Rust benchmark may not be directly comparable since it does not use an equivalent data structure.\n");
    // Create a Rust-compatible CitmCatalog structure from the JSON string
    serde_benchmark::CitmCatalog* rust_data =
      serde_benchmark::citm_from_str(json_str.c_str(), json_str.size());
    if (rust_data == nullptr) {
      printf("# Failed to initialize Rust data structure\n");
    } else {
      bench_rust(rust_data);
      serde_benchmark::free_citm(rust_data);
    }
  }
 #endif
 #if SIMDJSON_BENCH_CPP_REFLECT
  if (matches_filter("reflect_cpp", filter)) {
    bench_reflect_cpp(my_struct);
  }
 #endif
  return EXIT_SUCCESS;
 }
@@ -0,0 +1,82 @@
 #ifndef CITM_CATALOG_DATA_H
 #define CITM_CATALOG_DATA_H
 #include <string>
 #include <vector>
 #include <map>
 struct Area {
  int64_t id;
  std::string name;
  int64_t parent;
  std::vector<int64_t> childAreas;
  bool operator==(const Area &other) const = default;
 };
 struct AudienceSubCategory {
  int64_t id;
  std::string name;
  int64_t parent;
  bool operator==(const AudienceSubCategory &other) const = default;
 };
 struct Event {
  int64_t id;
  std::string name;
  std::string description;
  int64_t subTopic;
  int64_t topic;
  std::vector<int64_t> audience;
  bool operator==(const Event &other) const = default;
 };
 struct Performance {
  int64_t id;
  std::string name;
  int64_t event;
  std::string start;
  int64_t venueCode;
  bool operator==(const Performance &other) const = default;
 };
 struct SeatCategory {
  int64_t id;
  std::string name;
  std::vector<int64_t> areas;
  bool operator==(const SeatCategory &other) const = default;
 };
 struct SubTopic {
  int64_t id;
  std::string name;
  int64_t parent;
  bool operator==(const SubTopic &other) const = default;
 };
 struct Topic {
  int64_t id;
  std::string name;
  bool operator==(const Topic &other) const = default;
 };
 struct Venue {
  int64_t id;
  std::string name;
  int64_t address;
  bool operator==(const Venue &other) const = default;
 };
 struct CitmCatalog {
  std::map<std::string, Area> areas;
  std::map<std::string, AudienceSubCategory> audienceSubCategory;
  std::map<std::string, Event> events;
  std::map<std::string, Performance> performances;
  std::map<std::string, SeatCategory> seatCategory;
  std::map<std::string, SubTopic> subTopic;
  std::map<std::string, Topic> topic;
  std::map<std::string, Venue> venue;
  bool operator==(const CitmCatalog &other) const = default;
 };
 #endif
@@ -0,0 +1,171 @@
 // nlohmann_citm_catalog_data.h
 #ifndef NLOHMANN_CITM_CATALOG_DATA_H
 #define NLOHMANN_CITM_CATALOG_DATA_H
 #include "citm_catalog_data.h"
 #include <nlohmann/json.hpp>
 #include <string>
 using json = nlohmann::json;
 // ---- Area ----
 inline void to_json(json &j, const Area &a) {
    j = json{
      {"id", a.id},
      {"name", a.name},
      {"parent", a.parent},
      {"childAreas", a.childAreas}
    };
 }
 inline void from_json(const json &j, Area &a) {
    j.at("id").get_to(a.id);
    j.at("name").get_to(a.name);
    j.at("parent").get_to(a.parent);
    j.at("childAreas").get_to(a.childAreas);
 }
 // ---- AudienceSubCategory ----
 inline void to_json(json &j, const AudienceSubCategory &asc) {
    j = json{
      {"id", asc.id},
      {"name", asc.name},
      {"parent", asc.parent}
    };
 }
 inline void from_json(const json &j, AudienceSubCategory &asc) {
    j.at("id").get_to(asc.id);
    j.at("name").get_to(asc.name);
    j.at("parent").get_to(asc.parent);
 }
 // ---- Event ----
 inline void to_json(json &j, const Event &e) {
    j = json{
      {"id", e.id},
      {"name", e.name},
      {"description", e.description},
      {"subTopic", e.subTopic},
      {"topic", e.topic},
      {"audience", e.audience}
    };
 }
 inline void from_json(const json &j, Event &e) {
    j.at("id").get_to(e.id);
    j.at("name").get_to(e.name);
    j.at("description").get_to(e.description);
    j.at("subTopic").get_to(e.subTopic);
    j.at("topic").get_to(e.topic);
    j.at("audience").get_to(e.audience);
 }
 // ---- Performance ----
 inline void to_json(json &j, const Performance &p) {
    j = json{
      {"id", p.id},
      {"name", p.name},
      {"event", p.event},
      {"start", p.start},
      {"venueCode", p.venueCode}
    };
 }
 inline void from_json(const json &j, Performance &p) {
    j.at("id").get_to(p.id);
    j.at("name").get_to(p.name);
    j.at("event").get_to(p.event);
    j.at("start").get_to(p.start);
    j.at("venueCode").get_to(p.venueCode);
 }
 // ---- SeatCategory ----
 inline void to_json(json &j, const SeatCategory &sc) {
    j = json{
      {"id", sc.id},
      {"name", sc.name},
      {"areas", sc.areas}
    };
 }
 inline void from_json(const json &j, SeatCategory &sc) {
    j.at("id").get_to(sc.id);
    j.at("name").get_to(sc.name);
    j.at("areas").get_to(sc.areas);
 }
 // ---- SubTopic ----
 inline void to_json(json &j, const SubTopic &st) {
    j = json{
      {"id", st.id},
      {"name", st.name},
      {"parent", st.parent}
    };
 }
 inline void from_json(const json &j, SubTopic &st) {
    j.at("id").get_to(st.id);
    j.at("name").get_to(st.name);
    j.at("parent").get_to(st.parent);
 }
 // ---- Topic ----
 inline void to_json(json &j, const Topic &t) {
    j = json{
      {"id", t.id},
      {"name", t.name}
    };
 }
 inline void from_json(const json &j, Topic &t) {
    j.at("id").get_to(t.id);
    j.at("name").get_to(t.name);
 }
 // ---- Venue ----
 inline void to_json(json &j, const Venue &v) {
    j = json{
      {"id", v.id},
      {"name", v.name},
      {"address", v.address}
    };
 }
 inline void from_json(const json &j, Venue &v) {
    j.at("id").get_to(v.id);
    j.at("name").get_to(v.name);
    j.at("address").get_to(v.address);
 }
 // ---- CitmCatalog ----
 inline void to_json(json &j, const CitmCatalog &c) {
    j = json{
      {"areas", c.areas},
      {"audienceSubCategory", c.audienceSubCategory},
      {"events", c.events},
      {"performances", c.performances},
      {"seatCategory", c.seatCategory},
      {"subTopic", c.subTopic},
      {"topic", c.topic},
      {"venue", c.venue}
    };
 }
 inline void from_json(const json &j, CitmCatalog &c) {
    j.at("areas").get_to(c.areas);
    j.at("audienceSubCategory").get_to(c.audienceSubCategory);
    j.at("events").get_to(c.events);
    j.at("performances").get_to(c.performances);
    j.at("seatCategory").get_to(c.seatCategory);
    j.at("subTopic").get_to(c.subTopic);
    j.at("topic").get_to(c.topic);
    j.at("venue").get_to(c.venue);
 }
 // Optional convenience functions for benchmarking
 inline std::string nlohmann_serialize(const CitmCatalog &catalog) {
    json j = catalog;
    return j.dump();
 }
 inline bool nlohmann_deserialize(const std::string &json_in, CitmCatalog &catalog) {
    try {
        catalog = json::parse(json_in);
        return false; // success
    } catch(...) {
        return true;  // failure
    }
 }
 #endif // NLOHMANN_CITM_CATALOG_DATA_H
@@ -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,482 @@
 extern crate serde;
 extern crate serde_json;
 extern crate libc;
 use libc::{c_char, size_t};
 use serde::{Serialize, Deserialize};
 use std::{collections::HashMap, ffi::CString, ptr, slice};
 use serde::de::{self, Deserializer};
 /******************************************************/
 /******************************************************/
 /**
 * 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 _);
 }
 // Functions associated with the CitmCatalog benchmark
 #[derive(Serialize, Deserialize)]
 pub struct Area {
    pub id: i64,
    pub name: Option<String>,  // Changed to Option
    pub parent: i64,
    #[serde(rename = "childAreas")]
    pub child_areas: Vec<i64>,
 }
 #[derive(Serialize, Deserialize)]
 pub struct AudienceSubCategory {
    pub id: i64,
    pub name: Option<String>,  // Changed to Option
    pub parent: i64,
 }
 #[derive(Serialize, Deserialize, Debug)]
 pub struct Event {
    #[serde(default)]
    pub description: Option<String>,
    pub id: i64,
    #[serde(default)]
    pub logo: Option<String>,
    #[serde(default)]
    pub name: Option<String>,
    #[serde(default)]
    pub subTopicIds: Vec<i64>,
    #[serde(default)]
    pub subjectCode: Option<String>,
    #[serde(default)]
    pub subtitle: Option<String>,
    #[serde(default)]
    pub topicIds: Vec<i64>,
    // Add a catch-all for any other fields
    #[serde(flatten)]
    pub extra: HashMap<String, serde_json::Value>,
 }
 #[derive(Serialize, Deserialize, Debug)]
 pub struct Performance {
    #[serde(default)]
    pub id: i64,
    #[serde(default)]
    pub name: Option<String>,
    #[serde(default)]
    pub event: i64,
    // This is the key fix - accept any JSON value type for timestamps
    // This allows both string dates and integer timestamps (line 3511)
    #[serde(default)]
    pub start: serde_json::Value,
    #[serde(rename = "venueCode")]
    pub venue_code: String,
    // Add a catch-all for any other fields
    #[serde(flatten)]
    pub extra: HashMap<String, serde_json::Value>,
 }
 #[derive(Serialize, Deserialize)]
 pub struct SeatCategory {
    pub id: i64,
    pub name: Option<String>,  // Changed to Option
    pub areas: Vec<i64>,
 }
 #[derive(Serialize, Deserialize)]
 pub struct SubTopic {
    pub id: i64,
    pub name: Option<String>,  // Changed to Option
    pub parent: i64,
 }
 #[derive(Serialize, Deserialize)]
 pub struct Topic {
    pub id: i64,
    pub name: Option<String>,  // Changed to Option
 }
 #[derive(Serialize, Deserialize)]
 pub struct Venue {
    pub id: i64,
    pub name: Option<String>,  // Changed to Option
    pub address: i64,
 }
 // Custom deserializers
 fn deserialize_string_to_area<'de, D>(deserializer: D) -> Result<HashMap<String, Area>, D::Error>
 where D: Deserializer<'de> {
    let string_map: HashMap<String, String> = HashMap::deserialize(deserializer)?;
    let mut result = HashMap::new();
    for (id, name) in string_map {
        let id_num = id.parse::<i64>().unwrap_or(0);
        result.insert(id.clone(), Area {
            id: id_num,
            name: Some(name),
            parent: 0,
            child_areas: Vec::new(),
        });
    }
    Ok(result)
 }
 fn deserialize_string_to_audience_subcategory<'de, D>(deserializer: D) -> Result<HashMap<String, AudienceSubCategory>, D::Error>
 where D: Deserializer<'de> {
    let string_map: HashMap<String, String> = HashMap::deserialize(deserializer)?;
    let mut result = HashMap::new();
    for (id, name) in string_map {
        let id_num = id.parse::<i64>().unwrap_or(0);
        result.insert(id.clone(), AudienceSubCategory {
            id: id_num,
            name: Some(name),
            parent: 0,
        });
    }
    Ok(result)
 }
 fn deserialize_string_to_seat_category<'de, D>(deserializer: D) -> Result<HashMap<String, SeatCategory>, D::Error>
 where D: Deserializer<'de> {
    let string_map: HashMap<String, String> = HashMap::deserialize(deserializer)?;
    let mut result = HashMap::new();
    for (id, name) in string_map {
        let id_num = id.parse::<i64>().unwrap_or(0);
        result.insert(id.clone(), SeatCategory {
            id: id_num,
            name: Some(name),
            areas: Vec::new(),
        });
    }
    Ok(result)
 }
 fn deserialize_string_to_subtopic<'de, D>(deserializer: D) -> Result<HashMap<String, SubTopic>, D::Error>
 where D: Deserializer<'de> {
    let string_map: HashMap<String, String> = HashMap::deserialize(deserializer)?;
    let mut result = HashMap::new();
    for (id, name) in string_map {
        let id_num = id.parse::<i64>().unwrap_or(0);
        result.insert(id.clone(), SubTopic {
            id: id_num,
            name: Some(name),
            parent: 0,
        });
    }
    Ok(result)
 }
 fn deserialize_string_to_topic<'de, D>(deserializer: D) -> Result<HashMap<String, Topic>, D::Error>
 where D: Deserializer<'de> {
    let string_map: HashMap<String, String> = HashMap::deserialize(deserializer)?;
    let mut result = HashMap::new();
    for (id, name) in string_map {
        let id_num = id.parse::<i64>().unwrap_or(0);
        result.insert(id.clone(), Topic {
            id: id_num,
            name: Some(name),
        });
    }
    Ok(result)
 }
 fn deserialize_string_to_venue<'de, D>(deserializer: D) -> Result<HashMap<String, Venue>, D::Error>
 where D: Deserializer<'de> {
    let string_map: HashMap<String, String> = HashMap::deserialize(deserializer)?;
    let mut result = HashMap::new();
    for (id, name) in string_map {
        result.insert(id.clone(), Venue {
            id: 0,
            name: Some(name),
            address: 0,
        });
    }
    Ok(result)
 }
 #[derive(Serialize, Deserialize, Debug)]
 pub struct CitmCatalog {
    #[serde(rename = "areaNames")]
    pub area_names: HashMap<String, String>,
    #[serde(rename = "audienceSubCategoryNames")]
    pub audience_subcategory_names: HashMap<String, String>,
    #[serde(default)]
    #[serde(rename = "blockNames")]
    pub block_names: HashMap<String, String>,
    pub events: HashMap<String, Event>,
    #[serde(default)]
    pub performances: Vec<Performance>,
    #[serde(rename = "seatCategoryNames")]
    pub seat_category_names: HashMap<String, String>,
    #[serde(rename = "subTopicNames")]
    pub subtopic_names: HashMap<String, String>,
    #[serde(default)]
    #[serde(rename = "subjectNames")]
    pub subject_names: HashMap<String, String>,
    #[serde(rename = "topicNames")]
    pub topic_names: HashMap<String, String>,
    #[serde(rename = "topicSubTopics")]
    pub topic_subtopics: HashMap<String, Vec<i64>>,
    #[serde(rename = "venueNames")]
    pub venue_names: HashMap<String, String>,
    // Catch-all for other fields
    #[serde(flatten)]
    pub extra: HashMap<String, serde_json::Value>,
 }
 /// Creates a CitmCatalog from a JSON string (UTF-8 encoded).
 #[no_mangle]
 pub unsafe extern "C" fn citm_from_str(
    raw_input: *const c_char,
    raw_input_length: usize
 ) -> *mut CitmCatalog {
    if raw_input.is_null() {
        eprintln!("Error: Input pointer is null");
        return ptr::null_mut();
    }
    // Convert the raw pointer + length into a Rust slice
    let bytes = slice::from_raw_parts(raw_input as *const u8, raw_input_length);
    let input_str = match std::str::from_utf8(bytes) {
        Ok(s) => s,
        Err(e) => {
            eprintln!("Error: Invalid UTF-8 string: {}", e);
            return ptr::null_mut();
        }
    };
    // Try deserializing the input string into CitmCatalog
    match serde_json::from_str::<CitmCatalog>(input_str) {
        Ok(catalog) => Box::into_raw(Box::new(catalog)),
        Err(e) => {
            eprintln!("Error deserializing JSON: {}", e);
            eprintln!("JSON snippet (first 200 chars): {:.200}...", input_str);
            ptr::null_mut()
        }
    }
 }
 /// Serializes a CitmCatalog into a JSON string (UTF-8).
 #[no_mangle]
 pub unsafe extern "C" fn str_from_citm(raw_catalog: *mut CitmCatalog) -> *mut c_char {
    if raw_catalog.is_null() {
        eprintln!("Error: Catalog pointer is null");
        return ptr::null_mut();
    }
    // Fix: Actually serialize the catalog
    let catalog = &*raw_catalog;
    match serde_json::to_string(catalog) {
        Ok(serialized) => {
            match CString::new(serialized) {
                Ok(cstr) => cstr.into_raw(),
                Err(e) => {
                    eprintln!("Error creating CString: {}", e);
                    ptr::null_mut()
                }
            }
        },
        Err(e) => {
            eprintln!("Error serializing catalog to JSON: {}", e);
            ptr::null_mut()
        }
    }
 }
 /// Frees the CitmCatalog pointer.
 #[no_mangle]
 pub unsafe extern "C" fn free_citm(raw_catalog: *mut CitmCatalog) {
    if !raw_catalog.is_null() {
        drop(Box::from_raw(raw_catalog));
    }
 }
 #[no_mangle]
 pub extern "C" fn free_str(ptr: *mut c_char) {
    if !ptr.is_null() {
        unsafe {
            // Convert back into a CString, which automatically frees the memory
            let _ = CString::from_raw(ptr);
        }
    }
 }
@@ -0,0 +1,45 @@
 #ifndef serde_benchmark_ffi_h
 #define serde_benchmark_ffi_h
 /* Generated with cbindgen:0.28.0 */
 /* 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 CitmCatalog;
 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);
 /// Creates a CitmCatalog from a JSON string (UTF-8 encoded).
 CitmCatalog *citm_from_str(const char *raw_input, uintptr_t raw_input_length);
 /// Serializes a CitmCatalog into a JSON string (UTF-8).
 char *str_from_citm(CitmCatalog *raw_catalog);
 /// Frees the CitmCatalog pointer.
 void free_citm(CitmCatalog *raw_catalog);
 void free_str(char *ptr);
 }  // extern "C"
 }  // namespace serde_benchmark
 #endif  // serde_benchmark_ffi_h
@@ -0,0 +1,14 @@
 # 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,168 @@
 #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_utils/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;
 }
 // Function to check if benchmark name contains filter substring
 bool matches_filter(const std::string& benchmark_name, const std::string& filter) {
  return filter.empty() || benchmark_name.find(filter) != std::string::npos;
 }
 int main(int argc, char* argv[]) {
  std::string filter;
  // Parse command-line arguments
  for (int i = 1; i < argc; ++i) {
      if (strcmp(argv[i], "-f") == 0 || strcmp(argv[i], "--filter") == 0) {
          if (i + 1 < argc) {
              filter = argv[++i];
          } else {
              std::cerr << "Error: -f/--filter requires an argument" << std::endl;
              return EXIT_FAILURE;
          }
      }
  }
  // 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
  if (matches_filter("nlohmann", filter)) {
    bench_nlohmann(my_struct);
  }
  if (matches_filter("simdjson_static_reflection", filter)) {
    bench_simdjson_static_reflection(my_struct);
  }
 #ifdef SIMDJSON_RUST_VERSION
  if (matches_filter("rust", filter)) {
    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
  if (matches_filter("reflect_cpp", filter)) {
    bench_reflect_cpp(my_struct);
  }
 #endif
  return EXIT_SUCCESS;
 }
@@ -0,0 +1,116 @@
 #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
@@ -2,7 +2,10 @@
 # Flags used by exes and by the simdjson library (project-wide flags)
 #
 add_library(simdjson-internal-flags INTERFACE)
-
+if(NOT DEFINED CMAKE_POSITION_INDEPENDENT_CODE)
  # We default to ON for all targets, so that we can use the library in shared libraries.
  set_target_properties(simdjson-internal-flags PROPERTIES POSITION_INDEPENDENT_CODE ON)
 endif(NOT DEFINED CMAKE_POSITION_INDEPENDENT_CODE)
 option(SIMDJSON_CHECK_EOF "Check for the end of the input buffer. The setting is unnecessary since we require padding of the inputs. You should expect tests to fail with this option turned on." OFF)
 if(SIMDJSON_CHECK_EOF)
@@ -52,7 +55,6 @@ endif()
 option(SIMDJSON_SANITIZE_MEMORY "Sanitize memory" OFF)
 if(SIMDJSON_SANITIZE_MEMORY)
  message(STATUS "Setting the memory sanitizer.")
  add_compile_options(
@@ -110,8 +112,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")
+if(SIMDJSON_STATIC_REFLECTION)
-set(CMAKE_CXX_STANDARD ${SIMDJSON_CXX_STANDARD})
+  # 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)
@@ -158,9 +166,6 @@ We recommend Visual Studio 2019 or better on a 64-bit system.")
    add_compile_options(/Zi)
  endif()
 else()
  if(NOT WIN32)
    target_compile_options(simdjson-internal-flags INTERFACE -fPIC)
  endif()
  target_compile_options(
      simdjson-internal-flags INTERFACE
      -Werror -Wall -Wextra -Weffc++ -Wsign-compare -Wshadow -Wwrite-strings
@@ -7,7 +7,7 @@ option(SIMDJSON_ALLOW_DOWNLOADS
 cmake_dependent_option(SIMDJSON_COMPETITION "Compile competitive benchmarks" ON
        SIMDJSON_ALLOW_DOWNLOADS OFF)
 cmake_dependent_option(SIMDJSON_GOOGLE_BENCHMARKS "compile the Google Benchmark benchmarks" ON
-        SIMDJSON_ALLOW_DOWNLOADS OFF)
+        "SIMDJSON_ALLOW_DOWNLOADS OR MINGW" OFF)
 if(SIMDJSON_GOOGLE_BENCHMARKS)
  CPMAddPackage(
@@ -106,7 +106,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)
@@ -322,13 +322,15 @@ transcode the UTF-8 strings produced by the simdjson library to other formats. S
 Avoiding pitfalls: enable development checks
 --------------------
-We recommend that you first compile and run your code in Debug mode:
+We recommend that you first compile and run your code in debug mode:
 - under Visual Studio, it means having the `_DEBUG` macro defined,
-  for other compilers, it means leaving the `__OPTIMIZE__` macro undefined.
+- for many other compilers, it means leaving the `__OPTIMIZE__` macro undefined.
-The simdjson code will set `SIMDJSON_DEVELOPMENT_CHECKS=1` in debug mode.
+The simdjson code will set `SIMDJSON_DEVELOPMENT_CHECKS=1` in debug mode. Because
-Alternatively, you can set the macro `SIMDJSON_DEVELOPMENT_CHECKS` to 1 prior to including
+the C++ standard does not provide a direct way of checking for a debug build, and
 because you may want the checks while building with otimizations, you can set
 the  macro `SIMDJSON_DEVELOPMENT_CHECKS` to 1 prior to including
 the `simdjson.h` header to enable these additional checks: just make sure you remove the
 definition once your code has been tested. When `SIMDJSON_DEVELOPMENT_CHECKS` is set to 1, the
 simdjson library runs additional (expensive) tests on your code to help ensure that you are
@@ -337,9 +339,12 @@ using the library in a safe manner.
 Once your code has been tested, you can then run it in
 Release mode: under Visual Studio, it means having the `_DEBUG` macro undefined, and, for other
 compilers, it means setting `__OPTIMIZE__` to a positive integer. You can also forcefully
-disable these checks by setting `SIMDJSON_DEVELOPMENT_CHECKS` to 0. Once your code is tested, we
+disable these checks by setting `SIMDJSON_DEVELOPMENT_CHECKS` to 0.
-further encourage you to define `NDEBUG` in your Release builds to disable additional runtime
+
-testing and get the best performance.
+Once your code is tested, we further encourage you to define `NDEBUG` in your release
 builds to disable additional runtime testing and get the best performance. We
 disable these checks on a best-effort basis but the C++ standard does not provide
 a direct way to check for a release build.
 Using the parsed JSON
 ---------------------
@@ -815,15 +820,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)
@@ -1296,8 +1303,8 @@ from `std::string_view` instances:
 })"_padded;
  ondemand::parser parser;
  ondemand::document doc = parser.iterate(json);
-  std:map<std::string,Car> cars;
+  std::map<std::string,Car> cars;
-  error = doc.get<std:map<std::string,Car>>().get(cars);
+  error = doc.get<std::map<std::string,Car>>().get(cars);
  // car has value car1->Car{"Toyota", "Camry", 2018, {40.1f, 39.9f}}
  // error is simdjson::SUCCESS
 ```
@@ -1336,6 +1343,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
 ----------------------
@@ -0,0 +1,132 @@
 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.start_object();
        // "make"
        builder.append_key_value("make", car.make);
        builder.append_comma();
        // "model"
        builder.append_key_value("model", car.model);
        builder.append_comma();
        // "year"
        builder.append_key_value("year", car.year);
        builder.append_comma();
        // "tire_pressure"
        builder.escape_and_append_with_quotes("tire_pressure");
        builder.append_colon();
        builder.start_array();
        // 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_comma();
            }
        }
        builder.end_array();
        builder.end_object();
    }
    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
  }
 ```
@@ -7,6 +7,7 @@ An overview of what you need to know to use simdjson, with examples.
 * [The Basics: Loading and Parsing JSON Documents](#the-basics-loading-and-parsing-json-documents-using-the-dom-front-end)
 * [Using the Parsed JSON](#using-the-parsed-json)
 * [C++17 Support](#c17-support)
 * [C++20 Support](#c20-support)
 * [JSON Pointer](#json-pointer)
 * [JSONPath](#jsonpath)
 * [Error Handling](#error-handling)
@@ -238,6 +239,23 @@ for (dom::key_value_pair field : object) {
 }
 ```
 C++20 Support
 ------------
 simdjson library also supports some C++20 feature including `std::ranges`:
 ```c++
 auto cars_json = R"( [
  { "make": "Toyota", "model": "Camry",  "year": 2018, "tire_pressure": [ 40.1, 39.9, 37.7, 40.4 ] },
  { "make": "Kia",    "model": "Soul",   "year": 2012, "tire_pressure": [ 30.1, 31.0, 28.6, 28.7 ] },
  { "make": "Toyota", "model": "Tercel", "year": 1999, "tire_pressure": [ 29.8, 30.0, 30.2, 30.5 ] }
 ] )"_padded;
 dom::parser parser;
 auto justmodel = [](auto car) { return car["model"]; };
 for (auto car : parser.parse(cars_json).get_array() | std::views::transform(justmodel)) {
  std::cout << car << std::endl;
 }
 ```
 JSON Pointer
 ------------
@@ -4,9 +4,9 @@ Performance Notes
 simdjson strives to be at its fastest *without tuning*, and generally achieves this. However, there
 are still some scenarios where tuning can enhance performance.
 Once your code is tested, we
-further encourage you to define `NDEBUG` in your Release builds to disable additional runtime
+further encourage you to define `NDEBUG` in your release builds to disable additional runtime
 testing and get the best performance.
-* [NDEBUG directive](#ndebug-directive)
+* [NDEBUG macro](#ndebug-macro)
 * [Reusing the parser for maximum efficiency](#reusing-the-parser-for-maximum-efficiency)
 * [Reusing string buffers](#reusing-string-buffers)
 * [Server Loops: Long-Running Processes and Memory Capacity](#server-loops-long-running-processes-and-memory-capacity)
@@ -17,16 +17,27 @@ testing and get the best performance.
 * [Free Padding](#free-padding)
-NDEBUG directive
+NDEBUG macro
 -------------
-In C/C++, the `NDEBUG` pre-processor directive is not set by default. When it is not set, the simdjson library does
+We recommend that you set `NDEBUG` macro in your release builds.
 many additional checks that may impact negatively the performance. We recommend that, once your code
 is well tested, you define `NDEBUG` directive in your Release builds. The `NDEBUG` directive should be defined
 prior to including the `simdjson.h` header.
-The `NDEBUG` directive is generally independent from optimization flags. For example, setting `-O3` under
+In C/C++, the `NDEBUG` macro is not set by default.
-GCC does not set the `NDEBUG` directive.
+When it is not set, the software may do many additional checks that may impact
 negatively the performance. We recommend that, once your code
 is well tested, you define `NDEBUG` directive in your release builds.
 The `NDEBUG` directive is generally independent from optimization flags.
 For example, setting `-O3` under GCC does not set the `NDEBUG` directive.
 However, tools like `CMake` automatically
 set `NDEBUG` for release builds.
 In the simdjson library, we check the `NDEBUG` macro as well as other
 macros to make performant release builds. However, the C++ standard
 does not provide a definitive approach to determine whether you are
 compiling for a release build. Thus we recommend that you follow
 the practice of setting the `NDEBUG` macro in release mode to make sure
 that you do not get undesirable expensive checks.
 Reusing the parser for maximum efficiency
 -----------------------------------------
@@ -20,10 +20,14 @@ IF(${CMAKE_SYSTEM_NAME} MATCHES "Linux")
  endif()
  add_quickstart_test(quickstart_noexceptions   quickstart_noexceptions.cpp NO_EXCEPTIONS LABELS acceptance)
  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)
  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)
  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()
@@ -23,6 +23,7 @@ public:
  ) const noexcept final;
  simdjson_warn_unused error_code minify(const uint8_t *buf, size_t len, uint8_t *dst, size_t &dst_len) const noexcept final;
  simdjson_warn_unused bool validate_utf8(const char *buf, size_t len) const noexcept final;
  simdjson_warn_unused size_t write_string_escaped(const std::string_view input, char *out) const noexcept final;
 };
 } // namespace arm64
@@ -134,6 +134,12 @@ namespace {
      tmp = vpaddq_u8(tmp, tmp);
      return vgetq_lane_u16(vreinterpretq_u16_u8(tmp), 0);
    }
    // Returns 4-bit out of each byte, alternating between the high 4 bits and low
    // bits result it is 64 bit.
    simdjson_inline uint64_t to_bitmask64() const {
      return vget_lane_u64(
          vreinterpret_u64_u8(vshrn_n_u16(vreinterpretq_u16_u8(*this), 4)), 0);
    }
    simdjson_inline bool any() const { return vmaxvq_u32(vreinterpretq_u32_u8(*this)) != 0; }
  };
@@ -210,7 +216,7 @@ namespace {
    // Bit-specific operations
    simdjson_inline simd8<bool> any_bits_set(simd8<uint8_t> bits) const { return vtstq_u8(*this, bits); }
-    simdjson_inline bool any_bits_set_anywhere() const { return this->max_val() != 0; }
+    simdjson_inline bool any_bits_set_anywhere() const { return vmaxvq_u32(vreinterpretq_u32_u8(*this)) != 0; }
    simdjson_inline bool any_bits_set_anywhere(simd8<uint8_t> bits) const { return (*this & bits).any_bits_set_anywhere(); }
    template<int N>
    simdjson_inline simd8<uint8_t> shr() const { return vshrq_n_u8(*this, N); }
@@ -223,7 +229,12 @@ namespace {
      return lookup_table.apply_lookup_16_to(*this);
    }
-
+    // Returns 4-bit out of each byte, alternating between the high 4 bits and low
    // bits result it is 64 bit.
    simdjson_inline uint64_t to_bitmask64() const {
      return vget_lane_u64(
          vreinterpret_u64_u8(vshrn_n_u16(vreinterpretq_u16_u8(*this), 4)), 0);
    }
    // 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 16 - count_ones(mask) bytes of the result are significant but 16 bytes
@@ -46,6 +46,32 @@ simdjson_inline backslash_and_quote backslash_and_quote::copy_and_find(const uin
  };
 }
 struct escaping {
  static constexpr uint32_t BYTES_PROCESSED = 16;
  simdjson_inline static escaping copy_and_find(const uint8_t *src, uint8_t *dst);
  simdjson_inline bool has_escape() { return escape_bits != 0; }
  simdjson_inline int escape_index() { return trailing_zeroes(escape_bits) / 4; }
  uint64_t escape_bits;
 }; // struct escaping
 simdjson_inline escaping escaping::copy_and_find(const uint8_t *src, uint8_t *dst) {
  static_assert(SIMDJSON_PADDING >= (BYTES_PROCESSED - 1), "escaping finder must process fewer than SIMDJSON_PADDING bytes");
  simd8<uint8_t> v(src);
  v.store(dst);
  simd8<bool> is_quote = (v == '"');
  simd8<bool> is_backslash = (v == '\\');
  simd8<bool> is_control = (v < 32);
  return {
    (is_backslash | is_quote | is_control).to_bitmask64()
  };
 }
 } // unnamed namespace
 } // namespace arm64
 } // namespace simdjson
@@ -282,16 +282,25 @@ namespace std {
 // It could also wrongly set SIMDJSON_DEVELOPMENT_CHECKS (e.g., if the programmer
 // sets _DEBUG in a release build under Visual Studio, or if some compiler fails to
 // set the __OPTIMIZE__ macro).
 // We make it so that if NDEBUG is defined, then SIMDJSON_DEVELOPMENT_CHECKS
 // is not defined, irrespective of the compiler.
 // We recommend that users set NDEBUG in release builds, so that
 // SIMDJSON_DEVELOPMENT_CHECKS is not defined in release builds by default,
 // irrespective of the compiler.
 #ifndef SIMDJSON_DEVELOPMENT_CHECKS
 #ifdef _MSC_VER
 // Visual Studio seems to set _DEBUG for debug builds.
-#ifdef _DEBUG
+// We set SIMDJSON_DEVELOPMENT_CHECKS to 1 if _DEBUG is defined
 // and NDEBUG is not defined.
 #if defined(_DEBUG) && !defined(NDEBUG)
 #define SIMDJSON_DEVELOPMENT_CHECKS 1
 #endif // _DEBUG
 #else // _MSC_VER
 // All other compilers appear to set __OPTIMIZE__ to a positive integer
 // when the compiler is optimizing.
-#ifndef __OPTIMIZE__
+// We only set SIMDJSON_DEVELOPMENT_CHECKS if both __OPTIMIZE__
 // and NDEBUG are not defined.
 #if !defined(__OPTIMIZE__) && !defined(NDEBUG)
 #define SIMDJSON_DEVELOPMENT_CHECKS 1
 #endif // __OPTIMIZE__
 #endif // _MSC_VER
@@ -50,12 +50,31 @@
 #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
 // 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
@@ -74,4 +93,12 @@
 #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
@@ -115,7 +115,6 @@ concept optional_type = requires(std::remove_cvref_t<T> obj) {
  { obj.value() } -> std::same_as<typename std::remove_cvref_t<T>::value_type&>;
  requires requires(typename std::remove_cvref_t<T>::value_type &&val) {
    obj.emplace(std::move(val));
    obj = std::move(val);
    {
      obj.value_or(val)
    } -> std::convertible_to<typename std::remove_cvref_t<T>::value_type>;
@@ -57,7 +57,7 @@ public:
    iterator& operator=(const iterator&) noexcept = default;
  private:
    simdjson_inline iterator(const internal::tape_ref &tape) noexcept;
-    internal::tape_ref tape;
+    internal::tape_ref tape{};
    friend class array;
  };
@@ -148,7 +148,7 @@ public:
 private:
  simdjson_inline array(const internal::tape_ref &tape) noexcept;
-  internal::tape_ref tape;
+  internal::tape_ref tape{};
  friend class element;
  friend struct simdjson_result<element>;
  template<typename T>
@@ -492,7 +492,7 @@ public:
 private:
  simdjson_inline element(const internal::tape_ref &tape) noexcept;
-  internal::tape_ref tape;
+  internal::tape_ref tape{};
  friend class document;
  friend class object;
  friend class array;
@@ -89,7 +89,7 @@ public:
  private:
    simdjson_inline iterator(const internal::tape_ref &tape) noexcept;
-    internal::tape_ref tape;
+    internal::tape_ref tape{};
    friend class object;
  };
@@ -224,7 +224,7 @@ public:
 private:
  simdjson_inline object(const internal::tape_ref &tape) noexcept;
-  internal::tape_ref tape;
+  internal::tape_ref tape{};
  friend class element;
  friend struct simdjson_result<element>;
@@ -49,7 +49,8 @@ enum error_code {
  SCALAR_DOCUMENT_AS_VALUE,   ///< A scalar document is treated as a value.
  OUT_OF_BOUNDS,              ///< Attempted to access location outside of document.
  TRAILING_CONTENT,           ///< Unexpected trailing content in the JSON input
-  NUM_ERROR_CODES
+  OUT_OF_CAPACITY,            ///< The capacity was exceeded, we cannot allocate enough memory.
  NUM_ERROR_CODES             ///< Placeholder for end of error code list.
 };
 /**
@@ -26,6 +26,7 @@ public:
  ) const noexcept final;
  simdjson_warn_unused error_code minify(const uint8_t *buf, size_t len, uint8_t *dst, size_t &dst_len) const noexcept final;
  simdjson_warn_unused bool validate_utf8(const char *buf, size_t len) const noexcept final;
  simdjson_warn_unused size_t write_string_escaped(const std::string_view input, char *out) const noexcept final;
 };
 } // namespace fallback
@@ -29,6 +29,24 @@ simdjson_inline backslash_and_quote backslash_and_quote::copy_and_find(const uin
  return { src[0] };
 }
 struct escaping {
  static constexpr uint32_t BYTES_PROCESSED = 1;
  simdjson_inline static escaping copy_and_find(const uint8_t *src, uint8_t *dst);
  simdjson_inline bool has_escape() { return escape_bits; }
  simdjson_inline int escape_index() { return 0; }
  bool escape_bits;
 }; // struct escaping
 simdjson_inline escaping escaping::copy_and_find(const uint8_t *src, uint8_t *dst) {
  dst[0] = src[0];
  return { (src[0] == '\\') || (src[0] == '"') || (src[0] < 32) };
 }
 } // unnamed namespace
 } // namespace fallback
 } // namespace simdjson
@@ -45,4 +45,9 @@
 #include "simdjson/generic/ondemand/token_iterator-inl.h"
 #include "simdjson/generic/ondemand/value_iterator-inl.h"
 // JSON builder, ideally they should not be part of the ondemand directory
 // 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"
@@ -131,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.
@@ -209,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
@@ -8,6 +8,7 @@
 // Internal headers needed for ondemand generics.
 // All includes not under simdjson/generic/ondemand must be here!
 // Otherwise, amalgamation will fail.
 #include "simdjson/concepts.h"
 #include "simdjson/dom/base.h" // for MINIMAL_DOCUMENT_CAPACITY
 #include "simdjson/implementation.h"
 #include "simdjson/padded_string.h"
@@ -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>
@@ -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>
@@ -0,0 +1,295 @@
 /**
 * 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"
 #include "simdjson/concepts.h"
 #endif // SIMDJSON_CONDITIONAL_INCLUDE
 #if SIMDJSON_STATIC_REFLECTION
 #include <charconv>
 #include <cstring>
 #include <experimental/meta>
 #include <memory>
 #include <string_view>
 #include <type_traits>
 #include <utility>
 // #include <static_reflection> // for std::define_static_string - header not available yet
 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 <concepts::string_view_keyed_map T>
 constexpr void atom(string_builder &b, const T &m) {
  if (m.empty()) {
    b.append_raw("{}");
    return;
  }
  b.append('{');
  bool first = true;
  for (const auto& [key, value] : m) {
    if (!first) {
      b.append(',');
    }
    first = false;
    // Keys must be convertible to string_view per the concept
    b.escape_and_append_with_quotes(key);
    b.append(':');
    atom(b, value);
  }
  b.append('}');
 }
 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> &&
           !concepts::string_view_keyed_map<T> &&
           !concepts::optional_type<T> &&
           !concepts::smart_pointer<T> &&
           !concepts::appendable_containers<T> &&
           !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) {
  int i = 0;
  b.append('{');
  [:expand(std::meta::nonstatic_data_members_of(^^T, std::meta::access_context::unchecked())):] >> [&]<auto dm>() {
    if (i != 0)
      b.append(',');
    constexpr auto key = std::define_static_string(consteval_to_quoted_escaped(std::meta::identifier_of(dm)));
    b.append_raw(key);
    b.append(':');
    atom(b, t.[:dm:]);
    i++;
  };
  b.append('}');
 }
 // Support for optional types (std::optional, etc.)
 template <concepts::optional_type T>
 constexpr void atom(string_builder &b, const T &opt) {
  if (opt) {
    atom(b, opt.value());
  } else {
    b.append_raw("null");
  }
 }
 // Support for smart pointers (std::unique_ptr, std::shared_ptr, etc.)
 template <concepts::smart_pointer T>
 constexpr void atom(string_builder &b, const T &ptr) {
  if (ptr) {
    atom(b, *ptr);
  } else {
    b.append_raw("null");
  }
 }
 // Support for enums - serialize as string representation using expand approach from P2996R12
 template <typename T>
  requires(std::is_enum_v<T>)
 void atom(string_builder &b, const T &e) {
 #if SIMDJSON_STATIC_REFLECTION
  std::string_view result = "<unnamed>";
  [:expand(std::meta::enumerators_of(^^T)):] >> [&]<auto enum_val>{
    if (e == [:enum_val:]) {
      result = std::meta::identifier_of(enum_val);
    }
  };
  if (result != "<unnamed>") {
    b.append_raw("\"");
    b.append_raw(result);
    b.append_raw("\"");
  } else {
    // Fallback to integer if enum value not found
    atom(b, static_cast<std::underlying_type_t<T>>(e));
  }
 #else
  // Fallback: serialize as integer if reflection not available
  atom(b, static_cast<std::underlying_type_t<T>>(e));
 #endif
 }
 // Support for appendable containers that don't have operator[] (sets, etc.)
 template <concepts::appendable_containers T>
  requires(!container_but_not_string<T> && !concepts::string_view_keyed_map<T> &&
           !concepts::optional_type<T> && !concepts::smart_pointer<T> &&
           !std::is_same_v<T, std::string> &&
           !std::is_same_v<T, std::string_view> && !std::is_same_v<T, const char*>)
 constexpr void atom(string_builder &b, const T &container) {
  if (container.empty()) {
    b.append_raw("[]");
    return;
  }
  b.append('[');
  bool first = true;
  for (const auto& item : container) {
    if (!first) {
      b.append(',');
    }
    first = false;
    atom(b, item);
  }
  b.append(']');
 }
 // append functions that delegate to atom functions for primitive types
 template <class T>
  requires(std::is_arithmetic_v<T> && !std::is_same_v<T, char>)
 void append(string_builder &b, const T &t) {
  atom(b, t);
 }
 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>)
 void append(string_builder &b, const T &t) {
  atom(b, t);
 }
 template <concepts::optional_type T>
 void append(string_builder &b, const T &t) {
  atom(b, t);
 }
 template <concepts::smart_pointer T>
 void append(string_builder &b, const T &t) {
  atom(b, t);
 }
 template <concepts::appendable_containers T>
  requires(!container_but_not_string<T> && !concepts::string_view_keyed_map<T> &&
           !concepts::optional_type<T> && !concepts::smart_pointer<T> &&
           !std::is_same_v<T, std::string> &&
           !std::is_same_v<T, std::string_view> && !std::is_same_v<T, const char*>)
 void append(string_builder &b, const T &t) {
  atom(b, t);
 }
 template <concepts::string_view_keyed_map T>
 void append(string_builder &b, const T &t) {
  atom(b, t);
 }
 // works for struct
 template <class Z>
  requires(std::is_class_v<Z> && !container_but_not_string<Z> &&
           !concepts::string_view_keyed_map<Z> &&
           !concepts::optional_type<Z> &&
           !concepts::smart_pointer<Z> &&
           !concepts::appendable_containers<Z> &&
           !std::is_same_v<Z, std::string> &&
           !std::is_same_v<Z, std::string_view> &&
           !std::is_same_v<Z, const char*> &&
           !std::is_same_v<Z, char>)
 void append(string_builder &b, const Z &z) {
  int i = 0;
  b.append('{');
  [:expand(std::meta::nonstatic_data_members_of(^^Z, std::meta::access_context::unchecked())):] >> [&]<auto dm>() {
    if (i != 0)
      b.append(',');
    constexpr auto key = std::define_static_string(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
@@ -0,0 +1,617 @@
 /**
 * 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_STRING_BUILDER_INL_H
 #ifndef SIMDJSON_CONDITIONAL_INCLUDE
 #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 {
 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};
 /**
 A possible SWAR implementation of has_json_escapable_byte. It is not used because
 it is slower than the current implementation. It is kept here for reference (to show
 that we tried it).
 inline bool has_json_escapable_byte(uint64_t x) {
  uint64_t is_ascii = 0x8080808080808080ULL & ~x;
  uint64_t xor2 = x ^ 0x0202020202020202ULL;
  uint64_t lt32_or_eq34 = xor2 - 0x2121212121212121ULL;
  uint64_t sub92 = x ^ 0x5C5C5C5C5C5C5C5CULL;
  uint64_t eq92 = (sub92 - 0x0101010101010101ULL);
  return ((lt32_or_eq34 | eq92) & is_ascii) != 0;
 }
 **/
 SIMDJSON_CONSTEXPR_LAMBDA simdjson_inline bool
 simple_needs_escaping(std::string_view v) {
  for (char c : v) {
    // a table lookup is faster than a series of comparisons
    if(json_quotable_character[static_cast<uint8_t>(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
 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;
  }
  // check for overflow, most of the time there is no overflow
  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.
  return is_valid;
 }
 simdjson_inline void string_builder::grow_buffer(size_t desired_capacity) {
  if (!is_valid) {
    return;
  }
  std::unique_ptr<char[]> new_buffer(new (std::nothrow) char[desired_capacity]);
  if (new_buffer.get() == nullptr) {
    set_valid(false);
    return;
  }
  std::memcpy(new_buffer.get(), buffer.get(), position);
  buffer.swap(new_buffer);
  capacity = desired_capacity;
 }
 simdjson_inline void string_builder::set_valid(bool valid) noexcept {
  if (!valid) {
    is_valid = false;
    capacity = 0;
    position = 0;
    buffer.reset();
  } else {
    is_valid = true;
  }
 }
 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;
  }
 }
 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)) {
    std::memcpy(buffer.get() + position, null_literal, null_len);
    position += null_len;
  }
 }
 simdjson_inline void string_builder::clear() noexcept {
  position = 0;
  // if it was invalid, we should try to repair it
  if (!is_valid) {
    capacity = 0;
    buffer.reset();
    is_valid = true;
  }
 }
 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(uint32_t x) {
  static uint64_t table[] = {
      4294967296,  8589934582,  8589934582,  8589934582,  12884901788,
      12884901788, 12884901788, 17179868184, 17179868184, 17179868184,
      21474826480, 21474826480, 21474826480, 21474826480, 25769703776,
      25769703776, 25769703776, 30063771072, 30063771072, 30063771072,
      34349738368, 34349738368, 34349738368, 34349738368, 38554705664,
      38554705664, 38554705664, 41949672960, 41949672960, 41949672960,
      42949672960, 42949672960};
  return uint32_t((x + table[int_log2(x)]) >> 32);
 }
 int int_log2(uint64_t x) { return 63 - leading_zeroes(x | 1); }
 int fast_digit_count(uint64_t x) {
  static uint64_t table[] = {9,
                             99,
                             999,
                             9999,
                             99999,
                             999999,
                             9999999,
                             99999999,
                             999999999,
                             9999999999,
                             99999999999,
                             999999999999,
                             9999999999999,
                             99999999999999,
                             999999999999999ULL,
                             9999999999999999ULL,
                             99999999999999999ULL,
                             999999999999999999ULL,
                             9999999999999999999ULL};
  int y = (19 * int_log2(x) >> 6);
  y += x > table[y];
  return y + 1;
 }
 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");
  return fast_digit_count(v);
 }
 static const char decimal_table[200] = {
  0x30, 0x30, 0x30, 0x31, 0x30, 0x32, 0x30, 0x33, 0x30, 0x34, 0x30, 0x35,
  0x30, 0x36, 0x30, 0x37, 0x30, 0x38, 0x30, 0x39, 0x31, 0x30, 0x31, 0x31,
  0x31, 0x32, 0x31, 0x33, 0x31, 0x34, 0x31, 0x35, 0x31, 0x36, 0x31, 0x37,
  0x31, 0x38, 0x31, 0x39, 0x32, 0x30, 0x32, 0x31, 0x32, 0x32, 0x32, 0x33,
  0x32, 0x34, 0x32, 0x35, 0x32, 0x36, 0x32, 0x37, 0x32, 0x38, 0x32, 0x39,
  0x33, 0x30, 0x33, 0x31, 0x33, 0x32, 0x33, 0x33, 0x33, 0x34, 0x33, 0x35,
  0x33, 0x36, 0x33, 0x37, 0x33, 0x38, 0x33, 0x39, 0x34, 0x30, 0x34, 0x31,
  0x34, 0x32, 0x34, 0x33, 0x34, 0x34, 0x34, 0x35, 0x34, 0x36, 0x34, 0x37,
  0x34, 0x38, 0x34, 0x39, 0x35, 0x30, 0x35, 0x31, 0x35, 0x32, 0x35, 0x33,
  0x35, 0x34, 0x35, 0x35, 0x35, 0x36, 0x35, 0x37, 0x35, 0x38, 0x35, 0x39,
  0x36, 0x30, 0x36, 0x31, 0x36, 0x32, 0x36, 0x33, 0x36, 0x34, 0x36, 0x35,
  0x36, 0x36, 0x36, 0x37, 0x36, 0x38, 0x36, 0x39, 0x37, 0x30, 0x37, 0x31,
  0x37, 0x32, 0x37, 0x33, 0x37, 0x34, 0x37, 0x35, 0x37, 0x36, 0x37, 0x37,
  0x37, 0x38, 0x37, 0x39, 0x38, 0x30, 0x38, 0x31, 0x38, 0x32, 0x38, 0x33,
  0x38, 0x34, 0x38, 0x35, 0x38, 0x36, 0x38, 0x37, 0x38, 0x38, 0x38, 0x39,
  0x39, 0x30, 0x39, 0x31, 0x39, 0x32, 0x39, 0x33, 0x39, 0x34, 0x39, 0x35,
  0x39, 0x36, 0x39, 0x37, 0x39, 0x38, 0x39, 0x39,
 };
 } // namespace internal
 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");
  // If C++17 is available, we can 'if constexpr' here.
  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)) {
        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)) {
        std::memcpy(buffer.get() + position, false_literal, false_len);
        position += false_len;
      }
    }
  }
  else SIMDJSON_IF_CONSTEXPR(std::is_unsigned<number_type>::value) {
    constexpr size_t max_number_size = 20;
    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;
      while (pv >= 100) {
        memcpy(write_pointer - 1, &internal::decimal_table[(pv % 100)*2], 2);
        write_pointer -= 2;
        pv /= 100;
      }
      if (pv >= 10) {
        *write_pointer-- = char('0' + (pv % 10));
        pv /= 10;
      }
      *write_pointer = char('0' + pv);
      position += dc;
    }
  }
  else SIMDJSON_IF_CONSTEXPR(std::is_integral<number_type>::value) {
    constexpr size_t max_number_size = 20;
    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>(v);
      if (negative) {
        pv = 0 - pv; // the 0 is for Microsoft
      }
      size_t dc = internal::digit_count(pv);
      if (negative) {
        buffer.get()[position++] = '-';
      }
      char *write_pointer = buffer.get() + position + dc - 1;
      while (pv >= 100) {
        memcpy(write_pointer - 1, &internal::decimal_table[(pv % 100)*2], 2);
        write_pointer -= 2;
        pv /= 100;
      }
      if (pv >= 10) {
        *write_pointer-- = char('0' + (pv % 10));
        pv /= 10;
      }
      *write_pointer = char('0' + pv);
      position += dc;
    }
  }
  else SIMDJSON_IF_CONSTEXPR(std::is_floating_point<number_type>::value) {
    constexpr size_t max_number_size = 24;
    if (capacity_check(max_number_size)) {
      // We could specialize for float.
      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 {
  // escaping might turn a control character into \x00xx so 6 characters.
  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 {
  // escaping might turn a control character into \x00xx so 6 characters.
  if (capacity_check(2 + 6 * input.size())) {
    buffer.get()[position++] = '"';
    position += write_string_escaped(input, buffer.get() + position);
    buffer.get()[position++] = '"';
  }
 }
 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::escape_and_append_with_quotes(const char* input)  noexcept {
  std::string_view cinput(input);
  escape_and_append_with_quotes(cinput);
 }
 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)) {
    std::memcpy(buffer.get() + position, str, len);
    position += len;
  }
 }
 #if SIMDJSON_EXCEPTIONS
 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) {
  return view();
 }
 #endif
 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)) {
    buffer.get()[position] = '\0';
    return buffer.get();
  }
  return simdjson::OUT_OF_CAPACITY;
 }
 simdjson_inline bool string_builder::validate_unicode() const noexcept {
  return simdjson::validate_utf8(buffer.get(), position);
 }
 simdjson_inline void string_builder::start_object()  noexcept {
  if (capacity_check(1)) {
    buffer.get()[position++] = '{';
  }
 }
 simdjson_inline void string_builder::end_object()  noexcept {
  if (capacity_check(1)) {
    buffer.get()[position++] = '}';
  }
 }
 simdjson_inline void string_builder::start_array()  noexcept {
  if (capacity_check(1)) {
    buffer.get()[position++] = '[';
  }
 }
 simdjson_inline void string_builder::end_array()  noexcept {
  if (capacity_check(1)) {
    buffer.get()[position++] = ']';
  }
 }
 simdjson_inline void string_builder::append_comma()  noexcept {
  if (capacity_check(1)) {
    buffer.get()[position++] = ',';
  }
 }
 simdjson_inline void string_builder::append_colon()  noexcept {
  if (capacity_check(1)) {
    buffer.get()[position++] = ':';
  }
 }
 template<typename key_type, typename value_type>
 simdjson_inline void string_builder::append_key_value(key_type key, value_type value) noexcept {
  static_assert(
    std::is_arithmetic<value_type>::value ||
    std::is_same<value_type, char>::value ||
    std::is_same<value_type, const char*>::value ||
    std::is_convertible<value_type, std::string_view>::value ||
    std::is_same<value_type, std::nullptr_t>::value,
    "Unsupported value type");
  static_assert(
    std::is_same<key_type, const char*>::value ||
    std::is_convertible<key_type, std::string_view>::value,
    "Unsupported key type");
  escape_and_append_with_quotes(key);
  append_colon();
  SIMDJSON_IF_CONSTEXPR(std::is_same<value_type, std::nullptr_t>::value) {
    append_null();
  } else SIMDJSON_IF_CONSTEXPR(std::is_same<value_type, char>::value) {
    escape_and_append_with_quotes(value);
  } else SIMDJSON_IF_CONSTEXPR(std::is_convertible<value_type, std::string_view>::value) {
    escape_and_append_with_quotes(value);
  } else SIMDJSON_IF_CONSTEXPR(std::is_same<value_type, const char*>::value) {
    escape_and_append_with_quotes(value);
  } else {
    append(value);
  }
 }
 } // namespace builder
 } // namespace SIMDJSON_IMPLEMENTATION
 } // namespace simdjson
 #endif // SIMDJSON_GENERIC_STRING_BUILDER_INL_H
@@ -0,0 +1,215 @@
 /**
 * 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_STRING_BUILDER_H
 #ifndef SIMDJSON_CONDITIONAL_INCLUDE
 #define SIMDJSON_GENERIC_STRING_BUILDER_H
 #include "simdjson/generic/implementation_simdjson_result_base.h"
 #endif // SIMDJSON_CONDITIONAL_INCLUDE
 namespace simdjson {
 namespace SIMDJSON_IMPLEMENTATION {
 namespace builder {
 /**
 * A builder for JSON strings representing documents. This is a low-level
 * builder that is not meant to be used directly by end-users. Though it
 * supports atomic types (Booleans, strings), it does not support composed
 * types (arrays and objects).
 *
 * Ultimately, this class should support kernel-specific optimizations. E.g.,
 * it may make use of SIMD instructions to escape strings faster.
 */
 class string_builder {
 public:
  simdjson_inline string_builder(size_t initial_capacity = 1024);
  /**
   * Append number (includes Booleans). Booleans are mapped to the strings
   * false and true. Numbers are converted to strings abiding by the JSON standard.
   * Floating-point numbers are converted to the shortest string that 'correctly'
   * represents the number.
   */
  template<typename number_type,
         typename = typename std::enable_if<std::is_arithmetic<number_type>::value>::type>
  simdjson_inline void append(number_type v) noexcept;
  /**
   * Append character c.
   */
  simdjson_inline void append(char c)  noexcept;
  /**
   * Append the string 'null'.
   */
  simdjson_inline void append_null()  noexcept;
  /**
   * Clear the content.
   */
  simdjson_inline void clear()  noexcept;
  /**
   * Append the std::string_view, after escaping it.
   * There is no UTF-8 validation.
   */
  simdjson_inline void escape_and_append(std::string_view input)  noexcept;
  /**
   * Append the std::string_view surrounded by double quotes, after escaping it.
   * There is no UTF-8 validation.
   */
  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 character surrounded by double quotes, after escaping it.
   * There is no UTF-8 validation.
   */
   simdjson_inline void escape_and_append_with_quotes(const char* input)  noexcept;
  /**
   * Append the C string directly, without escaping.
   * There is no UTF-8 validation.
   */
  simdjson_inline void append_raw(const char *c)  noexcept;
  /**
   * Append "{" to the buffer.
   */
  simdjson_inline void start_object()  noexcept;
  /**
   * Append "}" to the buffer.
   */
  simdjson_inline void end_object()  noexcept;
  /**
   * Append "[" to the buffer.
   */
  simdjson_inline void start_array()  noexcept;
  /**
   * Append "]" to the buffer.
   */
  simdjson_inline void end_array()  noexcept;
  /**
   * Append "," to the buffer.
   */
  simdjson_inline void append_comma()  noexcept;
  /**
   * Append ":" to the buffer.
   */
  simdjson_inline void append_colon()  noexcept;
  /**
   * Append a key-value pair to the buffer.
   * The key is escaped and surrounded by double quotes.
   * The value is escaped if it is a string.
   */
   template<typename key_type, typename value_type>
  simdjson_inline void append_key_value(key_type key, value_type value) noexcept;
  /**
   * Append the std::string_view directly, without escaping.
   * There is no UTF-8 validation.
   */
  simdjson_inline void append_raw(std::string_view input)  noexcept;
  /**
   * Append len characters from str.
   * There is no UTF-8 validation.
   */
  simdjson_inline void append_raw(const char *str, size_t len) noexcept;
 #if SIMDJSON_EXCEPTIONS
  /**
   * Creates an std::string from the written JSON buffer.
   * Throws if memory allocation failed
   *
   * The result may not be valid UTF-8 if some of your content was not valid UTF-8.
   * Use validate_unicode() to check the content if needed.
   */
  simdjson_inline operator std::string() const noexcept(false);
  /**
   * Creates an std::string_view from the written JSON buffer.
   * Throws if memory allocation failed.
   *
   * The result may not be valid UTF-8 if some of your content was not valid UTF-8.
   * Use validate_unicode() to check the content if needed.
   */
  simdjson_inline operator std::string_view() const noexcept(false);
 #endif
  /**
   * Returns a view on the written JSON buffer. Returns an error
   * if memory allocation failed.
   *
   * The result may not be valid UTF-8 if some of your content was not valid UTF-8.
   * Use validate_unicode() to check the content.
   */
  simdjson_inline simdjson_result<std::string_view> view() const noexcept;
  /**
   * Appends the null character to the buffer and returns
   * a pointer to the beginning of the written JSON buffer.
   * Returns an error if memory allocation failed.
   * The result is null-terminated.
   *
   * The result may not be valid UTF-8 if some of your content was not valid UTF-8.
   * Use validate_unicode() to check the content.
   */
  simdjson_inline simdjson_result<const char *> c_str() noexcept;
  /**
   * Return true if the content is valid UTF-8.
   */
  simdjson_inline bool validate_unicode() const noexcept;
  /**
   * Returns the current size of the written JSON buffer.
   * If an error occurred, returns 0.
   */
  simdjson_inline size_t size() const noexcept;
 private:
  /**
   * Returns true if we can write at least upcoming_bytes bytes.
   * The underlying buffer is reallocated if needed. It is designed
   * to be called before writing to the buffer. It should be fast.
   */
  simdjson_inline bool capacity_check(size_t upcoming_bytes);
  /**
   * Grow the buffer to at least desired_capacity bytes.
   * If the allocation fails, is_valid is set to false. We expect
   * that this function would not be repeatedly called.
   */
  simdjson_inline void grow_buffer(size_t desired_capacity);
  /**
   * We use this helper function to make sure that is_valid is kept consistent.
   */
  simdjson_inline void set_valid(bool valid) noexcept;
  std::unique_ptr<char[]> buffer{};
  size_t position{0};
  size_t capacity{0};
  bool is_valid{true};
 };
 }
 }
 } // namespace simdjson
 #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
@@ -9,6 +9,9 @@
 #include "simdjson/generic/ondemand/object.h"
 #include "simdjson/generic/ondemand/serialization.h"
 #include "simdjson/generic/ondemand/value.h"
 #if SIMDJSON_STATIC_REFLECTION
 #include "simdjson/generic/ondemand/json_builder.h"
 #endif
 #endif // SIMDJSON_CONDITIONAL_INCLUDE
 namespace simdjson {
@@ -35,6 +35,20 @@ inline simdjson_result<std::string_view> to_json_string(simdjson_result<SIMDJSON
 inline simdjson_result<std::string_view> to_json_string(simdjson_result<SIMDJSON_IMPLEMENTATION::ondemand::value> x);
 inline simdjson_result<std::string_view> to_json_string(simdjson_result<SIMDJSON_IMPLEMENTATION::ondemand::object> x);
 inline simdjson_result<std::string_view> to_json_string(simdjson_result<SIMDJSON_IMPLEMENTATION::ondemand::array> x);
 #if SIMDJSON_STATIC_REFLECTION
 /**
 * Create a JSON string from any user-defined type using static reflection.
 * Only available when SIMDJSON_STATIC_REFLECTION is enabled.
 */
 template<typename T>
  requires(!std::same_as<T, SIMDJSON_IMPLEMENTATION::ondemand::document> &&
           !std::same_as<T, SIMDJSON_IMPLEMENTATION::ondemand::value> &&
           !std::same_as<T, SIMDJSON_IMPLEMENTATION::ondemand::object> &&
           !std::same_as<T, SIMDJSON_IMPLEMENTATION::ondemand::array>)
 inline std::string to_json_string(const T& obj);
 #endif
 } // namespace simdjson
 /**
@@ -3,12 +3,17 @@
 #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>
 // #include <static_reflection> // for std::define_static_string - header not available yet
 #endif
 namespace simdjson {
 template <typename T>
@@ -55,6 +60,22 @@ error_code tag_invoke(deserialize_tag, auto &val, T &out) noexcept {
  return SUCCESS;
 }
 //////////////////////////////
 // String deserialization
 //////////////////////////////
 // just a character!
 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;
 }
 // any string-like type (can be constructed from std::string_view)
 template <concepts::constructible_from_string_view T, typename ValT>
  requires(!require_custom_serialization<T>)
 error_code tag_invoke(deserialize_tag, ValT &val, T &out) noexcept(std::is_nothrow_constructible_v<T, std::string_view>) {
@@ -76,15 +97,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;
  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));
@@ -141,7 +167,45 @@ error_code tag_invoke(deserialize_tag, ValT &val, T &out) noexcept(false) {
 return SUCCESS;
 }
 template <concepts::string_view_keyed_map T>
 error_code tag_invoke(deserialize_tag, SIMDJSON_IMPLEMENTATION::ondemand::object &obj, T &out) noexcept {
  using value_type = typename std::remove_cvref_t<T>::mapped_type;
  out.clear();
  for (auto field : obj) {
    std::string_view key;
    SIMDJSON_TRY(field.unescaped_key().get(key));
    SIMDJSON_IMPLEMENTATION::ondemand::value value_obj;
    SIMDJSON_TRY(field.value().get(value_obj));
    value_type this_value;
    SIMDJSON_TRY(value_obj.get(this_value));
    out.emplace(typename T::key_type(key), std::move(this_value));
  }
  return SUCCESS;
 }
 template <concepts::string_view_keyed_map T>
 error_code tag_invoke(deserialize_tag, SIMDJSON_IMPLEMENTATION::ondemand::value &val, T &out) noexcept {
  SIMDJSON_IMPLEMENTATION::ondemand::object obj;
  SIMDJSON_TRY(val.get_object().get(obj));
  return simdjson::deserialize(obj, out);
 }
 template <concepts::string_view_keyed_map T>
 error_code tag_invoke(deserialize_tag, SIMDJSON_IMPLEMENTATION::ondemand::document &doc, T &out) noexcept {
  SIMDJSON_IMPLEMENTATION::ondemand::object obj;
  SIMDJSON_TRY(doc.get_object().get(obj));
  return simdjson::deserialize(obj, out);
 }
 template <concepts::string_view_keyed_map T>
 error_code tag_invoke(deserialize_tag, SIMDJSON_IMPLEMENTATION::ondemand::document_reference &doc, T &out) noexcept {
  SIMDJSON_IMPLEMENTATION::ondemand::object obj;
  SIMDJSON_TRY(doc.get_object().get(obj));
  return simdjson::deserialize(obj, out);
 }
 /**
@@ -191,10 +255,16 @@ error_code tag_invoke(deserialize_tag, ValT &val, T &out) noexcept(nothrow_deser
  static_assert(
      deserializable<value_type, ValT>,
-      "The specified type inside the unique_ptr must itself be deserializable");
+      "The specified type inside the optional must itself be deserializable");
  static_assert(
      std::is_default_constructible_v<value_type>,
-      "The specified type inside the unique_ptr must default constructible.");
+      "The specified type inside the optional must default constructible.");
  // Check if the value is null
  if (val.is_null()) {
    out.reset(); // Set to nullopt
    return SUCCESS;
  }
  if (!out) {
    out.emplace();
@@ -203,6 +273,352 @@ 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/p2996r10.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 = {};
 }
 template<typename R>
 consteval auto expand(R range) {
  std::vector<std::meta::info> args;
  for (auto r : range) {
    args.push_back(reflect_constant(r));
  }
  return substitute(^^__impl::replicator, args);
 }
 // end of workaround
 template <typename T, typename ValT>
  requires(user_defined_type<T> && std::is_class_v<T>)
 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));
  }
  error_code e = simdjson::SUCCESS;
  [:expand(std::meta::nonstatic_data_members_of(^^T, std::meta::access_context::unchecked())):] >> [&]<auto mem>() {
    if constexpr (!std::meta::is_const(mem) && std::meta::is_public(mem)) {
      constexpr std::string_view key = std::define_static_string(std::meta::identifier_of(mem));
      static_assert(
        deserializable<decltype(out.[:mem:]), SIMDJSON_IMPLEMENTATION::ondemand::object>,
        "The specified type inside the class must itself be deserializable");
      // as long we are succesful or the field is not found, we continue
      if(e == simdjson::SUCCESS || e == simdjson::NO_SUCH_FIELD) {
        obj[key].get(out.[:mem:]);
      }
    }
  };
  return e;
 }
 // Support for enum deserialization - deserialize from string representation using expand approach from P2996R12
 template <typename T, typename ValT>
  requires(std::is_enum_v<T>)
 error_code tag_invoke(deserialize_tag, ValT &val, T &out) noexcept {
 #if SIMDJSON_STATIC_REFLECTION
  std::string_view str;
  SIMDJSON_TRY(val.get_string().get(str));
  bool found = false;
  [:expand(std::meta::enumerators_of(^^T)):] >> [&]<auto enum_val>{
    if (!found && str == std::meta::identifier_of(enum_val)) {
      out = [:enum_val:];
      found = true;
    }
  };
  return found ? SUCCESS : INCORRECT_TYPE;
 #else
  // Fallback: deserialize as integer if reflection not available
  std::underlying_type_t<T> int_val;
  SIMDJSON_TRY(val.get(int_val));
  out = static_cast<T>(int_val);
  return SUCCESS;
 #endif
 }
 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 (val.is_null()) {
    out.reset();
    return SUCCESS;
  }
  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 (val.is_null()) {
    out.reset();
    return SUCCESS;
  }
  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 (val.is_null()) {
    out.reset();
    return SUCCESS;
  }
  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 (val.is_null()) {
    out.reset();
    return SUCCESS;
  }
  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 (val.is_null()) {
    out.reset();
    return SUCCESS;
  }
  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 (val.is_null()) {
    out.reset();
    return SUCCESS;
  }
  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 (val.is_null()) {
    out.reset();
    return SUCCESS;
  }
  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 (val.is_null()) {
    out.reset();
    return SUCCESS;
  }
  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 (val.is_null()) {
    out.reset();
    return SUCCESS;
  }
  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 (val.is_null()) {
    out.reset();
    return SUCCESS;
  }
  if (!out) {
    out = std::make_shared<std::string_view>();
    if (!out) { return MEMALLOC; }
  }
  SIMDJSON_TRY(val.get_string().get(*out));
  return SUCCESS;
 }
 ////////////////////////////////////////
 // Explicit optional specializations
 ////////////////////////////////////////
 error_code tag_invoke(deserialize_tag, auto &val, concepts::optional_type auto&out) noexcept {
  // Check if the value is null
  if (val.is_null()) {
    out.reset(); // Set to nullopt
    return SUCCESS;
  }
  if (!out) {
    out.emplace();
  }
  std::string_view str;
  SIMDJSON_TRY(val.get_string().get(str));
  out.value() = std::string{str};
  return SUCCESS;
 }
 error_code tag_invoke(deserialize_tag, auto &val, concepts::optional_type auto&out) noexcept {
  // Check if the value is null
  if (val.is_null()) {
    out.reset(); // Set to nullopt
    return SUCCESS;
  }
  if (!out) {
    out.emplace();
  }
  int64_t temp;
  SIMDJSON_TRY(val.get_int64().get(temp));
  out.value() = static_cast<int>(temp);
  return SUCCESS;
 }
 ////////////////////////////////////////
 // Explicit smart pointer specializations for string and int types
 ////////////////////////////////////////
 error_code tag_invoke(deserialize_tag, auto &val, std::unique_ptr<std::string> &out) noexcept {
  // Check if the value is null
  if (val.is_null()) {
    out.reset(); // Set to nullptr
    return SUCCESS;
  }
  if (!out) {
    out = std::make_unique<std::string>();
  }
  std::string_view str;
  SIMDJSON_TRY(val.get_string().get(str));
  *out = std::string{str};
  return SUCCESS;
 }
 error_code tag_invoke(deserialize_tag, auto &val, std::shared_ptr<std::string> &out) noexcept {
  // Check if the value is null
  if (val.is_null()) {
    out.reset(); // Set to nullptr
    return SUCCESS;
  }
  if (!out) {
    out = std::make_shared<std::string>();
  }
  std::string_view str;
  SIMDJSON_TRY(val.get_string().get(str));
  *out = std::string{str};
  return SUCCESS;
 }
 error_code tag_invoke(deserialize_tag, auto &val, std::unique_ptr<int> &out) noexcept {
  // Check if the value is null
  if (val.is_null()) {
    out.reset(); // Set to nullptr
    return SUCCESS;
  }
  if (!out) {
    out = std::make_unique<int>();
  }
  int64_t temp;
  SIMDJSON_TRY(val.get_int64().get(temp));
  *out = static_cast<int>(temp);
  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.
@@ -28,6 +28,7 @@ public:
  ) const noexcept final;
  simdjson_warn_unused error_code minify(const uint8_t *buf, size_t len, uint8_t *dst, size_t &dst_len) const noexcept final;
  simdjson_warn_unused bool validate_utf8(const char *buf, size_t len) const noexcept final;
  simdjson_warn_unused size_t write_string_escaped(const std::string_view input, char *out) const noexcept final;
 };
 } // namespace haswell
@@ -41,6 +41,31 @@ simdjson_inline backslash_and_quote backslash_and_quote::copy_and_find(const uin
  };
 }
 struct escaping {
  static constexpr uint32_t BYTES_PROCESSED = 32;
  simdjson_inline static escaping copy_and_find(const uint8_t *src, uint8_t *dst);
  simdjson_inline bool has_escape() { return escape_bits != 0; }
  simdjson_inline int escape_index() { return trailing_zeroes(escape_bits); }
  uint64_t escape_bits;
 }; // struct escaping
 simdjson_inline escaping escaping::copy_and_find(const uint8_t *src, uint8_t *dst) {
  static_assert(SIMDJSON_PADDING >= (BYTES_PROCESSED - 1), "escaping finder must process fewer than SIMDJSON_PADDING bytes");
  simd8<uint8_t> v(src);
  v.store(dst);
  simd8<bool> is_quote = (v == '"');
  simd8<bool> is_backslash = (v == '\\');
  simd8<bool> is_control = (v < 32);
  return {
    uint64_t((is_backslash | is_quote | is_control).to_bitmask())
  };
 }
 } // unnamed namespace
 } // namespace haswell
 } // namespace simdjson
@@ -28,6 +28,7 @@ public:
  ) const noexcept final;
  simdjson_warn_unused error_code minify(const uint8_t *buf, size_t len, uint8_t *dst, size_t &dst_len) const noexcept final;
  simdjson_warn_unused bool validate_utf8(const char *buf, size_t len) const noexcept final;
  simdjson_warn_unused size_t write_string_escaped(const std::string_view input, char *out) const noexcept final;
 };
 } // namespace icelake
@@ -77,7 +77,6 @@ namespace simd {
    friend simdjson_really_inline uint64_t operator==(const simd8<T> lhs, const simd8<T> rhs) {
      return _mm512_cmpeq_epi8_mask(lhs, rhs);
    }
    static const int SIZE = sizeof(base<T>::value);
    template<int N=1>
@@ -41,6 +41,35 @@ simdjson_inline backslash_and_quote backslash_and_quote::copy_and_find(const uin
  };
 }
 struct escaping {
  static constexpr uint32_t BYTES_PROCESSED = 64;
  simdjson_inline static escaping copy_and_find(const uint8_t *src, uint8_t *dst);
  simdjson_inline bool has_escape() { return escape_bits != 0; }
  simdjson_inline int escape_index() { return trailing_zeroes(uint64_t(escape_bits)); }
  __mmask64 escape_bits;
 }; // struct escaping
 simdjson_inline escaping escaping::copy_and_find(const uint8_t *src, uint8_t *dst) {
  static_assert(SIMDJSON_PADDING >= (BYTES_PROCESSED - 1), "escaping finder must process fewer than SIMDJSON_PADDING bytes");
  simd8<uint8_t> v(src);
  v.store(dst);
  __mmask64 is_quote = _mm512_cmpeq_epi8_mask(v, _mm512_set1_epi8('"'));
  __mmask64 is_backslash = _mm512_cmpeq_epi8_mask(v, _mm512_set1_epi8('\\'));
  __mmask64 is_control = _mm512_cmplt_epi8_mask(v, _mm512_set1_epi8(32));
  return {
    (is_backslash | is_quote | is_control)
  };
 }
 } // unnamed namespace
 } // namespace icelake
 } // namespace simdjson
@@ -26,6 +26,15 @@ simdjson_inline simdjson_warn_unused bool validate_utf8(const std::string_view s
  return validate_utf8(sv.data(), sv.size());
 }
 /**
 * Write the string to the output buffer while escaping double-quote, backlash and ascii control characters.
 *
 * @param input the string_view to escape
 * @param out output buffer (for escaped string): to be safe, it should have 6 * input.size() allocated bytes.
 * @return number of bytes written
 */
 simdjson_warn_unused size_t write_string_escaped(const std::string_view input, char *out) noexcept;
 /**
 * Validate the UTF-8 string.
 *
@@ -127,6 +136,14 @@ public:
   */
  simdjson_warn_unused virtual bool validate_utf8(const char *buf, size_t len) const noexcept = 0;
  /**
   * Write the string to the output buffer while escaping double-quote, backlash and ascii control characters.
   *
   * @param input the string_view to escape
   * @param out output buffer (for escaped string): to be safe, it should have 6 * input.size() allocated bytes.
   * @return number of bytes written
   */
  simdjson_warn_unused virtual size_t write_string_escaped(const std::string_view input, char *out) const noexcept = 0;
 protected:
  /** @private Construct an implementation with the given name and description. For subclasses. */
  simdjson_inline implementation(
@@ -23,6 +23,7 @@ public:
  ) const noexcept final;
  simdjson_warn_unused error_code minify(const uint8_t *buf, size_t len, uint8_t *dst, size_t &dst_len) const noexcept final;
  simdjson_warn_unused bool validate_utf8(const char *buf, size_t len) const noexcept final;
  simdjson_warn_unused size_t write_string_escaped(const std::string_view input, char *out) const noexcept final;
 };
 } // namespace lasx
@@ -40,6 +40,31 @@ simdjson_inline backslash_and_quote backslash_and_quote::copy_and_find(const uin
  };
 }
 struct escaping {
  static constexpr uint32_t BYTES_PROCESSED = 16;
  simdjson_inline static escaping copy_and_find(const uint8_t *src, uint8_t *dst);
  simdjson_inline bool has_escape() { return escape_bits != 0; }
  simdjson_inline int escape_index() { return trailing_zeroes(escape_bits); }
  uint64_t escape_bits;
 }; // struct escaping
 simdjson_inline escaping escaping::copy_and_find(const uint8_t *src, uint8_t *dst) {
  static_assert(SIMDJSON_PADDING >= (BYTES_PROCESSED - 1), "escaping finder must process fewer than SIMDJSON_PADDING bytes");
  simd8<uint8_t> v(src);
  v.store(dst);
  simd8<bool> is_quote = (v == '"');
  simd8<bool> is_backslash = (v == '\\');
  simd8<bool> is_control = (v < 32);
  return {
    (is_backslash | is_quote | is_control).to_bitmask()
  };
 }
 } // unnamed namespace
 } // namespace lasx
 } // namespace simdjson
@@ -23,6 +23,7 @@ public:
  ) const noexcept final;
  simdjson_warn_unused error_code minify(const uint8_t *buf, size_t len, uint8_t *dst, size_t &dst_len) const noexcept final;
  simdjson_warn_unused bool validate_utf8(const char *buf, size_t len) const noexcept final;
  simdjson_warn_unused size_t write_string_escaped(const std::string_view input, char *out) const noexcept final;
 };
 } // namespace lsx
@@ -46,6 +46,31 @@ simdjson_inline backslash_and_quote backslash_and_quote::copy_and_find(const uin
  };
 }
 struct escaping {
  static constexpr uint32_t BYTES_PROCESSED = 16;
  simdjson_inline static escaping copy_and_find(const uint8_t *src, uint8_t *dst);
  simdjson_inline bool has_escape() { return escape_bits != 0; }
  simdjson_inline int escape_index() { return trailing_zeroes(escape_bits); }
  uint64_t escape_bits;
 }; // struct escaping
 simdjson_inline escaping escaping::copy_and_find(const uint8_t *src, uint8_t *dst) {
  static_assert(SIMDJSON_PADDING >= (BYTES_PROCESSED - 1), "escaping finder must process fewer than SIMDJSON_PADDING bytes");
  simd8<uint8_t> v(src);
  v.store(dst);
  simd8<bool> is_quote = (v == '"');
  simd8<bool> is_backslash = (v == '\\');
  simd8<bool> is_control = (v < 32);
  return {
    (is_backslash | is_quote | is_control).to_bitmask()
  };
 }
 } // unnamed namespace
 } // namespace lsx
 } // namespace simdjson
@@ -8,6 +8,32 @@ namespace simdjson {
   * @copydoc simdjson::builtin::ondemand
   */
  namespace ondemand = builtin::ondemand;
  /**
   * @copydoc simdjson::builtin::builder
   */
  namespace builder = builtin::builder;
 #if SIMDJSON_STATIC_REFLECTION
  /**
   * Create a JSON string from any user-defined type using static reflection.
   * Only available when SIMDJSON_STATIC_REFLECTION is enabled.
   */
  template<typename T>
    requires(!std::same_as<T, builtin::ondemand::document> &&
             !std::same_as<T, builtin::ondemand::value> &&
             !std::same_as<T, builtin::ondemand::object> &&
             !std::same_as<T, builtin::ondemand::array>)
  inline std::string to_json_string(const T& obj) {
    builder::string_builder str_builder;
    append(str_builder, obj);
    std::string_view view;
    if (str_builder.view().get(view) == SUCCESS) {
      return std::string(view);
    }
    return "";
  }
 #endif
 } // namespace simdjson
 #endif // SIMDJSON_ONDEMAND_H
@@ -191,6 +191,7 @@ using std::size_t;
 #if defined(NDEBUG) || defined(__OPTIMIZE__) || (defined(_MSC_VER) && !defined(_DEBUG))
 // If NDEBUG is set, or __OPTIMIZE__ is set, or we are under MSVC in release mode,
 // then do away with asserts and use __assume.
 // We still recommend that our users set NDEBUG in release mode.
 #if SIMDJSON_VISUAL_STUDIO
 #define SIMDJSON_UNREACHABLE() __assume(0)
 #define SIMDJSON_ASSUME(COND) __assume(COND)
@@ -32,6 +32,7 @@ public:
                                         size_t &dst_len) const noexcept final;
  simdjson_warn_unused bool validate_utf8(const char *buf,
                                          size_t len) const noexcept final;
  simdjson_warn_unused size_t write_string_escaped(const std::string_view input, char *out) const noexcept final;
 };
 } // namespace ppc64
@@ -58,6 +58,32 @@ backslash_and_quote::copy_and_find(const uint8_t *src, uint8_t *dst) {
  };
 }
 struct escaping {
  static constexpr uint32_t BYTES_PROCESSED = 16;
  simdjson_inline static escaping copy_and_find(const uint8_t *src, uint8_t *dst);
  simdjson_inline bool has_escape() { return escape_bits != 0; }
  simdjson_inline int escape_index() { return trailing_zeroes(escape_bits); }
  uint64_t escape_bits;
 }; // struct escaping
 simdjson_inline escaping escaping::copy_and_find(const uint8_t *src, uint8_t *dst) {
  static_assert(SIMDJSON_PADDING >= (BYTES_PROCESSED - 1), "escaping finder must process fewer than SIMDJSON_PADDING bytes");
  simd8<uint8_t> v(src);
  v.store(dst);
  simd8<bool> is_quote = (v == '"');
  simd8<bool> is_backslash = (v == '\\');
  simd8<bool> is_control = (v < 32);
  return {
    // 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())
  };
 }
 } // unnamed namespace
 } // namespace ppc64
 } // namespace simdjson
@@ -24,6 +24,7 @@ public:
  ) const noexcept final;
  simdjson_warn_unused error_code minify(const uint8_t *buf, size_t len, uint8_t *dst, size_t &dst_len) const noexcept final;
  simdjson_warn_unused bool validate_utf8(const char *buf, size_t len) const noexcept final;
  simdjson_warn_unused size_t write_string_escaped(const std::string_view input, char *out) const noexcept final;
 };
 } // namespace westmere
@@ -40,6 +40,31 @@ simdjson_inline backslash_and_quote backslash_and_quote::copy_and_find(const uin
  };
 }
 struct escaping {
  static constexpr uint32_t BYTES_PROCESSED = 16;
  simdjson_inline static escaping copy_and_find(const uint8_t *src, uint8_t *dst);
  simdjson_inline bool has_escape() { return escape_bits != 0; }
  simdjson_inline int escape_index() { return trailing_zeroes(escape_bits); }
  uint64_t escape_bits;
 }; // struct escaping
 simdjson_inline escaping escaping::copy_and_find(const uint8_t *src, uint8_t *dst) {
  static_assert(SIMDJSON_PADDING >= (BYTES_PROCESSED - 1), "escaping finder must process fewer than SIMDJSON_PADDING bytes");
  simd8<uint8_t> v(src);
  v.store(dst);
  simd8<bool> is_quote = (v == '"');
  simd8<bool> is_backslash = (v == '\\');
  simd8<bool> is_control = (v < 32);
  return {
    uint64_t((is_backslash | is_quote | is_control).to_bitmask())
  };
 }
 } // unnamed namespace
 } // namespace westmere
 } // namespace simdjson
@@ -1,6 +1,7 @@
 # The bulk of our data files is found in https://github.com/simdjson/simdjson-data
 set(EXAMPLE_JSON ${CMAKE_CURRENT_BINARY_DIR}/twitter.json PARENT_SCOPE)
 set(EXAMPLE_NDJSON ${CMAKE_CURRENT_BINARY_DIR}/amazon_cellphones.ndjson PARENT_SCOPE)
 set(BENCH_CITM_JSON ${CMAKE_CURRENT_BINARY_DIR}/citm_catalog.json PARENT_SCOPE)
 # Copy static files to the build dir so they live alongside the generated ones
 file(GLOB_RECURSE example_files RELATIVE ${CMAKE_CURRENT_SOURCE_DIR} *.json *.ndjson)
@@ -0,0 +1,42 @@
 # Stage 1. Check out LLVM source code and run the build.
 FROM debian:12 AS builder
 # First, Update the apt's source list and include the sources of the packages.
 RUN grep deb /etc/apt/sources.list | \
    sed 's/^deb/deb-src /g' >> /etc/apt/sources.list
 # Install compiler, python and subversion.
 RUN apt-get update && \
    apt-get install -y --no-install-recommends ca-certificates gnupg \
           build-essential cmake make python3 zlib1g wget subversion unzip ninja-build git linux-perf && \
    rm -rf /var/lib/apt/lists/*
 RUN git clone --depth=1 --branch p2996  https://github.com/bloomberg/clang-p2996.git /tmp/clang-source
 RUN cmake -S /tmp/clang-source/llvm -B /tmp/clang-source/build-llvm -DCMAKE_BUILD_TYPE=Release \
    -DLLVM_ENABLE_ASSERTIONS=ON \
    -DLLVM_UNREACHABLE_OPTIMIZE=ON \
    -DLLVM_ENABLE_RUNTIMES="libcxx;libcxxabi;libunwind" \
    -DCLANG_DEFAULT_CXX_STDLIB=libc++ \
    -DLLVM_ENABLE_PROJECTS=clang -G Ninja
 RUN cmake --build /tmp/clang-source/build-llvm -j
 RUN cmake --install /tmp/clang-source/build-llvm --prefix /tmp/clang-install
 # Stage 2. Produce a minimal release image with build results.
 FROM debian:12
 ARG USER_NAME
 ARG USER_ID
 ARG GROUP_ID
 LABEL maintainer "LLVM Developers"
 # Install packages for minimal useful image.
 RUN apt-get update && \
    apt-get install -y --no-install-recommends build-essential  ca-certificates rust-all libcurl4-openssl-dev cmake make wget python3 python3-dev sudo curl ninja-build vim git binutils linux-perf && \
    rm -rf /var/lib/apt/lists/*
 # Copy build results of stage 1 to /usr/local.
 COPY --from=builder /tmp/clang-install/ /usr/local/
 RUN P=`/usr/local/bin/clang++ -v 2>&1 | grep Target | cut -d' ' -f2-`; echo /usr/local/lib/$P > /etc/ld.so.conf.d/$P.conf
 RUN ldconfig
 RUN addgroup --gid $GROUP_ID user; exit 0
 RUN adduser --disabled-password --gecos '' --uid $USER_ID --gid $GROUP_ID $USER_NAME; exit 0
 RUN echo "$USER_NAME:$USER_NAME" | chpasswd && adduser $USER_NAME sudo
 RUN echo '----->'
 RUN echo 'root:Docker!' | chpasswd
 ENV TERM xterm-256color
 USER $USER_NAME
@@ -0,0 +1,79 @@
 # Building the experimental LLVM compiler for static reflection
 The simdjson has experimental support for static reflection, when the compiler supports it.
 We focus on the [latest p2996 paper](https://isocpp.org/files/papers/P2996R10.html) that is targeting C++26.
 ## Current status
 There are 2 versions of compiler that aim to support the C++26 reflection paper ([p2996](https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2024/p2996r10.html)).
 1. [Clang-p2996 llvm branch](https://github.com/bloomberg/clang-p2996/tree/p2996) that open-source and available in the [Compiler Explorer](https://godbolt.org/z/eoEej3E6j).
 2. EDG reflection branch that is only publicly available in the [Compiler Explorer](https://godbolt.org).
 For now, we will resort to #1, since it is open-source.
 We are excited to hear that this reflection proposal seems to be on-track for C++26. [As per Herb Sutter](https://herbsutter.com/2024/03/22/trip-report-winter-iso-c-standards-meeting-tokyo-japan/).
 ## Instructions for building simdjson for static reflection (using docker)
 We are assuming that you are running Linux or macOS. We recommend that Windows users rely on WSL.
 Follow the following two steps:
 1. Clone the project
 ```bash
 git clone https://github.com/simdjson/simdjson.git
 cd simdjson
 ```
 As of March 2025, support for static reflection is available only in the `json_builder_init` branch, so you should switch:
 ```bash
 git checkout -B json_builder_init
 ```
 2. Make sure that you have [docker installed and running](https://docs.docker.com/engine/install/) on your system. Most Linux distributions support docker though some (like RedHat) have the equivalent (Podman). Users of Apple systems may want to [consider OrbStack](https://orbstack.dev). You do not need to familiar with docker, you just need to make sure that you are have it running.
 3. While inside the `simdjson` repository, run the following bash script:
 ```bash
 bash ./p2996/run_docker.sh bash
 ```
 This will enter a bash shell with access to the repo directory. Note that this will take some time when running it for the first time, since the specific container image has to be built.
 This step builds and executes a docker container defined by our Dockerfile which provides the necessary environment.
 Importantly, we build the experimental LLVM compiler based on the current state of the
 `p2996` branch of the `https://github.com/bloomberg/clang-p2996.git` repository. It is possible that the build could fail. Furthermore, you may need to refresh the build from time to time. We provide a script which allows you to delete the docker image you have built (`bash ./p2996/remove_docker.sh`) so you can start anew.
 4. While inside the docker shell, configure the build system with cmake:
 ```bash
 CXX=clang++ cmake -B buildreflect -D SIMDJSON_STATIC_REFLECTION=ON -DSIMDJSON_DEVELOPER_MODE=ON
 ```
 This only needs to be done once.
 5. Build the code...
 ```bash
 cmake --build buildreflect --target benchmark_serialization_citm_catalog benchmark_serialization_twitter
 ```
 6. Run the tests...
 ```bash
 ctest --test-dir buildreflect --output-on-failure
 ```
 7. Run the benchmarks.
 ```bash
 ./buildreflect/benchmark/static_reflect/citm_catalog_benchmark/benchmark_serialization_citm_catalog
 ./buildreflect/benchmark/static_reflect/twitter_benchmark/benchmark_serialization_twitter
 ```
 You can modify the source code with your favorite editor and run again steps 5 (Build the code) and 6 (Run the tests) and 7 (Run the benchmark). Importantly, you should remain in the docker shell.
 You can create a new docker shell at any time by running step 3 (bash script).
@@ -0,0 +1,8 @@
 #!/usr/bin/env bash
 tuser=$(echo $USER | tr -dc 'a-z')
 container_name=${CONTAINER_NAME:-"debian12-clang-p2996-programming_station-for-$tuser-simdjson"}
 echo $container_name
 echo " Removing the container "
 docker ps -a | awk '{ print $1,$2 }' | grep $container_name| awk '{print $1 }' | xargs -I {} docker stop -t 1 {} | xargs docker rm
 # removing image
 docker image rm $container_name
@@ -0,0 +1,30 @@
 #!/usr/bin/env bash
 if [ -z "$1" ]
  then
    echo "The run-docker-station script takes a command as a argument. E.g., try ./run-docker-station 'ls' "
    exit 1
 fi
 set -o noglob
 SCRIPTPATH="$( cd "$(dirname "$0")" ; pwd -P )"
 COMMAND=$@
 tuser=$(echo $USER | tr -dc 'a-z')
 container_name=${CONTAINER_NAME:-"debian12-clang-p2996-programming_station-for-$tuser-simdjson"}
 command -v docker >/dev/null 2>&1 || { echo >&2 "Please install docker. E.g., go to https://www.docker.com/products/docker-desktop Type 'docker' to diagnose the problem."; exit 1; }
 docker info >/dev/null 2>&1 || { echo >&2 "Docker server is not running? type 'docker info'."; exit 1; }
 SSHPARAM=""
 [ -e "${SSH_AUTH_SOCK}" ] && SSHPARAM="--volume /run/host-services/ssh-auth.sock:/run/host-services/ssh-auth.sock  --env SSH_AUTH_SOCK=/run/host-services/ssh-auth.sock"
 [ -e "${HOME}/.ssh" ] && SSHPARAM="--volume ${HOME}/.ssh:/home/$tuser/.ssh:ro"
 docker image inspect $container_name >/dev/null 2>&1 || ( echo "instantiating the container" ; docker build --no-cache -t $container_name -f $SCRIPTPATH/Dockerfile --build-arg USER_NAME="$tuser"  --build-arg USER_ID=$(id -u)  --build-arg GROUP_ID=$(id -g) .  )
 if [ -t 0 ]; then DOCKER_ARGS=-it; fi
 docker run --rm $DOCKER_ARGS -h $container_name $SSHPARAM -v $(pwd):$(pwd):Z --privileged  -w $(pwd)  $container_name sh -c "$COMMAND"
@@ -10,12 +10,41 @@ import os
 import re
 import shutil
 import datetime
 import json
 from typing import Dict, List, Optional, Set, TextIO, Union, cast
 # Check for Python 3, this does not actually work.
 if sys.version_info < (3, 0):
    sys.stdout.write("Sorry, requires Python 3.x or better\n")
    sys.exit(1)
 rules = """
 We refer your to the HACKING.md file for more information on how the project is organized.
 To help understand the error, here are the rules for including files in simdjson:
 All implementation-specific files, including arm64.h, arm64/implementation.h and
 arm64/ondemand.h, must be within SIMDJSON_CONDITIONAL_INCLUDE blocks.
 Top-level headers must not be included in any SIMDJSON_CONDITIONAL_INCLUDE block.
 Generic files must be included only in amalgamator files (arm64.h,
 arm64/implementation.h, arm64/ondemand.h, generic/amalgamated.h).
 We fail if an implementation-specific file is included more than once in the same block.
 We fail if a generic file is included more than once per implementation in the same block.
 Tip: generally, "file" will search the including file's source directory first, then
 the search paths while <file> does it the other way around.
 We prefer to use <> in simdjson headers to avoid accidentally including a file from the
 wrong directory.
 The amalgamate.py script checks that all files are included.
 """
 SCRIPTPATH = os.path.dirname(os.path.abspath(sys.argv[0]))
 PROJECTPATH = os.path.dirname(SCRIPTPATH)
 print(f"SCRIPTPATH={SCRIPTPATH} PROJECTPATH={PROJECTPATH}")
@@ -62,6 +91,22 @@ class SimdjsonFile:
    def __str__(self):
        return self.include_path
    def dump(self):
        return {
            'root': self.root,
            'include_path': self.include_path,
            'includes': [include.include_path for include in self.includes],
            'included_from': [included_from.include_path for included_from in self.included_from],
            'editor_only_includes': [editor_only_include.include_path for editor_only_include in self.editor_only_includes],
            'editor_only_included_from': [editor_only_included_from.include_path for editor_only_included_from in self.editor_only_included_from],
            'processed': self.processed,
            'dependency_file': self.dependency_file.include_path if self.dependency_file else None,
            'is_amalgamator': self.is_amalgamator,
            'implementation': self.implementation,
        }
    def json(self):
        return json.dumps(self.dump(), indent=4, sort_keys=True, ensure_ascii=False)
    def __repr__(self):
        return self.include_path
@@ -162,20 +207,21 @@ class SimdjsonFile:
    def add_include(self, include: 'SimdjsonFile'):
        if self.is_conditional_include:
-            assert include.is_conditional_include, f"{self} cannot include {include} without #ifndef SIMDJSON_CONDITIONAL_INCLUDE."
+            # If I have a dependency file, I can only include something that has a dependency file.
            assert include.is_conditional_include, f"{self} cannot include {include} without #ifndef SIMDJSON_CONDITIONAL_INCLUDE. {rules}"
            # TODO make sure we only include amalgamated files that are guaranteed to be included with us (or before us)
            # if include.amalgamator_file:
            #     assert include.amalgamator_file == self, f"{self} cannot include {include}: it should be included from {include.amalgamator_file} instead."
        else:
-            assert include.is_amalgamator or not include.is_conditional_include, f"{self} cannot include {include} because it is an amalgamated file."
+            assert include.is_amalgamator or not include.is_conditional_include, f"{self} cannot include {include} because it is an amalgamated file. {rules}"
        self.includes.append(include)
        include.included_from.add(self)
    def add_editor_only_include(self, include: 'SimdjsonFile'):
-        assert self.is_conditional_include, f"Cannot use #ifndef SIMDJSON_CONDITIONAL_INCLUDE in {self} because it is not an amalgamated file."
+        assert self.is_conditional_include, f"Cannot use #ifndef SIMDJSON_CONDITIONAL_INCLUDE in {self} because it is not an amalgamated file. {rules}"
        if not include.is_conditional_include:
-            assert self.dependency_file, f"{self} cannot include {include} without #ifndef SIMDJSON_CONDITIONAL_INCLUDE."
+            assert self.dependency_file, f"{self} cannot include {include} without #ifndef SIMDJSON_CONDITIONAL_INCLUDE. {rules}"
        # TODO make sure we only include amalgamated files that are guaranteed to be included with us (or before us)
        # elif include.amalgamator_file:
        #     assert self.is_amalgamated_before(self.amalgamator_file), f"{self} cannot include {include}: it should be included from {include.amalgamator_file} instead."
@@ -190,11 +236,11 @@ class SimdjsonFile:
                if file.dependency_file == self:
                    for editor_only_include in file.editor_only_includes:
                        if not editor_only_include.is_conditional_include:
-                            assert editor_only_include in self.includes, f"{file} includes {editor_only_include}, but it is not included from {self}. It must be added to {self}."
+                            assert editor_only_include in self.includes, f"{file} includes {editor_only_include}, but it is not included from {self}. It must be added to {self}. {rules}"
                            if editor_only_include in extra_include_set:
                                extra_include_set.remove(editor_only_include)
-            assert len(extra_include_set) == 0, f"{self} unnecessarily includes {extra_include_set}. They are not included in the corresponding amalgamated files."
+            assert len(extra_include_set) == 0, f"{self} unnecessarily includes {extra_include_set}. They are not included in the corresponding amalgamated files. {rules}"
 class SimdjsonRepository:
    def __init__(self, project_path: str, relative_roots: List[RelativeRoot]):
@@ -320,6 +366,7 @@ class Amalgamator:
        assert not self.editor_only_region
        with open(file.absolute_path, 'r') as fid2:
            print(f"including: {file}")
            for line in fid2:
                line = line.rstrip('\n')
@@ -329,9 +376,9 @@ class Amalgamator:
                # Ignore lines inside #ifndef SIMDJSON_CONDITIONAL_INCLUDE
                if re.search(r'^#ifndef\s+SIMDJSON_CONDITIONAL_INCLUDE\s*$', line):
-                    assert file.is_conditional_include, f"{file} uses #ifndef SIMDJSON_CONDITIONAL_INCLUDE but is not an amalgamated file!"
+                    assert file.is_conditional_include, f"{file} uses #ifndef SIMDJSON_CONDITIONAL_INCLUDE but is not an amalgamated file! {rules}"
-                    assert self.in_conditional_include_block, f"{file} uses #ifndef SIMDJSON_CONDITIONAL_INCLUDE without a prior #define SIMDJSON_CONDITIONAL_INCLUDE: {self.include_stack}"
+                    assert self.in_conditional_include_block, f"{file} uses #ifndef SIMDJSON_CONDITIONAL_INCLUDE without a prior #define SIMDJSON_CONDITIONAL_INCLUDE: {self.include_stack} {rules}"
-                    assert not self.editor_only_region, f"{file} uses #ifndef SIMDJSON_CONDITIONAL_INCLUDE twice in a row"
+                    assert not self.editor_only_region, f"{file} uses #ifndef SIMDJSON_CONDITIONAL_INCLUDE twice in a row {rules}"
                    self.editor_only_region = True
                # Handle ignored lines (and ending ignore blocks)
@@ -349,7 +396,7 @@ class Amalgamator:
                        self.editor_only_region = False
                    continue
-                assert not end_ignore, f"{file} has #endif // SIMDJSON_CONDITIONAL_INCLUDE without #ifndef SIMDJSON_CONDITIONAL_INCLUDE"
+                assert not end_ignore, f"{file} has #endif // SIMDJSON_CONDITIONAL_INCLUDE without #ifndef SIMDJSON_CONDITIONAL_INCLUDE {rules}"
                # Handle #include lines
                included = re.search(r'^#include\s+["<]([^">]*)[">]', line)
@@ -376,26 +423,26 @@ class Amalgamator:
                    self.implementation = None
                elif re.search(r'\bSIMDJSON_IMPLEMENTATION\b', line) and file.include_path != IMPLEMENTATION_DETECTION_H:
                    # copy the line, with SIMDJSON_IMPLEMENTATION replace to what it is currently defined to
-                    assert self.implementation, f"Use of SIMDJSON_IMPLEMENTATION while not defined in {file}: {line}"
+                    assert self.implementation, f"Use of SIMDJSON_IMPLEMENTATION while not defined in {file}: {line}\n{rules}"
                    line = re.sub(r'\bSIMDJSON_IMPLEMENTATION\b',self.implementation,line)
                # Handle defining and undefining SIMDJSON_CONDITIONAL_INCLUDE
                defined = re.search(r'^#define\s+SIMDJSON_CONDITIONAL_INCLUDE\s*$', line)
                if defined:
-                    assert not file.is_conditional_include, "SIMDJSON_CONDITIONAL_INCLUDE defined in amalgamated file {file}! Not allowed."
+                    assert not file.is_conditional_include, "SIMDJSON_CONDITIONAL_INCLUDE defined in amalgamated file {file}! Not allowed. {rules}"
-                    assert not self.in_conditional_include_block, f"{file} redefines SIMDJSON_CONDITIONAL_INCLUDE"
+                    assert not self.in_conditional_include_block, f"{file} redefines SIMDJSON_CONDITIONAL_INCLUDE {rules}"
                    self.in_conditional_include_block = True
                    self.found_includes_per_conditional_block.clear()
                    self.write(f'/* defining SIMDJSON_CONDITIONAL_INCLUDE */')
                elif re.search(r'^#undef\s+SIMDJSON_CONDITIONAL_INCLUDE\s*$', line):
-                    assert not file.is_conditional_include, "SIMDJSON_CONDITIONAL_INCLUDE undefined in amalgamated file {file}! Not allowed."
+                    assert not file.is_conditional_include, "SIMDJSON_CONDITIONAL_INCLUDE undefined in amalgamated file {file}! Not allowed. {rules}"
-                    assert self.in_conditional_include_block, f"{file} undefines SIMDJSON_CONDITIONAL_INCLUDE without defining it"
+                    assert self.in_conditional_include_block, f"{file} undefines SIMDJSON_CONDITIONAL_INCLUDE without defining it {rules}"
                    self.write(f'/* undefining SIMDJSON_CONDITIONAL_INCLUDE */')
                    self.in_conditional_include_block = False
                self.write(line)
-            assert not self.editor_only_region, f"{file} ended without #endif // SIMDJSON_CONDITIONAL_INCLUDE"
+            assert not self.editor_only_region, f"{file} ended without #endif // SIMDJSON_CONDITIONAL_INCLUDE {rules}"
        self.write(f"/* end file {self.file_to_str(file)} */")
@@ -1,4 +1,4 @@
-/* auto-generated on 2025-06-04 00:22:10 -0400. Do not edit! */
+/* auto-generated on 2025-06-24 15:13:44 -0400. Do not edit! */
 /* including simdjson.cpp:  */
 /* begin file simdjson.cpp */
 #define SIMDJSON_SRC_SIMDJSON_CPP
@@ -1,4 +1,4 @@
-/* auto-generated on 2025-06-04 00:22:10 -0400. Do not edit! */
+/* auto-generated on 2025-06-24 15:13:44 -0400. Do not edit! */
 /* including simdjson.h:  */
 /* begin file simdjson.h */
 #ifndef SIMDJSON_H
@@ -4491,7 +4491,7 @@ public:
    iterator& operator=(const iterator&) noexcept = default;
  private:
    simdjson_inline iterator(const internal::tape_ref &tape) noexcept;
-    internal::tape_ref tape;
+    internal::tape_ref tape{};
    friend class array;
  };
@@ -4582,7 +4582,7 @@ public:
 private:
  simdjson_inline array(const internal::tape_ref &tape) noexcept;
-  internal::tape_ref tape;
+  internal::tape_ref tape{};
  friend class element;
  friend struct simdjson_result<element>;
  template<typename T>
@@ -6220,7 +6220,7 @@ public:
 private:
  simdjson_inline element(const internal::tape_ref &tape) noexcept;
-  internal::tape_ref tape;
+  internal::tape_ref tape{};
  friend class document;
  friend class object;
  friend class array;
@@ -6391,7 +6391,7 @@ public:
  private:
    simdjson_inline iterator(const internal::tape_ref &tape) noexcept;
-    internal::tape_ref tape;
+    internal::tape_ref tape{};
    friend class object;
  };
@@ -6526,7 +6526,7 @@ public:
 private:
  simdjson_inline object(const internal::tape_ref &tape) noexcept;
-  internal::tape_ref tape;
+  internal::tape_ref tape{};
  friend class element;
  friend struct simdjson_result<element>;
@@ -165,6 +165,10 @@ simdjson_warn_unused error_code dom_parser_implementation::parse(const uint8_t *
  return stage2(_doc);
 }
 simdjson_warn_unused size_t implementation::write_string_escaped(const std::string_view input, char *out) const noexcept {
  return arm64::stringparsing::write_string_escaped(input, out);
 }
 } // namespace arm64
 } // namespace simdjson
@@ -121,10 +121,78 @@ simdjson_inline void validate_utf8_character() {
  idx += 4;
 }
 static const uint8_t CHAR_TYPE_SPACE     = 1 << 0;
 static const uint8_t CHAR_TYPE_OPERATOR  = 1 << 1;
 static const uint8_t CHAR_TYPE_ESC_ASCII = 1 << 2;
 static const uint8_t CHAR_TYPE_NON_ASCII = 1 << 3;
 const uint8_t char_table[256] = {
  0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04,
  0x04, 0x05, 0x05, 0x04, 0x04, 0x05, 0x04, 0x04,
  0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04,
  0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04,
  0x01, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00,
  0x00, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00,
  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00,
  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  0x00, 0x00, 0x00, 0x02, 0x04, 0x02, 0x00, 0x00,
  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  0x00, 0x00, 0x00, 0x02, 0x00, 0x02, 0x00, 0x00,
  0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08,
  0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08,
  0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08,
  0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08,
  0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08,
  0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08,
  0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08,
  0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08,
  0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08,
  0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08,
  0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08,
  0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08,
  0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08,
  0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08,
  0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08,
  0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08
 };
 simdjson_inline bool char_is_type(uint8_t c, uint8_t type) {
  return (char_table[c] & type);
 }
 simdjson_inline bool char_is_space(uint8_t c) {
  return char_is_type(c, CHAR_TYPE_SPACE);
 }
 simdjson_inline bool char_is_operator(uint8_t c) {
  return char_is_type(c, CHAR_TYPE_OPERATOR);
 }
 simdjson_inline bool char_is_space_or_operator(uint8_t c) {
  return char_is_type(c, CHAR_TYPE_SPACE | CHAR_TYPE_OPERATOR);
 }
 simdjson_inline bool char_is_ascii_stop(uint8_t c) {
  return char_is_type(c, CHAR_TYPE_ESC_ASCII | CHAR_TYPE_NON_ASCII);
 }
 // Returns true if the string is unclosed.
 simdjson_inline bool validate_string() {
  idx++; // skip first quote
-  while (idx < len && buf[idx] != '"') {
+  while (idx < len) {
    do {
      if (char_is_ascii_stop(buf[idx])) { break; }
      idx++;
    } while (idx < len);
    if (idx >= len) { return true; }
    if (buf[idx] == '"') {
      return false;
    }
    if (buf[idx] == '\\') {
      idx += 2;
    } else if (simdjson_unlikely(buf[idx] & 0x80)) {
@@ -138,43 +206,31 @@ simdjson_inline bool validate_string() {
  return false;
 }
 simdjson_inline bool is_whitespace_or_operator(uint8_t c) {
  switch (c) {
    case '{': case '}': case '[': case ']': case ',': case ':':
    case ' ': case '\r': case '\n': case '\t':
      return true;
    default:
      return false;
  }
 }
 //
 // Parse the entire input in STEP_SIZE-byte chunks.
 //
 simdjson_inline error_code scan() {
  bool unclosed_string = false;
  for (;idx<len;idx++) {
-    switch (buf[idx]) {
+    do {
      if (!char_is_space(buf[idx])) { break; }
      idx++;
    } while (idx < len);
    if (idx >= len) { break; }
    // String
-      case '"':
+    if (buf[idx] == '"') {
      add_structural();
      unclosed_string |= validate_string();
        break;
    // Operator
-      case '{': case '}': case '[': case ']': case ',': case ':':
+    } else if (char_is_operator(buf[idx])) {
      add_structural();
        break;
      // Whitespace
      case ' ': case '\r': case '\n': case '\t':
        break;
    // Primitive or invalid character (invalid characters will be checked in stage 2)
-      default:
+    } else {
      // Anything else, add the structural and go until we find the next one
      add_structural();
-        while (idx+1<len && !is_whitespace_or_operator(buf[idx+1])) {
+      while (idx+1<len && !char_is_space_or_operator(buf[idx+1])) {
        idx++;
      };
        break;
    }
  }
  // We pad beyond.
@@ -403,6 +459,10 @@ simdjson_warn_unused error_code dom_parser_implementation::parse(const uint8_t *
  return stage2(_doc);
 }
 simdjson_warn_unused size_t implementation::write_string_escaped(const std::string_view input, char *out) const noexcept {
  return fallback::stringparsing::write_string_escaped(input, out);
 }
 } // namespace fallback
 } // namespace simdjson
@@ -1,3 +1,4 @@
 #include <cstdint>
 #ifndef SIMDJSON_SRC_GENERIC_STAGE2_STRINGPARSING_H
 #ifndef SIMDJSON_CONDITIONAL_INCLUDE
@@ -236,7 +237,106 @@ 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) {
    auto vec_processing = [input,out]() -> size_t {
      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 index + vinput.escape_index(); // We have a character that needs escaping
        }
        position += escaping::BYTES_PROCESSED;
      }
      if(index == input.size()) { return input.size(); }
      // We virtually backtrack so we can load a full vector register
      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 index + vinput.escape_index(); // We have a character that needs escaping
      }
      return input.size();
    };
    i = vec_processing();
    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",
    "\\x000e", "\\x000f", "\\x0010", "\\x0011", "\\x0012", "\\x0013", "\\x0014",
    "\\x0015", "\\x0016", "\\x0017", "\\x0018", "\\x0019", "\\x001a", "\\x001b",
    "\\x001c", "\\x001d", "\\x001e", "\\x001f"};
  static std::array<uint8_t, 256> json_quotable_character =
    []() SIMDJSON_CONSTEXPR_LAMBDA {
      std::array<uint8_t, 256> result{};
      for (int index = 0; index < 32; index++) {
        result[index] = 1;
      }
      for (int index : {'"', '\\'}) {
        result[index] = 1;
      }
      return result;
    }();
  // The rest could possibly be vectorized, but consider that we expect most strings
  // to be short or not to require escaping.
  for (; i < input.size(); i++) {
    uint8_t c = static_cast<uint8_t>(input[i]);
    if(json_quotable_character[c]) {
      switch (c) {
      case '"':
        out[pos++] = '\\';
        out[pos++] = '"';
        break;
      case '\\':
        out[pos++] = '\\';
        out[pos++] = '\\';
        break;
      case '\b':
        out[pos++] = '\\';
        out[pos++] = 'b';
        break;
      case '\f':
        out[pos++] = '\\';
        out[pos++] = 'f';
        break;
      case '\n':
        out[pos++] = '\\';
        out[pos++] = 'n';
        break;
      case '\r':
        out[pos++] = '\\';
        out[pos++] = 'r';
        break;
      case '\t':
        out[pos++] = '\\';
        out[pos++] = 't';
        break;
      default:
        control_chars[c].copy(out + pos, 6);
        pos += 6;
      }
    } else {
      out[pos++] = c;
    }
  }
  return pos;
 }
 } // namespace stringparsing
 } // unnamed namespace
 } // namespace SIMDJSON_IMPLEMENTATION
 } // namespace simdjson
@@ -162,6 +162,10 @@ simdjson_warn_unused error_code dom_parser_implementation::parse(const uint8_t *
  return stage2(_doc);
 }
 simdjson_warn_unused size_t implementation::write_string_escaped(const std::string_view input, char *out) const noexcept {
  return haswell::stringparsing::write_string_escaped(input, out);
 }
 } // namespace SIMDJSON_IMPLEMENTATION
 } // namespace simdjson
@@ -208,6 +208,10 @@ simdjson_warn_unused error_code dom_parser_implementation::parse(const uint8_t *
  return stage2(_doc);
 }
 simdjson_warn_unused size_t implementation::write_string_escaped(const std::string_view input, char *out) const noexcept {
  return icelake::stringparsing::write_string_escaped(input, out);
 }
 } // namespace icelake
 } // namespace simdjson
@@ -186,6 +186,9 @@ public:
  simdjson_warn_unused bool validate_utf8(const char * buf, size_t len) const noexcept final override {
    return set_best()->validate_utf8(buf, len);
  }
  simdjson_warn_unused size_t write_string_escaped(const std::string_view input, char *out) const noexcept final {
    return set_best()->write_string_escaped(input, out);
  }
  simdjson_inline detect_best_supported_implementation_on_first_use() noexcept : implementation("best_supported_detector", "Detects the best supported implementation and sets it", 0) {}
 private:
  const implementation *set_best() const noexcept;
@@ -236,6 +239,9 @@ 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, 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
    // it seems unlikely that unsupported_implementation will ever be used. If it is used,
@@ -319,6 +325,9 @@ simdjson_warn_unused error_code minify(const char *buf, size_t len, char *dst, s
 simdjson_warn_unused bool validate_utf8(const char *buf, size_t len) noexcept {
  return get_active_implementation()->validate_utf8(buf, len);
 }
 simdjson_warn_unused size_t write_string_escaped(const std::string_view input, char *out) noexcept {
  return get_active_implementation()->write_string_escaped(input, out);
 }
 const implementation * builtin_implementation() {
  static const implementation * builtin_impl = get_available_implementations()[SIMDJSON_STRINGIFY(SIMDJSON_BUILTIN_IMPLEMENTATION)];
  assert(builtin_impl);
@@ -125,6 +125,10 @@ simdjson_warn_unused error_code dom_parser_implementation::parse(const uint8_t *
  return stage2(_doc);
 }
 simdjson_warn_unused size_t implementation::write_string_escaped(const std::string_view input, char *out) const noexcept {
  return lasx::stringparsing::write_string_escaped(input, out);
 }
 } // namespace lasx
 } // namespace simdjson
@@ -129,6 +129,10 @@ simdjson_warn_unused error_code dom_parser_implementation::parse(const uint8_t *
  return stage2(_doc);
 }
 simdjson_warn_unused size_t implementation::write_string_escaped(const std::string_view input, char *out) const noexcept {
  return lsx::stringparsing::write_string_escaped(input, out);
 }
 } // namespace lsx
 } // namespace simdjson
@@ -135,6 +135,10 @@ simdjson_warn_unused error_code dom_parser_implementation::parse(const uint8_t *
  return stage2(_doc);
 }
 simdjson_warn_unused size_t implementation::write_string_escaped(const std::string_view input, char *out) const noexcept {
  return ppc64::stringparsing::write_string_escaped(input, out);
 }
 } // namespace ppc64
 } // namespace simdjson
@@ -167,6 +167,10 @@ simdjson_warn_unused error_code dom_parser_implementation::parse(const uint8_t *
  return stage2(_doc);
 }
 simdjson_warn_unused size_t implementation::write_string_escaped(const std::string_view input, char *out) const noexcept {
  return westmere::stringparsing::write_string_escaped(input, out);
 }
 } // namespace westmere
 } // namespace simdjson
@@ -26,3 +26,4 @@ endif()
 add_cpp_test(checkimplementation LABELS other per_implementation)
 add_subdirectory(compilation_failure_tests)
 add_subdirectory(builder)
@@ -0,0 +1,16 @@
 # All remaining tests link with simdjson proper
 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)
  add_cpp_test(static_reflection_comprehensive_tests     LABELS ondemand acceptance per_implementation)
  add_cpp_test(static_reflection_edge_cases_tests        LABELS ondemand acceptance per_implementation)
  add_cpp_test(static_reflection_enum_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
    COMMAND ${CMAKE_COMMAND} -E copy_if_different  # which executes "cmake -E copy_if_different..."
        "$<TARGET_FILE:simdjson>"      # <--this is in-file
        "$<TARGET_FILE_DIR:builder_string_builder_tests>")                 # <--this is out-file path
 endif(MSVC AND BUILD_SHARED_LIBS)
@@ -0,0 +1,349 @@
 #include "simdjson.h"
 #include "test_builder.h"
 #include <string_view>
 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;
    #if SIMDJSON_EXCEPTIONS
    bool string_convertion_except() {
        TEST_START();
        simdjson::ondemand::parser p;
        simdjson::builder::string_builder sb;
        sb.append('a');
        std::string r(sb);
        ASSERT_EQUAL(r, "a");
        TEST_SUCCEED();
    }
    #endif
    bool append_char() {
        TEST_START();
        simdjson::builder::string_builder sb;
        sb.append('a');
        ASSERT_EQUAL(sb.size(), 1);
        std::string_view p;
        auto result = sb.view().get(p);
        ASSERT_SUCCESS(result);
        ASSERT_EQUAL(p, "a");
        TEST_SUCCEED();
    }
    bool append_integer() {
        TEST_START();
        simdjson::builder::string_builder sb;
        sb.append(42);
        ASSERT_EQUAL(sb.size(), 2);
        std::string_view p;
        auto result = sb.view().get(p);
        ASSERT_SUCCESS(result);
        ASSERT_EQUAL(p, "42");
        TEST_SUCCEED();
    }
    bool append_float() {
        TEST_START();
        simdjson::builder::string_builder sb;
        sb.append(1.1);
        ASSERT_EQUAL(sb.size(), 3);
        std::string_view p;
        auto result = sb.view().get(p);
        ASSERT_SUCCESS(result);
        ASSERT_EQUAL(p, "1.1");
        TEST_SUCCEED();
    }
    bool append_null() {
        TEST_START();
        simdjson::builder::string_builder sb;
        sb.append_null();
        ASSERT_EQUAL(sb.size(), 4);
        std::string_view p;
        auto result = sb.view().get(p);
        ASSERT_SUCCESS(result);
        ASSERT_EQUAL(p, "null");
        TEST_SUCCEED();
    }
    bool clear() {
        TEST_START();
        simdjson::builder::string_builder sb;
        sb.append('a');
        sb.clear();
        ASSERT_EQUAL(sb.size(), 0);
        TEST_SUCCEED();
    }
    bool escape_and_append() {
        TEST_START();
        simdjson::builder::string_builder sb;
        sb.escape_and_append("Hello, \"world\"!");
        std::string_view p;
        auto result = sb.view().get(p);
        ASSERT_SUCCESS(result);
        ASSERT_EQUAL(p, "Hello, \\\"world\\\"!");
        TEST_SUCCEED();
    }
    bool escape_and_append_with_quotes() {
        TEST_START();
        simdjson::builder::string_builder sb;
        sb.escape_and_append_with_quotes("Hello, \"world\"!");
        std::string_view p;
        auto result = sb.view().get(p);
        ASSERT_SUCCESS(result);
        ASSERT_EQUAL(p, "\"Hello, \\\"world\\\"!\"");
        TEST_SUCCEED();
    }
    bool various_integers() {
        TEST_START();
        std::vector<std::pair<int64_t, std::string_view>> test_cases = {
            {0, "0"},
            {1, "1"},
            {-1, "-1"},
            {42, "42"},
            {-42, "-42"},
            {100, "100"},
            {-100, "-100"},
            {999, "999"},
            {-999, "-999"},
            {2147483647, "2147483647"},  // max 32-bit integer
            {-2147483648, "-2147483648"}, // min 32-bit integer
            {4294967296ULL, "4294967296"}, // 2^32
            {-4294967296LL, "-4294967296"},
            {10000000000LL, "10000000000"}, // 10 billion
            {-10000000000LL, "-10000000000"},
            {9223372036854775807LL, "9223372036854775807"}, // max 64-bit integer
            {-9223372036854775807LL-1, "-9223372036854775808"}, // min 64-bit integer
            {1234567890123LL, "1234567890123"},
            {-1234567890123LL, "-1234567890123"},
        };
        for (const auto& [value, expected] : test_cases) {
            simdjson::builder::string_builder sb;
            sb.append(value);
            std::string_view p;
            auto result = sb.view().get(p);
            ASSERT_SUCCESS(result);
            ASSERT_EQUAL(p, expected);
        }
        TEST_SUCCEED();
    }
    bool various_unsigned_integers() {
        TEST_START();
        std::vector<std::pair<uint64_t, std::string_view>> test_cases = {
            {0, "0"},
            {1, "1"},
            {42, "42"},
            {100, "100"},
            {999, "999"},
            {2147483647, "2147483647"},  // max 32-bit integer
            {4294967296ULL, "4294967296"}, // 2^32
            {10000000000LL, "10000000000"}, // 10 billion
            {9223372036854775807LL, "9223372036854775807"}, // max 64-bit integer
            {1234567890123LL, "1234567890123"},
        };
        for (const auto& [value, expected] : test_cases) {
            simdjson::builder::string_builder sb;
            sb.append(value);
            std::string_view p;
            auto result = sb.view().get(p);
            ASSERT_SUCCESS(result);
            ASSERT_EQUAL(p, expected);
        }
        TEST_SUCCEED();
    }
    bool append_raw() {
        TEST_START();
        simdjson::builder::string_builder sb;
        sb.append_raw("Test");
        std::string_view p;
        auto result = sb.view().get(p);
        ASSERT_SUCCESS(result);
        ASSERT_EQUAL(p, "Test");
        TEST_SUCCEED();
    }
    bool raw_with_length() {
        TEST_START();
        simdjson::builder::string_builder sb;
        sb.append_raw("Test String", 4);
        std::string_view p;
        auto result = sb.view().get(p);
        ASSERT_SUCCESS(result);
        ASSERT_EQUAL(p, "Test");
        TEST_SUCCEED();
    }
    bool string_convertion() {
        TEST_START();
        simdjson::builder::string_builder sb;
        sb.append('a');
        std::string_view p;
        auto result = sb.view().get(p);
        ASSERT_SUCCESS(result);
        ASSERT_EQUAL(p, "a");
        TEST_SUCCEED();
    }
    bool unicode_validation() {
        TEST_START();
        simdjson::builder::string_builder sb;
        sb.append('a');
        ASSERT_TRUE(sb.validate_unicode());
        TEST_SUCCEED();
    }
    bool buffer_growth() {
        TEST_START();
        simdjson::builder::string_builder sb;
        for(int i = 0; i < 3; ++i) {
            sb.append('a');
        }
        ASSERT_EQUAL(sb.size(), 3);
        TEST_SUCCEED();
    }
    void serialize_car_long(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_long() {
        TEST_START();
        simdjson::builder::string_builder sb;
        Car c = {"Toyota", "Corolla", 2017, {30.0,30.2,30.513,30.79}};
        serialize_car_long(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();
    }
    void serialize_car(const Car& car, simdjson::builder::string_builder& builder) {
        // start of JSON
        builder.start_object();
        // "make"
        builder.append_key_value("make", car.make);
        builder.append_comma();
        // "model"
        builder.append_key_value("model", car.model);
        builder.append_comma();
        // "year"
        builder.append_key_value("year", car.year);
        builder.append_comma();
        // "tire_pressure"
        builder.escape_and_append_with_quotes("tire_pressure");
        builder.append_colon();
        builder.start_array();
        // 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_comma();
            }
        }
        // end of array
        builder.end_array();
        // end of object
        builder.end_object();
    }
    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
            various_integers() &&
            various_unsigned_integers() &&
            car_test_long() &&
            car_test() &&
    #if SIMDJSON_EXCEPTIONS
            string_convertion_except() &&
    #endif
            append_char() &&
            append_integer() &&
            append_float() &&
            append_null() &&
            clear() &&
            escape_and_append() &&
            escape_and_append_with_quotes() &&
            append_raw() &&
            raw_with_length() &&
            string_convertion() &&
            buffer_growth() &&
            unicode_validation() &&
            true;
    }
 } // 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);
 }
@@ -0,0 +1,260 @@
 #include "simdjson.h"
 #include "test_builder.h"
 #include <string>
 #include <string_view>
 #include <vector>
 #include <set>
 #include <map>
 #include <optional>
 #include <memory>
 using namespace simdjson;
 namespace builder_tests {
  bool test_primitive_types() {
    TEST_START();
 #if SIMDJSON_STATIC_REFLECTION
    struct PrimitiveTypes {
      bool bool_val;
      char char_val;
      int int_val;
      double double_val;
      float float_val;
    };
    PrimitiveTypes test{true, 'X', 42, 3.14159, 2.71f};
    auto result = builder::to_json_string(test);
    ASSERT_SUCCESS(result);
    std::string json = result.value();
    ASSERT_TRUE(json.find("\"bool_val\":true") != std::string::npos);
    ASSERT_TRUE(json.find("\"char_val\":\"X\"") != std::string::npos);
    ASSERT_TRUE(json.find("\"int_val\":42") != std::string::npos);
    ASSERT_TRUE(json.find("\"double_val\":3.14159") != std::string::npos);
    // Test round-trip
    ondemand::parser parser;
    auto doc_result = parser.iterate(pad(json));
    ASSERT_SUCCESS(doc_result);
    auto get_result = doc_result.value().get<PrimitiveTypes>();
    ASSERT_SUCCESS(get_result);
    PrimitiveTypes deserialized = std::move(get_result.value());
    ASSERT_EQUAL(deserialized.bool_val, test.bool_val);
    ASSERT_EQUAL(deserialized.char_val, test.char_val);
    ASSERT_EQUAL(deserialized.int_val, test.int_val);
    ASSERT_EQUAL(deserialized.double_val, test.double_val);
 #endif
    TEST_SUCCEED();
  }
  bool test_string_types() {
    TEST_START();
 #if SIMDJSON_STATIC_REFLECTION
    struct StringTypes {
      std::string string_val;
      std::string_view string_view_val;
    };
    StringTypes test{"hello world", "test_view"};
    auto result = builder::to_json_string(test);
    ASSERT_SUCCESS(result);
    std::string json = result.value();
    ASSERT_TRUE(json.find("\"string_val\":\"hello world\"") != std::string::npos);
    ASSERT_TRUE(json.find("\"string_view_val\":\"test_view\"") != std::string::npos);
    // Test round-trip
    ondemand::parser parser;
    auto doc_result = parser.iterate(pad(json));
    ASSERT_SUCCESS(doc_result);
    auto get_result = doc_result.value().get<StringTypes>();
    ASSERT_SUCCESS(get_result);
    StringTypes deserialized = std::move(get_result.value());
    ASSERT_EQUAL(deserialized.string_val, test.string_val);
 #endif
    TEST_SUCCEED();
  }
  bool test_optional_types() {
    TEST_START();
 #if SIMDJSON_STATIC_REFLECTION
    struct OptionalTypes {
      std::optional<int> opt_int_with_value;
      std::optional<std::string> opt_string_with_value;
      std::optional<int> opt_int_null;
      std::optional<std::string> opt_string_null;
    };
    OptionalTypes test;
    test.opt_int_with_value = 42;
    test.opt_string_with_value = "optional_test";
    test.opt_int_null = std::nullopt;
    test.opt_string_null = std::nullopt;
    auto result = builder::to_json_string(test);
    ASSERT_SUCCESS(result);
    std::string json = result.value();
    ASSERT_TRUE(json.find("\"opt_int_with_value\":42") != std::string::npos);
    ASSERT_TRUE(json.find("\"opt_string_with_value\":\"optional_test\"") != std::string::npos);
    ASSERT_TRUE(json.find("\"opt_int_null\":null") != std::string::npos);
    ASSERT_TRUE(json.find("\"opt_string_null\":null") != std::string::npos);
    // Test round-trip
    ondemand::parser parser;
    auto doc_result = parser.iterate(pad(json));
    ASSERT_SUCCESS(doc_result);
    auto get_result = doc_result.value().get<OptionalTypes>();
    ASSERT_SUCCESS(get_result);
    OptionalTypes deserialized = std::move(get_result.value());
    ASSERT_TRUE(deserialized.opt_int_with_value.has_value());
    ASSERT_EQUAL(*deserialized.opt_int_with_value, 42);
    ASSERT_TRUE(deserialized.opt_string_with_value.has_value());
    ASSERT_EQUAL(*deserialized.opt_string_with_value, "optional_test");
    ASSERT_FALSE(deserialized.opt_int_null.has_value());
    ASSERT_FALSE(deserialized.opt_string_null.has_value());
 #endif
    TEST_SUCCEED();
  }
  bool test_smart_pointer_types() {
    TEST_START();
 #if SIMDJSON_STATIC_REFLECTION
    struct SmartPointerTypes {
      std::unique_ptr<int> unique_int_with_value;
      std::shared_ptr<std::string> shared_string_with_value;
      std::unique_ptr<bool> unique_bool_with_value;
      std::unique_ptr<int> unique_int_null;
      std::shared_ptr<std::string> shared_string_null;
    };
    SmartPointerTypes test;
    test.unique_int_with_value = std::make_unique<int>(123);
    test.shared_string_with_value = std::make_shared<std::string>("shared_test");
    test.unique_bool_with_value = std::make_unique<bool>(true);
    test.unique_int_null = nullptr;
    test.shared_string_null = nullptr;
    auto result = builder::to_json_string(test);
    ASSERT_SUCCESS(result);
    std::string json = result.value();
    ASSERT_TRUE(json.find("\"unique_int_with_value\":123") != std::string::npos);
    ASSERT_TRUE(json.find("\"shared_string_with_value\":\"shared_test\"") != std::string::npos);
    ASSERT_TRUE(json.find("\"unique_bool_with_value\":true") != std::string::npos);
    ASSERT_TRUE(json.find("\"unique_int_null\":null") != std::string::npos);
    ASSERT_TRUE(json.find("\"shared_string_null\":null") != std::string::npos);
    // Test round-trip
    ondemand::parser parser;
    auto doc_result = parser.iterate(pad(json));
    ASSERT_SUCCESS(doc_result);
    auto get_result = doc_result.value().get<SmartPointerTypes>();
    ASSERT_SUCCESS(get_result);
    SmartPointerTypes deserialized = std::move(get_result.value());
    ASSERT_TRUE(deserialized.unique_int_with_value != nullptr);
    ASSERT_EQUAL(*deserialized.unique_int_with_value, 123);
    ASSERT_TRUE(deserialized.shared_string_with_value != nullptr);
    ASSERT_EQUAL(*deserialized.shared_string_with_value, "shared_test");
    ASSERT_TRUE(deserialized.unique_bool_with_value != nullptr);
    ASSERT_EQUAL(*deserialized.unique_bool_with_value, true);
    ASSERT_TRUE(deserialized.unique_int_null == nullptr);
    ASSERT_TRUE(deserialized.shared_string_null == nullptr);
 #endif
    TEST_SUCCEED();
  }
  bool test_container_types() {
    TEST_START();
 #if SIMDJSON_STATIC_REFLECTION
    struct ContainerTypes {
      std::vector<int> int_vector;
      std::set<std::string> string_set;
      std::map<std::string, int> string_map;
    };
    ContainerTypes test;
    test.int_vector = {1, 2, 3, 4, 5};
    test.string_set = {"apple", "banana", "cherry"};
    test.string_map = {{"key1", 10}, {"key2", 20}, {"key3", 30}};
    auto result = builder::to_json_string(test);
    ASSERT_SUCCESS(result);
    std::string json = result.value();
    ASSERT_TRUE(json.find("\"int_vector\":[1,2,3,4,5]") != std::string::npos);
    ASSERT_TRUE(json.find("\"string_set\":[") != std::string::npos);
    ASSERT_TRUE(json.find("\"string_map\":{") != std::string::npos);
    // Test round-trip
    ondemand::parser parser;
    auto doc_result = parser.iterate(pad(json));
    ASSERT_SUCCESS(doc_result);
    auto get_result = doc_result.value().get<ContainerTypes>();
    ASSERT_SUCCESS(get_result);
    ContainerTypes deserialized = std::move(get_result.value());
    ASSERT_EQUAL(deserialized.int_vector.size(), 5);
    ASSERT_EQUAL(deserialized.string_set.size(), 3);
    ASSERT_EQUAL(deserialized.string_map.size(), 3);
    ASSERT_EQUAL(deserialized.int_vector[0], 1);
    ASSERT_EQUAL(deserialized.int_vector[4], 5);
 #endif
    TEST_SUCCEED();
  }
  bool test_individual_serialization() {
    TEST_START();
    // Test individual type serialization (not part of structs)
    auto bool_result = builder::to_json_string(true);
    ASSERT_SUCCESS(bool_result);
    ASSERT_EQUAL(bool_result.value(), "true");
    auto int_result = builder::to_json_string(42);
    ASSERT_SUCCESS(int_result);
    ASSERT_EQUAL(int_result.value(), "42");
    auto string_result = builder::to_json_string(std::string("hello"));
    ASSERT_SUCCESS(string_result);
    ASSERT_EQUAL(string_result.value(), "\"hello\"");
    auto char_result = builder::to_json_string('X');
    ASSERT_SUCCESS(char_result);
    ASSERT_EQUAL(char_result.value(), "\"X\"");
    // Test const char* serialization (serialization only, not round-trip)
    const char* cstring = "cstring";
    auto cstring_result = builder::to_json_string(cstring);
    ASSERT_SUCCESS(cstring_result);
    ASSERT_EQUAL(cstring_result.value(), "\"cstring\"");
    TEST_SUCCEED();
  }
  bool run() {
    return test_primitive_types() &&
           test_string_types() &&
           test_optional_types() &&
           test_smart_pointer_types() &&
           test_container_types() &&
           test_individual_serialization();
  }
 } // namespace builder_tests
 int main(int argc, char *argv[]) {
  return test_main(argc, argv, builder_tests::run);
 }
@@ -0,0 +1,249 @@
 #include "simdjson.h"
 #include "test_builder.h"
 #include <string>
 #include <vector>
 #include <optional>
 #include <memory>
 #include <limits>
 using namespace simdjson;
 namespace builder_tests {
  bool test_empty_values() {
    TEST_START();
 #if SIMDJSON_STATIC_REFLECTION
    struct EmptyValues {
      std::string empty_string;
      std::vector<int> empty_vector;
      std::optional<int> null_optional;
      std::unique_ptr<int> null_unique_ptr;
      std::shared_ptr<std::string> null_shared_ptr;
    };
    EmptyValues test;
    test.empty_string = "";
    // empty_vector is already empty by default
    test.null_optional = std::nullopt;
    test.null_unique_ptr = nullptr;
    test.null_shared_ptr = nullptr;
    auto result = builder::to_json_string(test);
    ASSERT_SUCCESS(result);
    std::string json = result.value();
    ASSERT_TRUE(json.find("\"empty_string\":\"\"") != std::string::npos);
    ASSERT_TRUE(json.find("\"empty_vector\":[]") != std::string::npos);
    ASSERT_TRUE(json.find("\"null_optional\":null") != std::string::npos);
    ASSERT_TRUE(json.find("\"null_unique_ptr\":null") != std::string::npos);
    ASSERT_TRUE(json.find("\"null_shared_ptr\":null") != std::string::npos);
    // Test round-trip
    ondemand::parser parser;
    auto doc_result = parser.iterate(pad(json));
    ASSERT_SUCCESS(doc_result);
    auto get_result = doc_result.value().get<EmptyValues>();
    ASSERT_SUCCESS(get_result);
    EmptyValues deserialized = std::move(get_result.value());
    ASSERT_EQUAL(deserialized.empty_string, "");
    ASSERT_EQUAL(deserialized.empty_vector.size(), 0);
    ASSERT_FALSE(deserialized.null_optional.has_value());
    ASSERT_TRUE(deserialized.null_unique_ptr == nullptr);
    ASSERT_TRUE(deserialized.null_shared_ptr == nullptr);
 #endif
    TEST_SUCCEED();
  }
  bool test_special_characters() {
    TEST_START();
 #if SIMDJSON_STATIC_REFLECTION
    struct SpecialChars {
      std::string quotes;
      std::string backslashes;
      std::string newlines;
      std::string unicode;
      char null_char;
    };
    SpecialChars test;
    test.quotes = "He said \"Hello\"";
    test.backslashes = "Path\\to\\file";
    test.newlines = "Line1\nLine2\tTabbed";
    test.unicode = "Café résumé";
    test.null_char = '\0';
    auto result = builder::to_json_string(test);
    ASSERT_SUCCESS(result);
    std::string json = result.value();
    // Test that quotes are properly escaped
    ASSERT_TRUE(json.find("\\\"Hello\\\"") != std::string::npos);
    // Test that backslashes are properly escaped
    ASSERT_TRUE(json.find("\\\\to\\\\") != std::string::npos);
    // Test that newlines are properly escaped
    ASSERT_TRUE(json.find("\\n") != std::string::npos);
    ASSERT_TRUE(json.find("\\t") != std::string::npos);
    // Test round-trip (excluding null char which has special handling)
    struct SpecialCharsNoNull {
      std::string quotes;
      std::string backslashes;
      std::string newlines;
      std::string unicode;
    };
    SpecialCharsNoNull test_no_null;
    test_no_null.quotes = test.quotes;
    test_no_null.backslashes = test.backslashes;
    test_no_null.newlines = test.newlines;
    test_no_null.unicode = test.unicode;
    auto result_no_null = builder::to_json_string(test_no_null);
    ASSERT_SUCCESS(result_no_null);
    ondemand::parser parser;
    auto doc_result = parser.iterate(pad(result_no_null.value()));
    ASSERT_SUCCESS(doc_result);
    auto get_result = doc_result.value().get<SpecialCharsNoNull>();
    ASSERT_SUCCESS(get_result);
    SpecialCharsNoNull deserialized = std::move(get_result.value());
    ASSERT_EQUAL(deserialized.quotes, test.quotes);
    ASSERT_EQUAL(deserialized.backslashes, test.backslashes);
    ASSERT_EQUAL(deserialized.newlines, test.newlines);
    ASSERT_EQUAL(deserialized.unicode, test.unicode);
 #endif
    TEST_SUCCEED();
  }
  bool test_numeric_limits() {
    TEST_START();
 #if SIMDJSON_STATIC_REFLECTION
    struct NumericLimits {
      int max_int;
      int min_int;
      double max_double;
      double min_double;
      bool true_val;
      bool false_val;
    };
    NumericLimits test;
    test.max_int = std::numeric_limits<int>::max();
    test.min_int = std::numeric_limits<int>::min();
    test.max_double = 1e100;  // Large but safe double value
    test.min_double = -1e100; // Large negative but safe double value
    test.true_val = true;
    test.false_val = false;
    auto result = builder::to_json_string(test);
    ASSERT_SUCCESS(result);
    std::string json = result.value();
    ASSERT_TRUE(json.find("\"true_val\":true") != std::string::npos);
    ASSERT_TRUE(json.find("\"false_val\":false") != std::string::npos);
    // Test round-trip
    ondemand::parser parser;
    auto doc_result = parser.iterate(pad(json));
    ASSERT_SUCCESS(doc_result);
    auto get_result = doc_result.value().get<NumericLimits>();
    ASSERT_SUCCESS(get_result);
    NumericLimits deserialized = std::move(get_result.value());
    ASSERT_EQUAL(deserialized.max_int, test.max_int);
    ASSERT_EQUAL(deserialized.min_int, test.min_int);
    ASSERT_EQUAL(deserialized.true_val, true);
    ASSERT_EQUAL(deserialized.false_val, false);
 #endif
    TEST_SUCCEED();
  }
  bool test_nested_structures() {
    TEST_START();
 #if SIMDJSON_STATIC_REFLECTION
    struct Inner {
      int value;
      std::string name;
    };
    struct Outer {
      Inner inner_obj;
      std::vector<Inner> inner_vector;
      std::optional<Inner> optional_inner;
      std::unique_ptr<Inner> unique_inner;
    };
    Outer test;
    test.inner_obj = {42, "inner"};
    test.inner_vector = {{1, "first"}, {2, "second"}};
    test.optional_inner = Inner{99, "optional"};
    test.unique_inner = std::make_unique<Inner>(Inner{123, "unique"});
    auto result = builder::to_json_string(test);
    ASSERT_SUCCESS(result);
    std::string json = result.value();
    ASSERT_TRUE(json.find("\"inner_obj\":{") != std::string::npos);
    ASSERT_TRUE(json.find("\"inner_vector\":[") != std::string::npos);
    ASSERT_TRUE(json.find("\"optional_inner\":{") != std::string::npos);
    ASSERT_TRUE(json.find("\"unique_inner\":{") != std::string::npos);
    // Test round-trip
    ondemand::parser parser;
    auto doc_result = parser.iterate(pad(json));
    ASSERT_SUCCESS(doc_result);
    auto get_result = doc_result.value().get<Outer>();
    ASSERT_SUCCESS(get_result);
    Outer deserialized = std::move(get_result.value());
    ASSERT_EQUAL(deserialized.inner_obj.value, 42);
    ASSERT_EQUAL(deserialized.inner_obj.name, "inner");
    ASSERT_EQUAL(deserialized.inner_vector.size(), 2);
    ASSERT_EQUAL(deserialized.inner_vector[0].value, 1);
    ASSERT_EQUAL(deserialized.inner_vector[1].name, "second");
    ASSERT_TRUE(deserialized.optional_inner.has_value());
    ASSERT_EQUAL(deserialized.optional_inner->value, 99);
    ASSERT_TRUE(deserialized.unique_inner != nullptr);
    ASSERT_EQUAL(deserialized.unique_inner->value, 123);
 #endif
    TEST_SUCCEED();
  }
  bool test_const_char_serialization_only() {
    TEST_START();
    // Test that const char* can be serialized (but not round-tripped)
    const char* test_cstring = "const char test";
    auto result = builder::to_json_string(test_cstring);
    ASSERT_SUCCESS(result);
    ASSERT_EQUAL(result.value(), "\"const char test\"");
    // Test with special characters in const char*
    const char* special_cstring = "quotes\"and\\backslashes";
    auto special_result = builder::to_json_string(special_cstring);
    ASSERT_SUCCESS(special_result);
    ASSERT_TRUE(special_result.value().find("\\\"") != std::string::npos);
    ASSERT_TRUE(special_result.value().find("\\\\") != std::string::npos);
    TEST_SUCCEED();
  }
  bool run() {
    return test_empty_values() &&
           test_special_characters() &&
           test_numeric_limits() &&
           test_nested_structures() &&
           test_const_char_serialization_only();
  }
 } // namespace builder_tests
 int main(int argc, char *argv[]) {
  return test_main(argc, argv, builder_tests::run);
 }
@@ -0,0 +1,258 @@
 #include "simdjson.h"
 #include "test_builder.h"
 #include <string>
 using namespace simdjson;
 namespace builder_tests {
  bool test_enum_serialization() {
    TEST_START();
 #if SIMDJSON_STATIC_REFLECTION
    enum class Color {
      Red,
      Green,
      Blue
    };
    struct EnumStruct {
      Color color;
      int value;
    };
    EnumStruct test{Color::Red, 42};
    auto result = builder::to_json_string(test);
    ASSERT_SUCCESS(result);
    std::string json = result.value();
    // Enum should be serialized as string (Red)
    ASSERT_TRUE(json.find("\"color\":\"Red\"") != std::string::npos);
    ASSERT_TRUE(json.find("\"value\":42") != std::string::npos);
    // Test different enum values
    test.color = Color::Green;
    auto result2 = builder::to_json_string(test);
    ASSERT_SUCCESS(result2);
    std::string json2 = result2.value();
    ASSERT_TRUE(json2.find("\"color\":\"Green\"") != std::string::npos);
    test.color = Color::Blue;
    auto result3 = builder::to_json_string(test);
    ASSERT_SUCCESS(result3);
    std::string json3 = result3.value();
    ASSERT_TRUE(json3.find("\"color\":\"Blue\"") != std::string::npos);
 #endif
    TEST_SUCCEED();
  }
  bool test_enum_deserialization() {
    TEST_START();
 #if SIMDJSON_STATIC_REFLECTION
    enum class Status {
      Active,
      Inactive,
      Pending
    };
    struct StatusStruct {
      Status status;
      std::string name;
    };
    // Test deserialization of different enum values with string representation
    std::string json1 = "{\"status\":\"Active\",\"name\":\"test1\"}";
    ondemand::parser parser1;
    auto doc_result1 = parser1.iterate(pad(json1));
    ASSERT_SUCCESS(doc_result1);
    auto get_result1 = doc_result1.value().get<StatusStruct>();
    ASSERT_SUCCESS(get_result1);
    StatusStruct deserialized1 = std::move(get_result1.value());
    ASSERT_TRUE(deserialized1.status == Status::Active);
    ASSERT_EQUAL(deserialized1.name, "test1");
    // Test Status::Inactive
    std::string json2 = "{\"status\":\"Inactive\",\"name\":\"test2\"}";
    ondemand::parser parser2;
    auto doc_result2 = parser2.iterate(pad(json2));
    ASSERT_SUCCESS(doc_result2);
    auto get_result2 = doc_result2.value().get<StatusStruct>();
    ASSERT_SUCCESS(get_result2);
    StatusStruct deserialized2 = std::move(get_result2.value());
    ASSERT_TRUE(deserialized2.status == Status::Inactive);
    ASSERT_EQUAL(deserialized2.name, "test2");
    // Test Status::Pending
    std::string json3 = "{\"status\":\"Pending\",\"name\":\"test3\"}";
    ondemand::parser parser3;
    auto doc_result3 = parser3.iterate(pad(json3));
    ASSERT_SUCCESS(doc_result3);
    auto get_result3 = doc_result3.value().get<StatusStruct>();
    ASSERT_SUCCESS(get_result3);
    StatusStruct deserialized3 = std::move(get_result3.value());
    ASSERT_TRUE(deserialized3.status == Status::Pending);
    ASSERT_EQUAL(deserialized3.name, "test3");
 #endif
    TEST_SUCCEED();
  }
  bool test_enum_round_trip() {
    TEST_START();
 #if SIMDJSON_STATIC_REFLECTION
    enum class Priority {
      Low,
      Medium,
      High,
      Critical
    };
    struct Task {
      Priority priority;
      std::string description;
      int id;
    };
    Task original{Priority::High, "Important task", 123};
    // Serialize
    auto serialize_result = builder::to_json_string(original);
    ASSERT_SUCCESS(serialize_result);
    std::string json = serialize_result.value();
    ASSERT_TRUE(json.find("\"priority\":\"High\"") != std::string::npos); // High as string
    ASSERT_TRUE(json.find("\"description\":\"Important task\"") != std::string::npos);
    ASSERT_TRUE(json.find("\"id\":123") != std::string::npos);
    // Deserialize
    ondemand::parser parser;
    auto doc_result = parser.iterate(pad(json));
    ASSERT_SUCCESS(doc_result);
    auto get_result = doc_result.value().get<Task>();
    ASSERT_SUCCESS(get_result);
    Task deserialized = std::move(get_result.value());
    ASSERT_TRUE(deserialized.priority == Priority::High);
    ASSERT_EQUAL(deserialized.description, "Important task");
    ASSERT_EQUAL(deserialized.id, 123);
 #endif
    TEST_SUCCEED();
  }
  bool test_enum_with_underlying_type() {
    TEST_START();
 #if SIMDJSON_STATIC_REFLECTION
    enum class ErrorCode : int {
      Success = 0,
      NotFound = 404,
      ServerError = 500
    };
    struct Response {
      ErrorCode error;
      std::string message;
    };
    Response test{ErrorCode::NotFound, "Resource not found"};
    auto result = builder::to_json_string(test);
    ASSERT_SUCCESS(result);
    std::string json = result.value();
    ASSERT_TRUE(json.find("\"error\":\"NotFound\"") != std::string::npos);
    ASSERT_TRUE(json.find("\"message\":\"Resource not found\"") != std::string::npos);
    // Test round-trip
    ondemand::parser parser;
    auto doc_result = parser.iterate(pad(json));
    ASSERT_SUCCESS(doc_result);
    auto get_result = doc_result.value().get<Response>();
    ASSERT_SUCCESS(get_result);
    Response deserialized = std::move(get_result.value());
    ASSERT_TRUE(deserialized.error == ErrorCode::NotFound);
    ASSERT_EQUAL(deserialized.message, "Resource not found");
 #endif
    TEST_SUCCEED();
  }
  bool test_multiple_enums() {
    TEST_START();
 #if SIMDJSON_STATIC_REFLECTION
    enum class Day {
      Monday,
      Tuesday,
      Wednesday,
      Thursday,
      Friday,
      Saturday,
      Sunday
    };
    enum class Month {
      January,
      February,
      March,
      April,
      May,
      June,
      July,
      August,
      September,
      October,
      November,
      December
    };
    struct Date {
      Day day;
      Month month;
      int year;
    };
    Date test{Day::Friday, Month::July, 2024};
    auto result = builder::to_json_string(test);
    ASSERT_SUCCESS(result);
    std::string json = result.value();
    ASSERT_TRUE(json.find("\"day\":\"Friday\"") != std::string::npos);      // Friday as string
    ASSERT_TRUE(json.find("\"month\":\"July\"") != std::string::npos);    // July as string
    ASSERT_TRUE(json.find("\"year\":2024") != std::string::npos);
    // Test round-trip
    ondemand::parser parser;
    auto doc_result = parser.iterate(pad(json));
    ASSERT_SUCCESS(doc_result);
    auto get_result = doc_result.value().get<Date>();
    ASSERT_SUCCESS(get_result);
    Date deserialized = std::move(get_result.value());
    ASSERT_TRUE(deserialized.day == Day::Friday);
    ASSERT_TRUE(deserialized.month == Month::July);
    ASSERT_EQUAL(deserialized.year, 2024);
 #endif
    TEST_SUCCEED();
  }
  bool run() {
    return test_enum_serialization() &&
           test_enum_deserialization() &&
           test_enum_round_trip() &&
           test_enum_with_underlying_type() &&
           test_multiple_enums();
  }
 } // namespace builder_tests
 int main(int argc, char *argv[]) {
  return test_main(argc, argv, builder_tests::run);
 }
@@ -0,0 +1,51 @@
 #ifndef ONDEMAND_TEST_BUILDER_H
 #define ONDEMAND_TEST_BUILDER_H
 #include <iostream>
 #include <unistd.h>
 #include "simdjson.h"
 #include "cast_tester.h"
 #include "test_macros.h"
 template<typename F>
 int test_main(int argc, char *argv[], const F& test_function) {
  std::cout << std::unitbuf;
  int c;
  while ((c = getopt(argc, argv, "a:")) != -1) {
    switch (c) {
    case 'a': {
      const simdjson::implementation *impl = simdjson::get_available_implementations()[optarg];
      if (!impl) {
        std::fprintf(stderr, "Unsupported architecture value -a %s\n", optarg);
        return EXIT_FAILURE;
      }
      simdjson::get_active_implementation() = impl;
      break;
    }
    default:
      std::fprintf(stderr, "Unexpected argument %c\n", c);
      return EXIT_FAILURE;
    }
  }
  // this is put here deliberately to check that the documentation is correct (README),
  // should this fail to compile, you should update the documentation:
  if (simdjson::get_active_implementation()->name() == "unsupported") {
    std::printf("unsupported CPU\n");
    std::abort();
  }
  // We want to know what we are testing.
  std::cout << "builtin_implementation -- " << simdjson::builtin_implementation()->name() << std::endl;
  std::cout << "------------------------------------------------------------" << std::endl;
  std::cout << "Running tests." << std::endl;
  if (test_function()) {
    std::cout << "Success!" << std::endl;
    return EXIT_SUCCESS;
  } else {
    std::cerr << "FAILED." << std::endl;
    return EXIT_FAILURE;
  }
 }
 #endif // ONDEMAND_TEST_BUILDER_H
@@ -99,20 +99,41 @@ endif()
 if(NOT (MSVC AND MSVC_VERSION LESS 1920))
  if(SIMDJSON_EXCEPTIONS)
    add_cpp_test(readme_examples COMPILE_ONLY LABELS acceptance)
    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)
  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)
  target_compile_definitions(readme_examples_will_fail_with_exceptions_off PRIVATE SIMDJSON_EXCEPTIONS=0)
 endif()
 #
 # Test C++20 features
 #
 # Add the tests if we're on:
 #   1. Visual Studio 2022 v17.6 or later
 #   2. GCC v14.0.0 or later (GCC v13.0.0 cannot handle pipe oprator of lambda)
 #   3. Clang v15.0.0 or later (certain version C++ headers occur error when compiling)
 if(
  (MSVC AND MSVC_VERSION LESS 1930) OR
  (CMAKE_CXX_COMPILER_ID STREQUAL "GNU" AND CMAKE_CXX_COMPILER_VERSION VERSION_GREATER_EQUAL "14.0.0") OR
  (CMAKE_CXX_COMPILER_ID MATCHES "Clang" AND CMAKE_CXX_COMPILER_VERSION VERSION_GREATER_EQUAL "15.0.0")
  )
  message(STATUS "compiler id: ${CMAKE_CXX_COMPILER_ID} version: ${CMAKE_CXX_COMPILER_VERSION}")
  add_cpp_test(ranges_test LABELS dom acceptance per_implementation)
  set_target_properties(ranges_test PROPERTIES CXX_STANDARD 20 CXX_STANDARD_REQUIRED ON CXX_EXTENSIONS OFF)
 endif()
 if(WIN32 AND BUILD_SHARED_LIBS)
  add_custom_command(TARGET basictests POST_BUILD        # Adds a post-build event
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
Daniel Lemire	01b4710ff8	added missing 'auto'	2025-07-18 13:02:52 -04:00
Daniel Lemire	049f70aef3	removing <optional>, use concepts	2025-07-18 08:54:02 -04:00
Francisco Geiman Thiesen	d874ab7239	Removing trailing whitespace.	2025-07-18 10:49:47 +00:00
Francisco Geiman Thiesen	a27a17484d	Removing unintentional endline.	2025-07-18 05:12:21 +00:00
Francisco Geiman Thiesen	20cea8b477	Adding support for string-based enum serlalization and deserialization.	2025-07-18 05:01:40 +00:00
Francisco Geiman Thiesen	0517fb3aaa	Adding type validation, enhancing optional type support and adding test a few more tests.	2025-07-17 21:43:44 +00:00
evbse	6029af75b3	Improve fallback implementation (#2393 )	2025-07-15 14:39:09 -04:00
Daniel Lemire	c806e955c4	C++26 static reflection (#2282 ) * Initial work on JSON builder * moving the files back to ondemand for now. * tweak * more later * update * minor edits * dropping vs arm (missing support) * adding tests. we still specialized write_string_escaped * tweaking * fix typo * tweaking the approach * minor fix * missing store * another missing store * Attempt at fixing failing serialization tests. (#2292) * Fixing appeand_float typo (#2294) * applying a couple of fixes * updating single header * fix for pre C++17 if constexpr * Fixing unused argument problem and updating the singleheader file * various pedantic fixes * Sketch of builder * reordering. * simplify * Adding draft of static reflection based deserialization * Updating simdjson singleheader * patching the automated deserialization. * automated * Adding support for smart pointers of user defined types. * Adding specialization for smart pointers for basic types. I think it is highly likely that this can be done in a more generic way. * Referncing a later version of rapidjson that fixed the issue related with assignment attempt of a const variable for GenericStringRef class. * guarding the tests * adding documentation for string_builder * saving * rename to 'append' * saving * 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> * tuning * various minor fixes * minor tweak * minor simplification * updating amal * adding a cast * update * fancy casting * removing dead code * Pushing latest changes. CITM benchmark is still not working. * Still not working, but now I am getting only 10 errors. * 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> * Removing std::map from CitmCatalog definition, since that is not currently supported. * Added free to rust bench, segfault is still happening.. * The syntax changed: ^E became ^^E. (#2350) * The syntax changed: ^E became ^^E. * guarding --------- Co-authored-by: Daniel Lemire <dlemire@lemire.me> * Adding support for string_view_keyed_map types. * Adding concepts as a conditional include. * updating single-header * Adding concepts to ondemand deps * rust benchmark is finally working * Fixing small typo in docs. * adding docker config and instructions so that our users can test the static reflection (#2358) * adding docker config and instructions so that our users can test the static reflection * completing the instructions * pruning white spaces --------- Co-authored-by: Daniel Lemire <dlemire@lemire.me> * minor optimizations on the JSON builder branch * avoiding undef behaviour * saving * somewhat nicer builder * make it possible to run just one benchmark * adding linux perf * fixing minor issue * updating swar * Adding real world compilation benchmark (#2379) * Adding compilation benchmark for json parsing with and without reflection * Moving it to the benchmark folder, also reducing a bit the number of iterations. * Removing script from root folder. * Reducing number of iterations * Update benchmark/benchmark_reflection_usage_compilation.sh Co-authored-by: Daniel Lemire <daniel@lemire.me> * Update benchmark/benchmark_reflection_usage_compilation.sh Co-authored-by: Daniel Lemire <daniel@lemire.me> * Update benchmark/benchmark_reflection_usage_compilation.sh Co-authored-by: Daniel Lemire <daniel@lemire.me> * Making the script more customizable and also test whether the compiler being used supports reflection before actually running the benchmark --------- Co-authored-by: Daniel Lemire <daniel@lemire.me> * Using define_static_string from https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2025/p3491r2.html (#2389) * Applying changes needed after latest reflection paper updates. * Working, but no template for yet. * Updating single-header to incldue the use of define_static_string. * copying over master --------- Co-authored-by: Daniel Lemire <dlemire@lemire.me> Co-authored-by: Francisco Geiman Thiesen <franciscogthiesen@gmail.com>	2025-07-14 15:43:52 -04:00
Daniel Lemire	4acaf2ea1c	improving DOM ranges test and silencing a warning (#2385 ) * improving DOM ranges test and silencing a warning * moving test_main to macros (even though it is not a macro) * moving test_main	2025-07-04 15:46:50 -04:00
Daniel Lemire	86adda06d0	clarifying NDEBUG usage (#2388 ) * clarifying NDEBUG usage * init	2025-07-04 15:46:37 -04:00
Daniel Lemire	8df5f96eba	guarding the POSITION_INDEPENDENT_CODE (#2386 )	2025-06-30 16:41:49 -04:00
xkszltl	937667796c	Replace `-fPIC` with `POSITION_INDEPENDENT_CODE`. (#2383 )	2025-06-30 11:26:27 -04:00
Cuda Chen	7d86b04247	Add document and tests of std::ranges support of DOM API (#2381 ) * Add document and tests of std::ranges support of DOM API * Alter lambda * Fix require of range	2025-06-24 15:13:44 -04:00
Daniel Lemire	265022ad8f	Fixing MSYS2 issue (#2380 ) * Google Benchmarks does not support MSYS2. * narrowing it down	2025-06-21 21:26:52 -04:00