mirror of
https://github.com/simdjson/simdjson
synced 2026-06-08 17:27:07 +00:00
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>
This commit is contained in:
Daniel Lemire
+24
-1
@@ -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)
|
||||
+618
@@ -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}")
|
||||
+177
@@ -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
|
||||
+103
@@ -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
|
||||
@@ -112,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")
|
||||
set(CMAKE_CXX_STANDARD ${SIMDJSON_CXX_STANDARD})
|
||||
if(SIMDJSON_STATIC_REFLECTION)
|
||||
# This is temporary.
|
||||
set(SIMDJSON_CXX_STANDARD 26 CACHE STRING "the C++ standard to use for simdjson")
|
||||
#set(CMAKE_CXX_STANDARD ${SIMDJSON_CXX_STANDARD})
|
||||
else()
|
||||
set(SIMDJSON_CXX_STANDARD 17 CACHE STRING "the C++ standard to use for simdjson")
|
||||
set(CMAKE_CXX_STANDARD ${SIMDJSON_CXX_STANDARD})
|
||||
endif()
|
||||
set(CMAKE_CXX_STANDARD_REQUIRED ON)
|
||||
set(CMAKE_CXX_EXTENSIONS OFF)
|
||||
set(CMAKE_THREAD_PREFER_PTHREAD ON)
|
||||
|
||||
Vendored
+1
-1
@@ -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)
|
||||
|
||||
+29
-4
@@ -820,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)
|
||||
|
||||
@@ -1301,8 +1303,8 @@ from `std::string_view` instances:
|
||||
})"_padded;
|
||||
ondemand::parser parser;
|
||||
ondemand::document doc = parser.iterate(json);
|
||||
std:map<std::string,Car> cars;
|
||||
error = doc.get<std:map<std::string,Car>>().get(cars);
|
||||
std::map<std::string,Car> 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
|
||||
```
|
||||
@@ -1341,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
|
||||
----------------------
|
||||
|
||||
+132
@@ -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
|
||||
}
|
||||
```
|
||||
@@ -20,10 +20,14 @@ IF(${CMAKE_SYSTEM_NAME} MATCHES "Linux")
|
||||
endif()
|
||||
|
||||
add_quickstart_test(quickstart_noexceptions quickstart_noexceptions.cpp NO_EXCEPTIONS LABELS acceptance)
|
||||
add_quickstart_test(quickstart_noexceptions11 quickstart_noexceptions.cpp NO_EXCEPTIONS CXX_STANDARD c++11)
|
||||
if(NOT SIMDJSON_STATIC_REFLECTION)
|
||||
add_quickstart_test(quickstart_noexceptions11 quickstart_noexceptions.cpp NO_EXCEPTIONS CXX_STANDARD c++11)
|
||||
endif(NOT SIMDJSON_STATIC_REFLECTION)
|
||||
|
||||
add_quickstart_test(quickstart2_noexceptions quickstart2_noexceptions.cpp NO_EXCEPTIONS LABELS acceptance)
|
||||
add_quickstart_test(quickstart2_noexceptions11 quickstart2_noexceptions.cpp NO_EXCEPTIONS CXX_STANDARD c++11)
|
||||
if(NOT SIMDJSON_STATIC_REFLECTION)
|
||||
add_quickstart_test(quickstart2_noexceptions11 quickstart2_noexceptions.cpp NO_EXCEPTIONS CXX_STANDARD c++11)
|
||||
endif(NOT SIMDJSON_STATIC_REFLECTION)
|
||||
|
||||
# On-Demand Quick Start
|
||||
if (SIMDJSON_EXCEPTIONS)
|
||||
@@ -33,6 +37,8 @@ IF(${CMAKE_SYSTEM_NAME} MATCHES "Linux")
|
||||
endif()
|
||||
|
||||
add_quickstart_test(quickstart_ondemand_noexceptions quickstart_ondemand_noexceptions.cpp NO_EXCEPTIONS LABELS quickstart_ondemand acceptance)
|
||||
add_quickstart_test(quickstart_ondemand_noexceptions11 quickstart_ondemand_noexceptions.cpp NO_EXCEPTIONS CXX_STANDARD c++11 LABELS quickstart_ondemand)
|
||||
if(NOT SIMDJSON_STATIC_REFLECTION)
|
||||
add_quickstart_test(quickstart_ondemand_noexceptions11 quickstart_ondemand_noexceptions.cpp NO_EXCEPTIONS CXX_STANDARD c++11 LABELS quickstart_ondemand)
|
||||
endif(NOT SIMDJSON_STATIC_REFLECTION)
|
||||
|
||||
endif()
|
||||
|
||||
@@ -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
|
||||
|
||||
@@ -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
|
||||
|
||||
@@ -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,170 @@
|
||||
/**
|
||||
* 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 <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> &&
|
||||
!std::is_same_v<T, std::string> &&
|
||||
!std::is_same_v<T, std::string_view>)
|
||||
constexpr void atom(string_builder &b, const T &t) {
|
||||
int i = 0;
|
||||
b.append('{');
|
||||
[: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('}');
|
||||
}
|
||||
|
||||
// works for struct
|
||||
template <class Z> 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
|
||||
|
||||
@@ -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;
|
||||
SIMDJSON_TRY(val.get_array().get(arr));
|
||||
if constexpr (std::is_same_v<std::remove_cvref_t<ValT>, SIMDJSON_IMPLEMENTATION::ondemand::array>) {
|
||||
arr = val;
|
||||
} else {
|
||||
SIMDJSON_TRY(val.get_array().get(arr));
|
||||
}
|
||||
|
||||
for (auto v : arr) {
|
||||
if constexpr (concepts::returns_reference<T>) {
|
||||
if (auto const err = v.get<value_type>().get(concepts::emplace_one(out));
|
||||
@@ -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);
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
@@ -203,6 +267,199 @@ 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_value(r));
|
||||
}
|
||||
return substitute(^^__impl::replicator, args);
|
||||
}
|
||||
// end of workaround
|
||||
|
||||
template <typename T, typename ValT>
|
||||
requires(user_defined_type<T> && std::is_class_v<T>)
|
||||
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;
|
||||
}
|
||||
template <typename simdjson_value, typename T>
|
||||
requires(user_defined_type<std::remove_cvref_t<T>>)
|
||||
error_code tag_invoke(deserialize_tag, simdjson_value &val, std::unique_ptr<T> &out) noexcept {
|
||||
if (!out) {
|
||||
out = std::make_unique<T>();
|
||||
if (!out) {
|
||||
return MEMALLOC;
|
||||
}
|
||||
}
|
||||
if (auto err = val.get(*out)) {
|
||||
out.reset();
|
||||
return err;
|
||||
}
|
||||
return SUCCESS;
|
||||
}
|
||||
|
||||
template <typename simdjson_value, typename T>
|
||||
requires(user_defined_type<std::remove_cvref_t<T>>)
|
||||
error_code tag_invoke(deserialize_tag, simdjson_value &val, std::shared_ptr<T> &out) noexcept {
|
||||
if (!out) {
|
||||
out = std::make_shared<T>();
|
||||
if (!out) {
|
||||
return MEMALLOC;
|
||||
}
|
||||
}
|
||||
if (auto err = val.get(*out)) {
|
||||
out.reset();
|
||||
return err;
|
||||
}
|
||||
return SUCCESS;
|
||||
}
|
||||
|
||||
#endif // SIMDJSON_STATIC_REFLECTION
|
||||
|
||||
////////////////////////////////////////
|
||||
// Unique pointers
|
||||
////////////////////////////////////////
|
||||
error_code tag_invoke(deserialize_tag, auto &val, std::unique_ptr<bool> &out) noexcept {
|
||||
if (!out) {
|
||||
out = std::make_unique<bool>();
|
||||
if (!out) { return MEMALLOC; }
|
||||
}
|
||||
SIMDJSON_TRY(val.get_bool().get(*out));
|
||||
return SUCCESS;
|
||||
}
|
||||
|
||||
error_code tag_invoke(deserialize_tag, auto &val, std::unique_ptr<int64_t> &out) noexcept {
|
||||
if (!out) {
|
||||
out = std::make_unique<int64_t>();
|
||||
if (!out) { return MEMALLOC; }
|
||||
}
|
||||
SIMDJSON_TRY(val.get_int64().get(*out));
|
||||
return SUCCESS;
|
||||
}
|
||||
|
||||
error_code tag_invoke(deserialize_tag, auto &val, std::unique_ptr<uint64_t> &out) noexcept {
|
||||
if (!out) {
|
||||
out = std::make_unique<uint64_t>();
|
||||
if (!out) { return MEMALLOC; }
|
||||
}
|
||||
SIMDJSON_TRY(val.get_uint64().get(*out));
|
||||
return SUCCESS;
|
||||
}
|
||||
|
||||
error_code tag_invoke(deserialize_tag, auto &val, std::unique_ptr<double> &out) noexcept {
|
||||
if (!out) {
|
||||
out = std::make_unique<double>();
|
||||
if (!out) { return MEMALLOC; }
|
||||
}
|
||||
SIMDJSON_TRY(val.get_double().get(*out));
|
||||
return SUCCESS;
|
||||
}
|
||||
|
||||
error_code tag_invoke(deserialize_tag, auto &val, std::unique_ptr<std::string_view> &out) noexcept {
|
||||
if (!out) {
|
||||
out = std::make_unique<std::string_view>();
|
||||
if (!out) { return MEMALLOC; }
|
||||
}
|
||||
SIMDJSON_TRY(val.get_string().get(*out));
|
||||
return SUCCESS;
|
||||
}
|
||||
|
||||
|
||||
////////////////////////////////////////
|
||||
// Shared pointers
|
||||
////////////////////////////////////////
|
||||
error_code tag_invoke(deserialize_tag, auto &val, std::shared_ptr<bool> &out) noexcept {
|
||||
if (!out) {
|
||||
out = std::make_shared<bool>();
|
||||
if (!out) { return MEMALLOC; }
|
||||
}
|
||||
SIMDJSON_TRY(val.get_bool().get(*out));
|
||||
return SUCCESS;
|
||||
}
|
||||
|
||||
error_code tag_invoke(deserialize_tag, auto &val, std::shared_ptr<int64_t> &out) noexcept {
|
||||
if (!out) {
|
||||
out = std::make_shared<int64_t>();
|
||||
if (!out) { return MEMALLOC; }
|
||||
}
|
||||
SIMDJSON_TRY(val.get_int64().get(*out));
|
||||
return SUCCESS;
|
||||
}
|
||||
|
||||
error_code tag_invoke(deserialize_tag, auto &val, std::shared_ptr<uint64_t> &out) noexcept {
|
||||
if (!out) {
|
||||
out = std::make_shared<uint64_t>();
|
||||
if (!out) { return MEMALLOC; }
|
||||
}
|
||||
SIMDJSON_TRY(val.get_uint64().get(*out));
|
||||
return SUCCESS;
|
||||
}
|
||||
|
||||
error_code tag_invoke(deserialize_tag, auto &val, std::shared_ptr<double> &out) noexcept {
|
||||
if (!out) {
|
||||
out = std::make_shared<double>();
|
||||
if (!out) { return MEMALLOC; }
|
||||
}
|
||||
SIMDJSON_TRY(val.get_double().get(*out));
|
||||
return SUCCESS;
|
||||
}
|
||||
|
||||
error_code tag_invoke(deserialize_tag, auto &val, std::shared_ptr<std::string_view> &out) noexcept {
|
||||
if (!out) {
|
||||
out = std::make_shared<std::string_view>();
|
||||
if (!out) { return MEMALLOC; }
|
||||
}
|
||||
SIMDJSON_TRY(val.get_string().get(*out));
|
||||
return SUCCESS;
|
||||
}
|
||||
|
||||
|
||||
} // namespace simdjson
|
||||
|
||||
#endif // SIMDJSON_ONDEMAND_DESERIALIZE_H
|
||||
|
||||
@@ -34,6 +34,7 @@ public:
|
||||
*
|
||||
* You may use get_double(), get_bool(), get_uint64(), get_int64(),
|
||||
* get_object(), get_array(), get_raw_json_string(), or get_string() instead.
|
||||
* When SIMDJSON_SUPPORTS_DESERIALIZATION is set, custom types are also supported.
|
||||
*
|
||||
* @returns A value of the given type, parsed from the JSON.
|
||||
* @returns INCORRECT_TYPE If the JSON value is not the given type.
|
||||
@@ -57,6 +58,7 @@ public:
|
||||
* Get this value as the given type.
|
||||
*
|
||||
* Supported types: object, array, raw_json_string, string_view, uint64_t, int64_t, double, bool
|
||||
* If the macro SIMDJSON_SUPPORTS_DESERIALIZATION is set, then custom types are also supported.
|
||||
*
|
||||
* @param out This is set to a value of the given type, parsed from the JSON. If there is an error, this may not be initialized.
|
||||
* @returns INCORRECT_TYPE If the JSON value is not an object.
|
||||
|
||||
@@ -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,10 @@ namespace simdjson {
|
||||
* @copydoc simdjson::builtin::ondemand
|
||||
*/
|
||||
namespace ondemand = builtin::ondemand;
|
||||
/**
|
||||
* @copydoc simdjson::builtin::builder
|
||||
*/
|
||||
namespace builder = builtin::builder;
|
||||
} // namespace simdjson
|
||||
|
||||
#endif // SIMDJSON_ONDEMAND_H
|
||||
|
||||
@@ -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)
|
||||
|
||||
File diff suppressed because it is too large
Load Diff
@@ -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).
|
||||
|
||||
Executable
+8
@@ -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
|
||||
Executable
+30
@@ -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"
|
||||
+63
-16
@@ -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 self.in_conditional_include_block, f"{file} uses #ifndef SIMDJSON_CONDITIONAL_INCLUDE without a prior #define SIMDJSON_CONDITIONAL_INCLUDE: {self.include_stack}"
|
||||
assert not self.editor_only_region, f"{file} uses #ifndef SIMDJSON_CONDITIONAL_INCLUDE twice in a row"
|
||||
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} {rules}"
|
||||
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 self.in_conditional_include_block, f"{file} redefines SIMDJSON_CONDITIONAL_INCLUDE"
|
||||
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 {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 self.in_conditional_include_block, f"{file} undefines SIMDJSON_CONDITIONAL_INCLUDE without defining it"
|
||||
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 {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)} */")
|
||||
|
||||
|
||||
Binary file not shown.
@@ -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
|
||||
|
||||
|
||||
@@ -403,6 +403,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,13 @@
|
||||
# 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)
|
||||
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,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,14 +99,18 @@ endif()
|
||||
if(NOT (MSVC AND MSVC_VERSION LESS 1920))
|
||||
if(SIMDJSON_EXCEPTIONS)
|
||||
add_cpp_test(readme_examples COMPILE_ONLY LABELS acceptance)
|
||||
add_cpp_test(readme_examples11 COMPILE_ONLY LABELS acceptance SOURCES readme_examples.cpp)
|
||||
set_target_properties(readme_examples11 PROPERTIES CXX_STANDARD 11 CXX_STANDARD_REQUIRED ON CXX_EXTENSIONS OFF)
|
||||
if(NOT SIMDJSON_STATIC_REFLECTION)
|
||||
add_cpp_test(readme_examples11 COMPILE_ONLY LABELS acceptance SOURCES readme_examples.cpp)
|
||||
set_target_properties(readme_examples11 PROPERTIES CXX_STANDARD 11 CXX_STANDARD_REQUIRED ON CXX_EXTENSIONS OFF)
|
||||
endif(NOT SIMDJSON_STATIC_REFLECTION)
|
||||
endif()
|
||||
|
||||
add_cpp_test(readme_examples_noexceptions COMPILE_ONLY LABELS acceptance)
|
||||
|
||||
add_cpp_test(readme_examples_noexceptions11 COMPILE_ONLY LABELS acceptance SOURCES readme_examples_noexceptions.cpp)
|
||||
set_target_properties(readme_examples_noexceptions11 PROPERTIES CXX_STANDARD 11 CXX_STANDARD_REQUIRED ON CXX_EXTENSIONS OFF)
|
||||
if(NOT SIMDJSON_STATIC_REFLECTION)
|
||||
add_cpp_test(readme_examples_noexceptions11 COMPILE_ONLY LABELS acceptance SOURCES readme_examples_noexceptions.cpp)
|
||||
set_target_properties(readme_examples_noexceptions11 PROPERTIES CXX_STANDARD 11 CXX_STANDARD_REQUIRED ON CXX_EXTENSIONS OFF)
|
||||
endif(NOT SIMDJSON_STATIC_REFLECTION)
|
||||
|
||||
# Compile tests that *should fail*
|
||||
add_cpp_test(readme_examples_will_fail_with_exceptions_off WILL_FAIL COMPILE_ONLY LABELS acceptance SOURCES readme_examples.cpp)
|
||||
|
||||
Reference in New Issue
Block a user