diff --git a/.gitignore b/.gitignore index 85a87c1..0d83803 100644 --- a/.gitignore +++ b/.gitignore @@ -1,41 +1,20 @@ -# Python caches and local environments +# Generated build/cache/runtime files +/build*/ __pycache__/ *.py[cod] -.venv/ -venv/ - -# Build outputs (keep the supplied vendor libraries in lib/) -build/ -/build-*/ *.o *.a -/vision-anti-pinch - -# Models and test media -models/ -*.engine -*.onnx -*.pt -*.mp4 -*.avi - -# Runtime outputs -logs/ +.venv/ +venv/ outputs/ -out/ -frames/ +logs/ *.log *.pid - -# Local credentials and legacy SSH authentication helper +*.mp4 +*.avi +/models/ +*.onnx +# Local credentials .env .env.* !.env.example -ssh_expect.exp - -# The checked-in Orin deployment bundle intentionally includes its runtime assets. -!/orin/build/ -!/orin/build/libvision_native.so -!/orin/models/ -!/orin/models/engines/ -!/orin/models/engines/*.engine diff --git a/BRANCHES.md b/BRANCHES.md deleted file mode 100644 index fa6ce16..0000000 --- a/BRANCHES.md +++ /dev/null @@ -1,9 +0,0 @@ -# 分支说明 - -| 分支 | 内容 | -|---|---| -| main | CMS v9.10 原始 YOLO + RTMW + risk 部署包，入口 run_risk.py，含 ONNX 模型 | -| use-can | 0923 V4L2/CAN + TensorRT + CMS 风险集成，提供最新结果变量、可选可视化及 orin/run.sh 可运行包 | -| inference-only | 原 main 的纯 C++ TensorRT 摄像头推理版本，保留原提交 26c5bfb88ddf9919ea46efcf5b12df6e09ebdfd9 | - -main 和 use-can 均在原 main 历史上追加提交；原 main 历史未改写。 diff --git a/CMakeLists.txt b/CMakeLists.txt index 48ab824..ff1376a 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -9,10 +9,10 @@ find_package(OpenCV REQUIRED COMPONENTS core imgproc) find_package(Threads REQUIRED) find_path(TRT_INCLUDE NvInfer.h PATH_SUFFIXES aarch64-linux-gnu REQUIRED) find_library(TRT_LIB nvinfer REQUIRED) -add_library(vision_native SHARED native/native_api.cpp v4l2_capture.cpp can_comm.cpp - accelerator/src/trt_engine.cpp accelerator/src/pose_engine.cu - accelerator/src/gpu_preprocess.cu accelerator/src/uyvy_converter.cu accelerator/src/detector.cpp) -target_include_directories(vision_native PRIVATE . include accelerator/include ${TRT_INCLUDE} ${OpenCV_INCLUDE_DIRS}) +add_library(vision_native SHARED native/native_api.cpp native/v4l2_capture.cpp native/can_comm.cpp + native/trt_engine.cpp native/pose_engine.cu + native/gpu_preprocess.cu native/uyvy_converter.cu native/detector.cpp) +target_include_directories(vision_native PRIVATE native/include ${TRT_INCLUDE} ${OpenCV_INCLUDE_DIRS}) target_link_libraries(vision_native PRIVATE ${TRT_LIB} ${OpenCV_LIBS} Threads::Threads CUDA::cudart CUDA::nppc CUDA::nppig CUDA::nppidei CUDA::nppicc - "${CMAKE_SOURCE_DIR}/lib/libusbcanfd.so" "${CMAKE_SOURCE_DIR}/lib/libusb-1.0.so") -set_target_properties(vision_native PROPERTIES BUILD_WITH_INSTALL_RPATH TRUE INSTALL_RPATH "$ORIGIN/../lib;/usr/local/cuda/lib64") + "${CMAKE_SOURCE_DIR}/orin/lib/libusbcanfd.so" "${CMAKE_SOURCE_DIR}/orin/lib/libusb-1.0.so") +set_target_properties(vision_native PROPERTIES BUILD_WITH_INSTALL_RPATH TRUE INSTALL_RPATH "$ORIGIN/../lib;$ORIGIN/../orin/lib;/usr/local/cuda/lib64") diff --git a/Makefile b/Makefile index d665629..787b6a7 100644 --- a/Makefile +++ b/Makefile @@ -1,11 +1,9 @@ -.PHONY: all run test baseline clean +.PHONY: all run package clean all: ./scripts/build.sh run: all ./run_camera.sh -test: - python3 -m unittest discover -s tests -v -baseline: - $(MAKE) -f Makefile.baseline +package: all + ./scripts/package_orin.sh clean: cmake --build build --target clean diff --git a/Makefile.baseline b/Makefile.baseline deleted file mode 100644 index cb54c55..0000000 --- a/Makefile.baseline +++ /dev/null @@ -1,71 +0,0 @@ -# Makefile - V4L2 MMAP 取图 demo (OpenCV + CAN 收发) -# -# 用法: -# make # 编译 -# make clean # 清理 -# make run # 编译并运行 (取 100 帧) -# make capture # 编译并取 5 帧保存到 ./out -# make no-can # 同 capture, 但关闭 CAN 收发 -# -# 说明: 本 Makefile 在 Orin 上本地编译。 -# CAN 模块依赖 include/zcan.h + lib/libusbcanfd.so + lib/libusb-1.0.so -# CAN 收发默认开启, 程序运行时加 --no-can 关闭 - -# ---- 工具链 ---- -CXX ?= g++ -CXXFLAGS ?= -std=c++17 -O3 -Wall -Wextra -Wno-unused-parameter -Wno-unused-result -LDFLAGS ?= - -# ---- OpenCV 检测 (优先 opencv4, 回退 opencv) ---- -OPENCV_PC := $(shell pkg-config --exists opencv4 && echo opencv4 || echo opencv) -OPENCV_CFLAGS := $(shell pkg-config --cflags $(OPENCV_PC)) -OPENCV_LIBS := $(shell pkg-config --libs $(OPENCV_PC)) - -# ---- 本地头文件/库目录 (zcan.h, libusbcanfd.so, libusb-1.0.so) ---- -INC_DIR := include -LIB_DIR := lib -IDIRS := -I$(INC_DIR) $(OPENCV_CFLAGS) -LDIRS := -L$(LIB_DIR) -RPATH := -Wl,-rpath,$$(pwd)/$(LIB_DIR) - -CXXFLAGS += $(IDIRS) -LDLIBS += $(OPENCV_LIBS) -lm -lpthread -lusbcanfd -lusb-1.0 - -# ---- 目标与源文件 ---- -BIN := vision-anti-pinch -SOURCES := main.cpp v4l2_capture.cpp can_comm.cpp -HEADERS := v4l2_capture.h can_comm.h $(INC_DIR)/zcan.h -OBJECTS := $(SOURCES:.cpp=.o) - -# ---- 默认目标 ---- -.PHONY: all clean run capture - -all: $(BIN) - -$(BIN): $(OBJECTS) - $(CXX) $(LDFLAGS) -o $@ $^ $(LDIRS) $(RPATH) $(LDLIBS) - -# ---- 依赖规则 (头文件改动则全部重编) ---- -$(OBJECTS): $(HEADERS) - -%.o: %.cpp - $(CXX) $(CXXFLAGS) -c -o $@ $< - -# ---- 便捷目标 ---- -run: $(BIN) - ./$(BIN) -d /dev/video5 -n 100 -v - -capture: $(BIN) - mkdir -p out - ./$(BIN) -d /dev/video5 -n 100 -s 5 -t jpg -o ./out - -# CAN 收发默认开启, 与 capture 相同 -can: capture - -# 关闭 CAN 收发的取图 -no-can: $(BIN) - mkdir -p out - ./$(BIN) -d /dev/video5 -n 100 -s 5 -t jpg -o ./out --no-can -v - -clean: - rm -f $(OBJECTS) $(BIN) diff --git a/PROVENANCE.json b/PROVENANCE.json deleted file mode 100644 index 7a083b2..0000000 --- a/PROVENANCE.json +++ /dev/null @@ -1,61 +0,0 @@ -{ - "baseline": "orin@192.168.195.100:/home/orin/vision-anti-pinch", - "baseline_sha256": [ - "a6f884d241b3b345fbdc3bbb2d0119467f6a01d6828786a7d33d7f97ad101f6e main.cpp", - "ba7ce790ec4b43403fd6b9ccc4693148414b7314060c29d9f9f92dee931509cf can_comm.cpp", - "5aaeaba6f0f25a6202ff2cf61c626b61bda2350f5bd9b36e36c828b5b8fec994 can_comm.h", - "f5c6658eb3e8362569c18d528fd4c8a2e311e5f779d9687e8ff10b79a11dc5b6 v4l2_capture.cpp", - "dd7a6f92e4d3335368691dd587715cec3d24816e9a96d44ff11c91296f5082eb v4l2_capture.h", - "65b16fe3d4549ad218679f510afe4049ad0f197912832060daaca13acc0f5f4f Makefile" - ], - "risk_source": "/home/thor/文档/cms_v9_10_yolo_rtmw_risk_deploy_20260923", - "risk_pipeline": { - "occlusion_aware_pose_v2.py": { - "source_sha256": "81088b8bc072162bec13f57c65eb0d396e6d1e1074a83f92bcf29e393e27e11f", - "integrated_sha256": "81088b8bc072162bec13f57c65eb0d396e6d1e1074a83f92bcf29e393e27e11f" - }, - "fuse_rtmw_l_temporal.py": { - "source_sha256": "bc74a400ce5c5608c2fa49a69ccd8b41ec8633cd6a8239d9d594b8d9e5c3732a", - "integrated_sha256": "bc74a400ce5c5608c2fa49a69ccd8b41ec8633cd6a8239d9d594b8d9e5c3732a" - }, - "rtmw_l_person_mask_ablation.py": { - "source_sha256": "d983c9431237afcd7a786c6c4610be6d57a8b4d9ea8f2e9d1889fc0b0ca1d5df", - "integrated_sha256": "bf8bb754cd841a52b4410f958a651b005de36ac4d17cc0992fbe1c90ed30caca" - }, - "door_mask_risk.py": { - "source_sha256": "6d6d14a972bc4e5e9f8256514169e73ba0392a301cacd1221eaa26146aad00d2", - "integrated_sha256": "6d6d14a972bc4e5e9f8256514169e73ba0392a301cacd1221eaa26146aad00d2" - }, - "live_pose_engine.py": { - "source_sha256": "a15baaedf5a25b9896ff898fc1a095388483dc52b1b7000b56d5506ff73bf67e", - "integrated_sha256": "cc8ea36d543896cd90f7a00822f06fc67771a1811859a4087995ac372df30276" - }, - "predict_optimized_pose_videos.py": { - "source_sha256": "36d203f257444e57f890cdc3826dad0c7a46725b938e5f8507e357a70ae2cef9", - "integrated_sha256": "059e2a67c17ce63354986d3242a5d361103ee4241c5391f18140eeb19e47c939" - }, - "door_zone_risk.py": { - "source_sha256": "46d70e1e90a1f36d544b7492ef1fbf08821377a1c460a6683f42d4d7006055c7", - "integrated_sha256": "46d70e1e90a1f36d544b7492ef1fbf08821377a1c460a6683f42d4d7006055c7" - }, - "rtmw_risk_pipeline.py": { - "source_sha256": "1bb58d851ba5d684527b8d1e1940db6241d2b0b2862687fa3b151899a65320d2", - "integrated_sha256": "1bb58d851ba5d684527b8d1e1940db6241d2b0b2862687fa3b151899a65320d2" - }, - "compare_rtmw_ml.py": { - "source_sha256": "5de11436bb888f2f1c4c0e7ad0853e3864193fe2625cc65294b40683ebe8729a", - "integrated_sha256": "fd3ae92255abf95ef037a1060ee75897f9705b4040f9394c3130f6ab860667e1" - } - }, - "engines_sha256": { - "rtmw_l_384.engine": "ebcd09e8c2e35008adbb0c1d222e580b17e0df1c8093df3481ba3374cd9a8174", - "yolo11s.engine": "f6a65b926ac1144484f4aa93cd26d7997d32d62310ab93fe867f2bd4412222e9" - }, - "engine_origin": "orin@192.168.195.100:/home/orin/vision-anti-pinch-0920/orin/engines", - "can_mapping_user_confirmed": [ - "left_front", - "right_front", - "left_rear", - "right_rear" - ] -} \ No newline at end of file diff --git a/README-risk-upstream.md b/README-risk-upstream.md deleted file mode 100644 index 5af9397..0000000 --- a/README-risk-upstream.md +++ /dev/null @@ -1,330 +0,0 @@ -# CMS v9.10 YOLO + RTMW 门区风险部署包 - -该目录是 v9.10 的精简部署版本，只保留运行 `YOLO + RTMW + risk` 所需的代码、模型、标定文件和依赖清单。历史推理结果、研发测试、标注网页、参考图片、缓存与离线分析入口均未放入部署包。 - -## 1. 功能链路 - -```text -视频帧 - -> YOLO11s 人体检测与轨迹 ID - -> RTMW-L COCO-WholeBody 133 点关键点 - -> 手臂/手部时序融合 - -> 骨骼位置和尺度为主、人体框为辅的前后门归属 - -> CAN 活跃门过滤 - -> 手部区域（无有效手部时使用人体框兜底） - -> 与固定车门危险区 mask 计算二维风险 - -> causal_results.jsonl -``` - -本版本不包含深度估计和 EdgeTAM。输出是二维图像风险，不是物理距离，也不是安全认证结论。 - -## 2. 目录结构 - -```text -run_risk.py 主入口 -requirements-realtime-gpu.txt CUDA 推理依赖 -requirements-tensorrt-windows.txt Windows TensorRT 可选依赖 -models/ - yolo11s.onnx 人体检测模型 - rtmw-l-384.onnx WholeBody 关键点模型 -annotations/ - constant_door_mask.json 当前固定机位车门危险区 - door_zone_multifeature.json 当前前门/后门多特征标定 -pipeline/ 推理、融合、门区和风险计算代码 -``` - -`annotations` 中的两个 JSON 都与摄像头机位相关。当前参数来自研发临时机位；换成实车机位后必须重新标定和验证，不能直接将临时机位结论作为量产参数。 - -## 3. 环境安装 - -推荐 Python 3.10～3.12 和 NVIDIA CUDA GPU。先安装与目标机 CUDA 或 JetPack 匹配的 PyTorch，再安装其余依赖： - -```powershell -python -m venv .venv -.\.venv\Scripts\Activate.ps1 -python -m pip install --upgrade pip -pip install -r requirements-realtime-gpu.txt -``` - -不要同时安装 CPU 版 `onnxruntime` 和 `onnxruntime-gpu`。Jetson Orin 应优先使用 NVIDIA 针对对应 JetPack 发布的 PyTorch/torchvision，而不是强制使用桌面 wheel。 - -如需在 Windows 上使用 RTMW TensorRT Execution Provider，再执行： - -```powershell -pip install -r requirements-tensorrt-windows.txt -``` - -## 4. 运行 - -### 4.1 固定车门危险区 - -以后门 CAN=0、前门未进入电吸范围为例： - -```powershell -python run_risk.py ` - --video D:\data\segment_008.mp4 ` - --constant-door-mask annotations\constant_door_mask.json ` - --door-zone-config annotations\door_zone_multifeature.json ` - --active-door rear ` - --output outputs\seg_08_rear ` - --det-device 0 ` - --pose-device cuda ` - --write-video -``` - -`--active-door` 对应当前 CAN=0 的车门： - -- `front`：只有前门进入电吸范围； -- `rear`：只有后门进入电吸范围； -- `both`：前后门都进入电吸范围； -- `none`：两门都不进行风险判断。 - -当前命令行参数对整个视频保持不变，用于离线部署验证。实车 CAN 随帧变化时，集成层需要把每帧实际 CAN 状态传给门级风险选择逻辑。 - -不需要叠加视频时不要传 `--write-video`，可减少编码和磁盘 I/O。完整参数说明： - -```powershell -python run_risk.py --help -``` - -### 4.2 TensorRT RTMW - -```powershell -python run_risk.py ` - --video D:\data\test.mp4 ` - --constant-door-mask annotations\constant_door_mask.json ` - --active-door rear ` - --output outputs\test_trt ` - --pose-provider tensorrt ` - --pose-device cuda -``` - -首次运行会在 `models/rtmw_l_trt_cache` 生成 TensorRT 缓存，该缓存与目标 GPU、TensorRT 版本和运行环境相关，不随部署包预置。 - -## 5. 输出文件 - -输出目录包含： - -- `causal_results.jsonl`：逐帧因果结果，一行一个 JSON 对象，是 Demo 对接的主要接口； -- `summary.json`：模型、帧数、吞吐、延迟及风险统计； -- `rtmw_risk_overlay.mp4`：仅在传入 `--write-video` 时生成。 - -`causal_results.jsonl` 每行顶层字段： - -| 字段 | 含义 | -|---|---| -| `frame_index` | 从 0 开始的视频帧号 | -| `track_ids` | 当前帧人体轨迹 ID 数组 | -| `boxes` | 与 `track_ids` 同序的人体框，格式 `[x1,y1,x2,y2]` | -| `skeletons` | 与检测人体对齐的 133 点融合骨骼 | -| `active_door` | 本次运行指定的 CAN=0 门：`front/rear/both/none` | -| `door_assignments` | 每个轨迹的前门/后门归属及特征解释 | -| `door_risks` | `front` 和 `rear` 两扇门各自的最终风险 | -| `risk` | 经过 CAN 和门区过滤后供业务使用的当前风险 | -| `ungated_risk` | 未经过前后门/CAN 过滤的原始二维风险，仅用于诊断 | - -数组关联规则：`boxes[i]`、`track_ids[i]`、`skeletons[i].person_index == i`、`door_assignments[i].person_index == i` 表示同一个人。跨帧关联应使用 `track_id`，不要依赖数组下标。 - -## 6. `risk` 的含义 - -### 6.1 应读取哪个字段 - -单门 CAN=0 时，业务防夹建议读取： - -```text -risk.risk_type -risk.risk_level -risk.risk_score -risk.decision -``` - -需要同时展示前后门时分别读取： - -```text -door_risks.front -door_risks.rear -``` - -`ungated_risk` 只用于排查“图像上是否靠近危险区”，不能直接代替门级最终结论，否则会绕过前后门归属和 CAN 过滤。 - -### 6.2 风险标签 - -`risk_type` 是带门位置的最终风险标签： - -| `risk_type` | `risk_level` | 含义 | -|---|---|---| -| `FRONT_CLEAR` / `REAR_CLEAR` | `clear` | 对应活跃门没有风险 | -| `FRONT_WATCH` / `REAR_WATCH` | `watch` | 进入关注距离，但未达到 warning | -| `FRONT_WARNING` / `REAR_WARNING` | `warning` | 距离达到 warning 阈值 | -| `FRONT_DANGER` / `REAR_DANGER` | `danger` | 人体风险区域与车门危险区相交 | -| `FRONT_UNKNOWN` / `REAR_UNKNOWN` | `unknown` | 人物处于 `transition`，无法可靠确定前后门 | -| `FRONT_INACTIVE` / `REAR_INACTIVE` | `inactive` | 该门 CAN 不活跃，不计算防夹风险 | -| `NO_ACTIVE_DOOR` | `inactive` | 前后门均不活跃 | - -对应的 `decision`： - -| `decision` | 含义 | -|---|---| -| `DANGER_INTERSECTION` | 风险区域与车门 mask 有像素相交 | -| `WARNING_NEAR` | 相对距离小于等于 warning 阈值 | -| `WATCH` | 相对距离处于 warning 与 release 之间 | -| `CLEAR` | 相对距离大于 release 阈值 | -| `CLEAR_NO_PERSON_ASSIGNED_TO_ACTIVE_DOOR` | 没有人被分配给该活跃门 | -| `EVIDENCE_UNAVAILABLE_TRANSITION_ZONE` | 存在 `transition` 人员，门归属不确定 | -| `DOOR_CAN_NOT_ACTIVE` | 该门 CAN 不活跃 | -| `NO_DOOR_CAN_ACTIVE` | 没有活跃门 | - -默认阈值： - -```text -warning_distance_relative = 0.30 -release_distance_relative = 0.45 -``` - -对每个风险区域： - -```text -distance_relative = min_distance_px / sqrt(region_area_px) -risk_score = clip(1 - distance_relative / release_distance_relative, 0, 1) -``` - -只要 `door_overlap_px > 0`，就强制 `risk_score=1.0` 且等级为 `danger`。因此 `risk_score` 是归一化二维接近程度，不是概率，也不是厘米/毫米距离。 - -### 6.3 `regions` 与证据来源 - -每个门风险中的 `regions` 保存独立人体区域的解释信息，常用字段包括： - -- `track_id`、`side`：所属轨迹和左右手； -- `source`：`RTMW_HAND_KEYPOINTS` 或 `YOLO_BODY_BOX_FALLBACK`； -- `region_area_px`：风险区域面积； -- `door_overlap_px`、`region_overlap_ratio`：与车门 mask 的相交量； -- `min_distance_px`：区域到车门 mask 的最小像素距离； -- `region_scale_px`：`sqrt(region_area_px)`； -- `distance_relative`：尺度归一化距离； -- `risk_score`、`risk_level`、`decision`：该区域自己的风险结果。 - -存在可用手部时，每只手用 21 点凸包计算风险；一个人没有任何可用手部时，才使用整个人体框兜底。人体框兜底更保守，也更容易产生误报。 - -### 6.4 `transition` 的当前行为 - -`door_assignments[].door_zone` 的位置标签为： - -- `front`：归属前门； -- `rear`：归属后门； -- `transition`：前后门证据不足或位于过渡区； -- `unassigned`：人体尺度低于有效阈值，不参与门级风险。 - -当前 v9.10 中，`transition` 人员即使在 `ungated_risk` 中距离很近，也不会直接变成 `FRONT_WARNING/REAR_WARNING` 或 `DANGER`，而是让活跃门输出 `*_UNKNOWN`，其 `risk_score` 为 `null`。Demo 必须显式展示或处理 `unknown`，不能把它当成 `clear`。这是当前版本行为，不代表最终量产安全策略。 - -## 7. `skeletons` 的含义与可视化对接 - -### 7.1 数据结构 - -每个人的骨骼对象如下： - -```json -{ - "track_id": 1, - "person_index": 0, - "layout": "coco_wholebody_133", - "keypoints": [[x0, y0], [x1, y1]], - "metadata": { - "left": {}, - "right": {} - } -} -``` - -- `keypoints` 实际固定为 `133 x 2`，示例中省略了其余点； -- 坐标单位是原视频像素，原点在左上角，x 向右、y 向下； -- 坐标保留 3 位小数； -- 这里没有逐点置信度，`metadata` 提供的是手臂/手部融合后的状态； -- `keypoints` 使用的正是当前叠加视频 `draw_fused` 使用的融合结果。 - -### 7.2 COCO-WholeBody 133 点索引 - -| 索引 | 含义 | -|---|---| -| `0` | nose | -| `1/2` | left/right eye | -| `3/4` | left/right ear | -| `5/6` | left/right shoulder | -| `7/8` | left/right elbow | -| `9/10` | left/right wrist | -| `11/12` | left/right hip | -| `13/14` | left/right knee | -| `15/16` | left/right ankle | -| `17/18/19` | left big toe / small toe / heel | -| `20/21/22` | right big toe / small toe / heel | -| `23–90` | 68 个面部关键点 | -| `91–111` | 左手 21 点 | -| `112–132` | 右手 21 点 | - -每只手的局部 21 点顺序： - -```text -0 wrist -1-4 thumb -5-8 index finger -9-12 middle finger -13-16 ring finger -17-20 little finger -``` - -左手局部索引需要加 91，右手局部索引需要加 112，才能得到 `keypoints` 中的全局索引。 - -### 7.3 与当前叠加视频一致的绘制规则 - -当前风险叠加视频只绘制手臂和双手，不绘制面部、躯干和腿部。手臂连线： - -```text -(5,7), (7,9) 左肩-左肘-左腕 -(6,8), (8,10) 右肩-右肘-右腕 -``` - -每只手使用以下局部连线，分别作用到 `91–111` 和 `112–132`： - -```text -(0,1),(1,2),(2,3),(3,4) -(0,5),(5,6),(6,7),(7,8) -(0,9),(9,10),(10,11),(11,12) -(0,13),(13,14),(14,15),(15,16) -(0,17),(17,18),(18,19),(19,20) -``` - -为了与现有视频表现一致： - -- `metadata[side].limb_state == "consensus"`：手臂画实线，否则画虚线； -- `metadata[side].hand_state == "rejected"`：不画该手； -- 手未被拒绝且 `distance_eligible == true`：手部画实线； -- 手未被拒绝但 `distance_eligible == false`：手部画虚线； -- `alarm_eligible == true` 表示该手允许进入 risk 区域计算。 - -Demo 如果只需要复现当前可视化，读取上述 48 个点即可；如果后续需要完整人体展示，可以使用全部 133 点，但应自行补充完整 WholeBody 连线定义。 - -## 8. `door_assignments` 对接说明 - -常用字段： - -- `track_id`、`person_index`：与检测框和骨骼关联； -- `door_zone`：经过最多 5 帧因果中值后的 `front/rear/transition/unassigned`； -- `raw_door_zone`：当前帧未经时序中值稳定的标签； -- `front_probability`：当前帧前门概率； -- `smoothed_front_probability`：因果时序中值； -- `confidence`：相对 0.5 的归属置信度，不是人体检测置信度； -- `pose_feature_count`：本帧可用骨骼特征数量； -- `features`、`feature_frontness`：标定特征值和各特征前门贡献； -- `history_frames`：当前轨迹已用于中值的历史帧数。 - -当前标定阈值为：`smoothed_front_probability >= 0.72` 判为前门，`<= 0.28` 判为后门，中间为 `transition`。这些参数应随实车机位重新验证。 - -## 9. Demo 集成注意事项 - -1. 每帧先按 `track_id` 关联检测框、骨骼、门区和风险，避免多人时按数组顺序长期跟踪。 -2. 主界面风险展示使用 `risk`；需要前后门双状态时使用 `door_risks.front/rear`。 -3. `unknown`、`inactive` 和 `clear` 是三种不同状态，不能合并显示。 -4. `risk_score == null` 表示该状态没有可用数值风险，不应转换成 0。 -5. `ungated_risk` 只用于诊断叠加，不能作为最终防夹指令。 -6. 更换分辨率或裁剪策略后必须核对车门 mask、骨骼坐标与视频坐标是否仍一致。 -7. 当前系统可能把玻璃倒影或反光误检成人，部署 Demo 应保留原视频、检测框、`track_id` 和风险解释字段用于问题回溯。 - diff --git a/README.md b/README.md index 3af6e70..13de587 100644 --- a/README.md +++ b/README.md @@ -1,205 +1,91 @@ -# vision-anti-pinch-0923 +# Vision Anti-Pinch — use-can -以 Orin `~/vision-anti-pinch` 的 V4L2 MMAP 摄像头及 USBCANFD 模块为基线，接入 CMS v9.10 `run_risk.py` 的完整风险流程。模型及 GPU 推理代码来自远端 `~/vision-anti-pinch-0920`。 +V4L2 摄像头 + CAN 门状态 + YOLO/RTMW TensorRT 推理 + CMS 风险判断。 +默认持续推理，将最新完整结果保存在内存；可视化和文件保存均按需开启。 -``` -基线 V4L2 MMAP → NPP UYVY 转 BGR → 最新帧槽位 - → YOLO11s TensorRT → RTMW-L TensorRT（含小人遮挡隔离推理） - → Python 原版轨迹 / 手臂手部融合 / 全局手关联 - → 骨骼主导的前后门归属 → 固定 mask 风险 → 逐帧 CAN 活跃门过滤 - → 内存中的最新只读结果（可选 JSONL / 浏览器预览） -``` +## Orin 直接运行 -## 仓库分支与 Orin 直接运行包 - -- `main`：原 CMS v9.10 Python/ONNX 部署包。 -- `inference-only`：保留原 main 的纯 C++ TensorRT 推理版本。 -- `use-can`（本分支）：0923 CAN 集成版本。 - -本分支已提供可单独复制的 `orin/` 运行包，包含预编译库和 TensorRT 模型： +适用：Jetson AGX Orin，JetPack 5.1.2 / L4T R35.4.1、CUDA 11.4、TensorRT 8.5.x、系统 OpenCV 4.5.4；Python 3.8+，numpy、cv2。 +`orin/` 包含编译库、TensorRT 引擎、CAN 库、摄像头驱动、Python 运行代码和标定文件，可以单独复制到其他目录。 ```bash -git clone --branch use-can https://git.kendeji.fun/zmv/vision-anti-pinch.git -cd vision-anti-pinch/orin -./scripts/initialize_camera.sh # 开机后需要初始化摄像头时执行 -./run.sh # 默认无可视化，结果保存在内存 -./run.sh --visualize # 可选预览 +cd orin +./scripts/initialize_camera.sh # 开机后无 /dev/video5 时初始化，需要 sudo +./run.sh # 默认无可视化，结果保存在内存 +# 或开启浏览器预览：http://设备IP:8765 +./run.sh --visualize ``` -`orin/run.sh` 通过相对目录定位运行库、模型与标定，使用系统 Python，无需现场编译。目标环境及下游调用说明见 `orin/README.md`。 -源码变更后，在目标 Orin 构建并执行 `scripts/package_orin.sh` 重新生成运行包；`ENGINE_DIR` 和 `DRIVER_DIR` 可指定模型/驱动目录。 +每次只运行一个采集进程；Ctrl+C / SIGTERM 停止。关闭浏览器不会停止推理。 +系统 CUDA/TensorRT/OpenCV/Python 运行环境由目标系统提供，不随包重复分发。TensorRT 引擎不能直接用于 Thor 或其他 JetPack/GPU 环境。 -## 两端目录和环境 +## 从源码编译 -- 本机：`/home/thor/文档/vision-anti-pinch-0923` -- Orin：`/home/orin/vision-anti-pinch-0923` -- 目标推理环境：Orin，JetPack R35.4.1、CUDA 11.4、系统 Python 3.8、原生 TensorRT。 -- 本机保存完整源码、测试报告、模型副本；本机是 Thor / R38，未发现 `/dev/video*`。Orin 的序列化 engine 不能直接作为 Thor 的本机模型使用，需在 Thor 上另行转换。本次实时采集/推理在 Orin，浏览器可在本机查看。 -- 远端 `models/engines` 软链接到 `../../vision-anti-pinch-0920/orin/engines`，避免重复占用有限磁盘。不要删除被引用的 0920 模型。 -- 原有远端 `vision-anti-pinch` / `vision-anti-pinch-0920` 源码均未修改。测试时已停止占用 `/dev/video5` 的旧 0920 演示进程，0923 可独立启动。 - -## 编译和运行（在 Orin） +在目标 Orin 上执行，依赖 CMake 3.24+、CUDA/NPP、TensorRT、OpenCV 开发库： ```bash -cd ~/vision-anti-pinch-0923 -./scripts/build.sh -# 开机后如 /dev/video5 不存在，加载已部署的 0920 摄像头驱动： -./scripts/initialize_camera.sh -# 编译也可使用 make -./run_camera.sh --active-door can --can-side left -# 等价入口：python3 run_risk.py --active-door can --can-side left +./scripts/build.sh # 或 make +./scripts/initialize_camera.sh # 摄像头尚未初始化时执行 +./run_camera.sh # 使用新编译的 build/libvision_native.so ``` -默认只在内存中发布结果，不创建结果目录，不绘制或编码图像，不启动 HTTP 服务。 - -后台启动、停止： +源码入口复用 `orin/models/engines/` 和 `orin/lib/`，不依赖旧版工程。 +修改源码后刷新直接运行包： ```bash -./scripts/start.sh # 无可视化 -./scripts/stop.sh -./scripts/start.sh --visualize # 可选浏览器预览 +./scripts/package_orin.sh # 或 make package +cd orin && sha256sum -c SHA256SUMS ``` -默认从 `/dev/video5` 采集 UYVY 1920×1536，驱动当前为 30 FPS。驱动不支持 `VIDIOC_G_PARM`，程序会打印警告并继续采集，命令行 fps 不代表驱动一定支持修改。 +打包会替换运行代码，清除已删除的旧 Python 模块，并更新文件校验值。 -- 开启 `--visualize` 后，预览：[http://192.168.195.100:8765](http://192.168.195.100:8765) -- 开启 `--visualize` 后，最新结果：[http://192.168.195.100:8765/result.json](http://192.168.195.100:8765/result.json) -- 开启 `--visualize` 后，最新图像：[http://192.168.195.100:8765/frame.jpg](http://192.168.195.100:8765/frame.jpg) -- 后台进程日志：`logs/live.log`，PID：`logs/camera.pid`；加保存开关后，后台结果写入 `outputs/live/`。 -- `--visualize` 开启预览；仅设置 `--preview-port` 不会开启预览。监听地址默认 `0.0.0.0:8765`，可用 `--preview-host 127.0.0.1` 限制为本机。可视化在独立观察线程中绘制和编码，只保留最新待绘制帧。端口占用或绘制失败不会终止推理；关闭浏览器也不会停止推理。 +## 下游读取结果 -摄像头限定时长、模拟门状态： - -```bash -./run_camera.sh --no-can --active-door both --duration 30 --save-results --output outputs/demo -``` - -有人视频回放（同一 TensorRT/融合/风险链路）： - -```bash -./run_camera.sh --video tests/person-test.mp4 --no-can --active-door both \ - --max-frames 150 --save-results --save-pose-records --output outputs/replay -``` - -`tests/person-test.mp4` 来自用户提供的 `segment_009.mp4` 第 10 秒起的 150 帧片段。 - -## 下游直接读取结果变量 - -参考 0920 的 `LatestResult` / `CameraPipeline.latest()`，0923 提供同进程 Python 接口： +在同一个 Python 进程中创建流水线，然后读取单个最新只读快照： ```python from run_camera import CameraPipeline, parse_args -args = parse_args([]) # 默认 CAN 模式；不打开可视化，不保存文件 -with CameraPipeline(args) as pipeline: - result = pipeline.wait_for_result(timeout=10) # 等待第一帧，可选 - # 在下游自己的循环/线程中读取当前完整快照： +with CameraPipeline(parse_args([])) as pipeline: + result = pipeline.wait_for_result(timeout=10) + # 下游自己的循环/线程中读取；首帧前为 None： result = pipeline.latest_result # 等价于 pipeline.latest() if result is not None: - risk = result["risk"] - door_risks = result["door_risks"] - skeletons = result["skeletons"] - can = result["can"] - print(result["frame_index"], risk["risk_type"], risk["risk_score"]) + print(result['frame_index'], result['risk']) + door_risks = result['door_risks'] + skeletons = result['skeletons'] ``` -完整持续读取示例：`examples/read_latest.py`，在 Orin 执行。示例会自己启动推理并占用摄像头，运行前先停止已有后台进程： +结果字段：`frame_index`、`track_ids`、`boxes`、`skeletons`（每人 133 点）、`door_assignments`、`active_door`、`door_risks`、`risk`、`ungated_risk`、`can`、`capture`、`capture_to_result_ms`、`calibration_verified`。 -```bash -./scripts/stop.sh -python3 examples/read_latest.py -# 或开启可视化： -python3 examples/read_latest.py --visualize -``` +- 读取不消费结果；多个读者可以持有同一个不可变快照，旧快照不会被下一帧改写。 +- 只保留最新结果，慢读者可以跳过帧；`wait_for_result(last_frame_index, timeout)` 可等待更新。 +- `request_stop()` 请求停止，`join()` 等待退出并传播异常；`with` 自动回收资源。 +- 停止后仍保留最后快照；下游应检查运行状态和帧时间，避免使用过期结果。 +- `result_to_dict(result)` 生成可修改、可序列化的副本。变量属于当前进程，不是跨进程共享内存。 -- `latest_result` 是单个最新结果变量，首帧前为 `None`。每帧完成风险计算后发布，早于任何可选绘制或文件写入。 -- 快照深度只读：字典使用只读映射，数组使用 tuple；字段和索引含义与原 JSON 一致。旧快照不会随下一帧变化，多个读取线程互不消费或修改结果。 -- 只保留最新一帧，没有结果队列；下游处理慢可跳过中间帧。需要每帧历史时显式开启 `--save-results`。 -- `pipeline.wait_for_result(after_frame_index, timeout)` 是可选等待接口，返回更新的最新结果；超时或结束且无新帧时返回 `None`。 -- `pipeline.request_stop()` 请求停止，`pipeline.join()` 等待退出并向调用方传播推理异常；停止后可读取最后快照及 `pipeline.summary`。使用 `with` 自动停止并回收资源。 -- 停止后的快照只是最后结果；持续控制时应同时检查 `pipeline.running()` 及帧序号/时间戳，避免使用旧结果。 -- 需要修改副本或 JSON 序列化时使用 `from run_camera import result_to_dict`，再调用 `result_to_dict(result)`。 -- 变量属于创建 `CameraPipeline` 的 Python 进程。另一个进程或 C++ 程序不能直接 import 读取后台服务的变量，需要另行使用 IPC/HTTP 接口；当前没有新增 C++ 风险结果 ABI。 +## CAN、风险与输出选项 -## 可选输出开关 +`0x391` 的 data[0..3] 依次为左前、右前、左后、右后。默认 `--can-side left`，右侧使用 `--can-side right`。值为 0 表示对应门活跃；报文缺失或超过默认 1000 ms 时，输出 `CAN_UNKNOWN`、分数 null。当前接口不发送防夹执行器指令。 -| 参数 | 行为 | +优先用融合后的有效手部区域判断风险，无有效手部时使用人体框兜底；最终读取 `risk` / `door_risks`。`ungated_risk` 仅供诊断，`unknown` 不能当作 clear。 +标定文件来自研发机位，默认 `calibration_verified=false`，换机位须重新标定。 + +| 参数 | 作用 | |---|---| -| 无输出参数 | 只发布内存结果，不绘制、不保存结果文件 | -| `--visualize` | 开启独立可视化线程和 HTTP 预览 | -| `--save-results` | 保存逐帧 JSONL 及约每 10 秒的 latest.json | -| `--save-snapshots` | 约每 10 秒绘制并保存 latest.jpg，无 HTTP 服务 | -| `--save-pose-records` | 保存诊断姿态 JSONL | -| `--write-video` | 绘制并保存叠加 MP4，无需打开预览 | +| `--visualize` | 开启独立绘制线程及 HTTP 预览；默认不绘制、不编码、不监听端口 | +| `--save-results` | 保存逐帧 JSONL 及 latest.json，默认不保存 | +| `--save-snapshots` | 每约 10 秒保存叠加图像 | +| `--write-video` | 保存叠加视频，可配合 `--duration` 限时运行 | +| `--output PATH` | 指定保存目录，本身不启用保存 | +| `--no-can --active-door both` | 显式模拟门状态 | -输出开关可组合。`--output` 仅指定保存目录，不会自动开启保存。未开启保存时，旧输出文件保留但不会更新。任一保存开关开启后，停止时额外保存 summary.json；默认内存模式的统计保存在 `pipeline.summary` 并打印到终端。 +运行 `./run_camera.sh --help` 或 `orin/run.sh --help` 查看全部选项。JSONL 每 32 MiB 轮换，保留两个历史文件；视频不轮换。开启可视化后可读取 `/result.json` 和 `/frame.jpg`。 -恢复此前的预览与文件输出行为： +## 目录 -```bash -./run_camera.sh --visualize --save-results --save-snapshots --output outputs/demo -``` - -## CAN 约定 - -按用户确认的 `0x391` 数据布局： - -| 字节 | 车门 | -|---|---| -| data[0] | 左前 | -| data[1] | 右前 | -| data[2] | 左后 | -| data[3] | 右后 | - -- `--can-side left` 使用 data[0]/data[2]；`right` 使用 data[1]/data[3]。默认 left，请按摄像头安装侧选择。 -- 值为 0 时对应门活跃，每帧读取最新 CAN 快照。有效报文至少需要 4 字节。 -- 未收到有效报文或超过 `--can-timeout-ms`（默认 1000 ms），整体输出 `CAN_UNKNOWN`，门级输出 `FRONT_UNKNOWN/REAR_UNKNOWN`，分数为 null。 -- 此时 `active_door=none` 仅为内部无有效活跃门输入，业务必须读取 `risk` 和 `can.valid`，不能将其解释为已确认两门关闭。 -- 显式 `--active-door front/rear/both/none` 是模拟模式，输出 `can.source=simulation`，预览显示 CAN SIMULATION。`--no-can` 要求显式选择模拟状态。 -- 本项目提供最终风险结果；基线未提供防夹执行器的 CAN 指令协议，因此没有自行添加执行器报文。 -- 本次 USB-CAN `VCI_OpenDevice` 返回失败，`lsusb` 中未见 USB-CAN 设备；真实 0x391 报文链路尚未验证。连接适配器后重新启动程序；字节映射及门状态组合通过软件测试。 - -## 风险行为与机位标定 - -风险算法、默认 warning=0.30 / release=0.45、133 点骨骼、track_id、前后门归属、transition→unknown、无有效手部时人体框兜底均沿用原版。详见 `README-risk-upstream.md`。 - -`annotations/constant_door_mask.json` 和 `door_zone_multifeature.json` 原样复制，属于原研发机位。当前室内摄像头位置与其不一致，默认输出 `calibration_verified=false`，预览显示 CALIBRATION UNVERIFIED。实车验证需更换标定文件；`--calibration-verified` 仅标记经人工验证的标定，不会自动标定。 - -当前实时场景没有人，约 29 FPS 是该场景的实测值，不能当作多人满负载帧率。 - -## 优化与输出 - -- 重用 0920 的常驻 TensorRT engine、CUDA/NPP 预处理、显存及锁页缓存、GPU UYVY 转换。 -- 独立取帧线程只保留最新帧，主动丢弃旧帧，避免积压；不像 0920 那样单独并行检测线程，完整 Python 融合阶段按结果顺序执行。 -- 风险 mask / 距离变换按原版缓存；开启预览时默认每 3 帧提交一次待绘制图像；开启快照保存时每 10 秒一次。 -- 长期运行清理过期轨迹，计时统计仅保留最近 3000 帧。 -- 开启 `--save-results` 后，`causal_results.jsonl` 默认每 32 MiB 轮换，保留 `.1` 和 `.2`；`--jsonl-max-mb 0` 可禁用轮换。读取全部历史时按 `.2 → .1 → 当前文件` 顺序处理。 -- `--save-pose-records` 额外保存同样轮换的诊断姿态记录；`--write-video` 录制叠加 MP4（视频不轮换，建议配合 `--duration`）。 -- 文件输出遵循上面的独立开关；关闭可视化仍可完整读取内存结果。 -- 新增 `capture`、`can`、`capture_to_result_ms`、`calibration_verified` 字段，原版核心 JSON 字段保留。 -- 驱动原始时间戳存在时钟偏移，保存在 `capture.driver_timestamp_ms` 供诊断。延迟采用主机单调时钟在 DQBUF 后取样，表示“主机取帧到风险结果”，不包含曝光到驱动交付的时间。 - -## 文件关系与测试 - -- `main.cpp`, `v4l2_capture.*`, `can_comm.*`, `include/zcan.h`, `lib/`：基线工程。新工程修正错误 V4L2 buffer 处理；旧 main 同步修正 CAN 字节解析。 -- `native/native_api.cpp`：采集线程、CAN 快照、TensorRT 的 ctypes C 接口。 -- `accelerator/`：远端 0920 源码快照，当前构建只选取 TensorRT/预处理/检测/姿态源文件。 -- `pipeline/`：原版 Python 算法，推理适配在 `native_backend.py`；ONNX/Ultralytics 的可选导入移到旧离线入口，原版风险公式不变。 -- `Makefile.baseline` 和 `make baseline`：旧基线演示程序的编译方式；默认 `make` 编译新的原生共享库。 -- `pipeline/latest_result.py`：线程安全的单结果发布槽位及不可变快照。 -- `examples/read_latest.py`：同进程下游读取示例。 -- `tests/test_latest_result.py`：结果所有权、线程生命周期、可选输出、独立可视化及异常传播测试。 -- `tests/test_risk_integration.py`：CAN 左右门组合、失效状态、手部/人体兜底、transition、轨迹回收、日志轮换测试。 -- `TEST_REPORT.md`：实测结果和限制。 - -```bash -python3 -m unittest discover -s tests -v -``` - -本机重新部署源码（会使用 SSH 交互认证，不保存密码）： - -```bash -./scripts/deploy.sh orin@192.168.195.100 -``` - -重新编译共享库前应先停止 0923 运行进程，再启动新进程加载新库。 +- `native/`：实际参与编译的摄像头/CAN、CUDA/NPP、TensorRT 源码及头文件。 +- `pipeline/`：运行时姿态融合、跟踪、遮挡处理、风险、可视化和结果变量。 +- `annotations/`：源码运行时的标定文件。 +- `scripts/`：构建、打包、摄像头初始化。 +- `orin/`：可单独复制并直接执行的运行包。 diff --git a/TEST_REPORT.md b/TEST_REPORT.md deleted file mode 100644 index 51b00e4..0000000 --- a/TEST_REPORT.md +++ /dev/null @@ -1,56 +0,0 @@ -# 2026-09-23 集成验证 - -执行设备：192.168.195.100 / Orin；摄像头 /dev/video5，UYVY 1920×1536。当前机位朝向室内设备，没有测试人员；用户确认暂不调整机位。 - -| 验证 | 结果 | -|---|---| -| 原生 C++/CUDA 共享库 | Orin Release 编译通过 | -| 摄像头 + CAN 模式，30 秒 | 882 帧，29.399 FPS，无运行异常 | -| 主机取帧到风险结果 | 均值 42.369 ms，P95 57.368 ms | -| latest-frame 策略 | 30 秒期间丢弃 16 个积压帧 | -| 真实 CAN | USB-CAN 打开失败，lsusb 未见该设备；882 帧均为 CAN_UNKNOWN，score=null | -| 有人视频 150 帧回放 | 32.898 FPS，31 帧有 1 人，119 帧无有效人体框 | -| RTMW 骨骼 | 31 个人体记录，每个 133 点 | -| 风险证据 | 22 个手部区域，9 个人体框兜底区域 | -| 视频门级风险 | clear 132，watch 5，warning 2，unknown 11 | -| 原始 run_risk.py 对照 | 同一姿态记录重放 150 帧，核心输出完全一致 | -| 行为测试 | 本机与 Orin 的 8 项测试均通过 | -| HTTP 实时预览 | 本机访问远端 /result.json 成功，连续返回新帧 | - -对照方式：将远端 `outputs/person-replay/pose_records.jsonl` 下载到本机，用用户原始工程的 `run_risk.py --pose-jsonl` 运行，逐帧比较原始 JSON 的所有顶层字段，包括 skeletons、door_assignments、door_risks、risk、ungated_risk。仅排除不同工程目录导致的绝对 mask 路径差异；150 帧无差异。**此项对照验证相同姿态输入下的风险集成，不是 TensorRT 与 ONNX 输出的数值误差测试。** - -证据： - -- `outputs/camera-can/summary.json` -- `outputs/person-replay/summary.json` 与 `causal_results.jsonl` -- `outputs/reference-replay/summary.json` 与 `causal_results.jsonl` -- `outputs/reference-parity.json` -- `logs/build.log`, `logs/camera-can.log`, `logs/person-replay.log` - -`outputs/camera-smoke/` 是初次调通记录，使用了不可靠的驱动时间戳，延迟统计无效。已修正计时来源，性能结论以 `camera-can` 为准。 - -未完成的硬件验证：有效 CAN 报文到达与门切换、真实摄像头下人员/手部靠近门区、实车机位 mask 与前后门参数标定。当前无法据此宣称已完成实车防夹效果验收。 - -本机没有摄像头设备节点；本机完成源码/模型归档、风险对照及行为测试，通过网络预览 Orin 的实时结果。 - - -## 最新结果变量与可选可视化改造 - -已对照重启后远端 0920 的 `include/latest_result.hpp` 和 `src/main.cpp`，采用默认关闭可视化、单个不可变最新快照、start/latest/request_stop/join 生命周期。 - -- 本机与 Orin：17 项测试通过，覆盖原有风险测试及只读快照、旧快照保持、跨线程等待/停止、错误传播、默认无绘制/HTTP/结果文件、JSON 与内存结果一致、预览端口失败不影响推理、独立可视化线程。 -- Orin 真实 TensorRT 视频回放：下游示例读取 90 帧，27.321 FPS；未开启可视化和文件保存。保留 watch/warning/unknown 等风险输出。 -- Orin 真实摄像头：下游示例读取 90 帧，28.858 FPS；主机取帧至结果均值 32.341 ms；关闭可视化，没有创建指定输出目录。 -- `--visualize` 实机运行 15 秒：成功通过 HTTP 读取逐帧结果及 JPEG 图像；未开启文件保存，没有创建指定输出目录。 -- 后台运行入口默认无可视化；开启预览需显式加 `--visualize`。 -- 重启后摄像头节点未自动生成。0920 初始化脚本因驱动缺少 vermagic 元数据而判定不匹配；0923 新增初始化脚本，存在 vermagic 时检查内核版本，缺失时交给正常 insmod 的内核检查，未使用强制加载参数。加载原有 0920 驱动后 /dev/video5 恢复。 - -日志：`logs/tests-optional-local.log`、`logs/tests-optional-orin.log`、`logs/result-api-video.log`、`logs/result-api-camera.log`、`logs/optional-preview.log`、`logs/optional-preview-probe.json`。 - -## use-can Orin 可运行包验证 - -- 独立运行包位于 `orin/`：包含预编译 ARM64 原生库、TensorRT 引擎、Python 风险代码、CAN USB 库、GMSL 驱动和 ./run.sh。 -- 在 Orin 新建的独立临时目录复制整个运行包，SHA256SUMS 全部通过。 -- 从临时目录执行 `./run.sh --max-frames 90`，实际摄像头 90 帧完成，29.080 FPS，主机取帧至风险结果平均 36.310 ms；无结果文件输出。 -- 原生库 RUNPATH 为 `$ORIGIN/../lib:/usr/local/cuda/lib64`，启动脚本按自身位置定位所有项目资产。 -- 系统依赖仍为目标 JetPack 的 CUDA / TensorRT / OpenCV 与 Python numpy/cv2，不包含操作系统或完整 Python 环境。 diff --git a/accelerator/.gitattributes b/accelerator/.gitattributes deleted file mode 100644 index 5f609e2..0000000 --- a/accelerator/.gitattributes +++ /dev/null @@ -1,5 +0,0 @@ -*.sh text eol=lf -*.engine -text -*.ko -text -/orin/** -text -/config/door_mask.json -text diff --git a/accelerator/.gitignore b/accelerator/.gitignore deleted file mode 100644 index 4097644..0000000 --- a/accelerator/.gitignore +++ /dev/null @@ -1,4 +0,0 @@ -/build/ -/engines/ -/logs/ -*.tmp diff --git a/accelerator/CMakeLists.txt b/accelerator/CMakeLists.txt deleted file mode 100644 index 1a5dede..0000000 --- a/accelerator/CMakeLists.txt +++ /dev/null @@ -1,23 +0,0 @@ -cmake_minimum_required(VERSION 3.24) -if(NOT DEFINED CMAKE_CUDA_ARCHITECTURES) - set(CMAKE_CUDA_ARCHITECTURES native) -endif() -project(camera_risk LANGUAGES CXX CUDA) -set(CMAKE_CXX_STANDARD 17) -set(CMAKE_CXX_STANDARD_REQUIRED ON) -set(CMAKE_CUDA_STANDARD 17) -find_package(CUDAToolkit REQUIRED) -find_package(OpenCV REQUIRED COMPONENTS core imgproc imgcodecs highgui) -find_package(Threads REQUIRED) -find_path(TENSORRT_INCLUDE_DIR NvInfer.h PATH_SUFFIXES aarch64-linux-gnu x86_64-linux-gnu REQUIRED) -find_library(TENSORRT_LIBRARY nvinfer REQUIRED) -add_library(camera_risk_core - src/trt_engine.cpp src/pose_engine.cu src/gpu_preprocess.cu src/uyvy_converter.cu - src/detector.cpp src/door_risk.cpp src/camera.cpp src/camera_pipeline.cpp src/config.cpp) -target_include_directories(camera_risk_core PUBLIC include third_party ${TENSORRT_INCLUDE_DIR} ${OpenCV_INCLUDE_DIRS}) -target_link_libraries(camera_risk_core PUBLIC ${TENSORRT_LIBRARY} ${OpenCV_LIBS} Threads::Threads CUDA::cudart CUDA::nppc CUDA::nppig CUDA::nppidei CUDA::nppicc) -target_compile_options(camera_risk_core PRIVATE $<$:-Wall;-Wextra;-Wpedantic>) -add_library(camera_risk_visualizer src/visualizer.cpp) -target_link_libraries(camera_risk_visualizer PUBLIC camera_risk_core) -add_executable(camera_risk src/main.cpp) -target_link_libraries(camera_risk PRIVATE camera_risk_visualizer) diff --git a/accelerator/README.md b/accelerator/README.md deleted file mode 100644 index 1f815a6..0000000 --- a/accelerator/README.md +++ /dev/null @@ -1,76 +0,0 @@ -# Vision Anti-Pinch - -C++ / TensorRT 实时摄像头风险推理，算法来自最新 run_risk.py。 -持续取图、推理并更新内存中的 FrameResult；可视化可选。 - -## Orin 直接运行 - -适用环境：Jetson AGX Orin、JetPack 5.1.2 / L4T R35.4.1、CUDA 11.4、TensorRT 8.5.2、OpenCV 4.5.4。 -仓库已包含该板端编译的程序和重新构建的 TensorRT 引擎，无需先编译或转换。 - -```bash -git clone https://git.kendeji.fun/zmv/vision-anti-pinch.git -cd vision-anti-pinch/orin -./scripts/initialize_camera.sh # 开机后初始化 /dev/video5 摄像头链路 -./run.sh # 持续推理，结果只保存在内存 -``` - -可选板端本地可视化： - -```bash -./run.sh --visualize -``` - -Ctrl+C / SIGTERM 停止程序。没有有限帧选项；正常运行和退出不输出统计。 -关闭预览窗口或按 q/Esc 只关闭预览，推理继续。没有图像网络服务、端口转发、JSONL 或视频输出。 - -摄像头为 /dev/video5，1920×1536 UYVY，30 FPS。 -当前 door mask 是指定的 constant_door_mask.json 副本，标定状态为 false；装车后应更换与实际画面匹配的门区并更新标定状态。 -即使不开启可视化，风险计算仍需要门区。 - -## 下游获取结果 - -main.cpp 注释中也包含以下示例。下游通过自己的调用位置或线程读取： - -```cpp -auto result = pipeline.latest(); -if (result) { - const auto& risk = result->risk; - const auto& people = result->persons; - // result->frame_index / track_ids / boxes - // result->image / door_mask_pixels / capture / timing - // people[i].selected / smoothed / temporal：各 133 个关键点 -} -``` - -latest() 返回 shared_ptr；首帧尚未完成时为空。 -读取不删除结果，也不产生消费状态。推理不关心是否有下游读取。 -下游持有的结果保持有效，后续更新不会改变旧快照；历史保存由下游自行负责。 -公共定义位于 include/camera_pipeline.hpp 和 include/frame_result.hpp。 - -## 从源码构建 - -```bash -./scripts/build.sh -./scripts/initialize_camera.sh -./run_camera.sh -``` - -源码构建要求 CMake 3.24+、CUDA/NPP、TensorRT 和 OpenCV 开发依赖。 -构建脚本会优先使用 Orin 上已有的 ~/miniconda3/envs/yolo/bin/cmake。 -源码配置直接使用 orin/engines/ 中的板端引擎。该引擎仅适用于上述 Orin 环境；仓库不包含 ONNX 或模型转换脚本。 -独立库目标为 camera_risk_core；可视化在 camera_risk_visualizer。 - -## 目录 - -- src/、include/：采集、推理、结果变量及可选绘制。 -- config/：源码构建程序的配置和固定门区。 -- scripts/：构建和摄像头初始化脚本。 -- orin/：已编译程序、TensorRT 引擎、配置、当前 GMSL 驱动及启动脚本。 -- third_party/：nlohmann JSON 及其许可证。 - -NPP 用于 UYVY 转换、YOLO 缩放填充、RTMW 仿射裁剪；CUDA 用于通道转换与归一化。 -风险几何计算仍包含 CPU/OpenCV 操作；算法内部的临时 JSON 对象只在内存中使用。 - -当前摄像头驱动启动时偶发首帧 ERROR，应用会丢弃并计数；持续错误、采集超时或推理错误会明确报错并退出。 -现有 GMSL 驱动停止采集时可产生 videobuf2 缓冲区告警，v4l2-ctl 同样复现；需在驱动侧完成量产修复和验证。 diff --git a/accelerator/config/camera.json b/accelerator/config/camera.json deleted file mode 100644 index 433c732..0000000 --- a/accelerator/config/camera.json +++ /dev/null @@ -1,22 +0,0 @@ -{ - "camera": { - "device": "/dev/video5", - "width": 1920, - "height": 1536, - "fps": 30, - "buffers": 4, - "timeout_ms": 2000 - }, - "inference": { - "engine_directory": "../orin/engines", - "detector_confidence": 0.3, - "max_people": 3, - "queue_capacity": 2 - }, - "door": { - "mask": "door_mask.json", - "warning_relative": 0.3, - "release_relative": 0.45, - "calibration_verified": false - } -} diff --git a/accelerator/config/door_mask.json b/accelerator/config/door_mask.json deleted file mode 100644 index 135b2a1..0000000 --- a/accelerator/config/door_mask.json +++ /dev/null @@ -1,77 +0,0 @@ -{ - "version": "x-anylabeling", - "flags": {}, - "shapes": [ - { - "label": "door", - "points": [ - [ - 212.86, - 145.919 - ], - [ - 378.891, - 851.857 - ], - [ - 468.293, - 996.446 - ], - [ - 536.408, - 1294.131 - ], - [ - 553.437, - 1404.7 - ], - [ - 561.951, - 1532.279 - ], - [ - 51.086, - 1532.279 - ], - [ - 8.514, - 1515.268 - ], - [ - 0.0, - 1468.489 - ], - [ - 8.514, - 26.845 - ], - [ - 25.543, - 5.582 - ], - [ - 131.973, - -2.924 - ], - [ - 191.574, - 1.329 - ], - [ - 208.603, - 145.919 - ] - ], - "group_id": null, - "shape_type": "polygon", - "flags": {} - } - ], - "imagePath": "constant_door_mask_reference.jpg", - "imageData": null, - "imageHeight": 1536, - "imageWidth": 1920, - "sourceVideo": "D:\\huang.xuewei\\CMS\\video\\20260921104502\\segment_009.mp4", - "sourceFrameIndex": 244, - "constantDoorMask": true -} \ No newline at end of file diff --git a/accelerator/include/bounded_queue.hpp b/accelerator/include/bounded_queue.hpp deleted file mode 100644 index 65e979b..0000000 --- a/accelerator/include/bounded_queue.hpp +++ /dev/null @@ -1,36 +0,0 @@ -#pragma once -#include -#include -#include -#include -#include - -namespace cms { -// FIFO with bounded ownership. Normal close drains; cancellation may discard. -template class BoundedQueue { -public: - explicit BoundedQueue(std::size_t capacity):capacity_(capacity) { - if(!capacity)throw std::invalid_argument("Queue capacity must be positive"); - } - bool push(T item) { - std::unique_lock lock(mutex_); - changed_.wait(lock,[&]{return closed_||items_.size() pop() { - std::unique_lock lock(mutex_); - changed_.wait(lock,[&]{return closed_||!items_.empty();}); - if(items_.empty())return {}; - T item=std::move(items_.front());items_.pop_front();changed_.notify_all();return item; - } - void close(bool discard=false) { - std::lock_guard lock(mutex_); - closed_=true;if(discard)items_.clear();changed_.notify_all(); - } -private: - const std::size_t capacity_; - std::mutex mutex_;std::condition_variable changed_; - std::deque items_;bool closed_{}; -}; -} diff --git a/accelerator/include/camera.hpp b/accelerator/include/camera.hpp deleted file mode 100644 index c07c729..0000000 --- a/accelerator/include/camera.hpp +++ /dev/null @@ -1,31 +0,0 @@ -#pragma once -#include "image.hpp" -#include -#include -#include -#include - -namespace cms { -struct CameraConfig { - std::string device{"/dev/video5"}; - int width{1920},height{1536},fps{30},buffers{4},timeout_ms{2000}; -}; -struct CapturedFrame { - CaptureMetadata metadata; - std::shared_ptr image; -}; -// The capture thread exclusively owns read(); requestStop() is thread safe. -class Camera { -public: - explicit Camera(CameraConfig config); - ~Camera(); - Camera(Camera const&)=delete; - Camera& operator=(Camera const&)=delete; - std::optional read(); - void requestStop() noexcept; -private: - struct Impl; - std::unique_ptr impl_; -}; -std::uint64_t monotonicNs(); -} diff --git a/accelerator/include/camera_pipeline.hpp b/accelerator/include/camera_pipeline.hpp deleted file mode 100644 index d1160f5..0000000 --- a/accelerator/include/camera_pipeline.hpp +++ /dev/null @@ -1,43 +0,0 @@ -#pragma once -#include "camera.hpp" -#include "frame_result.hpp" -#include -#include - -namespace cms { -struct PipelineConfig { - CameraConfig camera; - std::filesystem::path engines,door_mask; - double detector_confidence{0.30}; - int max_people{3}; - double warning_relative{0.30},release_relative{0.45}; - std::size_t queue_capacity{2}; - bool door_mask_calibration_verified{false}; -}; -struct PipelineStats { - std::uint64_t captured{},published{},driver_sequence_gaps{},discarded_error_frames{}; - double mean_capture_to_result_ms{}; -}; -// One lifecycle per instance. start() warms engines before starting capture. -// Runs continuously until requestStop() or a worker failure. -// latest() reads the immutable result variable without removing or acknowledging it. -// No result queue, consumer registration or frame-count termination. -// Stop is safe from any thread; -// destruction closes queues, interrupts capture and joins every worker. -class CameraPipeline { -public: - explicit CameraPipeline(PipelineConfig config); - ~CameraPipeline(); - CameraPipeline(CameraPipeline const&)=delete; - CameraPipeline& operator=(CameraPipeline const&)=delete; - void start(); - FrameResultPtr latest() const; - bool running() const noexcept; - void requestStop() noexcept; - void join(); - PipelineStats stats() const; -private: - struct Impl; - std::unique_ptr impl_; -}; -} diff --git a/accelerator/include/config.hpp b/accelerator/include/config.hpp deleted file mode 100644 index 66fdda5..0000000 --- a/accelerator/include/config.hpp +++ /dev/null @@ -1,5 +0,0 @@ -#pragma once -#include "camera_pipeline.hpp" -namespace cms { -PipelineConfig loadConfig(std::filesystem::path const& path); -} diff --git a/accelerator/include/door_risk.hpp b/accelerator/include/door_risk.hpp deleted file mode 100644 index e11ddb5..0000000 --- a/accelerator/include/door_risk.hpp +++ /dev/null @@ -1,35 +0,0 @@ -#pragma once -#include -#include -#include -#include -#include -using Json = nlohmann::ordered_json; -namespace cms { -struct DoorOptions { - std::filesystem::path constant, directory; - std::string format{"auto"}; - std::set labels{"door", "车门"}; - int offset{}; - bool require{}; - double warning{0.30}, release{0.45}; -}; -class DoorRisk { -public: - DoorRisk(DoorOptions options, cv::Size size); - void initialize() { load(0); } - Json evaluate(int frame, Json& record); - cv::Mat const& mask() const { return mask_; } -private: - void load(int frame); - cv::Mat rasterize(std::filesystem::path const& path) const; - DoorOptions options_; - cv::Size size_; - std::string format_, status_; - std::filesystem::path loadedPath_; - std::map paths_; - cv::Mat mask_, distance_; - bool cached_{}; -}; -double rounded(double value, int digits); -} diff --git a/accelerator/include/frame_result.hpp b/accelerator/include/frame_result.hpp deleted file mode 100644 index 7999cce..0000000 --- a/accelerator/include/frame_result.hpp +++ /dev/null @@ -1,80 +0,0 @@ -#pragma once -// Public downstream contract. Owns its data; no GPU, JSON or network handles. -#include "image.hpp" -#include -#include -#include -#include -#include -#include - -namespace cms { -struct DoorMaskResult { - std::string status; - int annotation_index{}; - std::optional path; - std::string format; - int area_px{}; -}; -struct RegionRisk { - std::string status; - std::optional risk_score; - std::string risk_level; - std::string decision; - std::string source; - int track_id{}; - std::string side; - std::optional state; - // Unavailable evidence has no geometric measurements, matching the reference. - std::optional region_area_px, door_overlap_px; - std::optional region_overlap_ratio, min_distance_px; - std::optional region_scale_px, distance_relative; -}; -struct RiskResult { - std::string status; - std::optional risk_score; - std::string risk_level; - std::string decision; - std::optional source; - std::optional track_id; - std::optional side; - DoorMaskResult door_mask; - double warning_distance_relative{}, release_distance_relative{}; - std::vector regions; -}; -struct PosePoint { double x{},y{},score{}; }; -struct HandState { - std::string state, source; - bool limb_consensus{}, distance_eligible{}, alarm_eligible{}; -}; -struct PersonResult { - int track_id{}; - double confidence{}; - std::array box{}; - std::array selected{}, smoothed{}, temporal{}; - std::array hands; // left, right -}; -struct HandRegion { - int person_id{},track_id{}; - std::string side; - std::array keypoints{}; -}; -struct StageTiming { - double detector_ms{}, pose_ms{}, fusion_risk_ms{}, capture_to_result_ms{}; -}; -struct FrameResult { - int frame_index{}; - std::vector track_ids; - std::vector> boxes; - RiskResult risk; - CaptureMetadata capture; - StageTiming timing; - std::vector persons; - std::vector hand_regions; - // Both images belong to this result. The constant mask is shared across frames. - std::shared_ptr image; - std::shared_ptr door_mask_pixels; - bool door_mask_calibration_verified{}; -}; -using FrameResultPtr = std::shared_ptr; -} diff --git a/accelerator/include/image.hpp b/accelerator/include/image.hpp deleted file mode 100644 index e69a87c..0000000 --- a/accelerator/include/image.hpp +++ /dev/null @@ -1,25 +0,0 @@ -#pragma once -#include -#include - -namespace cms { -// Immutable when published. Stride is explicit; no borrowed camera/GPU memory. -struct BgrImage { - int width{}, height{}, stride{}; - std::vector pixels; -}; -struct BinaryMask { - int width{}, height{}, stride{}; - std::vector pixels; -}; -struct CaptureMetadata { - std::uint64_t frame_index{}; - std::uint32_t driver_sequence{}; - std::uint64_t driver_timestamp_ns{}; - std::uint64_t received_monotonic_ns{}; - std::uint64_t capture_monotonic_ns{}; - bool driver_timestamp_monotonic{}; - std::uint32_t skipped_driver_frames{}; - std::uint32_t discarded_error_frames{}; -}; -} diff --git a/accelerator/include/latest_result.hpp b/accelerator/include/latest_result.hpp deleted file mode 100644 index d6e7623..0000000 --- a/accelerator/include/latest_result.hpp +++ /dev/null @@ -1,20 +0,0 @@ -#pragma once -#include "frame_result.hpp" -#include -#include - -namespace cms { -// One immutable result variable. Readers neither remove nor acknowledge results. -class LatestResult { -public: - void publish(FrameResultPtr result) { - if(!result)throw std::invalid_argument("Cannot publish a null result"); - std::atomic_store_explicit(&latest_,std::move(result),std::memory_order_release); - } - FrameResultPtr load() const { - return std::atomic_load_explicit(&latest_,std::memory_order_acquire); - } -private: - FrameResultPtr latest_; -}; -} diff --git a/accelerator/include/pipeline_types.hpp b/accelerator/include/pipeline_types.hpp deleted file mode 100644 index 331e693..0000000 --- a/accelerator/include/pipeline_types.hpp +++ /dev/null @@ -1,100 +0,0 @@ -#pragma once - -#include -#include -#include -#include -#include - -namespace fangjia { - -struct Box { - float x1{}; - float y1{}; - float x2{}; - float y2{}; - float score{}; - int trackId{}; -}; - -struct Keypoint { - float x{}; - float y{}; - float score{}; -}; - -struct PersonPose { - Box box; - std::array keypoints{}; -}; - -enum class LimbState { - Observed, - Provisional, - Recovered, - Reassigned, - Interpolated, - PredictedShort, - ReachableMedium, - ReachableLong, -}; - -inline char const* limbStateName(LimbState state) { - switch (state) { - case LimbState::Observed: return "observed"; - case LimbState::Provisional: return "provisional"; - case LimbState::Recovered: return "recovered"; - case LimbState::Reassigned: return "reassigned"; - case LimbState::Interpolated: return "interpolated"; - case LimbState::PredictedShort: return "predicted_short"; - case LimbState::ReachableMedium: return "reachable_medium"; - case LimbState::ReachableLong: return "reachable_long"; - } - return "unknown"; -} - -struct LimbObservation { - int trackId{}; - bool left{}; - LimbState state{LimbState::ReachableLong}; - Keypoint elbow{}; - Keypoint wrist{}; - std::array hand{}; - Box personBox{}; - bool handValid{}; - bool alarmEligible{}; - float handQuality{}; -}; - -// Exact pre-V2 hand evidence consumed by the Python risk stage. These points -// come from raw/isolated fusion before temporal reconstruction. -struct GlobalHand { - int personId{}; - int trackId{}; - bool left{}; - std::string source; - std::string state; - bool distanceEligible{}; - bool alarmEligible{}; - float score{}; - float spanPx{}; - std::array keypoints{}; - std::vector> aliases; -}; - -struct FusionMeta { - bool limbConsensus{}, handValid{}, distanceEligible{}, alarmEligible{}; - double handScore{}; - std::string handSource, handState; -}; - -struct PoseFrameResult { - std::vector> metadata; - std::vector selectedPeople; - std::vector smoothedPeople; - std::vector v2People; - std::vector limbs; - std::vector globalHands; -}; - -} // namespace fangjia diff --git a/accelerator/include/pose_engine.hpp b/accelerator/include/pose_engine.hpp deleted file mode 100644 index ee707e7..0000000 --- a/accelerator/include/pose_engine.hpp +++ /dev/null @@ -1,108 +0,0 @@ -#pragma once - -#include "pipeline_types.hpp" -#include "trt_engine.hpp" - -#include - -#include -#include -#include -#include -#include - -namespace fangjia { - -class BoxTracker { -public: - std::vector update(std::vector& boxes, int frameIndex, int width, int height); - -private: - struct Track { Box box; int lastFrame{}; }; - int nextId_{1}; - std::unordered_map tracks_; -}; - -class RtmwEngine { -public: - RtmwEngine( - std::filesystem::path const& enginePath, - TrtLogger& logger, - int maxSourceWidth, - int maxSourceHeight, - int maxPeople = 3); - ~RtmwEngine(); - - RtmwEngine(RtmwEngine const&) = delete; - RtmwEngine& operator=(RtmwEngine const&) = delete; - - std::vector infer( - cv::Mat const& frame, - std::vector const& boxes, - cudaStream_t stream, - float* preprocessMs = nullptr, - float* inferenceMs = nullptr, - float* postprocessMs = nullptr); - - void warmup(cudaStream_t stream); - -private: - TrtEngine engine_; - int maxSourceWidth_{}; - int maxSourceHeight_{}; - int maxPeople_{}; - std::uint8_t* sourceDevice_{}; - std::uint8_t* cropsDevice_{}; - float* networkDevice_{}; - std::vector centersHost_; - std::vector scalesHost_; - std::vector simccXHost_; - std::vector simccYHost_; -}; - -class PoseFusionTracker { -public: - PoseFrameResult update( - std::vector const& raw, - std::vector const& isolated, - int frameIndex); - -private: - struct Vec2 { double x{}; double y{}; }; - struct SideFusion { - std::array limbPrevious{}; - std::array limbVelocity{}; - std::array handPrevious{}; - std::array handVelocity{}; - bool hasLimbPrevious{}; - bool hasLimbVelocity{}; - bool hasHandPrevious{}; - bool hasHandVelocity{}; - std::string limbSource; - std::string handSource; - }; - struct Endpoint { - bool hasWrist{}; - Vec2 wrist{}; - Vec2 velocity{}; - std::array handShape{}; - bool hasHandShape{}; - int lastObservedFrame{-1}; - int missedFrames{}; - bool hasLastElbow{}; - Vec2 lastElbow{}; - bool hasLastDirection{}; - Vec2 lastDirection{}; - }; - struct PersonState { - std::array fusion; - std::array endpoints; - std::array>, 2> boneSamples; - std::array smoothed{}; - bool hasSmoothed{}; - int lastFrame{-1}; - }; - std::unordered_map states_; -}; - -} // namespace fangjia diff --git a/accelerator/include/records.hpp b/accelerator/include/records.hpp deleted file mode 100644 index e9b79ac..0000000 --- a/accelerator/include/records.hpp +++ /dev/null @@ -1,38 +0,0 @@ -#pragma once -#include "door_risk.hpp" -#include "pipeline_types.hpp" -namespace cms { -inline Json xy(std::vector const& people, int digits=3) { - Json a=Json::array(); for(auto const& p:people) { Json k=Json::array();for(auto const& v:p.keypoints) k.push_back({rounded(v.x,digits),rounded(v.y,digits)});a.push_back(k); } return a; -} -inline Json scores(std::vector const& people) { - Json a=Json::array();for(auto const& p:people) {Json k=Json::array();for(auto const& v:p.keypoints) k.push_back(v.score);a.push_back(k);}return a; -} -inline Json makeRecord(int frame,std::vector const& raw,std::vector const& isolated,fangjia::PoseFrameResult const& fused, bool diagnostics=true, bool visual=true) { - Json r={{"frame_index",frame},{"track_ids",Json::array()},{"boxes",Json::array()},{"det_confidences",Json::array()}}; - for(auto const&p:raw) {auto const&b=p.box;r["track_ids"].push_back(b.trackId);r["boxes"].push_back({rounded(b.x1,3),rounded(b.y1,3),rounded(b.x2,3),rounded(b.y2,3)});r["det_confidences"].push_back(rounded(b.score,4));} - if(diagnostics) { - r["raw_keypoints"]=xy(raw,9);r["raw_scores"]=scores(raw);r["isolated_keypoints"]=xy(isolated,9);r["isolated_scores"]=scores(isolated); - r["inference_boxes"]=Json::array();for(auto const&p:raw)r["inference_boxes"].push_back({p.box.x1,p.box.y1,p.box.x2,p.box.y2}); - } - if(visual||diagnostics) { - r["temporal_selected_keypoints"]=xy(fused.selectedPeople);r["temporal_keypoints"]=xy(fused.smoothedPeople);r["v2_keypoints"]=xy(fused.v2People); - r["temporal_metadata"]=Json::array();r["v2_metadata"]=Json::array(); - for(size_t p=0;p inline std::optional optionalField(Json const& value,char const* key) { - auto it=value.find(key);return it==value.end()||it->is_null()?std::nullopt:std::optional(it->get()); -} -inline FrameResult makeFrameResult(Json const& record,Json const& risk, - CaptureMetadata capture) { - FrameResult out; - out.frame_index=record.at("frame_index").get(); - out.track_ids=record.at("track_ids").get>(); - out.boxes=record.at("boxes").get>>(); - out.capture=capture; - auto& r=out.risk; - r.status=risk.at("status");r.risk_score=optionalField(risk,"risk_score"); - r.risk_level=risk.at("risk_level");r.decision=risk.at("decision"); - r.source=optionalField(risk,"source");r.track_id=optionalField(risk,"track_id");r.side=optionalField(risk,"side"); - auto const& d=risk.at("door_mask"); - r.door_mask={d.at("status"),d.at("annotation_index"),optionalField(d,"path"),d.at("format"),d.at("area_px")}; - r.warning_distance_relative=risk.at("warning_distance_relative");r.release_distance_relative=risk.at("release_distance_relative"); - for(auto const& j:risk.at("regions")) { - RegionRisk v; - v.status=j.at("status");v.risk_score=optionalField(j,"risk_score"); - v.risk_level=j.at("risk_level");v.decision=j.at("decision");v.source=j.at("source"); - v.track_id=j.at("track_id");v.side=j.at("side");v.state=optionalField(j,"state"); - v.region_area_px=optionalField(j,"region_area_px");v.door_overlap_px=optionalField(j,"door_overlap_px"); - v.region_overlap_ratio=optionalField(j,"region_overlap_ratio");v.min_distance_px=optionalField(j,"min_distance_px"); - v.region_scale_px=optionalField(j,"region_scale_px");v.distance_relative=optionalField(j,"distance_relative"); - r.regions.push_back(std::move(v)); - } - return out; -} -} diff --git a/accelerator/include/stop_signals.hpp b/accelerator/include/stop_signals.hpp deleted file mode 100644 index bd403ff..0000000 --- a/accelerator/include/stop_signals.hpp +++ /dev/null @@ -1,36 +0,0 @@ -#pragma once -#include "camera_pipeline.hpp" -#include -#include -#include -#include -#include - -namespace cms { -// Construct before starting workers so all threads inherit the signal mask. -// Stop requests run in an ordinary thread, never an asynchronous signal handler. -class StopSignals { -public: - explicit StopSignals(CameraPipeline& pipeline):pipeline_(pipeline) { - sigemptyset(&signals_);sigaddset(&signals_,SIGINT);sigaddset(&signals_,SIGTERM); - if(pthread_sigmask(SIG_BLOCK,&signals_,&old_)!=0)throw std::runtime_error("Cannot block termination signals"); - try { - thread_=std::thread([this]{ - while(!done_) { - timespec timeout{0,100000000}; - int signal=sigtimedwait(&signals_,nullptr,&timeout); - if(signal==SIGINT||signal==SIGTERM){pipeline_.requestStop();break;} - } - }); - }catch(...){pthread_sigmask(SIG_SETMASK,&old_,nullptr);throw;} - } - ~StopSignals(){done_=true;if(thread_.joinable())thread_.join();pthread_sigmask(SIG_SETMASK,&old_,nullptr);} - StopSignals(StopSignals const&)=delete; - StopSignals& operator=(StopSignals const&)=delete; -private: - CameraPipeline& pipeline_; - sigset_t signals_{},old_{}; - std::atomic done_{false}; - std::thread thread_; -}; -} diff --git a/accelerator/include/visualizer.hpp b/accelerator/include/visualizer.hpp deleted file mode 100644 index 59494b2..0000000 --- a/accelerator/include/visualizer.hpp +++ /dev/null @@ -1,11 +0,0 @@ -#pragma once -#include "frame_result.hpp" -#include - -namespace cms { -class CameraPipeline; -// Pure drawing from the immutable result. Never re-runs inference. -cv::Mat renderResult(FrameResult const& result); -// Optional observer: closing the window returns without stopping the pipeline. -void runLocalVisualization(CameraPipeline const& pipeline); -} diff --git a/accelerator/run_camera.sh b/accelerator/run_camera.sh deleted file mode 100755 index c153d56..0000000 --- a/accelerator/run_camera.sh +++ /dev/null @@ -1,4 +0,0 @@ -#!/usr/bin/env bash -set -euo pipefail -root="$(cd -- "$(dirname -- "${BASH_SOURCE[0]}")" && pwd)" -exec "$root/build/camera_risk" --config "$root/config/camera.json" "$@" diff --git a/accelerator/scripts/build.sh b/accelerator/scripts/build.sh deleted file mode 100755 index 5b0fa8d..0000000 --- a/accelerator/scripts/build.sh +++ /dev/null @@ -1,7 +0,0 @@ -#!/usr/bin/env bash -set -euo pipefail -root="$(cd -- "$(dirname -- "${BASH_SOURCE[0]}")/.." && pwd)" -cmake_bin="${CMAKE_COMMAND:-cmake}" -if [[ -x "$HOME/miniconda3/envs/yolo/bin/cmake" ]]; then cmake_bin="${CMAKE_COMMAND:-$HOME/miniconda3/envs/yolo/bin/cmake}"; fi -"$cmake_bin" -S "$root" -B "$root/build" -DCMAKE_BUILD_TYPE=Release -DCMAKE_CUDA_COMPILER="${CUDACXX:-/usr/local/cuda/bin/nvcc}" "$@" -"$cmake_bin" --build "$root/build" -j4 diff --git a/accelerator/scripts/initialize_camera.sh b/accelerator/scripts/initialize_camera.sh deleted file mode 100755 index 8da09bd..0000000 --- a/accelerator/scripts/initialize_camera.sh +++ /dev/null @@ -1,4 +0,0 @@ -#!/usr/bin/env bash -set -euo pipefail -root="$(cd -- "$(dirname -- "${BASH_SOURCE[0]}")/.." && pwd)" -exec "$root/orin/scripts/initialize_camera.sh" "$@" diff --git a/accelerator/src/camera.cpp b/accelerator/src/camera.cpp deleted file mode 100644 index 78c1d2c..0000000 --- a/accelerator/src/camera.cpp +++ /dev/null @@ -1,146 +0,0 @@ -#include "camera.hpp" -#include "uyvy_converter.hpp" -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include - -namespace cms { -std::uint64_t monotonicNs() { - timespec time{}; - if(clock_gettime(CLOCK_MONOTONIC,&time)!=0)throw std::runtime_error("clock_gettime failed"); - return std::uint64_t(time.tv_sec)*1000000000ULL+time.tv_nsec; -} -namespace { -void checkedIoctl(int fd,unsigned long request,void* argument,char const* operation) { - int status; - do {status=ioctl(fd,request,argument);} while(status<0&&errno==EINTR); - if(status<0)throw std::runtime_error(std::string(operation)+": "+std::strerror(errno)); -} -} -struct Camera::Impl { - struct Buffer {void* data{};std::size_t size{};}; - CameraConfig config; - int fd{-1},stopFd{-1};bool streaming{}; - std::uint32_t stride{},lastSequence{};bool haveSequence{}; - std::uint64_t index{}; - std::uint32_t consecutiveErrors{}; - std::atomic stopped{false}; - std::vector buffers; - std::unique_ptr converter; - explicit Impl(CameraConfig c):config(std::move(c)) { - if(config.width<=0||config.width>8192||config.height<=0||config.height>8192||config.width%2||config.fps<=0||config.fps>240||config.buffers<2||config.buffers>32||config.timeout_ms<1) - throw std::invalid_argument("Invalid camera configuration"); - try { - stopFd=eventfd(0,EFD_CLOEXEC|EFD_NONBLOCK); - if(stopFd<0)throw std::runtime_error("Cannot create camera stop event"); - fd=open(config.device.c_str(),O_RDWR|O_NONBLOCK|O_CLOEXEC); - if(fd<0)throw std::runtime_error("Cannot open "+config.device+": "+std::strerror(errno)); - v4l2_capability capability{};checkedIoctl(fd,VIDIOC_QUERYCAP,&capability,"VIDIOC_QUERYCAP"); - auto caps=(capability.capabilities&V4L2_CAP_DEVICE_CAPS)?capability.device_caps:capability.capabilities; - if(!(caps&V4L2_CAP_VIDEO_CAPTURE)||!(caps&V4L2_CAP_STREAMING))throw std::runtime_error("Camera does not support single-plane streaming capture"); - v4l2_format format{};format.type=V4L2_BUF_TYPE_VIDEO_CAPTURE; - format.fmt.pix.width=config.width;format.fmt.pix.height=config.height; - format.fmt.pix.pixelformat=V4L2_PIX_FMT_UYVY;format.fmt.pix.field=V4L2_FIELD_NONE; - checkedIoctl(fd,VIDIOC_S_FMT,&format,"VIDIOC_S_FMT"); - if(format.fmt.pix.pixelformat!=V4L2_PIX_FMT_UYVY||format.fmt.pix.width!=static_cast(config.width)||format.fmt.pix.height!=static_cast(config.height)) - throw std::runtime_error("Camera rejected the configured UYVY resolution; refusing mismatched mask coordinates"); - stride=format.fmt.pix.bytesperline; - if(stride(config.width*2))throw std::runtime_error("Invalid camera row stride"); - v4l2_streamparm params{};params.type=V4L2_BUF_TYPE_VIDEO_CAPTURE; - if(ioctl(fd,VIDIOC_G_PARM,¶ms)==0&&(params.parm.capture.capability&V4L2_CAP_TIMEPERFRAME)) { - params.parm.capture.timeperframe.numerator=1;params.parm.capture.timeperframe.denominator=config.fps; - checkedIoctl(fd,VIDIOC_S_PARM,¶ms,"VIDIOC_S_PARM"); - auto const& interval=params.parm.capture.timeperframe; - if(!interval.numerator||interval.denominator!=static_cast(config.fps)*interval.numerator) - throw std::runtime_error("Camera rejected requested frame rate"); - } - v4l2_requestbuffers request{};request.count=config.buffers; - request.type=V4L2_BUF_TYPE_VIDEO_CAPTURE;request.memory=V4L2_MEMORY_MMAP; - checkedIoctl(fd,VIDIOC_REQBUFS,&request,"VIDIOC_REQBUFS"); - if(request.count<2)throw std::runtime_error("Insufficient V4L2 buffers"); - buffers.resize(request.count); - for(unsigned i=0;i(config.width,config.height); - auto type=V4L2_BUF_TYPE_VIDEO_CAPTURE;checkedIoctl(fd,VIDIOC_STREAMON,&type,"VIDIOC_STREAMON");streaming=true; - } catch(...) {release();throw;} - } - ~Impl(){release();} - void release() noexcept { - if(streaming){auto type=V4L2_BUF_TYPE_VIDEO_CAPTURE;ioctl(fd,VIDIOC_STREAMOFF,&type);streaming=false;} - for(auto const& b:buffers)if(b.data)munmap(b.data,b.size); - buffers.clear(); - if(fd>=0){close(fd);fd=-1;} - if(stopFd>=0){close(stopFd);stopFd=-1;} - } - void stop() noexcept { - stopped=true;std::uint64_t one=1; - if(stopFd>=0){auto ignored=write(stopFd,&one,sizeof(one));(void)ignored;} - } - std::optional readFrame() { - while(!stopped.load()) { - pollfd descriptors[2]={{fd,POLLIN,0},{stopFd,POLLIN,0}}; - int ready=poll(descriptors,2,config.timeout_ms); - if(ready<0&&errno==EINTR)continue; - if(stopped.load()||(descriptors[1].revents&POLLIN))return {}; - if(ready==0)throw std::runtime_error("Camera capture timeout: "+config.device); - if(ready<0||(descriptors[0].revents&(POLLERR|POLLHUP|POLLNVAL)))throw std::runtime_error("Camera disconnected or poll failed"); - v4l2_buffer buffer{};buffer.type=V4L2_BUF_TYPE_VIDEO_CAPTURE;buffer.memory=V4L2_MEMORY_MMAP; - int status=ioctl(fd,VIDIOC_DQBUF,&buffer); - if(status<0&&(errno==EAGAIN||errno==EINTR))continue; - if(status<0)throw std::runtime_error("VIDIOC_DQBUF: "+std::string(std::strerror(errno))); - if(buffer.index>=buffers.size())throw std::runtime_error("Invalid V4L2 buffer index"); - // The GMSL driver can mark its startup buffer as corrupt. Requeue - // it without conversion or inference; persistent corruption is fatal. - if(buffer.flags&V4L2_BUF_FLAG_ERROR) { - checkedIoctl(fd,VIDIOC_QBUF,&buffer,"VIDIOC_QBUF(error frame)"); - if(++consecutiveErrors>=static_cast(config.fps)) - throw std::runtime_error("Camera produced one second of consecutive error frames"); - continue; - } - CapturedFrame frame; - try { - if(buffer.bytesusedbuffers[buffer.index].size) - throw std::runtime_error("Invalid camera frame: flags="+std::to_string(buffer.flags)+", used="+std::to_string(buffer.bytesused)+", required="+std::to_string(std::size_t(stride)*config.height)+", allocated="+std::to_string(buffers[buffer.index].size)); - auto& m=frame.metadata; - m.discarded_error_frames=consecutiveErrors;consecutiveErrors=0; - m.driver_sequence=buffer.sequence;m.received_monotonic_ns=monotonicNs(); - m.driver_timestamp_ns=std::uint64_t(buffer.timestamp.tv_sec)*1000000000ULL+std::uint64_t(buffer.timestamp.tv_usec)*1000; - m.driver_timestamp_monotonic=(buffer.flags&V4L2_BUF_FLAG_TIMESTAMP_MASK)==V4L2_BUF_FLAG_TIMESTAMP_MONOTONIC; - m.capture_monotonic_ns=m.driver_timestamp_monotonic&&m.driver_timestamp_ns>0&&m.driver_timestamp_ns<=m.received_monotonic_ns?m.driver_timestamp_ns:m.received_monotonic_ns; - if(haveSequence) { - auto delta=static_cast(buffer.sequence-lastSequence); - if(delta==0||delta>0x7fffffffU)throw std::runtime_error("Camera sequence reset or repeated frame"); - m.skipped_driver_frames=delta-1;index+=delta; - } - m.frame_index=index; - lastSequence=buffer.sequence;haveSequence=true; - // Convert before requeuing. No published result references MMAP memory. - frame.image=converter->convert(buffers[buffer.index].data,stride); - } catch(...) {ioctl(fd,VIDIOC_QBUF,&buffer);throw;} - checkedIoctl(fd,VIDIOC_QBUF,&buffer,"VIDIOC_QBUF");return frame; - } - return {}; - } -}; -Camera::Camera(CameraConfig config):impl_(std::make_unique(std::move(config))){} -Camera::~Camera()=default; -std::optional Camera::read(){return impl_->readFrame();} -void Camera::requestStop() noexcept {impl_->stop();} -} diff --git a/accelerator/src/camera_pipeline.cpp b/accelerator/src/camera_pipeline.cpp deleted file mode 100644 index cb13ae1..0000000 --- a/accelerator/src/camera_pipeline.cpp +++ /dev/null @@ -1,178 +0,0 @@ -#include "camera_pipeline.hpp" -#include "bounded_queue.hpp" -#include "latest_result.hpp" -#include "detector.hpp" -#include "door_risk.hpp" -#include "records.hpp" -#include "result_conversion.hpp" -#include -#include -#include -#include -#include -#include -#include -#include - -namespace cms { -namespace { -struct Stream { - cudaStream_t value{}; - Stream(){CUDA_CHECK(cudaStreamCreateWithFlags(&value,cudaStreamNonBlocking));} - ~Stream(){cudaStreamDestroy(value);} -}; -cv::Mat imageView(BgrImage const& image) { - return cv::Mat(image.height,image.width,CV_8UC3,const_cast(image.pixels.data()),image.stride); -} -double elapsedMs(std::uint64_t start){return (monotonicNs()-start)*1e-6;} -void attachPoses(FrameResult& result,fangjia::PoseFrameResult const& fused) { - for(std::size_t i=0;i boxes;double elapsed_ms{};}; - PipelineConfig config; - BoundedQueue captures; - BoundedQueue detections; - LatestResult results; - fangjia::TrtLogger logger; - std::unique_ptr detector; - std::unique_ptr pose; - std::unique_ptr risk; - std::shared_ptr doorPixels; - std::unique_ptr camera; - std::thread captureThread,detectorThread,inferenceThread; - mutable std::mutex stateMutex; - std::exception_ptr failure; - bool started{}; - std::atomic stopped{false},active{false}; - std::atomic captured{0},published{0},gaps{0},errorFrames{0}; - double totalLatency{}; - - explicit Impl(PipelineConfig c):config(std::move(c)),captures(config.queue_capacity),detections(config.queue_capacity) { - if(config.queue_capacity>8)throw std::invalid_argument("Queue capacity must be between 1 and 8"); - if(config.max_people<1||config.max_people>16||!std::isfinite(config.detector_confidence)||config.detector_confidence<=0||config.detector_confidence>=1) - throw std::invalid_argument("Invalid detector configuration"); - if(!std::filesystem::is_regular_file(config.door_mask))throw std::invalid_argument("Missing door mask: "+config.door_mask.string()); - } - ~Impl(){stop();joinWorkers();} - void joinWorkers() noexcept { - if(captureThread.joinable())captureThread.join(); - if(detectorThread.joinable())detectorThread.join(); - if(inferenceThread.joinable())inferenceThread.join(); - } - void stop() noexcept { - stopped=true;active=false; - // Camera stays alive until all threads have joined. start()/destruction - // are owner-thread operations; requestStop() only interrupts existing work. - {std::lock_guard lock(stateMutex);if(camera)camera->requestStop();} - captures.close(true);detections.close(true); - } - void fail() noexcept { - {std::lock_guard lock(stateMutex);if(!failure)failure=std::current_exception();} - stop(); - } - void rethrowFailure() const { - std::lock_guard lock(stateMutex);if(failure)std::rethrow_exception(failure); - } - void start() { - {std::lock_guard lock(stateMutex);if(started||stopped)throw std::logic_error("CameraPipeline can only be started once");started=true;} - try { - detector=std::make_unique(config.engines/"yolo11s.engine",logger,config.detector_confidence,config.max_people); - pose=std::make_unique(config.engines/"rtmw_l_384.engine",logger,config.camera.width,config.camera.height,config.max_people); - DoorOptions options;options.constant=config.door_mask;options.warning=config.warning_relative;options.release=config.release_relative; - risk=std::make_unique(options,cv::Size(config.camera.width,config.camera.height));risk->initialize(); - if(risk->mask().empty()||cv::countNonZero(risk->mask())==0)throw std::runtime_error("Door mask has no usable region"); - auto pixels=std::make_shared();pixels->width=config.camera.width;pixels->height=config.camera.height;pixels->stride=config.camera.width; - auto const& mask=risk->mask();pixels->pixels.resize(std::size_t(mask.cols)*mask.rows); - for(int y=0;ypixels.data()+std::size_t(y)*mask.cols,mask.ptr(y),mask.cols); - doorPixels=std::move(pixels); - Stream warmup; - pose->warmup(warmup.value); - detector->infer(cv::Mat(config.camera.height,config.camera.width,CV_8UC3,cv::Scalar()),warmup.value); - {std::lock_guard lock(stateMutex);camera=std::make_unique(config.camera);if(stopped)camera->requestStop();} - active=!stopped.load(); - captureThread=std::thread([this]{try{captureLoop();}catch(...){fail();}}); - detectorThread=std::thread([this]{try{detectorLoop();}catch(...){fail();}}); - inferenceThread=std::thread([this]{try{inferenceLoop();}catch(...){fail();}}); - }catch(...){stop();joinWorkers();throw;} - } - void captureLoop() { - while(!stopped) { - auto frame=camera->read();if(!frame)break; - gaps+=frame->metadata.skipped_driver_frames; - errorFrames+=frame->metadata.discarded_error_frames; - if(!captures.push(std::move(*frame)))break; - ++captured; - } - captures.close(); - } - void detectorLoop() { - Stream stream; - while(!stopped) { - auto frame=captures.pop();if(!frame)break; - auto startedAt=monotonicNs();auto boxes=detector->infer(imageView(*frame->image),stream.value); - if(!detections.push({std::move(*frame),std::move(boxes),elapsedMs(startedAt)}))break; - } - detections.close(); - } - void inferenceLoop() { - Stream stream;fangjia::BoxTracker boxesTracker;fangjia::PoseFusionTracker fusion; - while(!stopped) { - auto detected=detections.pop();if(!detected)break; - if(detected->frame.metadata.frame_index>static_cast(std::numeric_limits::max()))throw std::runtime_error("Frame index limit reached; restart pipeline"); - auto index=static_cast(detected->frame.metadata.frame_index); - auto& boxes=detected->boxes; - auto frame=imageView(*detected->frame.image); - boxesTracker.update(boxes,index,frame.cols,frame.rows); - auto poseStart=monotonicNs(); - auto raw=pose->infer(frame,boxes,stream.value);auto isolated=raw; - for(std::size_t p=0;pinfer(masked,{box},stream.value).at(0);} - } - auto poseElapsed=elapsedMs(poseStart);auto fusionStart=monotonicNs(); - auto fused=fusion.update(raw,isolated,index); - auto record=makeRecord(index,raw,isolated,fused,false,false); - auto riskData=risk->evaluate(index,record); - auto result=std::make_shared(makeFrameResult(record,riskData,detected->frame.metadata)); - attachPoses(*result,fused); - result->image=std::move(detected->frame.image);result->door_mask_pixels=doorPixels; - result->door_mask_calibration_verified=config.door_mask_calibration_verified; - result->timing={detected->elapsed_ms,poseElapsed,elapsedMs(fusionStart),elapsedMs(result->capture.capture_monotonic_ns)}; - FrameResultPtr immutable=result; - results.publish(std::move(immutable)); - {std::lock_guard lock(stateMutex);totalLatency+=result->timing.capture_to_result_ms;++published;} - } - active=false; - } -}; -CameraPipeline::CameraPipeline(PipelineConfig config):impl_(std::make_unique(std::move(config))){} -CameraPipeline::~CameraPipeline()=default; -void CameraPipeline::start(){impl_->start();} -FrameResultPtr CameraPipeline::latest()const{return impl_->results.load();} -bool CameraPipeline::running()const noexcept{return impl_->active.load();} -void CameraPipeline::requestStop()noexcept{impl_->stop();} -void CameraPipeline::join(){impl_->joinWorkers();{std::lock_guard lock(impl_->stateMutex);impl_->camera.reset();}impl_->rethrowFailure();} -PipelineStats CameraPipeline::stats()const { - std::lock_guard lock(impl_->stateMutex);auto count=impl_->published.load(); - return {impl_->captured.load(),count,impl_->gaps.load(),impl_->errorFrames.load(),count?impl_->totalLatency/count:0}; -} -} diff --git a/accelerator/src/config.cpp b/accelerator/src/config.cpp deleted file mode 100644 index d67f24e..0000000 --- a/accelerator/src/config.cpp +++ /dev/null @@ -1,24 +0,0 @@ -#include "config.hpp" -#include "door_risk.hpp" -#include -#include - -namespace cms { -PipelineConfig loadConfig(std::filesystem::path const& path) { - std::ifstream file(path); - if(!file)throw std::runtime_error("Cannot read configuration: "+path.string()); - auto j=Json::parse(file);PipelineConfig config; - auto const& camera=j.at("camera"); - config.camera.device=camera.at("device");config.camera.width=camera.at("width"); - config.camera.height=camera.at("height");config.camera.fps=camera.at("fps"); - config.camera.buffers=camera.at("buffers");config.camera.timeout_ms=camera.at("timeout_ms"); - auto resolve=[&](std::string const& value){auto p=std::filesystem::path(value);return std::filesystem::absolute(p.is_absolute()?p:path.parent_path()/p);}; - auto const& inference=j.at("inference"); - config.engines=resolve(inference.at("engine_directory"));config.max_people=inference.at("max_people"); - config.detector_confidence=inference.at("detector_confidence");config.queue_capacity=inference.at("queue_capacity"); - auto const& door=j.at("door");config.door_mask=resolve(door.at("mask")); - config.warning_relative=door.at("warning_relative");config.release_relative=door.at("release_relative"); - config.door_mask_calibration_verified=door.at("calibration_verified"); - return config; -} -} diff --git a/accelerator/src/door_risk.cpp b/accelerator/src/door_risk.cpp deleted file mode 100644 index fbd8864..0000000 --- a/accelerator/src/door_risk.cpp +++ /dev/null @@ -1,137 +0,0 @@ -#include "door_risk.hpp" -#include -#include -#include -#include -#include -#include -#include -namespace cms { -double rounded(double v, int d) { double s=std::pow(10.0,d); return std::nearbyint(v*s)/s; } -static std::string lower(std::string s) { for(auto& c:s) if(static_cast(c)<128) c=static_cast(std::tolower(c)); return s; } -static bool raster(std::filesystem::path const& p) { auto e=lower(p.extension().string()); return e==".png"||e==".bmp"||e==".tif"||e==".tiff"; } -DoorRisk::DoorRisk(DoorOptions o, cv::Size size):options_(std::move(o)),size_(size) { - if(options_.constant.empty()==options_.directory.empty()) throw std::runtime_error("Provide exactly one constant mask or door-mask directory"); - if(options_.warning<0 || options_.release<=options_.warning) throw std::runtime_error("Risk thresholds require 0 <= warning < release"); - format_=options_.format; - if(!options_.constant.empty()) { - if(!std::filesystem::is_regular_file(options_.constant)) throw std::runtime_error("Missing mask: "+options_.constant.string()); - if(format_=="auto") format_=lower(options_.constant.extension().string())==".json"?"xanylabeling":"raster"; - } else { - std::vector files; - for(auto const& e:std::filesystem::recursive_directory_iterator(options_.directory)) if(e.is_regular_file()) files.push_back(e.path()); - std::sort(files.begin(),files.end()); - if(format_=="auto") format_=std::any_of(files.begin(),files.end(),[](auto const& p){return p.extension()==".json";})?"xanylabeling":"raster"; - std::regex digits("[0-9]+"); - for(auto const& p:files) { - if(format_=="xanylabeling"?p.extension()!=".json":!raster(p)) continue; - int index=-1; std::string stem=p.stem().string(); - for(std::sregex_iterator i(stem.begin(),stem.end(),digits),end;i!=end;++i) index=std::stoi(i->str()); - if(index<0 && format_=="xanylabeling") { std::ifstream in(p); auto j=Json::parse(in); if(j.contains("frame_index")) index=j["frame_index"].get(); else if(j.contains("frameIndex")) index=j["frameIndex"].get(); } - if(index<0) continue; - if(!paths_.emplace(index,p).second) throw std::runtime_error("Duplicate mask frame: "+std::to_string(index)); - } - if(paths_.empty()) throw std::runtime_error("No indexed door masks in "+options_.directory.string()); - } - if(format_!="raster" && format_!="xanylabeling") throw std::runtime_error("Unknown door mask format"); -} -cv::Mat DoorRisk::rasterize(std::filesystem::path const& path) const { - cv::Mat mask(size_,CV_8U,cv::Scalar(0)); - if(format_=="raster") { - auto img=cv::imread(path.string(),cv::IMREAD_UNCHANGED); - if(img.empty()) throw std::runtime_error("Cannot read mask: "+path.string()); - if(img.channels()>1) { std::vector ch; cv::split(img,ch); img=ch[0]; for(size_t i=1;i0; - } - std::ifstream in(path); auto j=Json::parse(in); - double w=j.contains("imageWidth")&&!j["imageWidth"].is_null()?j["imageWidth"].get():size_.width; - double h=j.contains("imageHeight")&&!j["imageHeight"].is_null()?j["imageHeight"].get():size_.height; - if(w==0) w=size_.width; - if(h==0) h=size_.height; - float sx=static_cast(size_.width/std::max(w,1.0)),sy=static_cast(size_.height/std::max(h,1.0)); - for(auto const& s:j.value("shapes",Json::array())) { - if(!options_.labels.count(lower(s.value("label",std::string())))) continue; - std::vector points; - for(auto const& p:s.value("points",Json::array())) points.emplace_back(static_cast(std::nearbyint(p[0].get()*sx)),static_cast(std::nearbyint(p[1].get()*sy))); - auto type=lower(s.value("shape_type",std::string("polygon"))); - if(points.size()<2) continue; - if(type=="rectangle") cv::rectangle(mask,points[0],points[1],255,-1); - else if(type=="circle") cv::circle(mask,points[0],static_cast(std::nearbyint(cv::norm(points[1]-points[0]))),255,-1); - else if(points.size()>=3) cv::fillPoly(mask,std::vector>{points},255); - } - return mask; -} -void DoorRisk::load(int frame) { - if(cached_) return; - loadedPath_.clear(); mask_.release(); distance_.release(); - if(!options_.constant.empty()) loadedPath_=options_.constant; - else { auto it=paths_.find(frame+options_.offset); if(it!=paths_.end()) loadedPath_=it->second; } - if(loadedPath_.empty()) { - status_="missing"; - if(options_.require) throw std::runtime_error("No door mask for frame "+std::to_string(frame)); - return; - } - mask_=rasterize(loadedPath_); - status_=cv::countNonZero(mask_)?"loaded":"empty"; - if(status_=="loaded") cv::distanceTransform(mask_==0,distance_,cv::DIST_L2,cv::DIST_MASK_PRECISE); - cached_=!options_.constant.empty(); -} -Json DoorRisk::evaluate(int frame, Json& record) { - load(frame); - Json regions=Json::array(),fallbacks=Json::array(),nearest=nullptr; - std::set withHands; - auto measure=[&](cv::Mat const& region, std::string const& source,int track,std::string const& side,std::string const& state) { - Json m={{"status","door_mask_"+status_},{"risk_score",nullptr},{"risk_level","unavailable"},{"decision","EVIDENCE_UNAVAILABLE"},{"source",source},{"track_id",track},{"side",side}}; - if(status_=="loaded") { - int area=cv::countNonZero(region); cv::Mat intersection; cv::bitwise_and(region,mask_,intersection); int overlap=cv::countNonZero(intersection); - double distance=0; cv::minMaxLoc(distance_,&distance,nullptr,nullptr,nullptr,region); - double scale=std::max(std::sqrt(double(area)),1.0),relative=distance/scale; - double score=overlap?1:std::clamp(1-relative/options_.release,0.0,1.0); - std::string level=overlap?"danger":relative<=options_.warning?"warning":relative<=options_.release?"watch":"clear"; - std::string decision=overlap?"DANGER_INTERSECTION":relative<=options_.warning?"WARNING_NEAR":relative<=options_.release?"WATCH":"CLEAR"; - m={{"status","calculated"},{"risk_score",rounded(score,5)},{"risk_level",level},{"decision",decision},{"source",source},{"track_id",track},{"side",side},{"state",state},{"region_area_px",area},{"door_overlap_px",overlap},{"region_overlap_ratio",rounded(double(overlap)/std::max(area,1),6)},{"min_distance_px",rounded(distance,3)},{"region_scale_px",rounded(scale,3)},{"distance_relative",rounded(relative,6)}}; - if(nearest.is_null() || m["risk_score"].get()>nearest["risk_score"].get()) nearest=m; - } - regions.push_back(m); return m; - }; - auto const ids=record.value("track_ids",Json::array()); - auto trackFor=[&](int pos){return pos>=0&&pos():pos+1;}; - if(!record.contains("global_hands")) record["global_hands"]=Json::array(); - for(auto& hand:record["global_hands"]) { - int pos=hand.value("person_id",0)-1; std::vector points; - bool finite=true; - for(auto const& p:hand.value("keypoints",Json::array())) { - float x=p[0].get(),y=p[1].get(); - if(!std::isfinite(x)||!std::isfinite(y)) {finite=false;break;} - points.emplace_back(static_cast(std::nearbyint(x)),static_cast(std::nearbyint(y))); - } - if(!finite||points.size()<3) continue; - std::vector hull; cv::convexHull(points,hull); - cv::Mat region(size_,CV_8U,cv::Scalar(0)); cv::fillConvexPoly(region,hull,255); - if(!cv::countNonZero(region)) continue; - withHands.insert(pos); - hand["risk"]=measure(region,"RTMW_HAND_KEYPOINTS",trackFor(pos),hand.value("side",std::string("unknown")),hand.value("state",std::string("unknown"))); - } - auto const boxes=record.value("boxes",Json::array()); - for(int pos=0;pos())),0,size_.width-1),y1=std::clamp(int(std::nearbyint(b[1].get())),0,size_.height-1); - int x2=std::clamp(int(std::nearbyint(b[2].get())),0,size_.width-1),y2=std::clamp(int(std::nearbyint(b[3].get())),0,size_.height-1); - if(x1>x2) std::swap(x1,x2); - if(y1>y2) std::swap(y1,y2); - if(x2<=x1||y2<=y1) continue; - cv::Mat region(size_,CV_8U,cv::Scalar(0)); cv::rectangle(region,{x1,y1},{x2,y2},255,-1); - Json fallback={{"track_id",trackFor(pos)},{"side","body"},{"state","rtmw_hand_unavailable"},{"body_zone_box",b}}; - fallback["risk"]=measure(region,"YOLO_BODY_BOX_FALLBACK",trackFor(pos),"body","rtmw_hand_unavailable"); fallbacks.push_back(fallback); - } - record["body_fallbacks"]=fallbacks; - Json result={{"status",status_!="loaded"?"door_mask_"+status_:nearest.is_null()?"person_region_missing":"calculated"}}; - for(auto const* key:{"risk_score","risk_level","decision","source","track_id","side"}) result[key]=nearest.is_null()?Json(nullptr):nearest[key]; - if(nearest.is_null()) {result["risk_level"]="unavailable";result["decision"]="EVIDENCE_UNAVAILABLE";} - result["door_mask"]={{"status",status_},{"annotation_index",options_.constant.empty()?frame+options_.offset:frame},{"path",loadedPath_.empty()?Json(nullptr):Json(std::filesystem::absolute(loadedPath_).string())},{"format",format_},{"area_px",mask_.empty()?0:cv::countNonZero(mask_)}}; - result["warning_distance_relative"]=options_.warning; result["release_distance_relative"]=options_.release; result["regions"]=regions; - return result; -} -} diff --git a/accelerator/src/main.cpp b/accelerator/src/main.cpp deleted file mode 100644 index f3e8578..0000000 --- a/accelerator/src/main.cpp +++ /dev/null @@ -1,43 +0,0 @@ -#include "camera_pipeline.hpp" -#include "config.hpp" -#include "stop_signals.hpp" -#include "visualizer.hpp" -#include -#include -#include - -int main(int argc,char** argv)try { - auto root=std::filesystem::canonical("/proc/self/exe").parent_path().parent_path(); - auto configPath=root/"config/camera.json"; - bool visualize=false; - std::map> arguments{ - {"--visualize",[&](int&){visualize=true;}}, - {"--config",[&](int&i){if(++i>=argc)throw std::invalid_argument("--config needs a file");configPath=argv[i];}}, - {"--help",[](int&){std::cout<<"camera_risk [--config FILE] [--visualize]\nContinuous camera inference; latest FrameResult stays in memory. Stop with Ctrl+C or SIGTERM.\n";std::exit(0);}} - }; - for(int i=1;isecond(i);} - - cms::CameraPipeline pipeline(cms::loadConfig(configPath)); - cms::StopSignals signals(pipeline); - pipeline.start(); - /* - * 下游使用示例：在下游自己的线程/调用位置读取最新结果。 - * 首帧尚未完成时 result 为空；读取不会影响取图和推理。 - * - * auto result = pipeline.latest(); - * if (result) { - * const auto& risk = result->risk; - * const auto& people = result->persons; - * // result->frame_index / track_ids / boxes - * // result->image / door_mask_pixels / capture / timing - * // people[i].selected / smoothed / temporal：各 133 个关键点 - * } - */ - // Optional observer. Closing/failing the window never requests inference stop. - if(visualize) { - try {cms::runLocalVisualization(pipeline);} - catch(std::exception const& e){std::cerr<<"Visualization unavailable; inference continues: "< - -#include -#include -#include -#include -#include -#include - -namespace fangjia { -namespace { - -constexpr int kInputWidth = 288; -constexpr int kInputHeight = 384; -constexpr int kKeypoints = 133; -constexpr int kSimccX = 576; -constexpr int kSimccY = 768; - -__global__ void poseNormalizeKernel( - float* output, std::uint8_t const* input, int people, int inputStep) { - int index = blockIdx.x * blockDim.x + threadIdx.x; - int pixels = kInputWidth * kInputHeight; - int total = people * pixels; - if (index >= total) return; - int person = index / pixels; - int pixel = index - person * pixels; - int y = pixel / kInputWidth; - int x = pixel - y * kInputWidth; - auto const* value = input + person * inputStep * kInputHeight + y * inputStep + x * 3; - float* destination = output + static_cast(person) * 3 * pixels; - destination[pixel] = static_cast((static_cast(value[0]) - 123.675) / 58.395); - destination[pixels + pixel] = static_cast((static_cast(value[1]) - 116.28) / 57.12); - destination[2 * pixels + pixel] = static_cast((static_cast(value[2]) - 103.53) / 57.375); -} - -float iou(Box const& a, Box const& b) { - float x1 = std::max(a.x1, b.x1); - float y1 = std::max(a.y1, b.y1); - float x2 = std::min(a.x2, b.x2); - float y2 = std::min(a.y2, b.y2); - float intersection = std::max(x2 - x1, 0.0F) * std::max(y2 - y1, 0.0F); - float areaA = std::max(a.x2 - a.x1, 0.0F) * std::max(a.y2 - a.y1, 0.0F); - float areaB = std::max(b.x2 - b.x1, 0.0F) * std::max(b.y2 - b.y1, 0.0F); - return intersection / std::max(areaA + areaB - intersection, 1.0F); -} - -float distance(float x1, float y1, float x2, float y2) { - return std::hypot(x1 - x2, y1 - y2); -} - -} // namespace - -std::vector BoxTracker::update( - std::vector& boxes, int frameIndex, int width, int height) { - // Tracks older than Python's max_age can never be matched again. - // Reclaim them to bound memory during continuous camera operation. - for(auto it=tracks_.begin();it!=tracks_.end();) { - if(frameIndex-it->second.lastFrame>30)it=tracks_.erase(it); - else ++it; - } - struct Pair { float score; int detection; int track; }; - std::vector pairs; - float imageDiagonal = std::hypot(static_cast(width), static_cast(height)); - for (int d = 0; d < static_cast(boxes.size()); ++d) { - float cx = 0.5F * (boxes[d].x1 + boxes[d].x2); - float cy = 0.5F * (boxes[d].y1 + boxes[d].y2); - for (auto const& [id, track] : tracks_) { - if (frameIndex - track.lastFrame > 30) continue; - float pcx = 0.5F * (track.box.x1 + track.box.x2); - float pcy = 0.5F * (track.box.y1 + track.box.y2); - float overlap = iou(boxes[d], track.box); - float centerDistance = distance(cx, cy, pcx, pcy) / imageDiagonal; - if (overlap >= 0.05F || centerDistance <= 0.18F) { - pairs.push_back({2.0F * overlap + std::max(0.0F, 1.0F - centerDistance / 0.18F), d, id}); - } - } - } - std::sort(pairs.begin(), pairs.end(), [](Pair const& a, Pair const& b) { - if (a.score != b.score) return a.score > b.score; - if (a.detection != b.detection) return a.detection > b.detection; - return a.track > b.track; - }); - std::vector result(boxes.size(), 0); - std::unordered_map assigned; - for (auto const& pair : pairs) { - if (result[pair.detection] || assigned[pair.track]) continue; - result[pair.detection] = pair.track; - assigned[pair.track] = true; - } - for (int d = 0; d < static_cast(boxes.size()); ++d) { - if (!result[d]) result[d] = nextId_++; - boxes[d].trackId = result[d]; - tracks_[result[d]] = {boxes[d], frameIndex}; - } - return result; -} - -RtmwEngine::RtmwEngine( - std::filesystem::path const& enginePath, TrtLogger& logger, - int maxSourceWidth, int maxSourceHeight, int maxPeople) - : engine_(enginePath, logger), maxSourceWidth_(maxSourceWidth), - maxSourceHeight_(maxSourceHeight), maxPeople_(maxPeople), - centersHost_(maxPeople * 2), scalesHost_(maxPeople * 2), - simccXHost_(static_cast(maxPeople) * kKeypoints * kSimccX), - simccYHost_(static_cast(maxPeople) * kKeypoints * kSimccY) { - engine_.setInputShape("input", nvinfer1::Dims4{1,3,kInputHeight,kInputWidth}); - engine_.prepare(); - auto xs=engine_.shape("simcc_x"),ys=engine_.shape("simcc_y"); - if(xs.nbDims!=3||ys.nbDims!=3||xs.d[0]!=1||ys.d[0]!=1||xs.d[1]!=kKeypoints||ys.d[1]!=kKeypoints||xs.d[2]!=kSimccX||ys.d[2]!=kSimccY) - throw std::runtime_error("RTMW engine I/O shape does not match the 133-point model"); - for(auto name:{"input","simcc_x","simcc_y"})if(engine_.dataType(name)!=nvinfer1::DataType::kFLOAT) - throw std::runtime_error("RTMW requires float32 I/O bindings"); - std::size_t const values = static_cast(maxPeople) * 3 * kInputWidth * kInputHeight; - CUDA_CHECK(cudaMalloc( - &cropsDevice_, static_cast(maxPeople_) * kInputWidth * kInputHeight * 3)); - CUDA_CHECK(cudaMalloc(&networkDevice_, values * sizeof(float))); - CUDA_CHECK(cudaMalloc(&sourceDevice_, static_cast(maxSourceWidth_)*maxSourceHeight_*3)); -} - -RtmwEngine::~RtmwEngine() { - if (sourceDevice_) cudaFree(sourceDevice_); - if (cropsDevice_) cudaFree(cropsDevice_); - if (networkDevice_) cudaFree(networkDevice_); -} - -void RtmwEngine::warmup(cudaStream_t stream) { - std::vector boxes{{0, 0, static_cast(maxSourceWidth_), static_cast(maxSourceHeight_), 1, 1}}; - cv::Mat black(maxSourceHeight_, maxSourceWidth_, CV_8UC3, cv::Scalar(0, 0, 0)); - for (int i = 0; i < 2; ++i) infer(black, boxes, stream); -} - -std::vector RtmwEngine::infer( - cv::Mat const& frame, std::vector const& boxes, cudaStream_t stream, - float* preprocessMs, float* inferenceMs, float* postprocessMs) { - int batch = std::min(static_cast(boxes.size()), maxPeople_); - if (batch <= 0) return {}; - auto const preprocessStarted = std::chrono::steady_clock::now(); - int const cropStep = kInputWidth * 3; - int const pixels = kInputWidth * kInputHeight; - if (frame.cols>maxSourceWidth_ || frame.rows>maxSourceHeight_) throw std::runtime_error("Pose input exceeds allocation"); - auto npp = cms::nppContext(stream); - CUDA_CHECK(cudaMemcpy2DAsync(sourceDevice_, frame.cols*3, frame.data, frame.step, frame.cols*3, frame.rows, cudaMemcpyHostToDevice, stream)); - for (int i = 0; i < batch; ++i) { - auto const& box = boxes[i]; - double width = (static_cast(box.x2) - static_cast(box.x1)) * 1.25; - double height = (static_cast(box.y2) - static_cast(box.y1)) * 1.25; - constexpr double aspect = static_cast(kInputWidth) / kInputHeight; - if (width > height * aspect) height = width / aspect; - else width = height * aspect; - centersHost_[i * 2] = 0.5 * (static_cast(box.x1) + static_cast(box.x2)); - centersHost_[i * 2 + 1] = 0.5 * (static_cast(box.y1) + static_cast(box.y2)); - scalesHost_[i * 2] = width; - scalesHost_[i * 2 + 1] = height; - - cv::Point2f source[3]{ - {static_cast(centersHost_[i * 2]), static_cast(centersHost_[i * 2 + 1])}, - {static_cast(centersHost_[i * 2]), static_cast(centersHost_[i * 2 + 1] - width * 0.5)}, - {static_cast(centersHost_[i * 2] - width * 0.5), static_cast(centersHost_[i * 2 + 1] - width * 0.5)}}; - cv::Point2f destination[3]{ - {kInputWidth * 0.5F, kInputHeight * 0.5F}, - {kInputWidth * 0.5F, kInputHeight * 0.5F - kInputWidth * 0.5F}, - {0.0F, kInputHeight * 0.5F - kInputWidth * 0.5F}}; - cv::Mat affine = cv::getAffineTransform(source, destination); - auto* cropDevice=cropsDevice_+static_cast(i)*cropStep*kInputHeight; - Npp8u fill[3]={0,0,0}; - cms::nppCheck(nppiSet_8u_C3R_Ctx(fill,cropDevice,cropStep,{kInputWidth,kInputHeight},npp)); - double coeff[2][3]; - for(int row=0;row<2;++row) for(int col=0;col<3;++col) coeff[row][col]=affine.at(row,col); - cms::nppCheck(nppiWarpAffine_8u_C3R_Ctx(sourceDevice_,{frame.cols,frame.rows},frame.cols*3,{0,0,frame.cols,frame.rows},cropDevice,cropStep,{0,0,kInputWidth,kInputHeight},coeff,NPPI_INTER_LINEAR,npp)); - } - int const totalPixels = batch * pixels; - poseNormalizeKernel<<<(totalPixels + 255) / 256, 256, 0, stream>>>( - networkDevice_, cropsDevice_, batch, cropStep); - CUDA_CHECK(cudaGetLastError()); - CUDA_CHECK(cudaStreamSynchronize(stream)); - if (preprocessMs) { - *preprocessMs = static_cast(std::chrono::duration( - std::chrono::steady_clock::now() - preprocessStarted).count()); - } - - // RTMPose's Python API invokes the ONNX/TensorRT session once per person. - // Preserve that execution contract instead of batching people together. - engine_.setInputShape("input", nvinfer1::Dims4{1, 3, kInputHeight, kInputWidth}); - engine_.prepare(); - CudaEventTimer timer; - float inferTime = 0.0F; - std::size_t const inputValues = static_cast(3) * pixels; - std::size_t const xValues = static_cast(kKeypoints) * kSimccX; - std::size_t const yValues = static_cast(kKeypoints) * kSimccY; - for (int person = 0; person < batch; ++person) { - CUDA_CHECK(cudaMemcpyAsync( - engine_.device("input"), networkDevice_ + static_cast(person) * inputValues, - inputValues * sizeof(float), cudaMemcpyDeviceToDevice, stream)); - timer.start(stream); - if (!engine_.enqueue(stream)) throw std::runtime_error("RTMW enqueue failed"); - inferTime += timer.stop(stream); - CUDA_CHECK(cudaMemcpyAsync( - simccXHost_.data() + static_cast(person) * xValues, - engine_.device("simcc_x"), xValues * sizeof(float), cudaMemcpyDeviceToHost, stream)); - CUDA_CHECK(cudaMemcpyAsync( - simccYHost_.data() + static_cast(person) * yValues, - engine_.device("simcc_y"), yValues * sizeof(float), cudaMemcpyDeviceToHost, stream)); - } - if (inferenceMs) *inferenceMs = inferTime; - - auto const postprocessStarted = std::chrono::steady_clock::now(); - CUDA_CHECK(cudaStreamSynchronize(stream)); - std::vector result(batch); - for (int person = 0; person < batch; ++person) { - result[person].box = boxes[person]; - for (int keypoint = 0; keypoint < kKeypoints; ++keypoint) { - auto xBegin = simccXHost_.begin() + (person * kKeypoints + keypoint) * kSimccX; - auto yBegin = simccYHost_.begin() + (person * kKeypoints + keypoint) * kSimccY; - auto xIt = std::max_element(xBegin, xBegin + kSimccX); - auto yIt = std::max_element(yBegin, yBegin + kSimccY); - float score = 0.5F * (*xIt + *yIt); - if(!std::isfinite(score))throw std::runtime_error("Non-finite RTMW output"); - float localX = score > 0.0F ? static_cast(xIt - xBegin) * 0.5F : -0.5F; - float localY = score > 0.0F ? static_cast(yIt - yBegin) * 0.5F : -0.5F; - double scaleX = scalesHost_[person * 2]; - double scaleY = scalesHost_[person * 2 + 1]; - result[person].keypoints[keypoint] = { - static_cast(static_cast(localX) / kInputWidth * scaleX + centersHost_[person * 2] - scaleX * 0.5), - static_cast(static_cast(localY) / kInputHeight * scaleY + centersHost_[person * 2 + 1] - scaleY * 0.5), - score}; - } - } - float post = static_cast(std::chrono::duration( - std::chrono::steady_clock::now() - postprocessStarted).count()); - if (postprocessMs) *postprocessMs = post; - return result; -} - -PoseFrameResult PoseFusionTracker::update( - std::vector const& rawPeople, - std::vector const& isolatedPeople, - int frameIndex) { - for(auto it=states_.begin();it!=states_.end();) { - if(it->second.lastFrame>=0&&frameIndex-it->second.lastFrame>30)it=states_.erase(it); - else ++it; - } - struct SideMeta { - bool limbConsensus{}; - bool handValid{}; - bool distanceEligible{}; - bool alarmEligible{}; - double handScore{}; - double linkToSelectedLimb{}; - std::string handSource; - std::string handState; - }; - struct FusedPerson { - PersonPose pose; - std::array meta; - }; - struct Measurement { - std::array hand{}; - bool precise{}; - bool provisional{}; - double quality{}; - std::string source{"model"}; - }; - auto vec = [](Keypoint const& point) { return Vec2{point.x, point.y}; }; - auto add = [](Vec2 a, Vec2 b) { return Vec2{a.x + b.x, a.y + b.y}; }; - auto sub = [](Vec2 a, Vec2 b) { return Vec2{a.x - b.x, a.y - b.y}; }; - auto mul = [](Vec2 a, double value) { return Vec2{a.x * value, a.y * value}; }; - auto norm = [](Vec2 a) { return std::hypot(a.x, a.y); }; - auto median = [](std::vector values) { - if (values.empty()) return 0.0; - std::sort(values.begin(), values.end()); - auto middle = values.size() / 2; - return values.size() % 2 ? values[middle] : 0.5 * (values[middle - 1] + values[middle]); - }; - auto percentile90 = [](std::vector values) { - if (values.empty()) return 0.0; - std::sort(values.begin(), values.end()); - double position = 0.9 * (values.size() - 1); - auto lower = static_cast(position); - auto upper = std::min(lower + 1, values.size() - 1); - return values[lower] * (upper - position) + values[upper] * (position - lower); - }; - auto boxDiagonal = [](Box const& box) { - return std::max(std::hypot(box.x2 - box.x1, box.y2 - box.y1), 1.0F); - }; - auto normalized = [](Keypoint const& point, Box const& box) { - return Vec2{ - (point.x - box.x1) / std::max(box.x2 - box.x1, 1.0F), - (point.y - box.y1) / std::max(box.y2 - box.y1, 1.0F)}; - }; - auto denormalized = [](Vec2 point, Box const& box) { - return Vec2{ - point.x * std::max(box.x2 - box.x1, 1.0F) + box.x1, - point.y * std::max(box.y2 - box.y1, 1.0F) + box.y1}; - }; - auto solveTwoBoneElbow = [&](Vec2 shoulder, Vec2 wrist, double upperLength, - double forearmLength, Vec2 reference) { - Vec2 direction = sub(wrist, shoulder); - double length = norm(direction); - if (length < 1e-6) return reference; - Vec2 unit = mul(direction, 1.0 / length); - if (length >= upperLength + forearmLength) return add(shoulder, mul(unit, upperLength)); - if (length <= std::abs(upperLength - forearmLength)) { - double sign = upperLength >= forearmLength ? 1.0 : -1.0; - return add(shoulder, mul(unit, upperLength * sign)); - } - double along = (upperLength * upperLength - forearmLength * forearmLength + length * length) / - (2.0 * length); - double height = std::sqrt(std::max(upperLength * upperLength - along * along, 0.0)); - Vec2 base = add(shoulder, mul(unit, along)); - Vec2 perpendicular{-unit.y, unit.x}; - Vec2 first = add(base, mul(perpendicular, height)); - Vec2 second = sub(base, mul(perpendicular, height)); - return norm(sub(first, reference)) <= norm(sub(second, reference)) ? first : second; - }; - struct Candidate { - PersonPose const* pose{}; - std::string source; - std::array limb{}; - std::array hand{}; - double limbScore{}; - double handScore{}; - double handSpan{}; - double wristLink{}; - bool limbValid{}; - bool handValid{}; - }; - auto buildCandidate = [&](PersonPose const& pose, int side, std::string source) { - int shoulder = side == 0 ? 5 : 6; - int elbow = side == 0 ? 7 : 8; - int wrist = side == 0 ? 9 : 10; - int handStart = side == 0 ? 91 : 112; - Candidate candidate; - candidate.pose = &pose; - candidate.source = std::move(source); - candidate.limb = {normalized(pose.keypoints[shoulder], pose.box), - normalized(pose.keypoints[elbow], pose.box), - normalized(pose.keypoints[wrist], pose.box)}; - double minX = pose.keypoints[handStart].x, maxX = minX; - double minY = pose.keypoints[handStart].y, maxY = minY; - for (int index = 0; index < 21; ++index) { - candidate.hand[index] = normalized(pose.keypoints[handStart + index], pose.box); - minX = std::min(minX, pose.keypoints[handStart + index].x); - maxX = std::max(maxX, pose.keypoints[handStart + index].x); - minY = std::min(minY, pose.keypoints[handStart + index].y); - maxY = std::max(maxY, pose.keypoints[handStart + index].y); - candidate.handScore += pose.keypoints[handStart + index].score; - } - candidate.handScore /= 21.0; - candidate.limbScore = (pose.keypoints[shoulder].score + pose.keypoints[elbow].score + pose.keypoints[wrist].score) / 3.0; - double upper = norm(sub(candidate.limb[0], candidate.limb[1])); - double forearm = norm(sub(candidate.limb[1], candidate.limb[2])); - candidate.handSpan = std::hypot(maxX - minX, maxY - minY) / boxDiagonal(pose.box); - candidate.wristLink = distance( - pose.keypoints[wrist].x, pose.keypoints[wrist].y, - pose.keypoints[handStart].x, pose.keypoints[handStart].y) / boxDiagonal(pose.box); - candidate.limbValid = upper >= 0.025 && upper <= 0.8 && forearm >= 0.025 && forearm <= 0.8; - candidate.handValid = candidate.handSpan >= 0.008 && candidate.handSpan <= 0.35 && candidate.wristLink <= 0.12; - return candidate; - }; - auto robustDistance = [&](auto const& points, auto const& target, bool available) { - if (!available) return 0.0; - std::vector distances; - for (std::size_t index = 0; index < points.size(); ++index) { - distances.push_back(norm(sub(points[index], target[index]))); - } - return median(std::move(distances)); - }; - - std::vector fused; - fused.reserve(rawPeople.size()); - for (std::size_t personIndex = 0; personIndex < rawPeople.size(); ++personIndex) { - auto const& raw = rawPeople[personIndex]; - auto const& isolated = personIndex < isolatedPeople.size() ? isolatedPeople[personIndex] : raw; - auto& state = states_[raw.box.trackId]; - FusedPerson output; - output.pose = raw; - for (int side = 0; side < 2; ++side) { - int shoulder = side == 0 ? 5 : 6; - int elbow = side == 0 ? 7 : 8; - int wrist = side == 0 ? 9 : 10; - int handStart = side == 0 ? 91 : 112; - auto& track = state.fusion[side]; - std::array candidates{ - buildCandidate(raw, side, "raw"), buildCandidate(isolated, side, "isolated")}; - int limbChoice = 0; - double bestLimbScore = -1e30; - for (int choice = 0; choice < 2; ++choice) { - std::array target{}; - if (track.hasLimbPrevious) { - for (int i = 0; i < 3; ++i) target[i] = add(track.limbPrevious[i], track.hasLimbVelocity ? mul(track.limbVelocity[i], 0.65) : Vec2{}); - } - double temporal = robustDistance(candidates[choice].limb, target, track.hasLimbPrevious); - double score = candidates[choice].limbScore + (candidates[choice].limbValid ? 1.2 : -5.0) - + (track.limbSource == candidates[choice].source ? 0.35 : 0.0) - 7.0 * temporal; - if (score > bestLimbScore) { bestLimbScore = score; limbChoice = choice; } - } - int handChoice = 0; - double bestHandScore = -1e30; - double chosenTemporal = 0.0; - double chosenLink = 1.0; - for (int choice = 0; choice < 2; ++choice) { - std::array target{}; - if (track.hasHandPrevious) { - for (int i = 0; i < 21; ++i) target[i] = add(track.handPrevious[i], track.hasHandVelocity ? mul(track.handVelocity[i], 0.65) : Vec2{}); - } - double temporal = robustDistance(candidates[choice].hand, target, track.hasHandPrevious); - auto const& limbPose = *candidates[limbChoice].pose; - double link = distance( - candidates[choice].pose->keypoints[handStart].x, - candidates[choice].pose->keypoints[handStart].y, - limbPose.keypoints[wrist].x, limbPose.keypoints[wrist].y) / boxDiagonal(raw.box); - double linkPenalty = 1.5 * std::min(std::max(link - 0.12, 0.0), 0.2); - double score = candidates[choice].handScore + (candidates[choice].handValid ? 3.0 : -7.0) - + (track.handSource == candidates[choice].source ? 0.45 : 0.0) - + (candidates[choice].source == candidates[limbChoice].source ? 0.15 : 0.0) - - linkPenalty - 8.0 * std::min(temporal, 0.15); - if (score > bestHandScore) { - bestHandScore = score; - handChoice = choice; - chosenTemporal = temporal; - chosenLink = link; - } - } - double endpointAdvantage = candidates[handChoice].handScore - candidates[1 - handChoice].handScore; - if (handChoice != limbChoice && candidates[handChoice].handValid && endpointAdvantage >= 0.6) { - limbChoice = handChoice; - // fuse_person() rewrites this link after its visible-endpoint - // override. Temporal recovery consumes the rewritten value. - chosenLink = candidates[handChoice].wristLink; - } - auto const& limb = candidates[limbChoice]; - auto const& hand = candidates[handChoice]; - for (int index : {shoulder, elbow, wrist}) output.pose.keypoints[index] = limb.pose->keypoints[index]; - for (int index = 0; index < 21; ++index) output.pose.keypoints[handStart + index] = hand.pose->keypoints[handStart + index]; - std::vector limbDistances, handDistances; - for (int index = 0; index < 3; ++index) limbDistances.push_back(norm(sub(candidates[0].limb[index], candidates[1].limb[index]))); - for (int index = 0; index < 21; ++index) handDistances.push_back(norm(sub(candidates[0].hand[index], candidates[1].hand[index]))); - double handDisagreement = percentile90(handDistances); - double scoreAdvantage = candidates[0].handScore - candidates[1].handScore; - auto& meta = output.meta[side]; - meta.limbConsensus = median(limbDistances) <= 0.05; - meta.handValid = hand.handValid; - meta.distanceEligible = hand.handValid && ( - handDisagreement <= 0.06 || - (hand.source == "raw" && scoreAdvantage >= 0.6 && chosenTemporal <= 0.08)); - meta.alarmEligible = meta.distanceEligible || (hand.handValid && hand.source == "raw" && scoreAdvantage >= 0.6); - meta.handScore = std::nearbyint(hand.handScore * 1e4) / 1e4; - meta.linkToSelectedLimb = std::nearbyint(chosenLink * 1e5) / 1e5; - meta.handSource = hand.source; - if (!hand.handValid) meta.handState = "rejected"; - else if (handDisagreement <= 0.06) meta.handState = "consensus"; - else if (hand.source == "raw" && scoreAdvantage >= 0.6 && chosenTemporal <= 0.08) meta.handState = "visible_endpoint"; - else if (hand.source == "isolated") meta.handState = "inferred"; - else meta.handState = "conflict"; - if (track.hasLimbPrevious) { - for (int i = 0; i < 3; ++i) { - auto delta = sub(limb.limb[i], track.limbPrevious[i]); - track.limbVelocity[i] = track.hasLimbVelocity ? add(mul(track.limbVelocity[i], 0.65), mul(delta, 0.35)) : delta; - } - track.hasLimbVelocity = true; - } - if (hand.handValid) { - if (track.hasHandPrevious) { - for (int i = 0; i < 21; ++i) { - auto delta = sub(hand.hand[i], track.handPrevious[i]); - track.handVelocity[i] = track.hasHandVelocity ? add(mul(track.handVelocity[i], 0.65), mul(delta, 0.35)) : delta; - } - track.hasHandVelocity = true; - } - track.handPrevious = hand.hand; - track.hasHandPrevious = true; - track.handSource = hand.source; - } - track.limbPrevious = limb.limb; - track.hasLimbPrevious = true; - track.limbSource = limb.source; - } - // Same-person duplicate suppression from the reference fusion. - auto handCenter = [&](int side) { - int start = side == 0 ? 91 : 112; - Vec2 center{}; - for (int i = 0; i < 21; ++i) center = add(center, vec(output.pose.keypoints[start + i])); - return mul(center, 1.0 / 21.0); - }; - if (norm(sub(handCenter(0), handCenter(1))) / boxDiagonal(raw.box) < 0.08) { - int weaker = output.meta[0].handScore <= output.meta[1].handScore ? 0 : 1; - output.meta[weaker].handState = "duplicate"; - output.meta[weaker].distanceEligible = false; - output.meta[weaker].alarmEligible = false; - } - // Motion-adaptive EMA in person-box coordinates. - std::array now{}; - for (int i = 0; i < 133; ++i) now[i] = normalized(output.pose.keypoints[i], raw.box); - if (!state.hasSmoothed) { state.smoothed = now; state.hasSmoothed = true; } - else { - for (int i = 0; i < 133; ++i) { - double displacement = norm(sub(now[i], state.smoothed[i])); - double alpha = 0.32 + 0.58 * std::clamp(displacement / 0.08, 0.0, 1.0); - state.smoothed[i] = add(mul(now[i], alpha), mul(state.smoothed[i], 1.0 - alpha)); - } - } - fused.push_back(std::move(output)); - } - - // Exact build_global_hands() evidence: selected fusion output, stable - // score ordering, then the same cross-person duplicate collapse. - std::vector globalCandidates; - for (std::size_t person = 0; person < fused.size(); ++person) { - for (int side = 0; side < 2; ++side) { - auto const& meta = fused[person].meta[side]; - if (!meta.alarmEligible) continue; - int const start = side == 0 ? 91 : 112; - GlobalHand hand; - hand.personId = static_cast(person) + 1; - hand.trackId = fused[person].pose.box.trackId; - hand.left = side == 0; - hand.source = meta.handSource; - hand.state = meta.handState; - hand.distanceEligible = meta.distanceEligible; - hand.alarmEligible = meta.alarmEligible; - hand.score = static_cast(meta.handScore); - float minX = fused[person].pose.keypoints[start].x; - float maxX = minX; - float minY = fused[person].pose.keypoints[start].y; - float maxY = minY; - for (int point = 0; point < 21; ++point) { - hand.keypoints[point] = fused[person].pose.keypoints[start + point]; - minX = std::min(minX, hand.keypoints[point].x); - maxX = std::max(maxX, hand.keypoints[point].x); - minY = std::min(minY, hand.keypoints[point].y); - maxY = std::max(maxY, hand.keypoints[point].y); - } - hand.spanPx = std::hypot(maxX - minX, maxY - minY); - globalCandidates.push_back(std::move(hand)); - } - } - std::stable_sort(globalCandidates.begin(), globalCandidates.end(), [](auto const& first, auto const& second) { - return first.score > second.score; - }); - std::vector globalHands; - for (auto& candidate : globalCandidates) { - Vec2 candidateCenter{}; - for (auto const& point : candidate.keypoints) candidateCenter = add(candidateCenter, vec(point)); - candidateCenter = mul(candidateCenter, 1.0 / 21.0); - auto duplicate = globalHands.end(); - for (auto iterator = globalHands.begin(); iterator != globalHands.end(); ++iterator) { - Vec2 existingCenter{}; - for (auto const& point : iterator->keypoints) existingCenter = add(existingCenter, vec(point)); - existingCenter = mul(existingCenter, 1.0 / 21.0); - double const threshold = std::clamp( - 0.45 * std::max(candidate.spanPx, iterator->spanPx), 18.0, 70.0); - if (norm(sub(candidateCenter, existingCenter)) <= threshold) { - duplicate = iterator; - break; - } - } - if (duplicate == globalHands.end()) globalHands.push_back(std::move(candidate)); - else duplicate->aliases.emplace_back(candidate.personId, candidate.left); - } - - // Build the model measurements, then collapse cross-person duplicates. - std::vector, 2>> measurements(fused.size()); - for (std::size_t person = 0; person < fused.size(); ++person) { - for (int side = 0; side < 2; ++side) { - if (!fused[person].meta[side].alarmEligible) continue; - Measurement measurement; - int start = side == 0 ? 91 : 112; - for (int i = 0; i < 21; ++i) measurement.hand[i] = vec(fused[person].pose.keypoints[start + i]); - measurement.precise = fused[person].meta[side].distanceEligible; - measurement.provisional = !measurement.precise; - measurement.quality = fused[person].meta[side].handScore; - measurements[person][side] = measurement; - } - } - auto handSpan = [&](Measurement const& measurement) { - double minX = measurement.hand[0].x, maxX = minX, minY = measurement.hand[0].y, maxY = minY; - for (auto point : measurement.hand) { minX = std::min(minX, point.x); maxX = std::max(maxX, point.x); minY = std::min(minY, point.y); maxY = std::max(maxY, point.y); } - return std::hypot(maxX - minX, maxY - minY); - }; - auto handCenter = [&](Measurement const& measurement) { - Vec2 center{}; for (auto point : measurement.hand) center = add(center, point); return mul(center, 1.0 / 21.0); - }; - for (std::size_t firstPerson = 0; firstPerson < fused.size(); ++firstPerson) { - for (int firstSide = 0; firstSide < 2; ++firstSide) { - if (!measurements[firstPerson][firstSide]) continue; - for (std::size_t secondPerson = firstPerson + 1; secondPerson < fused.size(); ++secondPerson) { - for (int secondSide = 0; secondSide < 2; ++secondSide) { - if (!measurements[firstPerson][firstSide] || !measurements[secondPerson][secondSide]) continue; - auto const& first = *measurements[firstPerson][firstSide]; - auto const& second = *measurements[secondPerson][secondSide]; - double firstSpan = handSpan(first), secondSpan = handSpan(second); - if (norm(sub(handCenter(first), handCenter(second))) > std::max(70.0, 0.5 * std::max(firstSpan, secondSpan))) continue; - double firstArea = std::max((fused[firstPerson].pose.box.x2 - fused[firstPerson].pose.box.x1) * (fused[firstPerson].pose.box.y2 - fused[firstPerson].pose.box.y1), 1.0F); - double secondArea = std::max((fused[secondPerson].pose.box.x2 - fused[secondPerson].pose.box.x1) * (fused[secondPerson].pose.box.y2 - fused[secondPerson].pose.box.y1), 1.0F); - if (firstArea >= 2.5 * secondArea && - (firstSpan >= 1.45 * secondSpan || first.quality >= second.quality + 0.6)) { - measurements[secondPerson][secondSide].reset(); - states_[fused[secondPerson].pose.box.trackId].endpoints[secondSide] = {}; - } else if (secondArea >= 2.5 * firstArea && - (secondSpan >= 1.45 * firstSpan || second.quality >= first.quality + 0.6)) { - measurements[firstPerson][firstSide].reset(); - states_[fused[firstPerson].pose.box.trackId].endpoints[firstSide] = {}; - } - } - } - } - } - - // Match resolve_global_hand_assignments(): a large foreground track may reclaim - // a nearby hand that RTMW emitted only from a smaller background crop. - struct Reassignment { - double normalizedDistance{}; - std::size_t targetPerson{}; - int targetSide{}; - std::size_t sourcePerson{}; - int sourceSide{}; - Vec2 sourceCenter{}; - }; - std::vector reassignments; - for (std::size_t targetPerson = 0; targetPerson < fused.size(); ++targetPerson) { - for (int targetSide = 0; targetSide < 2; ++targetSide) { - if (measurements[targetPerson][targetSide]) continue; - auto& targetEndpoint = states_[fused[targetPerson].pose.box.trackId].endpoints[targetSide]; - if (!targetEndpoint.hasWrist || !targetEndpoint.hasHandShape || targetEndpoint.missedFrames > 30) continue; - double targetArea = std::max( - (fused[targetPerson].pose.box.x2 - fused[targetPerson].pose.box.x1) * - (fused[targetPerson].pose.box.y2 - fused[targetPerson].pose.box.y1), 1.0F); - Vec2 shapeCenter{}; - for (auto point : targetEndpoint.handShape) shapeCenter = add(shapeCenter, point); - shapeCenter = mul(shapeCenter, 1.0 / 21.0); - Vec2 predictedCenter = add(targetEndpoint.wrist, shapeCenter); - Measurement targetShape; - for (int point = 0; point < 21; ++point) targetShape.hand[point] = targetEndpoint.handShape[point]; - double targetSpan = handSpan(targetShape); - double gate = 0.20 * boxDiagonal(fused[targetPerson].pose.box); - for (std::size_t sourcePerson = 0; sourcePerson < fused.size(); ++sourcePerson) { - if (sourcePerson == targetPerson) continue; - for (int sourceSide = 0; sourceSide < 2; ++sourceSide) { - auto const& source = measurements[sourcePerson][sourceSide]; - if (!source || source->source != "model") continue; - double sourceArea = std::max( - (fused[sourcePerson].pose.box.x2 - fused[sourcePerson].pose.box.x1) * - (fused[sourcePerson].pose.box.y2 - fused[sourcePerson].pose.box.y1), 1.0F); - if (targetArea < 2.5 * sourceArea) continue; - Vec2 sourceCenter = handCenter(*source); - double sourceSpan = handSpan(*source); - double candidateDistance = norm(sub(sourceCenter, predictedCenter)); - if (candidateDistance > gate || targetSpan < 1.45 * std::max(sourceSpan, 1.0)) continue; - reassignments.push_back({ - candidateDistance / std::max(gate, 1e-6), targetPerson, targetSide, - sourcePerson, sourceSide, sourceCenter}); - } - } - } - } - std::sort(reassignments.begin(), reassignments.end(), [](auto const& first, auto const& second) { - return std::tie(first.normalizedDistance, first.targetPerson, first.targetSide, - first.sourcePerson, first.sourceSide) < - std::tie(second.normalizedDistance, second.targetPerson, second.targetSide, - second.sourcePerson, second.sourceSide); - }); - std::set> usedTargets, usedSources; - for (auto const& item : reassignments) { - auto targetKey = std::make_pair(item.targetPerson, item.targetSide); - auto sourceKey = std::make_pair(item.sourcePerson, item.sourceSide); - if (usedTargets.count(targetKey) || usedSources.count(sourceKey) || - measurements[item.targetPerson][item.targetSide] || - !measurements[item.sourcePerson][item.sourceSide]) continue; - auto& targetEndpoint = states_[fused[item.targetPerson].pose.box.trackId].endpoints[item.targetSide]; - Vec2 shapeCenter{}; - for (auto point : targetEndpoint.handShape) shapeCenter = add(shapeCenter, point); - shapeCenter = mul(shapeCenter, 1.0 / 21.0); - Vec2 reassignedWrist = sub(item.sourceCenter, shapeCenter); - Measurement reassigned; - for (int point = 0; point < 21; ++point) { - reassigned.hand[point] = add(reassignedWrist, targetEndpoint.handShape[point]); - } - reassigned.provisional = true; - reassigned.source = "global_reassignment"; - reassigned.quality = measurements[item.sourcePerson][item.sourceSide]->quality; - measurements[item.targetPerson][item.targetSide] = reassigned; - measurements[item.sourcePerson][item.sourceSide].reset(); - auto& sourceEndpoint = states_[fused[item.sourcePerson].pose.box.trackId].endpoints[item.sourceSide]; - sourceEndpoint = {}; - usedTargets.insert(targetKey); - usedSources.insert(sourceKey); - } - - PoseFrameResult result; - result.globalHands = std::move(globalHands); - result.selectedPeople.reserve(fused.size()); - result.smoothedPeople.reserve(fused.size()); - result.v2People.reserve(fused.size()); - for (auto const& person : fused) { - std::array meta{}; - for (int side=0;side<2;++side) { - auto const& m=person.meta[side]; - meta[side]={m.limbConsensus,m.handValid,m.distanceEligible,m.alarmEligible,m.handScore,m.handSource,m.handState}; - } - result.metadata.push_back(meta); - result.selectedPeople.push_back(person.pose); - PersonPose smoothed = person.pose; - auto const& state = states_[person.pose.box.trackId]; - for (int keypoint = 0; keypoint < 133; ++keypoint) { - Vec2 point = denormalized(state.smoothed[keypoint], person.pose.box); - smoothed.keypoints[keypoint].x = static_cast(point.x); - smoothed.keypoints[keypoint].y = static_cast(point.y); - } - result.smoothedPeople.push_back(smoothed); - result.v2People.push_back(std::move(smoothed)); - } - for (std::size_t person = 0; person < fused.size(); ++person) { - auto& state = states_[fused[person].pose.box.trackId]; - int frameGap = state.lastFrame < 0 ? 0 : std::max(frameIndex - state.lastFrame - 1, 0); - for (auto& endpoint : state.endpoints) endpoint.missedFrames += frameGap; - state.lastFrame = frameIndex; - for (int side = 0; side < 2; ++side) { - if (!fused[person].meta[side].limbConsensus || !fused[person].meta[side].distanceEligible) continue; - int shoulderIndex = side == 0 ? 5 : 6; - int elbowIndex = side == 0 ? 7 : 8; - int wristIndex = side == 0 ? 9 : 10; - Vec2 shoulder = vec(fused[person].pose.keypoints[shoulderIndex]); - Vec2 elbow = vec(fused[person].pose.keypoints[elbowIndex]); - Vec2 wrist = vec(fused[person].pose.keypoints[wristIndex]); - double diagonal = boxDiagonal(fused[person].pose.box); - double upper = norm(sub(shoulder, elbow)) / diagonal; - double forearm = norm(sub(elbow, wrist)) / diagonal; - if (upper >= 0.04 && upper <= 0.65 && forearm >= 0.04 && forearm <= 0.65) { - auto& samples = state.boneSamples[side]; - samples.push_back({upper, forearm}); - while (samples.size() > 120) samples.pop_front(); - } - } - for (int side = 0; side < 2; ++side) { - int shoulderIndex = side == 0 ? 5 : 6; - int elbowIndex = side == 0 ? 7 : 8; - int wristIndex = side == 0 ? 9 : 10; - int handStart = side == 0 ? 91 : 112; - auto& endpoint = state.endpoints[side]; - auto measurement = measurements[person][side]; - // Reference temporal recovery gate. - bool const recoverableHandState = fused[person].meta[side].handState == "conflict" || - fused[person].meta[side].handState == "inferred"; - if (!measurement && endpoint.hasWrist && endpoint.hasHandShape && endpoint.missedFrames <= 30 && - recoverableHandState && fused[person].meta[side].handValid && - fused[person].meta[side].handScore >= 2.0 && - fused[person].meta[side].linkToSelectedLimb <= 0.08) { - Vec2 measured = vec(fused[person].pose.keypoints[handStart]); - Vec2 prediction = add(endpoint.wrist, endpoint.velocity); - double gate = std::min(0.20, 0.05 + 0.008 * std::max(endpoint.missedFrames, 1)) * boxDiagonal(fused[person].pose.box); - if (norm(sub(measured, prediction)) <= gate) { - Measurement recovered; - for (int i = 0; i < 21; ++i) recovered.hand[i] = vec(fused[person].pose.keypoints[handStart + i]); - recovered.provisional = true; recovered.quality = fused[person].meta[side].handScore; recovered.source = "temporal_recovery"; - measurement = recovered; - } - } - LimbState outputState; - std::array outputHand{}; - bool hasOutput = false; - bool returningAfterLong = measurement && endpoint.missedFrames > 12; - if (measurement) { - Vec2 measuredWrist = measurement->hand[0]; - std::array measuredShape{}; - for (int i = 0; i < 21; ++i) measuredShape[i] = sub(measurement->hand[i], measuredWrist); - if (!endpoint.hasWrist || endpoint.missedFrames > 12) { - endpoint.wrist = measuredWrist; endpoint.velocity = {}; endpoint.handShape = measuredShape; - } else { - Vec2 prediction = add(endpoint.wrist, endpoint.velocity); - Vec2 residual = sub(measuredWrist, prediction); - double alpha = measurement->precise ? 0.78 : 0.88; - double beta = measurement->precise ? 0.18 : 0.24; - endpoint.wrist = add(prediction, mul(residual, alpha)); - endpoint.velocity = add(mul(endpoint.velocity, 0.82), mul(residual, beta)); - double shapeAlpha = measurement->precise ? 0.55 : 0.70; - for (int i = 0; i < 21; ++i) endpoint.handShape[i] = add(mul(measuredShape[i], shapeAlpha), mul(endpoint.handShape[i], 1.0 - shapeAlpha)); - } - endpoint.hasWrist = endpoint.hasHandShape = true; - endpoint.lastObservedFrame = frameIndex; - endpoint.missedFrames = 0; - outputState = measurement->source == "global_reassignment" ? LimbState::Reassigned : measurement->source == "temporal_recovery" ? LimbState::Recovered : measurement->precise ? LimbState::Observed : measurement->provisional ? LimbState::Provisional : LimbState::Interpolated; - for (int i = 0; i < 21; ++i) outputHand[i] = add(endpoint.wrist, endpoint.handShape[i]); - hasOutput = true; - } else { - ++endpoint.missedFrames; - if (!endpoint.hasWrist || endpoint.missedFrames > 30) outputState = LimbState::ReachableLong; - else if (endpoint.missedFrames <= 12) { - endpoint.wrist = add(endpoint.wrist, endpoint.velocity); - endpoint.velocity = mul(endpoint.velocity, 0.86); - for (int i = 0; i < 21; ++i) outputHand[i] = add(endpoint.wrist, endpoint.handShape[i]); - hasOutput = true; outputState = LimbState::PredictedShort; - } else outputState = LimbState::ReachableMedium; - } - Vec2 smoothedShoulder = denormalized(state.smoothed[shoulderIndex], fused[person].pose.box); - Vec2 smoothedElbow = denormalized(state.smoothed[elbowIndex], fused[person].pose.box); - Keypoint shoulder = fused[person].pose.keypoints[shoulderIndex]; - shoulder.x = static_cast(smoothedShoulder.x); - shoulder.y = static_cast(smoothedShoulder.y); - Keypoint elbow = fused[person].pose.keypoints[elbowIndex]; - elbow.x = static_cast(smoothedElbow.x); - elbow.y = static_cast(smoothedElbow.y); - Keypoint wrist = result.smoothedPeople[person].keypoints[wristIndex]; - std::array hand{}; - for (int i = 0; i < 21; ++i) { - hand[i] = result.smoothedPeople[person].keypoints[handStart + i]; - } - if (hasOutput) { - auto& ownSamples = state.boneSamples[side]; - auto& oppositeSamples = state.boneSamples[1 - side]; - auto const& samples = ownSamples.size() < 10 && oppositeSamples.size() >= 10 - ? oppositeSamples : ownSamples; - double upperRatio = 0.24, forearmRatio = 0.22; - if (!samples.empty()) { - std::vector upperValues, forearmValues; - upperValues.reserve(samples.size()); - forearmValues.reserve(samples.size()); - for (auto const& sample : samples) { - upperValues.push_back(sample[0]); - forearmValues.push_back(sample[1]); - } - upperRatio = median(std::move(upperValues)); - forearmRatio = median(std::move(forearmValues)); - } - double diagonal = boxDiagonal(fused[person].pose.box); - double upperLength = upperRatio * diagonal; - double forearmLength = forearmRatio * diagonal; - double totalLength = upperLength + forearmLength; - if (totalLength > 0.95 * diagonal) { - double lengthScale = 0.95 * diagonal / totalLength; - upperLength *= lengthScale; - forearmLength *= lengthScale; - } - Vec2 referenceElbow = returningAfterLong || !endpoint.hasLastElbow - ? vec(fused[person].pose.keypoints[elbowIndex]) : endpoint.lastElbow; - if (!fused[person].meta[side].limbConsensus || outputState != LimbState::Observed) { - Vec2 solved = solveTwoBoneElbow( - smoothedShoulder, outputHand[0], upperLength, forearmLength, referenceElbow); - elbow.x = static_cast(solved.x); - elbow.y = static_cast(solved.y); - } - endpoint.lastElbow = vec(elbow); - endpoint.hasLastElbow = true; - Vec2 armDirection = sub(outputHand[0], smoothedShoulder); - if (norm(armDirection) > 1e-6) { - endpoint.lastDirection = mul(armDirection, 1.0 / norm(armDirection)); - endpoint.hasLastDirection = true; - } - wrist.x = outputHand[0].x; wrist.y = outputHand[0].y; - for (int i = 0; i < 21; ++i) { - hand[i].x = outputHand[i].x; hand[i].y = outputHand[i].y; - } - } - auto& v2Pose = result.v2People[person]; - v2Pose.keypoints[shoulderIndex] = shoulder; - v2Pose.keypoints[elbowIndex] = elbow; - v2Pose.keypoints[wristIndex] = wrist; - if (hasOutput) { - for (int point = 0; point < 21; ++point) v2Pose.keypoints[handStart + point] = hand[point]; - } - result.limbs.push_back({ - fused[person].pose.box.trackId, side == 0, outputState, - elbow, wrist, hand, fused[person].pose.box, - fused[person].meta[side].distanceEligible, - fused[person].meta[side].alarmEligible, - static_cast(fused[person].meta[side].handScore)}); - } - } - return result; -} - -} // namespace fangjia diff --git a/accelerator/src/visualizer.cpp b/accelerator/src/visualizer.cpp deleted file mode 100644 index 75fbe50..0000000 --- a/accelerator/src/visualizer.cpp +++ /dev/null @@ -1,97 +0,0 @@ -#include "visualizer.hpp" -#include "camera_pipeline.hpp" -#include -#include -#include -#include -#include -#include -#include -#include - -namespace cms { -namespace { -constexpr char windowName[]="CMS Camera Risk"; -cv::Point point(PosePoint const& p){return {int(std::nearbyint(p.x)),int(std::nearbyint(p.y))};} -cv::Scalar color(std::string const& level) { - if(level=="danger")return {40,40,255}; - if(level=="warning")return {0,160,255}; - if(level=="watch")return {0,240,240}; - if(level=="clear")return {80,220,90}; - return {190,190,190}; -} -void segment(cv::Mat& image,cv::Point a,cv::Point b,cv::Scalar c,int thickness,bool dashed) { - if(!dashed){cv::line(image,a,b,c,thickness,cv::LINE_AA);return;} - cv::Point2d d=b-a;double length=cv::norm(d);if(length<1)return;d*=1.0/length; - for(double x=0;x(image.pixels.data()),image.stride); - auto canvas=view.clone(); - if(r.door_mask_pixels) { - auto const& m=*r.door_mask_pixels; - if(m.width!=image.width||m.height!=image.height||m.stride(m.pixels.data()),m.stride); - auto tint=canvas.clone();tint.setTo(cv::Scalar(255,180,0),mask); - cv::addWeighted(canvas,0.75,tint,0.25,0,canvas); - std::vector> contours;cv::findContours(mask.clone(),contours,cv::RETR_EXTERNAL,cv::CHAIN_APPROX_SIMPLE); - cv::drawContours(canvas,contours,-1,{255,180,0},2); - } - for(auto const& person:r.persons) { - auto const& b=person.box; - cv::rectangle(canvas,{int(b[0]),int(b[1])},{int(b[2]),int(b[3])},{0,220,255},2); - std::ostringstream text;text<<"ID "<>{{5+s,7+s},{7+s,9+s}}) { - segment(canvas,point(k[e.first]),point(k[e.second]),state.limb_consensus?arm:cv::Scalar(0,140,255),3,!state.limb_consensus); - cv::circle(canvas,point(k[e.second]),4,arm,-1,cv::LINE_AA); - } - if(state.state=="rejected")continue; - int start=s==0?91:112; - auto hand=state.distance_eligible?(s==0?cv::Scalar(255,80,220):cv::Scalar(255,190,40)):cv::Scalar(0,140,255); - for(int f=0;f<5;++f)for(int j=0;j<4;++j){int a=j==0?start:start+f*4+j;int b=start+1+f*4+j;segment(canvas,point(k[a]),point(k[b]),hand,2,!state.distance_eligible);} - for(int j=0;j<21;++j)cv::circle(canvas,point(k[start+j]),3,hand,-1,cv::LINE_AA); - } - } - for(auto const& h:r.hand_regions) { - std::vector points,hull;for(auto const& p:h.keypoints)points.push_back(point(p));cv::convexHull(points,hull); - auto risk=std::find_if(r.risk.regions.begin(),r.risk.regions.end(),[&](auto const& item){return item.track_id==h.track_id&&item.side==h.side;}); - auto c=color(risk==r.risk.regions.end()?"unavailable":risk->risk_level); - cv::polylines(canvas,std::vector>{hull},true,c,2,cv::LINE_AA); - } - for(auto const& region:r.risk.regions)if(region.source=="YOLO_BODY_BOX_FALLBACK") { - auto it=std::find(r.track_ids.begin(),r.track_ids.end(),region.track_id); - if(it!=r.track_ids.end()){auto const& b=r.boxes.at(it-r.track_ids.begin());cv::putText(canvas,"BODY FALLBACK",{int(b[0])+4,int(b[1])+50},cv::FONT_HERSHEY_SIMPLEX,.65,{0,160,255},2,cv::LINE_AA);} - } - cv::rectangle(canvas,{0,0},{canvas.cols,148},{20,24,30},-1); - std::ostringstream headline;headline<<"RISK ";if(r.risk.risk_score)headline< -// SPDX-License-Identifier: MIT - -/****************************************************************************\ - * Note on documentation: The source files contain links to the online * - * documentation of the public API at https://json.nlohmann.me. This URL * - * contains the most recent documentation and should also be applicable to * - * previous versions; documentation for deprecated functions is not * - * removed, but marked deprecated. See "Generate documentation" section in * - * file docs/README.md. * -\****************************************************************************/ - -#ifndef INCLUDE_NLOHMANN_JSON_HPP_ -#define INCLUDE_NLOHMANN_JSON_HPP_ - -#include // all_of, find, for_each -#include // nullptr_t, ptrdiff_t, size_t -#include // hash, less -#include // initializer_list -#ifndef JSON_NO_IO - #include // istream, ostream -#endif // JSON_NO_IO -#include // random_access_iterator_tag -#include // unique_ptr -#include // string, stoi, to_string -#include // declval, forward, move, pair, swap -#include // vector - -// #include -// __ _____ _____ _____ -// __| | __| | | | JSON for Modern C++ -// | | |__ | | | | | | version 3.11.3 -// |_____|_____|_____|_|___| https://github.com/nlohmann/json -// -// SPDX-FileCopyrightText: 2013-2023 Niels Lohmann -// SPDX-License-Identifier: MIT - - - -#include - -// #include -// __ _____ _____ _____ -// __| | __| | | | JSON for Modern C++ -// | | |__ | | | | | | version 3.11.3 -// |_____|_____|_____|_|___| https://github.com/nlohmann/json -// -// SPDX-FileCopyrightText: 2013-2023 Niels Lohmann -// SPDX-License-Identifier: MIT - - - -// This file contains all macro definitions affecting or depending on the ABI - -#ifndef JSON_SKIP_LIBRARY_VERSION_CHECK - #if defined(NLOHMANN_JSON_VERSION_MAJOR) && defined(NLOHMANN_JSON_VERSION_MINOR) && defined(NLOHMANN_JSON_VERSION_PATCH) - #if NLOHMANN_JSON_VERSION_MAJOR != 3 || NLOHMANN_JSON_VERSION_MINOR != 11 || NLOHMANN_JSON_VERSION_PATCH != 3 - #warning "Already included a different version of the library!" - #endif - #endif -#endif - -#define NLOHMANN_JSON_VERSION_MAJOR 3 // NOLINT(modernize-macro-to-enum) -#define NLOHMANN_JSON_VERSION_MINOR 11 // NOLINT(modernize-macro-to-enum) -#define NLOHMANN_JSON_VERSION_PATCH 3 // NOLINT(modernize-macro-to-enum) - -#ifndef JSON_DIAGNOSTICS - #define JSON_DIAGNOSTICS 0 -#endif - -#ifndef JSON_USE_LEGACY_DISCARDED_VALUE_COMPARISON - #define JSON_USE_LEGACY_DISCARDED_VALUE_COMPARISON 0 -#endif - -#if JSON_DIAGNOSTICS - #define NLOHMANN_JSON_ABI_TAG_DIAGNOSTICS _diag -#else - #define NLOHMANN_JSON_ABI_TAG_DIAGNOSTICS -#endif - -#if JSON_USE_LEGACY_DISCARDED_VALUE_COMPARISON - #define NLOHMANN_JSON_ABI_TAG_LEGACY_DISCARDED_VALUE_COMPARISON _ldvcmp -#else - #define NLOHMANN_JSON_ABI_TAG_LEGACY_DISCARDED_VALUE_COMPARISON -#endif - -#ifndef NLOHMANN_JSON_NAMESPACE_NO_VERSION - #define NLOHMANN_JSON_NAMESPACE_NO_VERSION 0 -#endif - -// Construct the namespace ABI tags component -#define NLOHMANN_JSON_ABI_TAGS_CONCAT_EX(a, b) json_abi ## a ## b -#define NLOHMANN_JSON_ABI_TAGS_CONCAT(a, b) \ - NLOHMANN_JSON_ABI_TAGS_CONCAT_EX(a, b) - -#define NLOHMANN_JSON_ABI_TAGS \ - NLOHMANN_JSON_ABI_TAGS_CONCAT( \ - NLOHMANN_JSON_ABI_TAG_DIAGNOSTICS, \ - NLOHMANN_JSON_ABI_TAG_LEGACY_DISCARDED_VALUE_COMPARISON) - -// Construct the namespace version component -#define NLOHMANN_JSON_NAMESPACE_VERSION_CONCAT_EX(major, minor, patch) \ - _v ## major ## _ ## minor ## _ ## patch -#define NLOHMANN_JSON_NAMESPACE_VERSION_CONCAT(major, minor, patch) \ - NLOHMANN_JSON_NAMESPACE_VERSION_CONCAT_EX(major, minor, patch) - -#if NLOHMANN_JSON_NAMESPACE_NO_VERSION -#define NLOHMANN_JSON_NAMESPACE_VERSION -#else -#define NLOHMANN_JSON_NAMESPACE_VERSION \ - NLOHMANN_JSON_NAMESPACE_VERSION_CONCAT(NLOHMANN_JSON_VERSION_MAJOR, \ - NLOHMANN_JSON_VERSION_MINOR, \ - NLOHMANN_JSON_VERSION_PATCH) -#endif - -// Combine namespace components -#define NLOHMANN_JSON_NAMESPACE_CONCAT_EX(a, b) a ## b -#define NLOHMANN_JSON_NAMESPACE_CONCAT(a, b) \ - NLOHMANN_JSON_NAMESPACE_CONCAT_EX(a, b) - -#ifndef NLOHMANN_JSON_NAMESPACE -#define NLOHMANN_JSON_NAMESPACE \ - nlohmann::NLOHMANN_JSON_NAMESPACE_CONCAT( \ - NLOHMANN_JSON_ABI_TAGS, \ - NLOHMANN_JSON_NAMESPACE_VERSION) -#endif - -#ifndef NLOHMANN_JSON_NAMESPACE_BEGIN -#define NLOHMANN_JSON_NAMESPACE_BEGIN \ - namespace nlohmann \ - { \ - inline namespace NLOHMANN_JSON_NAMESPACE_CONCAT( \ - NLOHMANN_JSON_ABI_TAGS, \ - NLOHMANN_JSON_NAMESPACE_VERSION) \ - { -#endif - -#ifndef NLOHMANN_JSON_NAMESPACE_END -#define NLOHMANN_JSON_NAMESPACE_END \ - } /* namespace (inline namespace) NOLINT(readability/namespace) */ \ - } // namespace nlohmann -#endif - -// #include -// __ _____ _____ _____ -// __| | __| | | | JSON for Modern C++ -// | | |__ | | | | | | version 3.11.3 -// |_____|_____|_____|_|___| https://github.com/nlohmann/json -// -// SPDX-FileCopyrightText: 2013-2023 Niels Lohmann -// SPDX-License-Identifier: MIT - - - -#include // transform -#include // array -#include // forward_list -#include // inserter, front_inserter, end -#include // map -#include // string -#include // tuple, make_tuple -#include // is_arithmetic, is_same, is_enum, underlying_type, is_convertible -#include // unordered_map -#include // pair, declval -#include // valarray - -// #include -// __ _____ _____ _____ -// __| | __| | | | JSON for Modern C++ -// | | |__ | | | | | | version 3.11.3 -// |_____|_____|_____|_|___| https://github.com/nlohmann/json -// -// SPDX-FileCopyrightText: 2013-2023 Niels Lohmann -// SPDX-License-Identifier: MIT - - - -#include // nullptr_t -#include // exception -#if JSON_DIAGNOSTICS - #include // accumulate -#endif -#include // runtime_error -#include // to_string -#include // vector - -// #include -// __ _____ _____ _____ -// __| | __| | | | JSON for Modern C++ -// | | |__ | | | | | | version 3.11.3 -// |_____|_____|_____|_|___| https://github.com/nlohmann/json -// -// SPDX-FileCopyrightText: 2013-2023 Niels Lohmann -// SPDX-License-Identifier: MIT - - - -#include // array -#include // size_t -#include // uint8_t -#include // string - -// #include -// __ _____ _____ _____ -// __| | __| | | | JSON for Modern C++ -// | | |__ | | | | | | version 3.11.3 -// |_____|_____|_____|_|___| https://github.com/nlohmann/json -// -// SPDX-FileCopyrightText: 2013-2023 Niels Lohmann -// SPDX-License-Identifier: MIT - - - -#include // declval, pair -// #include -// __ _____ _____ _____ -// __| | __| | | | JSON for Modern C++ -// | | |__ | | | | | | version 3.11.3 -// |_____|_____|_____|_|___| https://github.com/nlohmann/json -// -// SPDX-FileCopyrightText: 2013-2023 Niels Lohmann -// SPDX-License-Identifier: MIT - - - -#include - -// #include -// __ _____ _____ _____ -// __| | __| | | | JSON for Modern C++ -// | | |__ | | | | | | version 3.11.3 -// |_____|_____|_____|_|___| https://github.com/nlohmann/json -// -// SPDX-FileCopyrightText: 2013-2023 Niels Lohmann -// SPDX-License-Identifier: MIT - - - -// #include - - -NLOHMANN_JSON_NAMESPACE_BEGIN -namespace detail -{ - -template struct make_void -{ - using type = void; -}; -template using void_t = typename make_void::type; - -} // namespace detail -NLOHMANN_JSON_NAMESPACE_END - - -NLOHMANN_JSON_NAMESPACE_BEGIN -namespace detail -{ - -// https://en.cppreference.com/w/cpp/experimental/is_detected -struct nonesuch -{ - nonesuch() = delete; - ~nonesuch() = delete; - nonesuch(nonesuch const&) = delete; - nonesuch(nonesuch const&&) = delete; - void operator=(nonesuch const&) = delete; - void operator=(nonesuch&&) = delete; -}; - -template class Op, - class... Args> -struct detector -{ - using value_t = std::false_type; - using type = Default; -}; - -template class Op, class... Args> -struct detector>, Op, Args...> -{ - using value_t = std::true_type; - using type = Op; -}; - -template class Op, class... Args> -using is_detected = typename detector::value_t; - -template class Op, class... Args> -struct is_detected_lazy : is_detected { }; - -template class Op, class... Args> -using detected_t = typename detector::type; - -template class Op, class... Args> -using detected_or = detector; - -template class Op, class... Args> -using detected_or_t = typename detected_or::type; - -template class Op, class... Args> -using is_detected_exact = std::is_same>; - -template class Op, class... Args> -using is_detected_convertible = - std::is_convertible, To>; - -} // namespace detail -NLOHMANN_JSON_NAMESPACE_END - -// #include - - -// __ _____ _____ _____ -// __| | __| | | | JSON for Modern C++ -// | | |__ | | | | | | version 3.11.3 -// |_____|_____|_____|_|___| https://github.com/nlohmann/json -// -// SPDX-FileCopyrightText: 2013-2023 Niels Lohmann -// SPDX-FileCopyrightText: 2016-2021 Evan Nemerson -// SPDX-License-Identifier: MIT - -/* Hedley - https://nemequ.github.io/hedley - * Created by Evan Nemerson - */ - -#if !defined(JSON_HEDLEY_VERSION) || (JSON_HEDLEY_VERSION < 15) -#if defined(JSON_HEDLEY_VERSION) - #undef JSON_HEDLEY_VERSION -#endif -#define JSON_HEDLEY_VERSION 15 - -#if defined(JSON_HEDLEY_STRINGIFY_EX) - #undef JSON_HEDLEY_STRINGIFY_EX -#endif -#define JSON_HEDLEY_STRINGIFY_EX(x) #x - -#if defined(JSON_HEDLEY_STRINGIFY) - #undef JSON_HEDLEY_STRINGIFY -#endif -#define JSON_HEDLEY_STRINGIFY(x) JSON_HEDLEY_STRINGIFY_EX(x) - -#if defined(JSON_HEDLEY_CONCAT_EX) - #undef JSON_HEDLEY_CONCAT_EX -#endif -#define JSON_HEDLEY_CONCAT_EX(a,b) a##b - -#if defined(JSON_HEDLEY_CONCAT) - #undef JSON_HEDLEY_CONCAT -#endif -#define JSON_HEDLEY_CONCAT(a,b) JSON_HEDLEY_CONCAT_EX(a,b) - -#if defined(JSON_HEDLEY_CONCAT3_EX) - #undef JSON_HEDLEY_CONCAT3_EX -#endif -#define JSON_HEDLEY_CONCAT3_EX(a,b,c) a##b##c - -#if defined(JSON_HEDLEY_CONCAT3) - #undef JSON_HEDLEY_CONCAT3 -#endif -#define JSON_HEDLEY_CONCAT3(a,b,c) JSON_HEDLEY_CONCAT3_EX(a,b,c) - -#if defined(JSON_HEDLEY_VERSION_ENCODE) - #undef JSON_HEDLEY_VERSION_ENCODE -#endif -#define JSON_HEDLEY_VERSION_ENCODE(major,minor,revision) (((major) * 1000000) + ((minor) * 1000) + (revision)) - -#if defined(JSON_HEDLEY_VERSION_DECODE_MAJOR) - #undef JSON_HEDLEY_VERSION_DECODE_MAJOR -#endif -#define JSON_HEDLEY_VERSION_DECODE_MAJOR(version) ((version) / 1000000) - -#if defined(JSON_HEDLEY_VERSION_DECODE_MINOR) - #undef JSON_HEDLEY_VERSION_DECODE_MINOR -#endif -#define JSON_HEDLEY_VERSION_DECODE_MINOR(version) (((version) % 1000000) / 1000) - -#if defined(JSON_HEDLEY_VERSION_DECODE_REVISION) - #undef JSON_HEDLEY_VERSION_DECODE_REVISION -#endif -#define JSON_HEDLEY_VERSION_DECODE_REVISION(version) ((version) % 1000) - -#if defined(JSON_HEDLEY_GNUC_VERSION) - #undef JSON_HEDLEY_GNUC_VERSION -#endif -#if defined(__GNUC__) && defined(__GNUC_PATCHLEVEL__) - #define JSON_HEDLEY_GNUC_VERSION JSON_HEDLEY_VERSION_ENCODE(__GNUC__, __GNUC_MINOR__, __GNUC_PATCHLEVEL__) -#elif defined(__GNUC__) - #define JSON_HEDLEY_GNUC_VERSION JSON_HEDLEY_VERSION_ENCODE(__GNUC__, __GNUC_MINOR__, 0) -#endif - -#if defined(JSON_HEDLEY_GNUC_VERSION_CHECK) - #undef JSON_HEDLEY_GNUC_VERSION_CHECK -#endif -#if defined(JSON_HEDLEY_GNUC_VERSION) - #define JSON_HEDLEY_GNUC_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_GNUC_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch)) -#else - #define JSON_HEDLEY_GNUC_VERSION_CHECK(major,minor,patch) (0) -#endif - -#if defined(JSON_HEDLEY_MSVC_VERSION) - #undef JSON_HEDLEY_MSVC_VERSION -#endif -#if defined(_MSC_FULL_VER) && (_MSC_FULL_VER >= 140000000) && !defined(__ICL) - #define JSON_HEDLEY_MSVC_VERSION JSON_HEDLEY_VERSION_ENCODE(_MSC_FULL_VER / 10000000, (_MSC_FULL_VER % 10000000) / 100000, (_MSC_FULL_VER % 100000) / 100) -#elif defined(_MSC_FULL_VER) && !defined(__ICL) - #define JSON_HEDLEY_MSVC_VERSION JSON_HEDLEY_VERSION_ENCODE(_MSC_FULL_VER / 1000000, (_MSC_FULL_VER % 1000000) / 10000, (_MSC_FULL_VER % 10000) / 10) -#elif defined(_MSC_VER) && !defined(__ICL) - #define JSON_HEDLEY_MSVC_VERSION JSON_HEDLEY_VERSION_ENCODE(_MSC_VER / 100, _MSC_VER % 100, 0) -#endif - -#if defined(JSON_HEDLEY_MSVC_VERSION_CHECK) - #undef JSON_HEDLEY_MSVC_VERSION_CHECK -#endif -#if !defined(JSON_HEDLEY_MSVC_VERSION) - #define JSON_HEDLEY_MSVC_VERSION_CHECK(major,minor,patch) (0) -#elif defined(_MSC_VER) && (_MSC_VER >= 1400) - #define JSON_HEDLEY_MSVC_VERSION_CHECK(major,minor,patch) (_MSC_FULL_VER >= ((major * 10000000) + (minor * 100000) + (patch))) -#elif defined(_MSC_VER) && (_MSC_VER >= 1200) - #define JSON_HEDLEY_MSVC_VERSION_CHECK(major,minor,patch) (_MSC_FULL_VER >= ((major * 1000000) + (minor * 10000) + (patch))) -#else - #define JSON_HEDLEY_MSVC_VERSION_CHECK(major,minor,patch) (_MSC_VER >= ((major * 100) + (minor))) -#endif - -#if defined(JSON_HEDLEY_INTEL_VERSION) - #undef JSON_HEDLEY_INTEL_VERSION -#endif -#if defined(__INTEL_COMPILER) && defined(__INTEL_COMPILER_UPDATE) && !defined(__ICL) - #define JSON_HEDLEY_INTEL_VERSION JSON_HEDLEY_VERSION_ENCODE(__INTEL_COMPILER / 100, __INTEL_COMPILER % 100, __INTEL_COMPILER_UPDATE) -#elif defined(__INTEL_COMPILER) && !defined(__ICL) - #define JSON_HEDLEY_INTEL_VERSION JSON_HEDLEY_VERSION_ENCODE(__INTEL_COMPILER / 100, __INTEL_COMPILER % 100, 0) -#endif - -#if defined(JSON_HEDLEY_INTEL_VERSION_CHECK) - #undef JSON_HEDLEY_INTEL_VERSION_CHECK -#endif -#if defined(JSON_HEDLEY_INTEL_VERSION) - #define JSON_HEDLEY_INTEL_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_INTEL_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch)) -#else - #define JSON_HEDLEY_INTEL_VERSION_CHECK(major,minor,patch) (0) -#endif - -#if defined(JSON_HEDLEY_INTEL_CL_VERSION) - #undef JSON_HEDLEY_INTEL_CL_VERSION -#endif -#if defined(__INTEL_COMPILER) && defined(__INTEL_COMPILER_UPDATE) && defined(__ICL) - #define JSON_HEDLEY_INTEL_CL_VERSION JSON_HEDLEY_VERSION_ENCODE(__INTEL_COMPILER, __INTEL_COMPILER_UPDATE, 0) -#endif - -#if defined(JSON_HEDLEY_INTEL_CL_VERSION_CHECK) - #undef JSON_HEDLEY_INTEL_CL_VERSION_CHECK -#endif -#if defined(JSON_HEDLEY_INTEL_CL_VERSION) - #define JSON_HEDLEY_INTEL_CL_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_INTEL_CL_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch)) -#else - #define JSON_HEDLEY_INTEL_CL_VERSION_CHECK(major,minor,patch) (0) -#endif - -#if defined(JSON_HEDLEY_PGI_VERSION) - #undef JSON_HEDLEY_PGI_VERSION -#endif -#if defined(__PGI) && defined(__PGIC__) && defined(__PGIC_MINOR__) && defined(__PGIC_PATCHLEVEL__) - #define JSON_HEDLEY_PGI_VERSION JSON_HEDLEY_VERSION_ENCODE(__PGIC__, __PGIC_MINOR__, __PGIC_PATCHLEVEL__) -#endif - -#if defined(JSON_HEDLEY_PGI_VERSION_CHECK) - #undef JSON_HEDLEY_PGI_VERSION_CHECK -#endif -#if defined(JSON_HEDLEY_PGI_VERSION) - #define JSON_HEDLEY_PGI_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_PGI_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch)) -#else - #define JSON_HEDLEY_PGI_VERSION_CHECK(major,minor,patch) (0) -#endif - -#if defined(JSON_HEDLEY_SUNPRO_VERSION) - #undef JSON_HEDLEY_SUNPRO_VERSION -#endif -#if defined(__SUNPRO_C) && (__SUNPRO_C > 0x1000) - #define JSON_HEDLEY_SUNPRO_VERSION JSON_HEDLEY_VERSION_ENCODE((((__SUNPRO_C >> 16) & 0xf) * 10) + ((__SUNPRO_C >> 12) & 0xf), (((__SUNPRO_C >> 8) & 0xf) * 10) + ((__SUNPRO_C >> 4) & 0xf), (__SUNPRO_C & 0xf) * 10) -#elif defined(__SUNPRO_C) - #define JSON_HEDLEY_SUNPRO_VERSION JSON_HEDLEY_VERSION_ENCODE((__SUNPRO_C >> 8) & 0xf, (__SUNPRO_C >> 4) & 0xf, (__SUNPRO_C) & 0xf) -#elif defined(__SUNPRO_CC) && (__SUNPRO_CC > 0x1000) - #define JSON_HEDLEY_SUNPRO_VERSION JSON_HEDLEY_VERSION_ENCODE((((__SUNPRO_CC >> 16) & 0xf) * 10) + ((__SUNPRO_CC >> 12) & 0xf), (((__SUNPRO_CC >> 8) & 0xf) * 10) + ((__SUNPRO_CC >> 4) & 0xf), (__SUNPRO_CC & 0xf) * 10) -#elif defined(__SUNPRO_CC) - #define JSON_HEDLEY_SUNPRO_VERSION JSON_HEDLEY_VERSION_ENCODE((__SUNPRO_CC >> 8) & 0xf, (__SUNPRO_CC >> 4) & 0xf, (__SUNPRO_CC) & 0xf) -#endif - -#if defined(JSON_HEDLEY_SUNPRO_VERSION_CHECK) - #undef JSON_HEDLEY_SUNPRO_VERSION_CHECK -#endif -#if defined(JSON_HEDLEY_SUNPRO_VERSION) - #define JSON_HEDLEY_SUNPRO_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_SUNPRO_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch)) -#else - #define JSON_HEDLEY_SUNPRO_VERSION_CHECK(major,minor,patch) (0) -#endif - -#if defined(JSON_HEDLEY_EMSCRIPTEN_VERSION) - #undef JSON_HEDLEY_EMSCRIPTEN_VERSION -#endif -#if defined(__EMSCRIPTEN__) - #define JSON_HEDLEY_EMSCRIPTEN_VERSION JSON_HEDLEY_VERSION_ENCODE(__EMSCRIPTEN_major__, __EMSCRIPTEN_minor__, __EMSCRIPTEN_tiny__) -#endif - -#if defined(JSON_HEDLEY_EMSCRIPTEN_VERSION_CHECK) - #undef JSON_HEDLEY_EMSCRIPTEN_VERSION_CHECK -#endif -#if defined(JSON_HEDLEY_EMSCRIPTEN_VERSION) - #define JSON_HEDLEY_EMSCRIPTEN_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_EMSCRIPTEN_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch)) -#else - #define JSON_HEDLEY_EMSCRIPTEN_VERSION_CHECK(major,minor,patch) (0) -#endif - -#if defined(JSON_HEDLEY_ARM_VERSION) - #undef JSON_HEDLEY_ARM_VERSION -#endif -#if defined(__CC_ARM) && defined(__ARMCOMPILER_VERSION) - #define JSON_HEDLEY_ARM_VERSION JSON_HEDLEY_VERSION_ENCODE(__ARMCOMPILER_VERSION / 1000000, (__ARMCOMPILER_VERSION % 1000000) / 10000, (__ARMCOMPILER_VERSION % 10000) / 100) -#elif defined(__CC_ARM) && defined(__ARMCC_VERSION) - #define JSON_HEDLEY_ARM_VERSION JSON_HEDLEY_VERSION_ENCODE(__ARMCC_VERSION / 1000000, (__ARMCC_VERSION % 1000000) / 10000, (__ARMCC_VERSION % 10000) / 100) -#endif - -#if defined(JSON_HEDLEY_ARM_VERSION_CHECK) - #undef JSON_HEDLEY_ARM_VERSION_CHECK -#endif -#if defined(JSON_HEDLEY_ARM_VERSION) - #define JSON_HEDLEY_ARM_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_ARM_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch)) -#else - #define JSON_HEDLEY_ARM_VERSION_CHECK(major,minor,patch) (0) -#endif - -#if defined(JSON_HEDLEY_IBM_VERSION) - #undef JSON_HEDLEY_IBM_VERSION -#endif -#if defined(__ibmxl__) - #define JSON_HEDLEY_IBM_VERSION JSON_HEDLEY_VERSION_ENCODE(__ibmxl_version__, __ibmxl_release__, __ibmxl_modification__) -#elif defined(__xlC__) && defined(__xlC_ver__) - #define JSON_HEDLEY_IBM_VERSION JSON_HEDLEY_VERSION_ENCODE(__xlC__ >> 8, __xlC__ & 0xff, (__xlC_ver__ >> 8) & 0xff) -#elif defined(__xlC__) - #define JSON_HEDLEY_IBM_VERSION JSON_HEDLEY_VERSION_ENCODE(__xlC__ >> 8, __xlC__ & 0xff, 0) -#endif - -#if defined(JSON_HEDLEY_IBM_VERSION_CHECK) - #undef JSON_HEDLEY_IBM_VERSION_CHECK -#endif -#if defined(JSON_HEDLEY_IBM_VERSION) - #define JSON_HEDLEY_IBM_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_IBM_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch)) -#else - #define JSON_HEDLEY_IBM_VERSION_CHECK(major,minor,patch) (0) -#endif - -#if defined(JSON_HEDLEY_TI_VERSION) - #undef JSON_HEDLEY_TI_VERSION -#endif -#if \ - defined(__TI_COMPILER_VERSION__) && \ - ( \ - defined(__TMS470__) || defined(__TI_ARM__) || \ - defined(__MSP430__) || \ - defined(__TMS320C2000__) \ - ) -#if (__TI_COMPILER_VERSION__ >= 16000000) - #define JSON_HEDLEY_TI_VERSION JSON_HEDLEY_VERSION_ENCODE(__TI_COMPILER_VERSION__ / 1000000, (__TI_COMPILER_VERSION__ % 1000000) / 1000, (__TI_COMPILER_VERSION__ % 1000)) -#endif -#endif - -#if defined(JSON_HEDLEY_TI_VERSION_CHECK) - #undef JSON_HEDLEY_TI_VERSION_CHECK -#endif -#if defined(JSON_HEDLEY_TI_VERSION) - #define JSON_HEDLEY_TI_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_TI_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch)) -#else - #define JSON_HEDLEY_TI_VERSION_CHECK(major,minor,patch) (0) -#endif - -#if defined(JSON_HEDLEY_TI_CL2000_VERSION) - #undef JSON_HEDLEY_TI_CL2000_VERSION -#endif -#if defined(__TI_COMPILER_VERSION__) && defined(__TMS320C2000__) - #define JSON_HEDLEY_TI_CL2000_VERSION JSON_HEDLEY_VERSION_ENCODE(__TI_COMPILER_VERSION__ / 1000000, (__TI_COMPILER_VERSION__ % 1000000) / 1000, (__TI_COMPILER_VERSION__ % 1000)) -#endif - -#if defined(JSON_HEDLEY_TI_CL2000_VERSION_CHECK) - #undef JSON_HEDLEY_TI_CL2000_VERSION_CHECK -#endif -#if defined(JSON_HEDLEY_TI_CL2000_VERSION) - #define JSON_HEDLEY_TI_CL2000_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_TI_CL2000_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch)) -#else - #define JSON_HEDLEY_TI_CL2000_VERSION_CHECK(major,minor,patch) (0) -#endif - -#if defined(JSON_HEDLEY_TI_CL430_VERSION) - #undef JSON_HEDLEY_TI_CL430_VERSION -#endif -#if defined(__TI_COMPILER_VERSION__) && defined(__MSP430__) - #define JSON_HEDLEY_TI_CL430_VERSION JSON_HEDLEY_VERSION_ENCODE(__TI_COMPILER_VERSION__ / 1000000, (__TI_COMPILER_VERSION__ % 1000000) / 1000, (__TI_COMPILER_VERSION__ % 1000)) -#endif - -#if defined(JSON_HEDLEY_TI_CL430_VERSION_CHECK) - #undef JSON_HEDLEY_TI_CL430_VERSION_CHECK -#endif -#if defined(JSON_HEDLEY_TI_CL430_VERSION) - #define JSON_HEDLEY_TI_CL430_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_TI_CL430_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch)) -#else - #define JSON_HEDLEY_TI_CL430_VERSION_CHECK(major,minor,patch) (0) -#endif - -#if defined(JSON_HEDLEY_TI_ARMCL_VERSION) - #undef JSON_HEDLEY_TI_ARMCL_VERSION -#endif -#if defined(__TI_COMPILER_VERSION__) && (defined(__TMS470__) || defined(__TI_ARM__)) - #define JSON_HEDLEY_TI_ARMCL_VERSION JSON_HEDLEY_VERSION_ENCODE(__TI_COMPILER_VERSION__ / 1000000, (__TI_COMPILER_VERSION__ % 1000000) / 1000, (__TI_COMPILER_VERSION__ % 1000)) -#endif - -#if defined(JSON_HEDLEY_TI_ARMCL_VERSION_CHECK) - #undef JSON_HEDLEY_TI_ARMCL_VERSION_CHECK -#endif -#if defined(JSON_HEDLEY_TI_ARMCL_VERSION) - #define JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_TI_ARMCL_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch)) -#else - #define JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(major,minor,patch) (0) -#endif - -#if defined(JSON_HEDLEY_TI_CL6X_VERSION) - #undef JSON_HEDLEY_TI_CL6X_VERSION -#endif -#if defined(__TI_COMPILER_VERSION__) && defined(__TMS320C6X__) - #define JSON_HEDLEY_TI_CL6X_VERSION JSON_HEDLEY_VERSION_ENCODE(__TI_COMPILER_VERSION__ / 1000000, (__TI_COMPILER_VERSION__ % 1000000) / 1000, (__TI_COMPILER_VERSION__ % 1000)) -#endif - -#if defined(JSON_HEDLEY_TI_CL6X_VERSION_CHECK) - #undef JSON_HEDLEY_TI_CL6X_VERSION_CHECK -#endif -#if defined(JSON_HEDLEY_TI_CL6X_VERSION) - #define JSON_HEDLEY_TI_CL6X_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_TI_CL6X_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch)) -#else - #define JSON_HEDLEY_TI_CL6X_VERSION_CHECK(major,minor,patch) (0) -#endif - -#if defined(JSON_HEDLEY_TI_CL7X_VERSION) - #undef JSON_HEDLEY_TI_CL7X_VERSION -#endif -#if defined(__TI_COMPILER_VERSION__) && defined(__C7000__) - #define JSON_HEDLEY_TI_CL7X_VERSION JSON_HEDLEY_VERSION_ENCODE(__TI_COMPILER_VERSION__ / 1000000, (__TI_COMPILER_VERSION__ % 1000000) / 1000, (__TI_COMPILER_VERSION__ % 1000)) -#endif - -#if defined(JSON_HEDLEY_TI_CL7X_VERSION_CHECK) - #undef JSON_HEDLEY_TI_CL7X_VERSION_CHECK -#endif -#if defined(JSON_HEDLEY_TI_CL7X_VERSION) - #define JSON_HEDLEY_TI_CL7X_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_TI_CL7X_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch)) -#else - #define JSON_HEDLEY_TI_CL7X_VERSION_CHECK(major,minor,patch) (0) -#endif - -#if defined(JSON_HEDLEY_TI_CLPRU_VERSION) - #undef JSON_HEDLEY_TI_CLPRU_VERSION -#endif -#if defined(__TI_COMPILER_VERSION__) && defined(__PRU__) - #define JSON_HEDLEY_TI_CLPRU_VERSION JSON_HEDLEY_VERSION_ENCODE(__TI_COMPILER_VERSION__ / 1000000, (__TI_COMPILER_VERSION__ % 1000000) / 1000, (__TI_COMPILER_VERSION__ % 1000)) -#endif - -#if defined(JSON_HEDLEY_TI_CLPRU_VERSION_CHECK) - #undef JSON_HEDLEY_TI_CLPRU_VERSION_CHECK -#endif -#if defined(JSON_HEDLEY_TI_CLPRU_VERSION) - #define JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_TI_CLPRU_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch)) -#else - #define JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(major,minor,patch) (0) -#endif - -#if defined(JSON_HEDLEY_CRAY_VERSION) - #undef JSON_HEDLEY_CRAY_VERSION -#endif -#if defined(_CRAYC) - #if defined(_RELEASE_PATCHLEVEL) - #define JSON_HEDLEY_CRAY_VERSION JSON_HEDLEY_VERSION_ENCODE(_RELEASE_MAJOR, _RELEASE_MINOR, _RELEASE_PATCHLEVEL) - #else - #define JSON_HEDLEY_CRAY_VERSION JSON_HEDLEY_VERSION_ENCODE(_RELEASE_MAJOR, _RELEASE_MINOR, 0) - #endif -#endif - -#if defined(JSON_HEDLEY_CRAY_VERSION_CHECK) - #undef JSON_HEDLEY_CRAY_VERSION_CHECK -#endif -#if defined(JSON_HEDLEY_CRAY_VERSION) - #define JSON_HEDLEY_CRAY_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_CRAY_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch)) -#else - #define JSON_HEDLEY_CRAY_VERSION_CHECK(major,minor,patch) (0) -#endif - -#if defined(JSON_HEDLEY_IAR_VERSION) - #undef JSON_HEDLEY_IAR_VERSION -#endif -#if defined(__IAR_SYSTEMS_ICC__) - #if __VER__ > 1000 - #define JSON_HEDLEY_IAR_VERSION JSON_HEDLEY_VERSION_ENCODE((__VER__ / 1000000), ((__VER__ / 1000) % 1000), (__VER__ % 1000)) - #else - #define JSON_HEDLEY_IAR_VERSION JSON_HEDLEY_VERSION_ENCODE(__VER__ / 100, __VER__ % 100, 0) - #endif -#endif - -#if defined(JSON_HEDLEY_IAR_VERSION_CHECK) - #undef JSON_HEDLEY_IAR_VERSION_CHECK -#endif -#if defined(JSON_HEDLEY_IAR_VERSION) - #define JSON_HEDLEY_IAR_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_IAR_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch)) -#else - #define JSON_HEDLEY_IAR_VERSION_CHECK(major,minor,patch) (0) -#endif - -#if defined(JSON_HEDLEY_TINYC_VERSION) - #undef JSON_HEDLEY_TINYC_VERSION -#endif -#if defined(__TINYC__) - #define JSON_HEDLEY_TINYC_VERSION JSON_HEDLEY_VERSION_ENCODE(__TINYC__ / 1000, (__TINYC__ / 100) % 10, __TINYC__ % 100) -#endif - -#if defined(JSON_HEDLEY_TINYC_VERSION_CHECK) - #undef JSON_HEDLEY_TINYC_VERSION_CHECK -#endif -#if defined(JSON_HEDLEY_TINYC_VERSION) - #define JSON_HEDLEY_TINYC_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_TINYC_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch)) -#else - #define JSON_HEDLEY_TINYC_VERSION_CHECK(major,minor,patch) (0) -#endif - -#if defined(JSON_HEDLEY_DMC_VERSION) - #undef JSON_HEDLEY_DMC_VERSION -#endif -#if defined(__DMC__) - #define JSON_HEDLEY_DMC_VERSION JSON_HEDLEY_VERSION_ENCODE(__DMC__ >> 8, (__DMC__ >> 4) & 0xf, __DMC__ & 0xf) -#endif - -#if defined(JSON_HEDLEY_DMC_VERSION_CHECK) - #undef JSON_HEDLEY_DMC_VERSION_CHECK -#endif -#if defined(JSON_HEDLEY_DMC_VERSION) - #define JSON_HEDLEY_DMC_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_DMC_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch)) -#else - #define JSON_HEDLEY_DMC_VERSION_CHECK(major,minor,patch) (0) -#endif - -#if defined(JSON_HEDLEY_COMPCERT_VERSION) - #undef JSON_HEDLEY_COMPCERT_VERSION -#endif -#if defined(__COMPCERT_VERSION__) - #define JSON_HEDLEY_COMPCERT_VERSION JSON_HEDLEY_VERSION_ENCODE(__COMPCERT_VERSION__ / 10000, (__COMPCERT_VERSION__ / 100) % 100, __COMPCERT_VERSION__ % 100) -#endif - -#if defined(JSON_HEDLEY_COMPCERT_VERSION_CHECK) - #undef JSON_HEDLEY_COMPCERT_VERSION_CHECK -#endif -#if defined(JSON_HEDLEY_COMPCERT_VERSION) - #define JSON_HEDLEY_COMPCERT_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_COMPCERT_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch)) -#else - #define JSON_HEDLEY_COMPCERT_VERSION_CHECK(major,minor,patch) (0) -#endif - -#if defined(JSON_HEDLEY_PELLES_VERSION) - #undef JSON_HEDLEY_PELLES_VERSION -#endif -#if defined(__POCC__) - #define JSON_HEDLEY_PELLES_VERSION JSON_HEDLEY_VERSION_ENCODE(__POCC__ / 100, __POCC__ % 100, 0) -#endif - -#if defined(JSON_HEDLEY_PELLES_VERSION_CHECK) - #undef JSON_HEDLEY_PELLES_VERSION_CHECK -#endif -#if defined(JSON_HEDLEY_PELLES_VERSION) - #define JSON_HEDLEY_PELLES_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_PELLES_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch)) -#else - #define JSON_HEDLEY_PELLES_VERSION_CHECK(major,minor,patch) (0) -#endif - -#if defined(JSON_HEDLEY_MCST_LCC_VERSION) - #undef JSON_HEDLEY_MCST_LCC_VERSION -#endif -#if defined(__LCC__) && defined(__LCC_MINOR__) - #define JSON_HEDLEY_MCST_LCC_VERSION JSON_HEDLEY_VERSION_ENCODE(__LCC__ / 100, __LCC__ % 100, __LCC_MINOR__) -#endif - -#if defined(JSON_HEDLEY_MCST_LCC_VERSION_CHECK) - #undef JSON_HEDLEY_MCST_LCC_VERSION_CHECK -#endif -#if defined(JSON_HEDLEY_MCST_LCC_VERSION) - #define JSON_HEDLEY_MCST_LCC_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_MCST_LCC_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch)) -#else - #define JSON_HEDLEY_MCST_LCC_VERSION_CHECK(major,minor,patch) (0) -#endif - -#if defined(JSON_HEDLEY_GCC_VERSION) - #undef JSON_HEDLEY_GCC_VERSION -#endif -#if \ - defined(JSON_HEDLEY_GNUC_VERSION) && \ - !defined(__clang__) && \ - !defined(JSON_HEDLEY_INTEL_VERSION) && \ - !defined(JSON_HEDLEY_PGI_VERSION) && \ - !defined(JSON_HEDLEY_ARM_VERSION) && \ - !defined(JSON_HEDLEY_CRAY_VERSION) && \ - !defined(JSON_HEDLEY_TI_VERSION) && \ - !defined(JSON_HEDLEY_TI_ARMCL_VERSION) && \ - !defined(JSON_HEDLEY_TI_CL430_VERSION) && \ - !defined(JSON_HEDLEY_TI_CL2000_VERSION) && \ - !defined(JSON_HEDLEY_TI_CL6X_VERSION) && \ - !defined(JSON_HEDLEY_TI_CL7X_VERSION) && \ - !defined(JSON_HEDLEY_TI_CLPRU_VERSION) && \ - !defined(__COMPCERT__) && \ - !defined(JSON_HEDLEY_MCST_LCC_VERSION) - #define JSON_HEDLEY_GCC_VERSION JSON_HEDLEY_GNUC_VERSION -#endif - -#if defined(JSON_HEDLEY_GCC_VERSION_CHECK) - #undef JSON_HEDLEY_GCC_VERSION_CHECK -#endif -#if defined(JSON_HEDLEY_GCC_VERSION) - #define JSON_HEDLEY_GCC_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_GCC_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch)) -#else - #define JSON_HEDLEY_GCC_VERSION_CHECK(major,minor,patch) (0) -#endif - -#if defined(JSON_HEDLEY_HAS_ATTRIBUTE) - #undef JSON_HEDLEY_HAS_ATTRIBUTE -#endif -#if \ - defined(__has_attribute) && \ - ( \ - (!defined(JSON_HEDLEY_IAR_VERSION) || JSON_HEDLEY_IAR_VERSION_CHECK(8,5,9)) \ - ) -# define JSON_HEDLEY_HAS_ATTRIBUTE(attribute) __has_attribute(attribute) -#else -# define JSON_HEDLEY_HAS_ATTRIBUTE(attribute) (0) -#endif - -#if defined(JSON_HEDLEY_GNUC_HAS_ATTRIBUTE) - #undef JSON_HEDLEY_GNUC_HAS_ATTRIBUTE -#endif -#if defined(__has_attribute) - #define JSON_HEDLEY_GNUC_HAS_ATTRIBUTE(attribute,major,minor,patch) JSON_HEDLEY_HAS_ATTRIBUTE(attribute) -#else - #define JSON_HEDLEY_GNUC_HAS_ATTRIBUTE(attribute,major,minor,patch) JSON_HEDLEY_GNUC_VERSION_CHECK(major,minor,patch) -#endif - -#if defined(JSON_HEDLEY_GCC_HAS_ATTRIBUTE) - #undef JSON_HEDLEY_GCC_HAS_ATTRIBUTE -#endif -#if defined(__has_attribute) - #define JSON_HEDLEY_GCC_HAS_ATTRIBUTE(attribute,major,minor,patch) JSON_HEDLEY_HAS_ATTRIBUTE(attribute) -#else - #define JSON_HEDLEY_GCC_HAS_ATTRIBUTE(attribute,major,minor,patch) JSON_HEDLEY_GCC_VERSION_CHECK(major,minor,patch) -#endif - -#if defined(JSON_HEDLEY_HAS_CPP_ATTRIBUTE) - #undef JSON_HEDLEY_HAS_CPP_ATTRIBUTE -#endif -#if \ - defined(__has_cpp_attribute) && \ - defined(__cplusplus) && \ - (!defined(JSON_HEDLEY_SUNPRO_VERSION) || JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,15,0)) - #define JSON_HEDLEY_HAS_CPP_ATTRIBUTE(attribute) __has_cpp_attribute(attribute) -#else - #define JSON_HEDLEY_HAS_CPP_ATTRIBUTE(attribute) (0) -#endif - -#if defined(JSON_HEDLEY_HAS_CPP_ATTRIBUTE_NS) - #undef JSON_HEDLEY_HAS_CPP_ATTRIBUTE_NS -#endif -#if !defined(__cplusplus) || !defined(__has_cpp_attribute) - #define JSON_HEDLEY_HAS_CPP_ATTRIBUTE_NS(ns,attribute) (0) -#elif \ - !defined(JSON_HEDLEY_PGI_VERSION) && \ - !defined(JSON_HEDLEY_IAR_VERSION) && \ - (!defined(JSON_HEDLEY_SUNPRO_VERSION) || JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,15,0)) && \ - (!defined(JSON_HEDLEY_MSVC_VERSION) || JSON_HEDLEY_MSVC_VERSION_CHECK(19,20,0)) - #define JSON_HEDLEY_HAS_CPP_ATTRIBUTE_NS(ns,attribute) JSON_HEDLEY_HAS_CPP_ATTRIBUTE(ns::attribute) -#else - #define JSON_HEDLEY_HAS_CPP_ATTRIBUTE_NS(ns,attribute) (0) -#endif - -#if defined(JSON_HEDLEY_GNUC_HAS_CPP_ATTRIBUTE) - #undef JSON_HEDLEY_GNUC_HAS_CPP_ATTRIBUTE -#endif -#if defined(__has_cpp_attribute) && defined(__cplusplus) - #define JSON_HEDLEY_GNUC_HAS_CPP_ATTRIBUTE(attribute,major,minor,patch) __has_cpp_attribute(attribute) -#else - #define JSON_HEDLEY_GNUC_HAS_CPP_ATTRIBUTE(attribute,major,minor,patch) JSON_HEDLEY_GNUC_VERSION_CHECK(major,minor,patch) -#endif - -#if defined(JSON_HEDLEY_GCC_HAS_CPP_ATTRIBUTE) - #undef JSON_HEDLEY_GCC_HAS_CPP_ATTRIBUTE -#endif -#if defined(__has_cpp_attribute) && defined(__cplusplus) - #define JSON_HEDLEY_GCC_HAS_CPP_ATTRIBUTE(attribute,major,minor,patch) __has_cpp_attribute(attribute) -#else - #define JSON_HEDLEY_GCC_HAS_CPP_ATTRIBUTE(attribute,major,minor,patch) JSON_HEDLEY_GCC_VERSION_CHECK(major,minor,patch) -#endif - -#if defined(JSON_HEDLEY_HAS_BUILTIN) - #undef JSON_HEDLEY_HAS_BUILTIN -#endif -#if defined(__has_builtin) - #define JSON_HEDLEY_HAS_BUILTIN(builtin) __has_builtin(builtin) -#else - #define JSON_HEDLEY_HAS_BUILTIN(builtin) (0) -#endif - -#if defined(JSON_HEDLEY_GNUC_HAS_BUILTIN) - #undef JSON_HEDLEY_GNUC_HAS_BUILTIN -#endif -#if defined(__has_builtin) - #define JSON_HEDLEY_GNUC_HAS_BUILTIN(builtin,major,minor,patch) __has_builtin(builtin) -#else - #define JSON_HEDLEY_GNUC_HAS_BUILTIN(builtin,major,minor,patch) JSON_HEDLEY_GNUC_VERSION_CHECK(major,minor,patch) -#endif - -#if defined(JSON_HEDLEY_GCC_HAS_BUILTIN) - #undef JSON_HEDLEY_GCC_HAS_BUILTIN -#endif -#if defined(__has_builtin) - #define JSON_HEDLEY_GCC_HAS_BUILTIN(builtin,major,minor,patch) __has_builtin(builtin) -#else - #define JSON_HEDLEY_GCC_HAS_BUILTIN(builtin,major,minor,patch) JSON_HEDLEY_GCC_VERSION_CHECK(major,minor,patch) -#endif - -#if defined(JSON_HEDLEY_HAS_FEATURE) - #undef JSON_HEDLEY_HAS_FEATURE -#endif -#if defined(__has_feature) - #define JSON_HEDLEY_HAS_FEATURE(feature) __has_feature(feature) -#else - #define JSON_HEDLEY_HAS_FEATURE(feature) (0) -#endif - -#if defined(JSON_HEDLEY_GNUC_HAS_FEATURE) - #undef JSON_HEDLEY_GNUC_HAS_FEATURE -#endif -#if defined(__has_feature) - #define JSON_HEDLEY_GNUC_HAS_FEATURE(feature,major,minor,patch) __has_feature(feature) -#else - #define JSON_HEDLEY_GNUC_HAS_FEATURE(feature,major,minor,patch) JSON_HEDLEY_GNUC_VERSION_CHECK(major,minor,patch) -#endif - -#if defined(JSON_HEDLEY_GCC_HAS_FEATURE) - #undef JSON_HEDLEY_GCC_HAS_FEATURE -#endif -#if defined(__has_feature) - #define JSON_HEDLEY_GCC_HAS_FEATURE(feature,major,minor,patch) __has_feature(feature) -#else - #define JSON_HEDLEY_GCC_HAS_FEATURE(feature,major,minor,patch) JSON_HEDLEY_GCC_VERSION_CHECK(major,minor,patch) -#endif - -#if defined(JSON_HEDLEY_HAS_EXTENSION) - #undef JSON_HEDLEY_HAS_EXTENSION -#endif -#if defined(__has_extension) - #define JSON_HEDLEY_HAS_EXTENSION(extension) __has_extension(extension) -#else - #define JSON_HEDLEY_HAS_EXTENSION(extension) (0) -#endif - -#if defined(JSON_HEDLEY_GNUC_HAS_EXTENSION) - #undef JSON_HEDLEY_GNUC_HAS_EXTENSION -#endif -#if defined(__has_extension) - #define JSON_HEDLEY_GNUC_HAS_EXTENSION(extension,major,minor,patch) __has_extension(extension) -#else - #define JSON_HEDLEY_GNUC_HAS_EXTENSION(extension,major,minor,patch) JSON_HEDLEY_GNUC_VERSION_CHECK(major,minor,patch) -#endif - -#if defined(JSON_HEDLEY_GCC_HAS_EXTENSION) - #undef JSON_HEDLEY_GCC_HAS_EXTENSION -#endif -#if defined(__has_extension) - #define JSON_HEDLEY_GCC_HAS_EXTENSION(extension,major,minor,patch) __has_extension(extension) -#else - #define JSON_HEDLEY_GCC_HAS_EXTENSION(extension,major,minor,patch) JSON_HEDLEY_GCC_VERSION_CHECK(major,minor,patch) -#endif - -#if defined(JSON_HEDLEY_HAS_DECLSPEC_ATTRIBUTE) - #undef JSON_HEDLEY_HAS_DECLSPEC_ATTRIBUTE -#endif -#if defined(__has_declspec_attribute) - #define JSON_HEDLEY_HAS_DECLSPEC_ATTRIBUTE(attribute) __has_declspec_attribute(attribute) -#else - #define JSON_HEDLEY_HAS_DECLSPEC_ATTRIBUTE(attribute) (0) -#endif - -#if defined(JSON_HEDLEY_GNUC_HAS_DECLSPEC_ATTRIBUTE) - #undef JSON_HEDLEY_GNUC_HAS_DECLSPEC_ATTRIBUTE -#endif -#if defined(__has_declspec_attribute) - #define JSON_HEDLEY_GNUC_HAS_DECLSPEC_ATTRIBUTE(attribute,major,minor,patch) __has_declspec_attribute(attribute) -#else - #define JSON_HEDLEY_GNUC_HAS_DECLSPEC_ATTRIBUTE(attribute,major,minor,patch) JSON_HEDLEY_GNUC_VERSION_CHECK(major,minor,patch) -#endif - -#if defined(JSON_HEDLEY_GCC_HAS_DECLSPEC_ATTRIBUTE) - #undef JSON_HEDLEY_GCC_HAS_DECLSPEC_ATTRIBUTE -#endif -#if defined(__has_declspec_attribute) - #define JSON_HEDLEY_GCC_HAS_DECLSPEC_ATTRIBUTE(attribute,major,minor,patch) __has_declspec_attribute(attribute) -#else - #define JSON_HEDLEY_GCC_HAS_DECLSPEC_ATTRIBUTE(attribute,major,minor,patch) JSON_HEDLEY_GCC_VERSION_CHECK(major,minor,patch) -#endif - -#if defined(JSON_HEDLEY_HAS_WARNING) - #undef JSON_HEDLEY_HAS_WARNING -#endif -#if defined(__has_warning) - #define JSON_HEDLEY_HAS_WARNING(warning) __has_warning(warning) -#else - #define JSON_HEDLEY_HAS_WARNING(warning) (0) -#endif - -#if defined(JSON_HEDLEY_GNUC_HAS_WARNING) - #undef JSON_HEDLEY_GNUC_HAS_WARNING -#endif -#if defined(__has_warning) - #define JSON_HEDLEY_GNUC_HAS_WARNING(warning,major,minor,patch) __has_warning(warning) -#else - #define JSON_HEDLEY_GNUC_HAS_WARNING(warning,major,minor,patch) JSON_HEDLEY_GNUC_VERSION_CHECK(major,minor,patch) -#endif - -#if defined(JSON_HEDLEY_GCC_HAS_WARNING) - #undef JSON_HEDLEY_GCC_HAS_WARNING -#endif -#if defined(__has_warning) - #define JSON_HEDLEY_GCC_HAS_WARNING(warning,major,minor,patch) __has_warning(warning) -#else - #define JSON_HEDLEY_GCC_HAS_WARNING(warning,major,minor,patch) JSON_HEDLEY_GCC_VERSION_CHECK(major,minor,patch) -#endif - -#if \ - (defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L)) || \ - defined(__clang__) || \ - JSON_HEDLEY_GCC_VERSION_CHECK(3,0,0) || \ - JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \ - JSON_HEDLEY_IAR_VERSION_CHECK(8,0,0) || \ - JSON_HEDLEY_PGI_VERSION_CHECK(18,4,0) || \ - JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \ - JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \ - JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(4,7,0) || \ - JSON_HEDLEY_TI_CL430_VERSION_CHECK(2,0,1) || \ - JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,1,0) || \ - JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,0,0) || \ - JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \ - JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) || \ - JSON_HEDLEY_CRAY_VERSION_CHECK(5,0,0) || \ - JSON_HEDLEY_TINYC_VERSION_CHECK(0,9,17) || \ - JSON_HEDLEY_SUNPRO_VERSION_CHECK(8,0,0) || \ - (JSON_HEDLEY_IBM_VERSION_CHECK(10,1,0) && defined(__C99_PRAGMA_OPERATOR)) - #define JSON_HEDLEY_PRAGMA(value) _Pragma(#value) -#elif JSON_HEDLEY_MSVC_VERSION_CHECK(15,0,0) - #define JSON_HEDLEY_PRAGMA(value) __pragma(value) -#else - #define JSON_HEDLEY_PRAGMA(value) -#endif - -#if defined(JSON_HEDLEY_DIAGNOSTIC_PUSH) - #undef JSON_HEDLEY_DIAGNOSTIC_PUSH -#endif -#if defined(JSON_HEDLEY_DIAGNOSTIC_POP) - #undef JSON_HEDLEY_DIAGNOSTIC_POP -#endif -#if defined(__clang__) - #define JSON_HEDLEY_DIAGNOSTIC_PUSH _Pragma("clang diagnostic push") - #define JSON_HEDLEY_DIAGNOSTIC_POP _Pragma("clang diagnostic pop") -#elif JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) - #define JSON_HEDLEY_DIAGNOSTIC_PUSH _Pragma("warning(push)") - #define JSON_HEDLEY_DIAGNOSTIC_POP _Pragma("warning(pop)") -#elif JSON_HEDLEY_GCC_VERSION_CHECK(4,6,0) - #define JSON_HEDLEY_DIAGNOSTIC_PUSH _Pragma("GCC diagnostic push") - #define JSON_HEDLEY_DIAGNOSTIC_POP _Pragma("GCC diagnostic pop") -#elif \ - JSON_HEDLEY_MSVC_VERSION_CHECK(15,0,0) || \ - JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0) - #define JSON_HEDLEY_DIAGNOSTIC_PUSH __pragma(warning(push)) - #define JSON_HEDLEY_DIAGNOSTIC_POP __pragma(warning(pop)) -#elif JSON_HEDLEY_ARM_VERSION_CHECK(5,6,0) - #define JSON_HEDLEY_DIAGNOSTIC_PUSH _Pragma("push") - #define JSON_HEDLEY_DIAGNOSTIC_POP _Pragma("pop") -#elif \ - JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \ - JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,2,0) || \ - JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,4,0) || \ - JSON_HEDLEY_TI_CL6X_VERSION_CHECK(8,1,0) || \ - JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \ - JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) - #define JSON_HEDLEY_DIAGNOSTIC_PUSH _Pragma("diag_push") - #define JSON_HEDLEY_DIAGNOSTIC_POP _Pragma("diag_pop") -#elif JSON_HEDLEY_PELLES_VERSION_CHECK(2,90,0) - #define JSON_HEDLEY_DIAGNOSTIC_PUSH _Pragma("warning(push)") - #define JSON_HEDLEY_DIAGNOSTIC_POP _Pragma("warning(pop)") -#else - #define JSON_HEDLEY_DIAGNOSTIC_PUSH - #define JSON_HEDLEY_DIAGNOSTIC_POP -#endif - -/* JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_ is for - HEDLEY INTERNAL USE ONLY. API subject to change without notice. */ -#if defined(JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_) - #undef JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_ -#endif -#if defined(__cplusplus) -# if JSON_HEDLEY_HAS_WARNING("-Wc++98-compat") -# if JSON_HEDLEY_HAS_WARNING("-Wc++17-extensions") -# if JSON_HEDLEY_HAS_WARNING("-Wc++1z-extensions") -# define JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_(xpr) \ - JSON_HEDLEY_DIAGNOSTIC_PUSH \ - _Pragma("clang diagnostic ignored \"-Wc++98-compat\"") \ - _Pragma("clang diagnostic ignored \"-Wc++17-extensions\"") \ - _Pragma("clang diagnostic ignored \"-Wc++1z-extensions\"") \ - xpr \ - JSON_HEDLEY_DIAGNOSTIC_POP -# else -# define JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_(xpr) \ - JSON_HEDLEY_DIAGNOSTIC_PUSH \ - _Pragma("clang diagnostic ignored \"-Wc++98-compat\"") \ - _Pragma("clang diagnostic ignored \"-Wc++17-extensions\"") \ - xpr \ - JSON_HEDLEY_DIAGNOSTIC_POP -# endif -# else -# define JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_(xpr) \ - JSON_HEDLEY_DIAGNOSTIC_PUSH \ - _Pragma("clang diagnostic ignored \"-Wc++98-compat\"") \ - xpr \ - JSON_HEDLEY_DIAGNOSTIC_POP -# endif -# endif -#endif -#if !defined(JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_) - #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_(x) x -#endif - -#if defined(JSON_HEDLEY_CONST_CAST) - #undef JSON_HEDLEY_CONST_CAST -#endif -#if defined(__cplusplus) -# define JSON_HEDLEY_CONST_CAST(T, expr) (const_cast(expr)) -#elif \ - JSON_HEDLEY_HAS_WARNING("-Wcast-qual") || \ - JSON_HEDLEY_GCC_VERSION_CHECK(4,6,0) || \ - JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) -# define JSON_HEDLEY_CONST_CAST(T, expr) (__extension__ ({ \ - JSON_HEDLEY_DIAGNOSTIC_PUSH \ - JSON_HEDLEY_DIAGNOSTIC_DISABLE_CAST_QUAL \ - ((T) (expr)); \ - JSON_HEDLEY_DIAGNOSTIC_POP \ - })) -#else -# define JSON_HEDLEY_CONST_CAST(T, expr) ((T) (expr)) -#endif - -#if defined(JSON_HEDLEY_REINTERPRET_CAST) - #undef JSON_HEDLEY_REINTERPRET_CAST -#endif -#if defined(__cplusplus) - #define JSON_HEDLEY_REINTERPRET_CAST(T, expr) (reinterpret_cast(expr)) -#else - #define JSON_HEDLEY_REINTERPRET_CAST(T, expr) ((T) (expr)) -#endif - -#if defined(JSON_HEDLEY_STATIC_CAST) - #undef JSON_HEDLEY_STATIC_CAST -#endif -#if defined(__cplusplus) - #define JSON_HEDLEY_STATIC_CAST(T, expr) (static_cast(expr)) -#else - #define JSON_HEDLEY_STATIC_CAST(T, expr) ((T) (expr)) -#endif - -#if defined(JSON_HEDLEY_CPP_CAST) - #undef JSON_HEDLEY_CPP_CAST -#endif -#if defined(__cplusplus) -# if JSON_HEDLEY_HAS_WARNING("-Wold-style-cast") -# define JSON_HEDLEY_CPP_CAST(T, expr) \ - JSON_HEDLEY_DIAGNOSTIC_PUSH \ - _Pragma("clang diagnostic ignored \"-Wold-style-cast\"") \ - ((T) (expr)) \ - JSON_HEDLEY_DIAGNOSTIC_POP -# elif JSON_HEDLEY_IAR_VERSION_CHECK(8,3,0) -# define JSON_HEDLEY_CPP_CAST(T, expr) \ - JSON_HEDLEY_DIAGNOSTIC_PUSH \ - _Pragma("diag_suppress=Pe137") \ - JSON_HEDLEY_DIAGNOSTIC_POP -# else -# define JSON_HEDLEY_CPP_CAST(T, expr) ((T) (expr)) -# endif -#else -# define JSON_HEDLEY_CPP_CAST(T, expr) (expr) -#endif - -#if defined(JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED) - #undef JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED -#endif -#if JSON_HEDLEY_HAS_WARNING("-Wdeprecated-declarations") - #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED _Pragma("clang diagnostic ignored \"-Wdeprecated-declarations\"") -#elif JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) - #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED _Pragma("warning(disable:1478 1786)") -#elif JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0) - #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED __pragma(warning(disable:1478 1786)) -#elif JSON_HEDLEY_PGI_VERSION_CHECK(20,7,0) - #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED _Pragma("diag_suppress 1215,1216,1444,1445") -#elif JSON_HEDLEY_PGI_VERSION_CHECK(17,10,0) - #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED _Pragma("diag_suppress 1215,1444") -#elif JSON_HEDLEY_GCC_VERSION_CHECK(4,3,0) - #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED _Pragma("GCC diagnostic ignored \"-Wdeprecated-declarations\"") -#elif JSON_HEDLEY_MSVC_VERSION_CHECK(15,0,0) - #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED __pragma(warning(disable:4996)) -#elif JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10) - #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED _Pragma("diag_suppress 1215,1444") -#elif \ - JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \ - (JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(4,8,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ - JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,2,0) || \ - (JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ - JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,4,0) || \ - (JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ - JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,3,0) || \ - (JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,2,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ - JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,5,0) || \ - JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \ - JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) - #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED _Pragma("diag_suppress 1291,1718") -#elif JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,13,0) && !defined(__cplusplus) - #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED _Pragma("error_messages(off,E_DEPRECATED_ATT,E_DEPRECATED_ATT_MESS)") -#elif JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,13,0) && defined(__cplusplus) - #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED _Pragma("error_messages(off,symdeprecated,symdeprecated2)") -#elif JSON_HEDLEY_IAR_VERSION_CHECK(8,0,0) - #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED _Pragma("diag_suppress=Pe1444,Pe1215") -#elif JSON_HEDLEY_PELLES_VERSION_CHECK(2,90,0) - #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED _Pragma("warn(disable:2241)") -#else - #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED -#endif - -#if defined(JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS) - #undef JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS -#endif -#if JSON_HEDLEY_HAS_WARNING("-Wunknown-pragmas") - #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS _Pragma("clang diagnostic ignored \"-Wunknown-pragmas\"") -#elif JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) - #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS _Pragma("warning(disable:161)") -#elif JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0) - #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS __pragma(warning(disable:161)) -#elif JSON_HEDLEY_PGI_VERSION_CHECK(17,10,0) - #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS _Pragma("diag_suppress 1675") -#elif JSON_HEDLEY_GCC_VERSION_CHECK(4,3,0) - #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS _Pragma("GCC diagnostic ignored \"-Wunknown-pragmas\"") -#elif JSON_HEDLEY_MSVC_VERSION_CHECK(15,0,0) - #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS __pragma(warning(disable:4068)) -#elif \ - JSON_HEDLEY_TI_VERSION_CHECK(16,9,0) || \ - JSON_HEDLEY_TI_CL6X_VERSION_CHECK(8,0,0) || \ - JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \ - JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,3,0) - #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS _Pragma("diag_suppress 163") -#elif JSON_HEDLEY_TI_CL6X_VERSION_CHECK(8,0,0) - #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS _Pragma("diag_suppress 163") -#elif JSON_HEDLEY_IAR_VERSION_CHECK(8,0,0) - #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS _Pragma("diag_suppress=Pe161") -#elif JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10) - #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS _Pragma("diag_suppress 161") -#else - #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS -#endif - -#if defined(JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES) - #undef JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES -#endif -#if JSON_HEDLEY_HAS_WARNING("-Wunknown-attributes") - #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES _Pragma("clang diagnostic ignored \"-Wunknown-attributes\"") -#elif JSON_HEDLEY_GCC_VERSION_CHECK(4,6,0) - #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES _Pragma("GCC diagnostic ignored \"-Wdeprecated-declarations\"") -#elif JSON_HEDLEY_INTEL_VERSION_CHECK(17,0,0) - #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES _Pragma("warning(disable:1292)") -#elif JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0) - #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES __pragma(warning(disable:1292)) -#elif JSON_HEDLEY_MSVC_VERSION_CHECK(19,0,0) - #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES __pragma(warning(disable:5030)) -#elif JSON_HEDLEY_PGI_VERSION_CHECK(20,7,0) - #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES _Pragma("diag_suppress 1097,1098") -#elif JSON_HEDLEY_PGI_VERSION_CHECK(17,10,0) - #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES _Pragma("diag_suppress 1097") -#elif JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,14,0) && defined(__cplusplus) - #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES _Pragma("error_messages(off,attrskipunsup)") -#elif \ - JSON_HEDLEY_TI_VERSION_CHECK(18,1,0) || \ - JSON_HEDLEY_TI_CL6X_VERSION_CHECK(8,3,0) || \ - JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) - #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES _Pragma("diag_suppress 1173") -#elif JSON_HEDLEY_IAR_VERSION_CHECK(8,0,0) - #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES _Pragma("diag_suppress=Pe1097") -#elif JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10) - #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES _Pragma("diag_suppress 1097") -#else - #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES -#endif - -#if defined(JSON_HEDLEY_DIAGNOSTIC_DISABLE_CAST_QUAL) - #undef JSON_HEDLEY_DIAGNOSTIC_DISABLE_CAST_QUAL -#endif -#if JSON_HEDLEY_HAS_WARNING("-Wcast-qual") - #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_CAST_QUAL _Pragma("clang diagnostic ignored \"-Wcast-qual\"") -#elif JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) - #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_CAST_QUAL _Pragma("warning(disable:2203 2331)") -#elif JSON_HEDLEY_GCC_VERSION_CHECK(3,0,0) - #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_CAST_QUAL _Pragma("GCC diagnostic ignored \"-Wcast-qual\"") -#else - #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_CAST_QUAL -#endif - -#if defined(JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNUSED_FUNCTION) - #undef JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNUSED_FUNCTION -#endif -#if JSON_HEDLEY_HAS_WARNING("-Wunused-function") - #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNUSED_FUNCTION _Pragma("clang diagnostic ignored \"-Wunused-function\"") -#elif JSON_HEDLEY_GCC_VERSION_CHECK(3,4,0) - #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNUSED_FUNCTION _Pragma("GCC diagnostic ignored \"-Wunused-function\"") -#elif JSON_HEDLEY_MSVC_VERSION_CHECK(1,0,0) - #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNUSED_FUNCTION __pragma(warning(disable:4505)) -#elif JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10) - #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNUSED_FUNCTION _Pragma("diag_suppress 3142") -#else - #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNUSED_FUNCTION -#endif - -#if defined(JSON_HEDLEY_DEPRECATED) - #undef JSON_HEDLEY_DEPRECATED -#endif -#if defined(JSON_HEDLEY_DEPRECATED_FOR) - #undef JSON_HEDLEY_DEPRECATED_FOR -#endif -#if \ - JSON_HEDLEY_MSVC_VERSION_CHECK(14,0,0) || \ - JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0) - #define JSON_HEDLEY_DEPRECATED(since) __declspec(deprecated("Since " # since)) - #define JSON_HEDLEY_DEPRECATED_FOR(since, replacement) __declspec(deprecated("Since " #since "; use " #replacement)) -#elif \ - (JSON_HEDLEY_HAS_EXTENSION(attribute_deprecated_with_message) && !defined(JSON_HEDLEY_IAR_VERSION)) || \ - JSON_HEDLEY_GCC_VERSION_CHECK(4,5,0) || \ - JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \ - JSON_HEDLEY_ARM_VERSION_CHECK(5,6,0) || \ - JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,13,0) || \ - JSON_HEDLEY_PGI_VERSION_CHECK(17,10,0) || \ - JSON_HEDLEY_TI_VERSION_CHECK(18,1,0) || \ - JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(18,1,0) || \ - JSON_HEDLEY_TI_CL6X_VERSION_CHECK(8,3,0) || \ - JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \ - JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,3,0) || \ - JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10) - #define JSON_HEDLEY_DEPRECATED(since) __attribute__((__deprecated__("Since " #since))) - #define JSON_HEDLEY_DEPRECATED_FOR(since, replacement) __attribute__((__deprecated__("Since " #since "; use " #replacement))) -#elif defined(__cplusplus) && (__cplusplus >= 201402L) - #define JSON_HEDLEY_DEPRECATED(since) JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_([[deprecated("Since " #since)]]) - #define JSON_HEDLEY_DEPRECATED_FOR(since, replacement) JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_([[deprecated("Since " #since "; use " #replacement)]]) -#elif \ - JSON_HEDLEY_HAS_ATTRIBUTE(deprecated) || \ - JSON_HEDLEY_GCC_VERSION_CHECK(3,1,0) || \ - JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \ - JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \ - (JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(4,8,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ - JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,2,0) || \ - (JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ - JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,4,0) || \ - (JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ - JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,3,0) || \ - (JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,2,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ - JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,5,0) || \ - JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \ - JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) || \ - JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10) || \ - JSON_HEDLEY_IAR_VERSION_CHECK(8,10,0) - #define JSON_HEDLEY_DEPRECATED(since) __attribute__((__deprecated__)) - #define JSON_HEDLEY_DEPRECATED_FOR(since, replacement) __attribute__((__deprecated__)) -#elif \ - JSON_HEDLEY_MSVC_VERSION_CHECK(13,10,0) || \ - JSON_HEDLEY_PELLES_VERSION_CHECK(6,50,0) || \ - JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0) - #define JSON_HEDLEY_DEPRECATED(since) __declspec(deprecated) - #define JSON_HEDLEY_DEPRECATED_FOR(since, replacement) __declspec(deprecated) -#elif JSON_HEDLEY_IAR_VERSION_CHECK(8,0,0) - #define JSON_HEDLEY_DEPRECATED(since) _Pragma("deprecated") - #define JSON_HEDLEY_DEPRECATED_FOR(since, replacement) _Pragma("deprecated") -#else - #define JSON_HEDLEY_DEPRECATED(since) - #define JSON_HEDLEY_DEPRECATED_FOR(since, replacement) -#endif - -#if defined(JSON_HEDLEY_UNAVAILABLE) - #undef JSON_HEDLEY_UNAVAILABLE -#endif -#if \ - JSON_HEDLEY_HAS_ATTRIBUTE(warning) || \ - JSON_HEDLEY_GCC_VERSION_CHECK(4,3,0) || \ - JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \ - JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10) - #define JSON_HEDLEY_UNAVAILABLE(available_since) __attribute__((__warning__("Not available until " #available_since))) -#else - #define JSON_HEDLEY_UNAVAILABLE(available_since) -#endif - -#if defined(JSON_HEDLEY_WARN_UNUSED_RESULT) - #undef JSON_HEDLEY_WARN_UNUSED_RESULT -#endif -#if defined(JSON_HEDLEY_WARN_UNUSED_RESULT_MSG) - #undef JSON_HEDLEY_WARN_UNUSED_RESULT_MSG -#endif -#if \ - JSON_HEDLEY_HAS_ATTRIBUTE(warn_unused_result) || \ - JSON_HEDLEY_GCC_VERSION_CHECK(3,4,0) || \ - JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \ - JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \ - (JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(4,8,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ - JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,2,0) || \ - (JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ - JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,4,0) || \ - (JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ - JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,3,0) || \ - (JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,2,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ - JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,5,0) || \ - JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \ - JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) || \ - (JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,15,0) && defined(__cplusplus)) || \ - JSON_HEDLEY_PGI_VERSION_CHECK(17,10,0) || \ - JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10) - #define JSON_HEDLEY_WARN_UNUSED_RESULT __attribute__((__warn_unused_result__)) - #define JSON_HEDLEY_WARN_UNUSED_RESULT_MSG(msg) __attribute__((__warn_unused_result__)) -#elif (JSON_HEDLEY_HAS_CPP_ATTRIBUTE(nodiscard) >= 201907L) - #define JSON_HEDLEY_WARN_UNUSED_RESULT JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_([[nodiscard]]) - #define JSON_HEDLEY_WARN_UNUSED_RESULT_MSG(msg) JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_([[nodiscard(msg)]]) -#elif JSON_HEDLEY_HAS_CPP_ATTRIBUTE(nodiscard) - #define JSON_HEDLEY_WARN_UNUSED_RESULT JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_([[nodiscard]]) - #define JSON_HEDLEY_WARN_UNUSED_RESULT_MSG(msg) JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_([[nodiscard]]) -#elif defined(_Check_return_) /* SAL */ - #define JSON_HEDLEY_WARN_UNUSED_RESULT _Check_return_ - #define JSON_HEDLEY_WARN_UNUSED_RESULT_MSG(msg) _Check_return_ -#else - #define JSON_HEDLEY_WARN_UNUSED_RESULT - #define JSON_HEDLEY_WARN_UNUSED_RESULT_MSG(msg) -#endif - -#if defined(JSON_HEDLEY_SENTINEL) - #undef JSON_HEDLEY_SENTINEL -#endif -#if \ - JSON_HEDLEY_HAS_ATTRIBUTE(sentinel) || \ - JSON_HEDLEY_GCC_VERSION_CHECK(4,0,0) || \ - JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \ - JSON_HEDLEY_ARM_VERSION_CHECK(5,4,0) || \ - JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10) - #define JSON_HEDLEY_SENTINEL(position) __attribute__((__sentinel__(position))) -#else - #define JSON_HEDLEY_SENTINEL(position) -#endif - -#if defined(JSON_HEDLEY_NO_RETURN) - #undef JSON_HEDLEY_NO_RETURN -#endif -#if JSON_HEDLEY_IAR_VERSION_CHECK(8,0,0) - #define JSON_HEDLEY_NO_RETURN __noreturn -#elif \ - JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \ - JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10) - #define JSON_HEDLEY_NO_RETURN __attribute__((__noreturn__)) -#elif defined(__STDC_VERSION__) && __STDC_VERSION__ >= 201112L - #define JSON_HEDLEY_NO_RETURN _Noreturn -#elif defined(__cplusplus) && (__cplusplus >= 201103L) - #define JSON_HEDLEY_NO_RETURN JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_([[noreturn]]) -#elif \ - JSON_HEDLEY_HAS_ATTRIBUTE(noreturn) || \ - JSON_HEDLEY_GCC_VERSION_CHECK(3,2,0) || \ - JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,11,0) || \ - JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \ - JSON_HEDLEY_IBM_VERSION_CHECK(10,1,0) || \ - JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \ - (JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(4,8,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ - JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,2,0) || \ - (JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ - JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,4,0) || \ - (JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ - JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,3,0) || \ - (JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,2,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ - JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,5,0) || \ - JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \ - JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) || \ - JSON_HEDLEY_IAR_VERSION_CHECK(8,10,0) - #define JSON_HEDLEY_NO_RETURN __attribute__((__noreturn__)) -#elif JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,10,0) - #define JSON_HEDLEY_NO_RETURN _Pragma("does_not_return") -#elif \ - JSON_HEDLEY_MSVC_VERSION_CHECK(13,10,0) || \ - JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0) - #define JSON_HEDLEY_NO_RETURN __declspec(noreturn) -#elif JSON_HEDLEY_TI_CL6X_VERSION_CHECK(6,0,0) && defined(__cplusplus) - #define JSON_HEDLEY_NO_RETURN _Pragma("FUNC_NEVER_RETURNS;") -#elif JSON_HEDLEY_COMPCERT_VERSION_CHECK(3,2,0) - #define JSON_HEDLEY_NO_RETURN __attribute((noreturn)) -#elif JSON_HEDLEY_PELLES_VERSION_CHECK(9,0,0) - #define JSON_HEDLEY_NO_RETURN __declspec(noreturn) -#else - #define JSON_HEDLEY_NO_RETURN -#endif - -#if defined(JSON_HEDLEY_NO_ESCAPE) - #undef JSON_HEDLEY_NO_ESCAPE -#endif -#if JSON_HEDLEY_HAS_ATTRIBUTE(noescape) - #define JSON_HEDLEY_NO_ESCAPE __attribute__((__noescape__)) -#else - #define JSON_HEDLEY_NO_ESCAPE -#endif - -#if defined(JSON_HEDLEY_UNREACHABLE) - #undef JSON_HEDLEY_UNREACHABLE -#endif -#if defined(JSON_HEDLEY_UNREACHABLE_RETURN) - #undef JSON_HEDLEY_UNREACHABLE_RETURN -#endif -#if defined(JSON_HEDLEY_ASSUME) - #undef JSON_HEDLEY_ASSUME -#endif -#if \ - JSON_HEDLEY_MSVC_VERSION_CHECK(13,10,0) || \ - JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \ - JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0) - #define JSON_HEDLEY_ASSUME(expr) __assume(expr) -#elif JSON_HEDLEY_HAS_BUILTIN(__builtin_assume) - #define JSON_HEDLEY_ASSUME(expr) __builtin_assume(expr) -#elif \ - JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,2,0) || \ - JSON_HEDLEY_TI_CL6X_VERSION_CHECK(4,0,0) - #if defined(__cplusplus) - #define JSON_HEDLEY_ASSUME(expr) std::_nassert(expr) - #else - #define JSON_HEDLEY_ASSUME(expr) _nassert(expr) - #endif -#endif -#if \ - (JSON_HEDLEY_HAS_BUILTIN(__builtin_unreachable) && (!defined(JSON_HEDLEY_ARM_VERSION))) || \ - JSON_HEDLEY_GCC_VERSION_CHECK(4,5,0) || \ - JSON_HEDLEY_PGI_VERSION_CHECK(18,10,0) || \ - JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \ - JSON_HEDLEY_IBM_VERSION_CHECK(13,1,5) || \ - JSON_HEDLEY_CRAY_VERSION_CHECK(10,0,0) || \ - JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10) - #define JSON_HEDLEY_UNREACHABLE() __builtin_unreachable() -#elif defined(JSON_HEDLEY_ASSUME) - #define JSON_HEDLEY_UNREACHABLE() JSON_HEDLEY_ASSUME(0) -#endif -#if !defined(JSON_HEDLEY_ASSUME) - #if defined(JSON_HEDLEY_UNREACHABLE) - #define JSON_HEDLEY_ASSUME(expr) JSON_HEDLEY_STATIC_CAST(void, ((expr) ? 1 : (JSON_HEDLEY_UNREACHABLE(), 1))) - #else - #define JSON_HEDLEY_ASSUME(expr) JSON_HEDLEY_STATIC_CAST(void, expr) - #endif -#endif -#if defined(JSON_HEDLEY_UNREACHABLE) - #if \ - JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,2,0) || \ - JSON_HEDLEY_TI_CL6X_VERSION_CHECK(4,0,0) - #define JSON_HEDLEY_UNREACHABLE_RETURN(value) return (JSON_HEDLEY_STATIC_CAST(void, JSON_HEDLEY_ASSUME(0)), (value)) - #else - #define JSON_HEDLEY_UNREACHABLE_RETURN(value) JSON_HEDLEY_UNREACHABLE() - #endif -#else - #define JSON_HEDLEY_UNREACHABLE_RETURN(value) return (value) -#endif -#if !defined(JSON_HEDLEY_UNREACHABLE) - #define JSON_HEDLEY_UNREACHABLE() JSON_HEDLEY_ASSUME(0) -#endif - -JSON_HEDLEY_DIAGNOSTIC_PUSH -#if JSON_HEDLEY_HAS_WARNING("-Wpedantic") - #pragma clang diagnostic ignored "-Wpedantic" -#endif -#if JSON_HEDLEY_HAS_WARNING("-Wc++98-compat-pedantic") && defined(__cplusplus) - #pragma clang diagnostic ignored "-Wc++98-compat-pedantic" -#endif -#if JSON_HEDLEY_GCC_HAS_WARNING("-Wvariadic-macros",4,0,0) - #if defined(__clang__) - #pragma clang diagnostic ignored "-Wvariadic-macros" - #elif defined(JSON_HEDLEY_GCC_VERSION) - #pragma GCC diagnostic ignored "-Wvariadic-macros" - #endif -#endif -#if defined(JSON_HEDLEY_NON_NULL) - #undef JSON_HEDLEY_NON_NULL -#endif -#if \ - JSON_HEDLEY_HAS_ATTRIBUTE(nonnull) || \ - JSON_HEDLEY_GCC_VERSION_CHECK(3,3,0) || \ - JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \ - JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) - #define JSON_HEDLEY_NON_NULL(...) __attribute__((__nonnull__(__VA_ARGS__))) -#else - #define JSON_HEDLEY_NON_NULL(...) -#endif -JSON_HEDLEY_DIAGNOSTIC_POP - -#if defined(JSON_HEDLEY_PRINTF_FORMAT) - #undef JSON_HEDLEY_PRINTF_FORMAT -#endif -#if defined(__MINGW32__) && JSON_HEDLEY_GCC_HAS_ATTRIBUTE(format,4,4,0) && !defined(__USE_MINGW_ANSI_STDIO) - #define JSON_HEDLEY_PRINTF_FORMAT(string_idx,first_to_check) __attribute__((__format__(ms_printf, string_idx, first_to_check))) -#elif defined(__MINGW32__) && JSON_HEDLEY_GCC_HAS_ATTRIBUTE(format,4,4,0) && defined(__USE_MINGW_ANSI_STDIO) - #define JSON_HEDLEY_PRINTF_FORMAT(string_idx,first_to_check) __attribute__((__format__(gnu_printf, string_idx, first_to_check))) -#elif \ - JSON_HEDLEY_HAS_ATTRIBUTE(format) || \ - JSON_HEDLEY_GCC_VERSION_CHECK(3,1,0) || \ - JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \ - JSON_HEDLEY_ARM_VERSION_CHECK(5,6,0) || \ - JSON_HEDLEY_IBM_VERSION_CHECK(10,1,0) || \ - JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \ - (JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(4,8,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ - JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,2,0) || \ - (JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ - JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,4,0) || \ - (JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ - JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,3,0) || \ - (JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,2,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ - JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,5,0) || \ - JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \ - JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) || \ - JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10) - #define JSON_HEDLEY_PRINTF_FORMAT(string_idx,first_to_check) __attribute__((__format__(__printf__, string_idx, first_to_check))) -#elif JSON_HEDLEY_PELLES_VERSION_CHECK(6,0,0) - #define JSON_HEDLEY_PRINTF_FORMAT(string_idx,first_to_check) __declspec(vaformat(printf,string_idx,first_to_check)) -#else - #define JSON_HEDLEY_PRINTF_FORMAT(string_idx,first_to_check) -#endif - -#if defined(JSON_HEDLEY_CONSTEXPR) - #undef JSON_HEDLEY_CONSTEXPR -#endif -#if defined(__cplusplus) - #if __cplusplus >= 201103L - #define JSON_HEDLEY_CONSTEXPR JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_(constexpr) - #endif -#endif -#if !defined(JSON_HEDLEY_CONSTEXPR) - #define JSON_HEDLEY_CONSTEXPR -#endif - -#if defined(JSON_HEDLEY_PREDICT) - #undef JSON_HEDLEY_PREDICT -#endif -#if defined(JSON_HEDLEY_LIKELY) - #undef JSON_HEDLEY_LIKELY -#endif -#if defined(JSON_HEDLEY_UNLIKELY) - #undef JSON_HEDLEY_UNLIKELY -#endif -#if defined(JSON_HEDLEY_UNPREDICTABLE) - #undef JSON_HEDLEY_UNPREDICTABLE -#endif -#if JSON_HEDLEY_HAS_BUILTIN(__builtin_unpredictable) - #define JSON_HEDLEY_UNPREDICTABLE(expr) __builtin_unpredictable((expr)) -#endif -#if \ - (JSON_HEDLEY_HAS_BUILTIN(__builtin_expect_with_probability) && !defined(JSON_HEDLEY_PGI_VERSION)) || \ - JSON_HEDLEY_GCC_VERSION_CHECK(9,0,0) || \ - JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10) -# define JSON_HEDLEY_PREDICT(expr, value, probability) __builtin_expect_with_probability( (expr), (value), (probability)) -# define JSON_HEDLEY_PREDICT_TRUE(expr, probability) __builtin_expect_with_probability(!!(expr), 1 , (probability)) -# define JSON_HEDLEY_PREDICT_FALSE(expr, probability) __builtin_expect_with_probability(!!(expr), 0 , (probability)) -# define JSON_HEDLEY_LIKELY(expr) __builtin_expect (!!(expr), 1 ) -# define JSON_HEDLEY_UNLIKELY(expr) __builtin_expect (!!(expr), 0 ) -#elif \ - (JSON_HEDLEY_HAS_BUILTIN(__builtin_expect) && !defined(JSON_HEDLEY_INTEL_CL_VERSION)) || \ - JSON_HEDLEY_GCC_VERSION_CHECK(3,0,0) || \ - JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \ - (JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,15,0) && defined(__cplusplus)) || \ - JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \ - JSON_HEDLEY_IBM_VERSION_CHECK(10,1,0) || \ - JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \ - JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(4,7,0) || \ - JSON_HEDLEY_TI_CL430_VERSION_CHECK(3,1,0) || \ - JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,1,0) || \ - JSON_HEDLEY_TI_CL6X_VERSION_CHECK(6,1,0) || \ - JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \ - JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) || \ - JSON_HEDLEY_TINYC_VERSION_CHECK(0,9,27) || \ - JSON_HEDLEY_CRAY_VERSION_CHECK(8,1,0) || \ - JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10) -# define JSON_HEDLEY_PREDICT(expr, expected, probability) \ - (((probability) >= 0.9) ? __builtin_expect((expr), (expected)) : (JSON_HEDLEY_STATIC_CAST(void, expected), (expr))) -# define JSON_HEDLEY_PREDICT_TRUE(expr, probability) \ - (__extension__ ({ \ - double hedley_probability_ = (probability); \ - ((hedley_probability_ >= 0.9) ? __builtin_expect(!!(expr), 1) : ((hedley_probability_ <= 0.1) ? __builtin_expect(!!(expr), 0) : !!(expr))); \ - })) -# define JSON_HEDLEY_PREDICT_FALSE(expr, probability) \ - (__extension__ ({ \ - double hedley_probability_ = (probability); \ - ((hedley_probability_ >= 0.9) ? __builtin_expect(!!(expr), 0) : ((hedley_probability_ <= 0.1) ? __builtin_expect(!!(expr), 1) : !!(expr))); \ - })) -# define JSON_HEDLEY_LIKELY(expr) __builtin_expect(!!(expr), 1) -# define JSON_HEDLEY_UNLIKELY(expr) __builtin_expect(!!(expr), 0) -#else -# define JSON_HEDLEY_PREDICT(expr, expected, probability) (JSON_HEDLEY_STATIC_CAST(void, expected), (expr)) -# define JSON_HEDLEY_PREDICT_TRUE(expr, probability) (!!(expr)) -# define JSON_HEDLEY_PREDICT_FALSE(expr, probability) (!!(expr)) -# define JSON_HEDLEY_LIKELY(expr) (!!(expr)) -# define JSON_HEDLEY_UNLIKELY(expr) (!!(expr)) -#endif -#if !defined(JSON_HEDLEY_UNPREDICTABLE) - #define JSON_HEDLEY_UNPREDICTABLE(expr) JSON_HEDLEY_PREDICT(expr, 1, 0.5) -#endif - -#if defined(JSON_HEDLEY_MALLOC) - #undef JSON_HEDLEY_MALLOC -#endif -#if \ - JSON_HEDLEY_HAS_ATTRIBUTE(malloc) || \ - JSON_HEDLEY_GCC_VERSION_CHECK(3,1,0) || \ - JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \ - JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,11,0) || \ - JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \ - JSON_HEDLEY_IBM_VERSION_CHECK(12,1,0) || \ - JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \ - (JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(4,8,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ - JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,2,0) || \ - (JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ - JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,4,0) || \ - (JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ - JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,3,0) || \ - (JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,2,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ - JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,5,0) || \ - JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \ - JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) || \ - JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10) - #define JSON_HEDLEY_MALLOC __attribute__((__malloc__)) -#elif JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,10,0) - #define JSON_HEDLEY_MALLOC _Pragma("returns_new_memory") -#elif \ - JSON_HEDLEY_MSVC_VERSION_CHECK(14,0,0) || \ - JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0) - #define JSON_HEDLEY_MALLOC __declspec(restrict) -#else - #define JSON_HEDLEY_MALLOC -#endif - -#if defined(JSON_HEDLEY_PURE) - #undef JSON_HEDLEY_PURE -#endif -#if \ - JSON_HEDLEY_HAS_ATTRIBUTE(pure) || \ - JSON_HEDLEY_GCC_VERSION_CHECK(2,96,0) || \ - JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \ - JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,11,0) || \ - JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \ - JSON_HEDLEY_IBM_VERSION_CHECK(10,1,0) || \ - JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \ - (JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(4,8,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ - JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,2,0) || \ - (JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ - JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,4,0) || \ - (JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ - JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,3,0) || \ - (JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,2,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ - JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,5,0) || \ - JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \ - JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) || \ - JSON_HEDLEY_PGI_VERSION_CHECK(17,10,0) || \ - JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10) -# define JSON_HEDLEY_PURE __attribute__((__pure__)) -#elif JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,10,0) -# define JSON_HEDLEY_PURE _Pragma("does_not_write_global_data") -#elif defined(__cplusplus) && \ - ( \ - JSON_HEDLEY_TI_CL430_VERSION_CHECK(2,0,1) || \ - JSON_HEDLEY_TI_CL6X_VERSION_CHECK(4,0,0) || \ - JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) \ - ) -# define JSON_HEDLEY_PURE _Pragma("FUNC_IS_PURE;") -#else -# define JSON_HEDLEY_PURE -#endif - -#if defined(JSON_HEDLEY_CONST) - #undef JSON_HEDLEY_CONST -#endif -#if \ - JSON_HEDLEY_HAS_ATTRIBUTE(const) || \ - JSON_HEDLEY_GCC_VERSION_CHECK(2,5,0) || \ - JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \ - JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,11,0) || \ - JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \ - JSON_HEDLEY_IBM_VERSION_CHECK(10,1,0) || \ - JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \ - (JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(4,8,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ - JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,2,0) || \ - (JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ - JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,4,0) || \ - (JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ - JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,3,0) || \ - (JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,2,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ - JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,5,0) || \ - JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \ - JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) || \ - JSON_HEDLEY_PGI_VERSION_CHECK(17,10,0) || \ - JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10) - #define JSON_HEDLEY_CONST __attribute__((__const__)) -#elif \ - JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,10,0) - #define JSON_HEDLEY_CONST _Pragma("no_side_effect") -#else - #define JSON_HEDLEY_CONST JSON_HEDLEY_PURE -#endif - -#if defined(JSON_HEDLEY_RESTRICT) - #undef JSON_HEDLEY_RESTRICT -#endif -#if defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L) && !defined(__cplusplus) - #define JSON_HEDLEY_RESTRICT restrict -#elif \ - JSON_HEDLEY_GCC_VERSION_CHECK(3,1,0) || \ - JSON_HEDLEY_MSVC_VERSION_CHECK(14,0,0) || \ - JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \ - JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0) || \ - JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \ - JSON_HEDLEY_IBM_VERSION_CHECK(10,1,0) || \ - JSON_HEDLEY_PGI_VERSION_CHECK(17,10,0) || \ - JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,3,0) || \ - JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,2,4) || \ - JSON_HEDLEY_TI_CL6X_VERSION_CHECK(8,1,0) || \ - JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \ - (JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,14,0) && defined(__cplusplus)) || \ - JSON_HEDLEY_IAR_VERSION_CHECK(8,0,0) || \ - defined(__clang__) || \ - JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10) - #define JSON_HEDLEY_RESTRICT __restrict -#elif JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,3,0) && !defined(__cplusplus) - #define JSON_HEDLEY_RESTRICT _Restrict -#else - #define JSON_HEDLEY_RESTRICT -#endif - -#if defined(JSON_HEDLEY_INLINE) - #undef JSON_HEDLEY_INLINE -#endif -#if \ - (defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L)) || \ - (defined(__cplusplus) && (__cplusplus >= 199711L)) - #define JSON_HEDLEY_INLINE inline -#elif \ - defined(JSON_HEDLEY_GCC_VERSION) || \ - JSON_HEDLEY_ARM_VERSION_CHECK(6,2,0) - #define JSON_HEDLEY_INLINE __inline__ -#elif \ - JSON_HEDLEY_MSVC_VERSION_CHECK(12,0,0) || \ - JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0) || \ - JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \ - JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,1,0) || \ - JSON_HEDLEY_TI_CL430_VERSION_CHECK(3,1,0) || \ - JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,2,0) || \ - JSON_HEDLEY_TI_CL6X_VERSION_CHECK(8,0,0) || \ - JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \ - JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) || \ - JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10) - #define JSON_HEDLEY_INLINE __inline -#else - #define JSON_HEDLEY_INLINE -#endif - -#if defined(JSON_HEDLEY_ALWAYS_INLINE) - #undef JSON_HEDLEY_ALWAYS_INLINE -#endif -#if \ - JSON_HEDLEY_HAS_ATTRIBUTE(always_inline) || \ - JSON_HEDLEY_GCC_VERSION_CHECK(4,0,0) || \ - JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \ - JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,11,0) || \ - JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \ - JSON_HEDLEY_IBM_VERSION_CHECK(10,1,0) || \ - JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \ - (JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(4,8,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ - JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,2,0) || \ - (JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ - JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,4,0) || \ - (JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ - JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,3,0) || \ - (JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,2,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ - JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,5,0) || \ - JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \ - JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) || \ - JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10) || \ - JSON_HEDLEY_IAR_VERSION_CHECK(8,10,0) -# define JSON_HEDLEY_ALWAYS_INLINE __attribute__((__always_inline__)) JSON_HEDLEY_INLINE -#elif \ - JSON_HEDLEY_MSVC_VERSION_CHECK(12,0,0) || \ - JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0) -# define JSON_HEDLEY_ALWAYS_INLINE __forceinline -#elif defined(__cplusplus) && \ - ( \ - JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,2,0) || \ - JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,3,0) || \ - JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,4,0) || \ - JSON_HEDLEY_TI_CL6X_VERSION_CHECK(6,1,0) || \ - JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \ - JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) \ - ) -# define JSON_HEDLEY_ALWAYS_INLINE _Pragma("FUNC_ALWAYS_INLINE;") -#elif JSON_HEDLEY_IAR_VERSION_CHECK(8,0,0) -# define JSON_HEDLEY_ALWAYS_INLINE _Pragma("inline=forced") -#else -# define JSON_HEDLEY_ALWAYS_INLINE JSON_HEDLEY_INLINE -#endif - -#if defined(JSON_HEDLEY_NEVER_INLINE) - #undef JSON_HEDLEY_NEVER_INLINE -#endif -#if \ - JSON_HEDLEY_HAS_ATTRIBUTE(noinline) || \ - JSON_HEDLEY_GCC_VERSION_CHECK(4,0,0) || \ - JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \ - JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,11,0) || \ - JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \ - JSON_HEDLEY_IBM_VERSION_CHECK(10,1,0) || \ - JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \ - (JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(4,8,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ - JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,2,0) || \ - (JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ - JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,4,0) || \ - (JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ - JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,3,0) || \ - (JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,2,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ - JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,5,0) || \ - JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \ - JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) || \ - JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10) || \ - JSON_HEDLEY_IAR_VERSION_CHECK(8,10,0) - #define JSON_HEDLEY_NEVER_INLINE __attribute__((__noinline__)) -#elif \ - JSON_HEDLEY_MSVC_VERSION_CHECK(13,10,0) || \ - JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0) - #define JSON_HEDLEY_NEVER_INLINE __declspec(noinline) -#elif JSON_HEDLEY_PGI_VERSION_CHECK(10,2,0) - #define JSON_HEDLEY_NEVER_INLINE _Pragma("noinline") -#elif JSON_HEDLEY_TI_CL6X_VERSION_CHECK(6,0,0) && defined(__cplusplus) - #define JSON_HEDLEY_NEVER_INLINE _Pragma("FUNC_CANNOT_INLINE;") -#elif JSON_HEDLEY_IAR_VERSION_CHECK(8,0,0) - #define JSON_HEDLEY_NEVER_INLINE _Pragma("inline=never") -#elif JSON_HEDLEY_COMPCERT_VERSION_CHECK(3,2,0) - #define JSON_HEDLEY_NEVER_INLINE __attribute((noinline)) -#elif JSON_HEDLEY_PELLES_VERSION_CHECK(9,0,0) - #define JSON_HEDLEY_NEVER_INLINE __declspec(noinline) -#else - #define JSON_HEDLEY_NEVER_INLINE -#endif - -#if defined(JSON_HEDLEY_PRIVATE) - #undef JSON_HEDLEY_PRIVATE -#endif -#if defined(JSON_HEDLEY_PUBLIC) - #undef JSON_HEDLEY_PUBLIC -#endif -#if defined(JSON_HEDLEY_IMPORT) - #undef JSON_HEDLEY_IMPORT -#endif -#if defined(_WIN32) || defined(__CYGWIN__) -# define JSON_HEDLEY_PRIVATE -# define JSON_HEDLEY_PUBLIC __declspec(dllexport) -# define JSON_HEDLEY_IMPORT __declspec(dllimport) -#else -# if \ - JSON_HEDLEY_HAS_ATTRIBUTE(visibility) || \ - JSON_HEDLEY_GCC_VERSION_CHECK(3,3,0) || \ - JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,11,0) || \ - JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \ - JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \ - JSON_HEDLEY_IBM_VERSION_CHECK(13,1,0) || \ - ( \ - defined(__TI_EABI__) && \ - ( \ - (JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,2,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ - JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,5,0) \ - ) \ - ) || \ - JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10) -# define JSON_HEDLEY_PRIVATE __attribute__((__visibility__("hidden"))) -# define JSON_HEDLEY_PUBLIC __attribute__((__visibility__("default"))) -# else -# define JSON_HEDLEY_PRIVATE -# define JSON_HEDLEY_PUBLIC -# endif -# define JSON_HEDLEY_IMPORT extern -#endif - -#if defined(JSON_HEDLEY_NO_THROW) - #undef JSON_HEDLEY_NO_THROW -#endif -#if \ - JSON_HEDLEY_HAS_ATTRIBUTE(nothrow) || \ - JSON_HEDLEY_GCC_VERSION_CHECK(3,3,0) || \ - JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \ - JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10) - #define JSON_HEDLEY_NO_THROW __attribute__((__nothrow__)) -#elif \ - JSON_HEDLEY_MSVC_VERSION_CHECK(13,1,0) || \ - JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0) || \ - JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) - #define JSON_HEDLEY_NO_THROW __declspec(nothrow) -#else - #define JSON_HEDLEY_NO_THROW -#endif - -#if defined(JSON_HEDLEY_FALL_THROUGH) - #undef JSON_HEDLEY_FALL_THROUGH -#endif -#if \ - JSON_HEDLEY_HAS_ATTRIBUTE(fallthrough) || \ - JSON_HEDLEY_GCC_VERSION_CHECK(7,0,0) || \ - JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10) - #define JSON_HEDLEY_FALL_THROUGH __attribute__((__fallthrough__)) -#elif JSON_HEDLEY_HAS_CPP_ATTRIBUTE_NS(clang,fallthrough) - #define JSON_HEDLEY_FALL_THROUGH JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_([[clang::fallthrough]]) -#elif JSON_HEDLEY_HAS_CPP_ATTRIBUTE(fallthrough) - #define JSON_HEDLEY_FALL_THROUGH JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_([[fallthrough]]) -#elif defined(__fallthrough) /* SAL */ - #define JSON_HEDLEY_FALL_THROUGH __fallthrough -#else - #define JSON_HEDLEY_FALL_THROUGH -#endif - -#if defined(JSON_HEDLEY_RETURNS_NON_NULL) - #undef JSON_HEDLEY_RETURNS_NON_NULL -#endif -#if \ - JSON_HEDLEY_HAS_ATTRIBUTE(returns_nonnull) || \ - JSON_HEDLEY_GCC_VERSION_CHECK(4,9,0) || \ - JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10) - #define JSON_HEDLEY_RETURNS_NON_NULL __attribute__((__returns_nonnull__)) -#elif defined(_Ret_notnull_) /* SAL */ - #define JSON_HEDLEY_RETURNS_NON_NULL _Ret_notnull_ -#else - #define JSON_HEDLEY_RETURNS_NON_NULL -#endif - -#if defined(JSON_HEDLEY_ARRAY_PARAM) - #undef JSON_HEDLEY_ARRAY_PARAM -#endif -#if \ - defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L) && \ - !defined(__STDC_NO_VLA__) && \ - !defined(__cplusplus) && \ - !defined(JSON_HEDLEY_PGI_VERSION) && \ - !defined(JSON_HEDLEY_TINYC_VERSION) - #define JSON_HEDLEY_ARRAY_PARAM(name) (name) -#else - #define JSON_HEDLEY_ARRAY_PARAM(name) -#endif - -#if defined(JSON_HEDLEY_IS_CONSTANT) - #undef JSON_HEDLEY_IS_CONSTANT -#endif -#if defined(JSON_HEDLEY_REQUIRE_CONSTEXPR) - #undef JSON_HEDLEY_REQUIRE_CONSTEXPR -#endif -/* JSON_HEDLEY_IS_CONSTEXPR_ is for - HEDLEY INTERNAL USE ONLY. API subject to change without notice. */ -#if defined(JSON_HEDLEY_IS_CONSTEXPR_) - #undef JSON_HEDLEY_IS_CONSTEXPR_ -#endif -#if \ - JSON_HEDLEY_HAS_BUILTIN(__builtin_constant_p) || \ - JSON_HEDLEY_GCC_VERSION_CHECK(3,4,0) || \ - JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \ - JSON_HEDLEY_TINYC_VERSION_CHECK(0,9,19) || \ - JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \ - JSON_HEDLEY_IBM_VERSION_CHECK(13,1,0) || \ - JSON_HEDLEY_TI_CL6X_VERSION_CHECK(6,1,0) || \ - (JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,10,0) && !defined(__cplusplus)) || \ - JSON_HEDLEY_CRAY_VERSION_CHECK(8,1,0) || \ - JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10) - #define JSON_HEDLEY_IS_CONSTANT(expr) __builtin_constant_p(expr) -#endif -#if !defined(__cplusplus) -# if \ - JSON_HEDLEY_HAS_BUILTIN(__builtin_types_compatible_p) || \ - JSON_HEDLEY_GCC_VERSION_CHECK(3,4,0) || \ - JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \ - JSON_HEDLEY_IBM_VERSION_CHECK(13,1,0) || \ - JSON_HEDLEY_CRAY_VERSION_CHECK(8,1,0) || \ - JSON_HEDLEY_ARM_VERSION_CHECK(5,4,0) || \ - JSON_HEDLEY_TINYC_VERSION_CHECK(0,9,24) -#if defined(__INTPTR_TYPE__) - #define JSON_HEDLEY_IS_CONSTEXPR_(expr) __builtin_types_compatible_p(__typeof__((1 ? (void*) ((__INTPTR_TYPE__) ((expr) * 0)) : (int*) 0)), int*) -#else - #include - #define JSON_HEDLEY_IS_CONSTEXPR_(expr) __builtin_types_compatible_p(__typeof__((1 ? (void*) ((intptr_t) ((expr) * 0)) : (int*) 0)), int*) -#endif -# elif \ - ( \ - defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 201112L) && \ - !defined(JSON_HEDLEY_SUNPRO_VERSION) && \ - !defined(JSON_HEDLEY_PGI_VERSION) && \ - !defined(JSON_HEDLEY_IAR_VERSION)) || \ - (JSON_HEDLEY_HAS_EXTENSION(c_generic_selections) && !defined(JSON_HEDLEY_IAR_VERSION)) || \ - JSON_HEDLEY_GCC_VERSION_CHECK(4,9,0) || \ - JSON_HEDLEY_INTEL_VERSION_CHECK(17,0,0) || \ - JSON_HEDLEY_IBM_VERSION_CHECK(12,1,0) || \ - JSON_HEDLEY_ARM_VERSION_CHECK(5,3,0) -#if defined(__INTPTR_TYPE__) - #define JSON_HEDLEY_IS_CONSTEXPR_(expr) _Generic((1 ? (void*) ((__INTPTR_TYPE__) ((expr) * 0)) : (int*) 0), int*: 1, void*: 0) -#else - #include - #define JSON_HEDLEY_IS_CONSTEXPR_(expr) _Generic((1 ? (void*) ((intptr_t) * 0) : (int*) 0), int*: 1, void*: 0) -#endif -# elif \ - defined(JSON_HEDLEY_GCC_VERSION) || \ - defined(JSON_HEDLEY_INTEL_VERSION) || \ - defined(JSON_HEDLEY_TINYC_VERSION) || \ - defined(JSON_HEDLEY_TI_ARMCL_VERSION) || \ - JSON_HEDLEY_TI_CL430_VERSION_CHECK(18,12,0) || \ - defined(JSON_HEDLEY_TI_CL2000_VERSION) || \ - defined(JSON_HEDLEY_TI_CL6X_VERSION) || \ - defined(JSON_HEDLEY_TI_CL7X_VERSION) || \ - defined(JSON_HEDLEY_TI_CLPRU_VERSION) || \ - defined(__clang__) -# define JSON_HEDLEY_IS_CONSTEXPR_(expr) ( \ - sizeof(void) != \ - sizeof(*( \ - 1 ? \ - ((void*) ((expr) * 0L) ) : \ -((struct { char v[sizeof(void) * 2]; } *) 1) \ - ) \ - ) \ - ) -# endif -#endif -#if defined(JSON_HEDLEY_IS_CONSTEXPR_) - #if !defined(JSON_HEDLEY_IS_CONSTANT) - #define JSON_HEDLEY_IS_CONSTANT(expr) JSON_HEDLEY_IS_CONSTEXPR_(expr) - #endif - #define JSON_HEDLEY_REQUIRE_CONSTEXPR(expr) (JSON_HEDLEY_IS_CONSTEXPR_(expr) ? (expr) : (-1)) -#else - #if !defined(JSON_HEDLEY_IS_CONSTANT) - #define JSON_HEDLEY_IS_CONSTANT(expr) (0) - #endif - #define JSON_HEDLEY_REQUIRE_CONSTEXPR(expr) (expr) -#endif - -#if defined(JSON_HEDLEY_BEGIN_C_DECLS) - #undef JSON_HEDLEY_BEGIN_C_DECLS -#endif -#if defined(JSON_HEDLEY_END_C_DECLS) - #undef JSON_HEDLEY_END_C_DECLS -#endif -#if defined(JSON_HEDLEY_C_DECL) - #undef JSON_HEDLEY_C_DECL -#endif -#if defined(__cplusplus) - #define JSON_HEDLEY_BEGIN_C_DECLS extern "C" { - #define JSON_HEDLEY_END_C_DECLS } - #define JSON_HEDLEY_C_DECL extern "C" -#else - #define JSON_HEDLEY_BEGIN_C_DECLS - #define JSON_HEDLEY_END_C_DECLS - #define JSON_HEDLEY_C_DECL -#endif - -#if defined(JSON_HEDLEY_STATIC_ASSERT) - #undef JSON_HEDLEY_STATIC_ASSERT -#endif -#if \ - !defined(__cplusplus) && ( \ - (defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 201112L)) || \ - (JSON_HEDLEY_HAS_FEATURE(c_static_assert) && !defined(JSON_HEDLEY_INTEL_CL_VERSION)) || \ - JSON_HEDLEY_GCC_VERSION_CHECK(6,0,0) || \ - JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \ - defined(_Static_assert) \ - ) -# define JSON_HEDLEY_STATIC_ASSERT(expr, message) _Static_assert(expr, message) -#elif \ - (defined(__cplusplus) && (__cplusplus >= 201103L)) || \ - JSON_HEDLEY_MSVC_VERSION_CHECK(16,0,0) || \ - JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0) -# define JSON_HEDLEY_STATIC_ASSERT(expr, message) JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_(static_assert(expr, message)) -#else -# define JSON_HEDLEY_STATIC_ASSERT(expr, message) -#endif - -#if defined(JSON_HEDLEY_NULL) - #undef JSON_HEDLEY_NULL -#endif -#if defined(__cplusplus) - #if __cplusplus >= 201103L - #define JSON_HEDLEY_NULL JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_(nullptr) - #elif defined(NULL) - #define JSON_HEDLEY_NULL NULL - #else - #define JSON_HEDLEY_NULL JSON_HEDLEY_STATIC_CAST(void*, 0) - #endif -#elif defined(NULL) - #define JSON_HEDLEY_NULL NULL -#else - #define JSON_HEDLEY_NULL ((void*) 0) -#endif - -#if defined(JSON_HEDLEY_MESSAGE) - #undef JSON_HEDLEY_MESSAGE -#endif -#if JSON_HEDLEY_HAS_WARNING("-Wunknown-pragmas") -# define JSON_HEDLEY_MESSAGE(msg) \ - JSON_HEDLEY_DIAGNOSTIC_PUSH \ - JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS \ - JSON_HEDLEY_PRAGMA(message msg) \ - JSON_HEDLEY_DIAGNOSTIC_POP -#elif \ - JSON_HEDLEY_GCC_VERSION_CHECK(4,4,0) || \ - JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) -# define JSON_HEDLEY_MESSAGE(msg) JSON_HEDLEY_PRAGMA(message msg) -#elif JSON_HEDLEY_CRAY_VERSION_CHECK(5,0,0) -# define JSON_HEDLEY_MESSAGE(msg) JSON_HEDLEY_PRAGMA(_CRI message msg) -#elif JSON_HEDLEY_IAR_VERSION_CHECK(8,0,0) -# define JSON_HEDLEY_MESSAGE(msg) JSON_HEDLEY_PRAGMA(message(msg)) -#elif JSON_HEDLEY_PELLES_VERSION_CHECK(2,0,0) -# define JSON_HEDLEY_MESSAGE(msg) JSON_HEDLEY_PRAGMA(message(msg)) -#else -# define JSON_HEDLEY_MESSAGE(msg) -#endif - -#if defined(JSON_HEDLEY_WARNING) - #undef JSON_HEDLEY_WARNING -#endif -#if JSON_HEDLEY_HAS_WARNING("-Wunknown-pragmas") -# define JSON_HEDLEY_WARNING(msg) \ - JSON_HEDLEY_DIAGNOSTIC_PUSH \ - JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS \ - JSON_HEDLEY_PRAGMA(clang warning msg) \ - JSON_HEDLEY_DIAGNOSTIC_POP -#elif \ - JSON_HEDLEY_GCC_VERSION_CHECK(4,8,0) || \ - JSON_HEDLEY_PGI_VERSION_CHECK(18,4,0) || \ - JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) -# define JSON_HEDLEY_WARNING(msg) JSON_HEDLEY_PRAGMA(GCC warning msg) -#elif \ - JSON_HEDLEY_MSVC_VERSION_CHECK(15,0,0) || \ - JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0) -# define JSON_HEDLEY_WARNING(msg) JSON_HEDLEY_PRAGMA(message(msg)) -#else -# define JSON_HEDLEY_WARNING(msg) JSON_HEDLEY_MESSAGE(msg) -#endif - -#if defined(JSON_HEDLEY_REQUIRE) - #undef JSON_HEDLEY_REQUIRE -#endif -#if defined(JSON_HEDLEY_REQUIRE_MSG) - #undef JSON_HEDLEY_REQUIRE_MSG -#endif -#if JSON_HEDLEY_HAS_ATTRIBUTE(diagnose_if) -# if JSON_HEDLEY_HAS_WARNING("-Wgcc-compat") -# define JSON_HEDLEY_REQUIRE(expr) \ - JSON_HEDLEY_DIAGNOSTIC_PUSH \ - _Pragma("clang diagnostic ignored \"-Wgcc-compat\"") \ - __attribute__((diagnose_if(!(expr), #expr, "error"))) \ - JSON_HEDLEY_DIAGNOSTIC_POP -# define JSON_HEDLEY_REQUIRE_MSG(expr,msg) \ - JSON_HEDLEY_DIAGNOSTIC_PUSH \ - _Pragma("clang diagnostic ignored \"-Wgcc-compat\"") \ - __attribute__((diagnose_if(!(expr), msg, "error"))) \ - JSON_HEDLEY_DIAGNOSTIC_POP -# else -# define JSON_HEDLEY_REQUIRE(expr) __attribute__((diagnose_if(!(expr), #expr, "error"))) -# define JSON_HEDLEY_REQUIRE_MSG(expr,msg) __attribute__((diagnose_if(!(expr), msg, "error"))) -# endif -#else -# define JSON_HEDLEY_REQUIRE(expr) -# define JSON_HEDLEY_REQUIRE_MSG(expr,msg) -#endif - -#if defined(JSON_HEDLEY_FLAGS) - #undef JSON_HEDLEY_FLAGS -#endif -#if JSON_HEDLEY_HAS_ATTRIBUTE(flag_enum) && (!defined(__cplusplus) || JSON_HEDLEY_HAS_WARNING("-Wbitfield-enum-conversion")) - #define JSON_HEDLEY_FLAGS __attribute__((__flag_enum__)) -#else - #define JSON_HEDLEY_FLAGS -#endif - -#if defined(JSON_HEDLEY_FLAGS_CAST) - #undef JSON_HEDLEY_FLAGS_CAST -#endif -#if JSON_HEDLEY_INTEL_VERSION_CHECK(19,0,0) -# define JSON_HEDLEY_FLAGS_CAST(T, expr) (__extension__ ({ \ - JSON_HEDLEY_DIAGNOSTIC_PUSH \ - _Pragma("warning(disable:188)") \ - ((T) (expr)); \ - JSON_HEDLEY_DIAGNOSTIC_POP \ - })) -#else -# define JSON_HEDLEY_FLAGS_CAST(T, expr) JSON_HEDLEY_STATIC_CAST(T, expr) -#endif - -#if defined(JSON_HEDLEY_EMPTY_BASES) - #undef JSON_HEDLEY_EMPTY_BASES -#endif -#if \ - (JSON_HEDLEY_MSVC_VERSION_CHECK(19,0,23918) && !JSON_HEDLEY_MSVC_VERSION_CHECK(20,0,0)) || \ - JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0) - #define JSON_HEDLEY_EMPTY_BASES __declspec(empty_bases) -#else - #define JSON_HEDLEY_EMPTY_BASES -#endif - -/* Remaining macros are deprecated. */ - -#if defined(JSON_HEDLEY_GCC_NOT_CLANG_VERSION_CHECK) - #undef JSON_HEDLEY_GCC_NOT_CLANG_VERSION_CHECK -#endif -#if defined(__clang__) - #define JSON_HEDLEY_GCC_NOT_CLANG_VERSION_CHECK(major,minor,patch) (0) -#else - #define JSON_HEDLEY_GCC_NOT_CLANG_VERSION_CHECK(major,minor,patch) JSON_HEDLEY_GCC_VERSION_CHECK(major,minor,patch) -#endif - -#if defined(JSON_HEDLEY_CLANG_HAS_ATTRIBUTE) - #undef JSON_HEDLEY_CLANG_HAS_ATTRIBUTE -#endif -#define JSON_HEDLEY_CLANG_HAS_ATTRIBUTE(attribute) JSON_HEDLEY_HAS_ATTRIBUTE(attribute) - -#if defined(JSON_HEDLEY_CLANG_HAS_CPP_ATTRIBUTE) - #undef JSON_HEDLEY_CLANG_HAS_CPP_ATTRIBUTE -#endif -#define JSON_HEDLEY_CLANG_HAS_CPP_ATTRIBUTE(attribute) JSON_HEDLEY_HAS_CPP_ATTRIBUTE(attribute) - -#if defined(JSON_HEDLEY_CLANG_HAS_BUILTIN) - #undef JSON_HEDLEY_CLANG_HAS_BUILTIN -#endif -#define JSON_HEDLEY_CLANG_HAS_BUILTIN(builtin) JSON_HEDLEY_HAS_BUILTIN(builtin) - -#if defined(JSON_HEDLEY_CLANG_HAS_FEATURE) - #undef JSON_HEDLEY_CLANG_HAS_FEATURE -#endif -#define JSON_HEDLEY_CLANG_HAS_FEATURE(feature) JSON_HEDLEY_HAS_FEATURE(feature) - -#if defined(JSON_HEDLEY_CLANG_HAS_EXTENSION) - #undef JSON_HEDLEY_CLANG_HAS_EXTENSION -#endif -#define JSON_HEDLEY_CLANG_HAS_EXTENSION(extension) JSON_HEDLEY_HAS_EXTENSION(extension) - -#if defined(JSON_HEDLEY_CLANG_HAS_DECLSPEC_DECLSPEC_ATTRIBUTE) - #undef JSON_HEDLEY_CLANG_HAS_DECLSPEC_DECLSPEC_ATTRIBUTE -#endif -#define JSON_HEDLEY_CLANG_HAS_DECLSPEC_ATTRIBUTE(attribute) JSON_HEDLEY_HAS_DECLSPEC_ATTRIBUTE(attribute) - -#if defined(JSON_HEDLEY_CLANG_HAS_WARNING) - #undef JSON_HEDLEY_CLANG_HAS_WARNING -#endif -#define JSON_HEDLEY_CLANG_HAS_WARNING(warning) JSON_HEDLEY_HAS_WARNING(warning) - -#endif /* !defined(JSON_HEDLEY_VERSION) || (JSON_HEDLEY_VERSION < X) */ - - -// This file contains all internal macro definitions (except those affecting ABI) -// You MUST include macro_unscope.hpp at the end of json.hpp to undef all of them - -// #include - - -// exclude unsupported compilers -#if !defined(JSON_SKIP_UNSUPPORTED_COMPILER_CHECK) - #if defined(__clang__) - #if (__clang_major__ * 10000 + __clang_minor__ * 100 + __clang_patchlevel__) < 30400 - #error "unsupported Clang version - see https://github.com/nlohmann/json#supported-compilers" - #endif - #elif defined(__GNUC__) && !(defined(__ICC) || defined(__INTEL_COMPILER)) - #if (__GNUC__ * 10000 + __GNUC_MINOR__ * 100 + __GNUC_PATCHLEVEL__) < 40800 - #error "unsupported GCC version - see https://github.com/nlohmann/json#supported-compilers" - #endif - #endif -#endif - -// C++ language standard detection -// if the user manually specified the used c++ version this is skipped -#if !defined(JSON_HAS_CPP_20) && !defined(JSON_HAS_CPP_17) && !defined(JSON_HAS_CPP_14) && !defined(JSON_HAS_CPP_11) - #if (defined(__cplusplus) && __cplusplus >= 202002L) || (defined(_MSVC_LANG) && _MSVC_LANG >= 202002L) - #define JSON_HAS_CPP_20 - #define JSON_HAS_CPP_17 - #define JSON_HAS_CPP_14 - #elif (defined(__cplusplus) && __cplusplus >= 201703L) || (defined(_HAS_CXX17) && _HAS_CXX17 == 1) // fix for issue #464 - #define JSON_HAS_CPP_17 - #define JSON_HAS_CPP_14 - #elif (defined(__cplusplus) && __cplusplus >= 201402L) || (defined(_HAS_CXX14) && _HAS_CXX14 == 1) - #define JSON_HAS_CPP_14 - #endif - // the cpp 11 flag is always specified because it is the minimal required version - #define JSON_HAS_CPP_11 -#endif - -#ifdef __has_include - #if __has_include() - #include - #endif -#endif - -#if !defined(JSON_HAS_FILESYSTEM) && !defined(JSON_HAS_EXPERIMENTAL_FILESYSTEM) - #ifdef JSON_HAS_CPP_17 - #if defined(__cpp_lib_filesystem) - #define JSON_HAS_FILESYSTEM 1 - #elif defined(__cpp_lib_experimental_filesystem) - #define JSON_HAS_EXPERIMENTAL_FILESYSTEM 1 - #elif !defined(__has_include) - #define JSON_HAS_EXPERIMENTAL_FILESYSTEM 1 - #elif __has_include() - #define JSON_HAS_FILESYSTEM 1 - #elif __has_include() - #define JSON_HAS_EXPERIMENTAL_FILESYSTEM 1 - #endif - - // std::filesystem does not work on MinGW GCC 8: https://sourceforge.net/p/mingw-w64/bugs/737/ - #if defined(__MINGW32__) && defined(__GNUC__) && __GNUC__ == 8 - #undef JSON_HAS_FILESYSTEM - #undef JSON_HAS_EXPERIMENTAL_FILESYSTEM - #endif - - // no filesystem support before GCC 8: https://en.cppreference.com/w/cpp/compiler_support - #if defined(__GNUC__) && !defined(__clang__) && __GNUC__ < 8 - #undef JSON_HAS_FILESYSTEM - #undef JSON_HAS_EXPERIMENTAL_FILESYSTEM - #endif - - // no filesystem support before Clang 7: https://en.cppreference.com/w/cpp/compiler_support - #if defined(__clang_major__) && __clang_major__ < 7 - #undef JSON_HAS_FILESYSTEM - #undef JSON_HAS_EXPERIMENTAL_FILESYSTEM - #endif - - // no filesystem support before MSVC 19.14: https://en.cppreference.com/w/cpp/compiler_support - #if defined(_MSC_VER) && _MSC_VER < 1914 - #undef JSON_HAS_FILESYSTEM - #undef JSON_HAS_EXPERIMENTAL_FILESYSTEM - #endif - - // no filesystem support before iOS 13 - #if defined(__IPHONE_OS_VERSION_MIN_REQUIRED) && __IPHONE_OS_VERSION_MIN_REQUIRED < 130000 - #undef JSON_HAS_FILESYSTEM - #undef JSON_HAS_EXPERIMENTAL_FILESYSTEM - #endif - - // no filesystem support before macOS Catalina - #if defined(__MAC_OS_X_VERSION_MIN_REQUIRED) && __MAC_OS_X_VERSION_MIN_REQUIRED < 101500 - #undef JSON_HAS_FILESYSTEM - #undef JSON_HAS_EXPERIMENTAL_FILESYSTEM - #endif - #endif -#endif - -#ifndef JSON_HAS_EXPERIMENTAL_FILESYSTEM - #define JSON_HAS_EXPERIMENTAL_FILESYSTEM 0 -#endif - -#ifndef JSON_HAS_FILESYSTEM - #define JSON_HAS_FILESYSTEM 0 -#endif - -#ifndef JSON_HAS_THREE_WAY_COMPARISON - #if defined(__cpp_impl_three_way_comparison) && __cpp_impl_three_way_comparison >= 201907L \ - && defined(__cpp_lib_three_way_comparison) && __cpp_lib_three_way_comparison >= 201907L - #define JSON_HAS_THREE_WAY_COMPARISON 1 - #else - #define JSON_HAS_THREE_WAY_COMPARISON 0 - #endif -#endif - -#ifndef JSON_HAS_RANGES - // ranges header shipping in GCC 11.1.0 (released 2021-04-27) has syntax error - #if defined(__GLIBCXX__) && __GLIBCXX__ == 20210427 - #define JSON_HAS_RANGES 0 - #elif defined(__cpp_lib_ranges) - #define JSON_HAS_RANGES 1 - #else - #define JSON_HAS_RANGES 0 - #endif -#endif - -#ifndef JSON_HAS_STATIC_RTTI - #if !defined(_HAS_STATIC_RTTI) || _HAS_STATIC_RTTI != 0 - #define JSON_HAS_STATIC_RTTI 1 - #else - #define JSON_HAS_STATIC_RTTI 0 - #endif -#endif - -#ifdef JSON_HAS_CPP_17 - #define JSON_INLINE_VARIABLE inline -#else - #define JSON_INLINE_VARIABLE -#endif - -#if JSON_HEDLEY_HAS_ATTRIBUTE(no_unique_address) - #define JSON_NO_UNIQUE_ADDRESS [[no_unique_address]] -#else - #define JSON_NO_UNIQUE_ADDRESS -#endif - -// disable documentation warnings on clang -#if defined(__clang__) - #pragma clang diagnostic push - #pragma clang diagnostic ignored "-Wdocumentation" - #pragma clang diagnostic ignored "-Wdocumentation-unknown-command" -#endif - -// allow disabling exceptions -#if (defined(__cpp_exceptions) || defined(__EXCEPTIONS) || defined(_CPPUNWIND)) && !defined(JSON_NOEXCEPTION) - #define JSON_THROW(exception) throw exception - #define JSON_TRY try - #define JSON_CATCH(exception) catch(exception) - #define JSON_INTERNAL_CATCH(exception) catch(exception) -#else - #include - #define JSON_THROW(exception) std::abort() - #define JSON_TRY if(true) - #define JSON_CATCH(exception) if(false) - #define JSON_INTERNAL_CATCH(exception) if(false) -#endif - -// override exception macros -#if defined(JSON_THROW_USER) - #undef JSON_THROW - #define JSON_THROW JSON_THROW_USER -#endif -#if defined(JSON_TRY_USER) - #undef JSON_TRY - #define JSON_TRY JSON_TRY_USER -#endif -#if defined(JSON_CATCH_USER) - #undef JSON_CATCH - #define JSON_CATCH JSON_CATCH_USER - #undef JSON_INTERNAL_CATCH - #define JSON_INTERNAL_CATCH JSON_CATCH_USER -#endif -#if defined(JSON_INTERNAL_CATCH_USER) - #undef JSON_INTERNAL_CATCH - #define JSON_INTERNAL_CATCH JSON_INTERNAL_CATCH_USER -#endif - -// allow overriding assert -#if !defined(JSON_ASSERT) - #include // assert - #define JSON_ASSERT(x) assert(x) -#endif - -// allow to access some private functions (needed by the test suite) -#if defined(JSON_TESTS_PRIVATE) - #define JSON_PRIVATE_UNLESS_TESTED public -#else - #define JSON_PRIVATE_UNLESS_TESTED private -#endif - -/*! -@brief macro to briefly define a mapping between an enum and JSON -@def NLOHMANN_JSON_SERIALIZE_ENUM -@since version 3.4.0 -*/ -#define NLOHMANN_JSON_SERIALIZE_ENUM(ENUM_TYPE, ...) \ - template \ - inline void to_json(BasicJsonType& j, const ENUM_TYPE& e) \ - { \ - static_assert(std::is_enum::value, #ENUM_TYPE " must be an enum!"); \ - static const std::pair m[] = __VA_ARGS__; \ - auto it = std::find_if(std::begin(m), std::end(m), \ - [e](const std::pair& ej_pair) -> bool \ - { \ - return ej_pair.first == e; \ - }); \ - j = ((it != std::end(m)) ? it : std::begin(m))->second; \ - } \ - template \ - inline void from_json(const BasicJsonType& j, ENUM_TYPE& e) \ - { \ - static_assert(std::is_enum::value, #ENUM_TYPE " must be an enum!"); \ - static const std::pair m[] = __VA_ARGS__; \ - auto it = std::find_if(std::begin(m), std::end(m), \ - [&j](const std::pair& ej_pair) -> bool \ - { \ - return ej_pair.second == j; \ - }); \ - e = ((it != std::end(m)) ? it : std::begin(m))->first; \ - } - -// Ugly macros to avoid uglier copy-paste when specializing basic_json. They -// may be removed in the future once the class is split. - -#define NLOHMANN_BASIC_JSON_TPL_DECLARATION \ - template class ObjectType, \ - template class ArrayType, \ - class StringType, class BooleanType, class NumberIntegerType, \ - class NumberUnsignedType, class NumberFloatType, \ - template class AllocatorType, \ - template class JSONSerializer, \ - class BinaryType, \ - class CustomBaseClass> - -#define NLOHMANN_BASIC_JSON_TPL \ - basic_json - -// Macros to simplify conversion from/to types - -#define NLOHMANN_JSON_EXPAND( x ) x -#define NLOHMANN_JSON_GET_MACRO(_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, _39, _40, _41, _42, _43, _44, _45, _46, _47, _48, _49, _50, _51, _52, _53, _54, _55, _56, _57, _58, _59, _60, _61, _62, _63, _64, NAME,...) NAME -#define NLOHMANN_JSON_PASTE(...) NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_GET_MACRO(__VA_ARGS__, \ - NLOHMANN_JSON_PASTE64, \ - NLOHMANN_JSON_PASTE63, \ - NLOHMANN_JSON_PASTE62, \ - NLOHMANN_JSON_PASTE61, \ - NLOHMANN_JSON_PASTE60, \ - NLOHMANN_JSON_PASTE59, \ - NLOHMANN_JSON_PASTE58, \ - NLOHMANN_JSON_PASTE57, \ - NLOHMANN_JSON_PASTE56, \ - NLOHMANN_JSON_PASTE55, \ - NLOHMANN_JSON_PASTE54, \ - NLOHMANN_JSON_PASTE53, \ - NLOHMANN_JSON_PASTE52, \ - NLOHMANN_JSON_PASTE51, \ - NLOHMANN_JSON_PASTE50, \ - NLOHMANN_JSON_PASTE49, \ - NLOHMANN_JSON_PASTE48, \ - NLOHMANN_JSON_PASTE47, \ - NLOHMANN_JSON_PASTE46, \ - NLOHMANN_JSON_PASTE45, \ - NLOHMANN_JSON_PASTE44, \ - NLOHMANN_JSON_PASTE43, \ - NLOHMANN_JSON_PASTE42, \ - NLOHMANN_JSON_PASTE41, \ - NLOHMANN_JSON_PASTE40, \ - NLOHMANN_JSON_PASTE39, \ - NLOHMANN_JSON_PASTE38, \ - NLOHMANN_JSON_PASTE37, \ - NLOHMANN_JSON_PASTE36, \ - NLOHMANN_JSON_PASTE35, \ - NLOHMANN_JSON_PASTE34, \ - NLOHMANN_JSON_PASTE33, \ - NLOHMANN_JSON_PASTE32, \ - NLOHMANN_JSON_PASTE31, \ - NLOHMANN_JSON_PASTE30, \ - NLOHMANN_JSON_PASTE29, \ - NLOHMANN_JSON_PASTE28, \ - NLOHMANN_JSON_PASTE27, \ - NLOHMANN_JSON_PASTE26, \ - NLOHMANN_JSON_PASTE25, \ - NLOHMANN_JSON_PASTE24, \ - NLOHMANN_JSON_PASTE23, \ - NLOHMANN_JSON_PASTE22, \ - NLOHMANN_JSON_PASTE21, \ - NLOHMANN_JSON_PASTE20, \ - NLOHMANN_JSON_PASTE19, \ - NLOHMANN_JSON_PASTE18, \ - NLOHMANN_JSON_PASTE17, \ - NLOHMANN_JSON_PASTE16, \ - NLOHMANN_JSON_PASTE15, \ - NLOHMANN_JSON_PASTE14, \ - NLOHMANN_JSON_PASTE13, \ - NLOHMANN_JSON_PASTE12, \ - NLOHMANN_JSON_PASTE11, \ - NLOHMANN_JSON_PASTE10, \ - NLOHMANN_JSON_PASTE9, \ - NLOHMANN_JSON_PASTE8, \ - NLOHMANN_JSON_PASTE7, \ - NLOHMANN_JSON_PASTE6, \ - NLOHMANN_JSON_PASTE5, \ - NLOHMANN_JSON_PASTE4, \ - NLOHMANN_JSON_PASTE3, \ - NLOHMANN_JSON_PASTE2, \ - NLOHMANN_JSON_PASTE1)(__VA_ARGS__)) -#define NLOHMANN_JSON_PASTE2(func, v1) func(v1) -#define NLOHMANN_JSON_PASTE3(func, v1, v2) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE2(func, v2) -#define NLOHMANN_JSON_PASTE4(func, v1, v2, v3) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE3(func, v2, v3) -#define NLOHMANN_JSON_PASTE5(func, v1, v2, v3, v4) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE4(func, v2, v3, v4) -#define NLOHMANN_JSON_PASTE6(func, v1, v2, v3, v4, v5) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE5(func, v2, v3, v4, v5) -#define NLOHMANN_JSON_PASTE7(func, v1, v2, v3, v4, v5, v6) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE6(func, v2, v3, v4, v5, v6) -#define NLOHMANN_JSON_PASTE8(func, v1, v2, v3, v4, v5, v6, v7) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE7(func, v2, v3, v4, v5, v6, v7) -#define NLOHMANN_JSON_PASTE9(func, v1, v2, v3, v4, v5, v6, v7, v8) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE8(func, v2, v3, v4, v5, v6, v7, v8) -#define NLOHMANN_JSON_PASTE10(func, v1, v2, v3, v4, v5, v6, v7, v8, v9) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE9(func, v2, v3, v4, v5, v6, v7, v8, v9) -#define NLOHMANN_JSON_PASTE11(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE10(func, v2, v3, v4, v5, v6, v7, v8, v9, v10) -#define NLOHMANN_JSON_PASTE12(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE11(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11) -#define NLOHMANN_JSON_PASTE13(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE12(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12) -#define NLOHMANN_JSON_PASTE14(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE13(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13) -#define NLOHMANN_JSON_PASTE15(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE14(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14) -#define NLOHMANN_JSON_PASTE16(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE15(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15) -#define NLOHMANN_JSON_PASTE17(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE16(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16) -#define NLOHMANN_JSON_PASTE18(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE17(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17) -#define NLOHMANN_JSON_PASTE19(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE18(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18) -#define NLOHMANN_JSON_PASTE20(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE19(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19) -#define NLOHMANN_JSON_PASTE21(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE20(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20) -#define NLOHMANN_JSON_PASTE22(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE21(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21) -#define NLOHMANN_JSON_PASTE23(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE22(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22) -#define NLOHMANN_JSON_PASTE24(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE23(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23) -#define NLOHMANN_JSON_PASTE25(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE24(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24) -#define NLOHMANN_JSON_PASTE26(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE25(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25) -#define NLOHMANN_JSON_PASTE27(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE26(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26) -#define NLOHMANN_JSON_PASTE28(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE27(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27) -#define NLOHMANN_JSON_PASTE29(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE28(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28) -#define NLOHMANN_JSON_PASTE30(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE29(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29) -#define NLOHMANN_JSON_PASTE31(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE30(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30) -#define NLOHMANN_JSON_PASTE32(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE31(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31) -#define NLOHMANN_JSON_PASTE33(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE32(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32) -#define NLOHMANN_JSON_PASTE34(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE33(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33) -#define NLOHMANN_JSON_PASTE35(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE34(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34) -#define NLOHMANN_JSON_PASTE36(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE35(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35) -#define NLOHMANN_JSON_PASTE37(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE36(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36) -#define NLOHMANN_JSON_PASTE38(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE37(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37) -#define NLOHMANN_JSON_PASTE39(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE38(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38) -#define NLOHMANN_JSON_PASTE40(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE39(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39) -#define NLOHMANN_JSON_PASTE41(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE40(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40) -#define NLOHMANN_JSON_PASTE42(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE41(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41) -#define NLOHMANN_JSON_PASTE43(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE42(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42) -#define NLOHMANN_JSON_PASTE44(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE43(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43) -#define NLOHMANN_JSON_PASTE45(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE44(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44) -#define NLOHMANN_JSON_PASTE46(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE45(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45) -#define NLOHMANN_JSON_PASTE47(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE46(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46) -#define NLOHMANN_JSON_PASTE48(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE47(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47) -#define NLOHMANN_JSON_PASTE49(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE48(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48) -#define NLOHMANN_JSON_PASTE50(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE49(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49) -#define NLOHMANN_JSON_PASTE51(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE50(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50) -#define NLOHMANN_JSON_PASTE52(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE51(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51) -#define NLOHMANN_JSON_PASTE53(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE52(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52) -#define NLOHMANN_JSON_PASTE54(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE53(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53) -#define NLOHMANN_JSON_PASTE55(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE54(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54) -#define NLOHMANN_JSON_PASTE56(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE55(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55) -#define NLOHMANN_JSON_PASTE57(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE56(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56) -#define NLOHMANN_JSON_PASTE58(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56, v57) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE57(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56, v57) -#define NLOHMANN_JSON_PASTE59(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56, v57, v58) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE58(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56, v57, v58) -#define NLOHMANN_JSON_PASTE60(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56, v57, v58, v59) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE59(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56, v57, v58, v59) -#define NLOHMANN_JSON_PASTE61(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56, v57, v58, v59, v60) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE60(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56, v57, v58, v59, v60) -#define NLOHMANN_JSON_PASTE62(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56, v57, v58, v59, v60, v61) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE61(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56, v57, v58, v59, v60, v61) -#define NLOHMANN_JSON_PASTE63(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56, v57, v58, v59, v60, v61, v62) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE62(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56, v57, v58, v59, v60, v61, v62) -#define NLOHMANN_JSON_PASTE64(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56, v57, v58, v59, v60, v61, v62, v63) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE63(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56, v57, v58, v59, v60, v61, v62, v63) - -#define NLOHMANN_JSON_TO(v1) nlohmann_json_j[#v1] = nlohmann_json_t.v1; -#define NLOHMANN_JSON_FROM(v1) nlohmann_json_j.at(#v1).get_to(nlohmann_json_t.v1); -#define NLOHMANN_JSON_FROM_WITH_DEFAULT(v1) nlohmann_json_t.v1 = nlohmann_json_j.value(#v1, nlohmann_json_default_obj.v1); - -/*! -@brief macro -@def NLOHMANN_DEFINE_TYPE_INTRUSIVE -@since version 3.9.0 -*/ -#define NLOHMANN_DEFINE_TYPE_INTRUSIVE(Type, ...) \ - friend void to_json(nlohmann::json& nlohmann_json_j, const Type& nlohmann_json_t) { NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_TO, __VA_ARGS__)) } \ - friend void from_json(const nlohmann::json& nlohmann_json_j, Type& nlohmann_json_t) { NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_FROM, __VA_ARGS__)) } - -#define NLOHMANN_DEFINE_TYPE_INTRUSIVE_WITH_DEFAULT(Type, ...) \ - friend void to_json(nlohmann::json& nlohmann_json_j, const Type& nlohmann_json_t) { NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_TO, __VA_ARGS__)) } \ - friend void from_json(const nlohmann::json& nlohmann_json_j, Type& nlohmann_json_t) { const Type nlohmann_json_default_obj{}; NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_FROM_WITH_DEFAULT, __VA_ARGS__)) } - -#define NLOHMANN_DEFINE_TYPE_INTRUSIVE_ONLY_SERIALIZE(Type, ...) \ - friend void to_json(nlohmann::json& nlohmann_json_j, const Type& nlohmann_json_t) { NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_TO, __VA_ARGS__)) } - -/*! -@brief macro -@def NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE -@since version 3.9.0 -*/ -#define NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE(Type, ...) \ - inline void to_json(nlohmann::json& nlohmann_json_j, const Type& nlohmann_json_t) { NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_TO, __VA_ARGS__)) } \ - inline void from_json(const nlohmann::json& nlohmann_json_j, Type& nlohmann_json_t) { NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_FROM, __VA_ARGS__)) } - -#define NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE_ONLY_SERIALIZE(Type, ...) \ - inline void to_json(nlohmann::json& nlohmann_json_j, const Type& nlohmann_json_t) { NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_TO, __VA_ARGS__)) } - -#define NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE_WITH_DEFAULT(Type, ...) \ - inline void to_json(nlohmann::json& nlohmann_json_j, const Type& nlohmann_json_t) { NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_TO, __VA_ARGS__)) } \ - inline void from_json(const nlohmann::json& nlohmann_json_j, Type& nlohmann_json_t) { const Type nlohmann_json_default_obj{}; NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_FROM_WITH_DEFAULT, __VA_ARGS__)) } - -// inspired from https://stackoverflow.com/a/26745591 -// allows to call any std function as if (e.g. with begin): -// using std::begin; begin(x); -// -// it allows using the detected idiom to retrieve the return type -// of such an expression -#define NLOHMANN_CAN_CALL_STD_FUNC_IMPL(std_name) \ - namespace detail { \ - using std::std_name; \ - \ - template \ - using result_of_##std_name = decltype(std_name(std::declval()...)); \ - } \ - \ - namespace detail2 { \ - struct std_name##_tag \ - { \ - }; \ - \ - template \ - std_name##_tag std_name(T&&...); \ - \ - template \ - using result_of_##std_name = decltype(std_name(std::declval()...)); \ - \ - template \ - struct would_call_std_##std_name \ - { \ - static constexpr auto const value = ::nlohmann::detail:: \ - is_detected_exact::value; \ - }; \ - } /* namespace detail2 */ \ - \ - template \ - struct would_call_std_##std_name : detail2::would_call_std_##std_name \ - { \ - } - -#ifndef JSON_USE_IMPLICIT_CONVERSIONS - #define JSON_USE_IMPLICIT_CONVERSIONS 1 -#endif - -#if JSON_USE_IMPLICIT_CONVERSIONS - #define JSON_EXPLICIT -#else - #define JSON_EXPLICIT explicit -#endif - -#ifndef JSON_DISABLE_ENUM_SERIALIZATION - #define JSON_DISABLE_ENUM_SERIALIZATION 0 -#endif - -#ifndef JSON_USE_GLOBAL_UDLS - #define JSON_USE_GLOBAL_UDLS 1 -#endif - -#if JSON_HAS_THREE_WAY_COMPARISON - #include // partial_ordering -#endif - -NLOHMANN_JSON_NAMESPACE_BEGIN -namespace detail -{ - -/////////////////////////// -// JSON type enumeration // -/////////////////////////// - -/*! -@brief the JSON type enumeration - -This enumeration collects the different JSON types. It is internally used to -distinguish the stored values, and the functions @ref basic_json::is_null(), -@ref basic_json::is_object(), @ref basic_json::is_array(), -@ref basic_json::is_string(), @ref basic_json::is_boolean(), -@ref basic_json::is_number() (with @ref basic_json::is_number_integer(), -@ref basic_json::is_number_unsigned(), and @ref basic_json::is_number_float()), -@ref basic_json::is_discarded(), @ref basic_json::is_primitive(), and -@ref basic_json::is_structured() rely on it. - -@note There are three enumeration entries (number_integer, number_unsigned, and -number_float), because the library distinguishes these three types for numbers: -@ref basic_json::number_unsigned_t is used for unsigned integers, -@ref basic_json::number_integer_t is used for signed integers, and -@ref basic_json::number_float_t is used for floating-point numbers or to -approximate integers which do not fit in the limits of their respective type. - -@sa see @ref basic_json::basic_json(const value_t value_type) -- create a JSON -value with the default value for a given type - -@since version 1.0.0 -*/ -enum class value_t : std::uint8_t -{ - null, ///< null value - object, ///< object (unordered set of name/value pairs) - array, ///< array (ordered collection of values) - string, ///< string value - boolean, ///< boolean value - number_integer, ///< number value (signed integer) - number_unsigned, ///< number value (unsigned integer) - number_float, ///< number value (floating-point) - binary, ///< binary array (ordered collection of bytes) - discarded ///< discarded by the parser callback function -}; - -/*! -@brief comparison operator for JSON types - -Returns an ordering that is similar to Python: -- order: null < boolean < number < object < array < string < binary -- furthermore, each type is not smaller than itself -- discarded values are not comparable -- binary is represented as a b"" string in python and directly comparable to a - string; however, making a binary array directly comparable with a string would - be surprising behavior in a JSON file. - -@since version 1.0.0 -*/ -#if JSON_HAS_THREE_WAY_COMPARISON - inline std::partial_ordering operator<=>(const value_t lhs, const value_t rhs) noexcept // *NOPAD* -#else - inline bool operator<(const value_t lhs, const value_t rhs) noexcept -#endif -{ - static constexpr std::array order = {{ - 0 /* null */, 3 /* object */, 4 /* array */, 5 /* string */, - 1 /* boolean */, 2 /* integer */, 2 /* unsigned */, 2 /* float */, - 6 /* binary */ - } - }; - - const auto l_index = static_cast(lhs); - const auto r_index = static_cast(rhs); -#if JSON_HAS_THREE_WAY_COMPARISON - if (l_index < order.size() && r_index < order.size()) - { - return order[l_index] <=> order[r_index]; // *NOPAD* - } - return std::partial_ordering::unordered; -#else - return l_index < order.size() && r_index < order.size() && order[l_index] < order[r_index]; -#endif -} - -// GCC selects the built-in operator< over an operator rewritten from -// a user-defined spaceship operator -// Clang, MSVC, and ICC select the rewritten candidate -// (see GCC bug https://gcc.gnu.org/bugzilla/show_bug.cgi?id=105200) -#if JSON_HAS_THREE_WAY_COMPARISON && defined(__GNUC__) -inline bool operator<(const value_t lhs, const value_t rhs) noexcept -{ - return std::is_lt(lhs <=> rhs); // *NOPAD* -} -#endif - -} // namespace detail -NLOHMANN_JSON_NAMESPACE_END - -// #include -// __ _____ _____ _____ -// __| | __| | | | JSON for Modern C++ -// | | |__ | | | | | | version 3.11.3 -// |_____|_____|_____|_|___| https://github.com/nlohmann/json -// -// SPDX-FileCopyrightText: 2013-2023 Niels Lohmann -// SPDX-License-Identifier: MIT - - - -// #include - - -NLOHMANN_JSON_NAMESPACE_BEGIN -namespace detail -{ - -/*! -@brief replace all occurrences of a substring by another string - -@param[in,out] s the string to manipulate; changed so that all - occurrences of @a f are replaced with @a t -@param[in] f the substring to replace with @a t -@param[in] t the string to replace @a f - -@pre The search string @a f must not be empty. **This precondition is -enforced with an assertion.** - -@since version 2.0.0 -*/ -template -inline void replace_substring(StringType& s, const StringType& f, - const StringType& t) -{ - JSON_ASSERT(!f.empty()); - for (auto pos = s.find(f); // find first occurrence of f - pos != StringType::npos; // make sure f was found - s.replace(pos, f.size(), t), // replace with t, and - pos = s.find(f, pos + t.size())) // find next occurrence of f - {} -} - -/*! - * @brief string escaping as described in RFC 6901 (Sect. 4) - * @param[in] s string to escape - * @return escaped string - * - * Note the order of escaping "~" to "~0" and "/" to "~1" is important. - */ -template -inline StringType escape(StringType s) -{ - replace_substring(s, StringType{"~"}, StringType{"~0"}); - replace_substring(s, StringType{"/"}, StringType{"~1"}); - return s; -} - -/*! - * @brief string unescaping as described in RFC 6901 (Sect. 4) - * @param[in] s string to unescape - * @return unescaped string - * - * Note the order of escaping "~1" to "/" and "~0" to "~" is important. - */ -template -static void unescape(StringType& s) -{ - replace_substring(s, StringType{"~1"}, StringType{"/"}); - replace_substring(s, StringType{"~0"}, StringType{"~"}); -} - -} // namespace detail -NLOHMANN_JSON_NAMESPACE_END - -// #include -// __ _____ _____ _____ -// __| | __| | | | JSON for Modern C++ -// | | |__ | | | | | | version 3.11.3 -// |_____|_____|_____|_|___| https://github.com/nlohmann/json -// -// SPDX-FileCopyrightText: 2013-2023 Niels Lohmann -// SPDX-License-Identifier: MIT - - - -#include // size_t - -// #include - - -NLOHMANN_JSON_NAMESPACE_BEGIN -namespace detail -{ - -/// struct to capture the start position of the current token -struct position_t -{ - /// the total number of characters read - std::size_t chars_read_total = 0; - /// the number of characters read in the current line - std::size_t chars_read_current_line = 0; - /// the number of lines read - std::size_t lines_read = 0; - - /// conversion to size_t to preserve SAX interface - constexpr operator size_t() const - { - return chars_read_total; - } -}; - -} // namespace detail -NLOHMANN_JSON_NAMESPACE_END - -// #include - -// #include -// __ _____ _____ _____ -// __| | __| | | | JSON for Modern C++ -// | | |__ | | | | | | version 3.11.3 -// |_____|_____|_____|_|___| https://github.com/nlohmann/json -// -// SPDX-FileCopyrightText: 2013-2023 Niels Lohmann -// SPDX-FileCopyrightText: 2018 The Abseil Authors -// SPDX-License-Identifier: MIT - - - -#include // array -#include // size_t -#include // conditional, enable_if, false_type, integral_constant, is_constructible, is_integral, is_same, remove_cv, remove_reference, true_type -#include // index_sequence, make_index_sequence, index_sequence_for - -// #include - - -NLOHMANN_JSON_NAMESPACE_BEGIN -namespace detail -{ - -template -using uncvref_t = typename std::remove_cv::type>::type; - -#ifdef JSON_HAS_CPP_14 - -// the following utilities are natively available in C++14 -using std::enable_if_t; -using std::index_sequence; -using std::make_index_sequence; -using std::index_sequence_for; - -#else - -// alias templates to reduce boilerplate -template -using enable_if_t = typename std::enable_if::type; - -// The following code is taken from https://github.com/abseil/abseil-cpp/blob/10cb35e459f5ecca5b2ff107635da0bfa41011b4/absl/utility/utility.h -// which is part of Google Abseil (https://github.com/abseil/abseil-cpp), licensed under the Apache License 2.0. - -//// START OF CODE FROM GOOGLE ABSEIL - -// integer_sequence -// -// Class template representing a compile-time integer sequence. An instantiation -// of `integer_sequence` has a sequence of integers encoded in its -// type through its template arguments (which is a common need when -// working with C++11 variadic templates). `absl::integer_sequence` is designed -// to be a drop-in replacement for C++14's `std::integer_sequence`. -// -// Example: -// -// template< class T, T... Ints > -// void user_function(integer_sequence); -// -// int main() -// { -// // user_function's `T` will be deduced to `int` and `Ints...` -// // will be deduced to `0, 1, 2, 3, 4`. -// user_function(make_integer_sequence()); -// } -template -struct integer_sequence -{ - using value_type = T; - static constexpr std::size_t size() noexcept - { - return sizeof...(Ints); - } -}; - -// index_sequence -// -// A helper template for an `integer_sequence` of `size_t`, -// `absl::index_sequence` is designed to be a drop-in replacement for C++14's -// `std::index_sequence`. -template -using index_sequence = integer_sequence; - -namespace utility_internal -{ - -template -struct Extend; - -// Note that SeqSize == sizeof...(Ints). It's passed explicitly for efficiency. -template -struct Extend, SeqSize, 0> -{ - using type = integer_sequence < T, Ints..., (Ints + SeqSize)... >; -}; - -template -struct Extend, SeqSize, 1> -{ - using type = integer_sequence < T, Ints..., (Ints + SeqSize)..., 2 * SeqSize >; -}; - -// Recursion helper for 'make_integer_sequence'. -// 'Gen::type' is an alias for 'integer_sequence'. -template -struct Gen -{ - using type = - typename Extend < typename Gen < T, N / 2 >::type, N / 2, N % 2 >::type; -}; - -template -struct Gen -{ - using type = integer_sequence; -}; - -} // namespace utility_internal - -// Compile-time sequences of integers - -// make_integer_sequence -// -// This template alias is equivalent to -// `integer_sequence`, and is designed to be a drop-in -// replacement for C++14's `std::make_integer_sequence`. -template -using make_integer_sequence = typename utility_internal::Gen::type; - -// make_index_sequence -// -// This template alias is equivalent to `index_sequence<0, 1, ..., N-1>`, -// and is designed to be a drop-in replacement for C++14's -// `std::make_index_sequence`. -template -using make_index_sequence = make_integer_sequence; - -// index_sequence_for -// -// Converts a typename pack into an index sequence of the same length, and -// is designed to be a drop-in replacement for C++14's -// `std::index_sequence_for()` -template -using index_sequence_for = make_index_sequence; - -//// END OF CODE FROM GOOGLE ABSEIL - -#endif - -// dispatch utility (taken from ranges-v3) -template struct priority_tag : priority_tag < N - 1 > {}; -template<> struct priority_tag<0> {}; - -// taken from ranges-v3 -template -struct static_const -{ - static JSON_INLINE_VARIABLE constexpr T value{}; -}; - -#ifndef JSON_HAS_CPP_17 - template - constexpr T static_const::value; -#endif - -template -inline constexpr std::array make_array(Args&& ... args) -{ - return std::array {{static_cast(std::forward(args))...}}; -} - -} // namespace detail -NLOHMANN_JSON_NAMESPACE_END - -// #include -// __ _____ _____ _____ -// __| | __| | | | JSON for Modern C++ -// | | |__ | | | | | | version 3.11.3 -// |_____|_____|_____|_|___| https://github.com/nlohmann/json -// -// SPDX-FileCopyrightText: 2013-2023 Niels Lohmann -// SPDX-License-Identifier: MIT - - - -#include // numeric_limits -#include // false_type, is_constructible, is_integral, is_same, true_type -#include // declval -#include // tuple -#include // char_traits - -// #include -// __ _____ _____ _____ -// __| | __| | | | JSON for Modern C++ -// | | |__ | | | | | | version 3.11.3 -// |_____|_____|_____|_|___| https://github.com/nlohmann/json -// -// SPDX-FileCopyrightText: 2013-2023 Niels Lohmann -// SPDX-License-Identifier: MIT - - - -#include // random_access_iterator_tag - -// #include - -// #include - -// #include - - -NLOHMANN_JSON_NAMESPACE_BEGIN -namespace detail -{ - -template -struct iterator_types {}; - -template -struct iterator_types < - It, - void_t> -{ - using difference_type = typename It::difference_type; - using value_type = typename It::value_type; - using pointer = typename It::pointer; - using reference = typename It::reference; - using iterator_category = typename It::iterator_category; -}; - -// This is required as some compilers implement std::iterator_traits in a way that -// doesn't work with SFINAE. See https://github.com/nlohmann/json/issues/1341. -template -struct iterator_traits -{ -}; - -template -struct iterator_traits < T, enable_if_t < !std::is_pointer::value >> - : iterator_types -{ -}; - -template -struct iterator_traits::value>> -{ - using iterator_category = std::random_access_iterator_tag; - using value_type = T; - using difference_type = ptrdiff_t; - using pointer = T*; - using reference = T&; -}; - -} // namespace detail -NLOHMANN_JSON_NAMESPACE_END - -// #include - -// #include -// __ _____ _____ _____ -// __| | __| | | | JSON for Modern C++ -// | | |__ | | | | | | version 3.11.3 -// |_____|_____|_____|_|___| https://github.com/nlohmann/json -// -// SPDX-FileCopyrightText: 2013-2023 Niels Lohmann -// SPDX-License-Identifier: MIT - - - -// #include - - -NLOHMANN_JSON_NAMESPACE_BEGIN - -NLOHMANN_CAN_CALL_STD_FUNC_IMPL(begin); - -NLOHMANN_JSON_NAMESPACE_END - -// #include -// __ _____ _____ _____ -// __| | __| | | | JSON for Modern C++ -// | | |__ | | | | | | version 3.11.3 -// |_____|_____|_____|_|___| https://github.com/nlohmann/json -// -// SPDX-FileCopyrightText: 2013-2023 Niels Lohmann -// SPDX-License-Identifier: MIT - - - -// #include - - -NLOHMANN_JSON_NAMESPACE_BEGIN - -NLOHMANN_CAN_CALL_STD_FUNC_IMPL(end); - -NLOHMANN_JSON_NAMESPACE_END - -// #include - -// #include - -// #include -// __ _____ _____ _____ -// __| | __| | | | JSON for Modern C++ -// | | |__ | | | | | | version 3.11.3 -// |_____|_____|_____|_|___| https://github.com/nlohmann/json -// -// SPDX-FileCopyrightText: 2013-2023 Niels Lohmann -// SPDX-License-Identifier: MIT - -#ifndef INCLUDE_NLOHMANN_JSON_FWD_HPP_ - #define INCLUDE_NLOHMANN_JSON_FWD_HPP_ - - #include // int64_t, uint64_t - #include // map - #include // allocator - #include // string - #include // vector - - // #include - - - /*! - @brief namespace for Niels Lohmann - @see https://github.com/nlohmann - @since version 1.0.0 - */ - NLOHMANN_JSON_NAMESPACE_BEGIN - - /*! - @brief default JSONSerializer template argument - - This serializer ignores the template arguments and uses ADL - ([argument-dependent lookup](https://en.cppreference.com/w/cpp/language/adl)) - for serialization. - */ - template - struct adl_serializer; - - /// a class to store JSON values - /// @sa https://json.nlohmann.me/api/basic_json/ - template class ObjectType = - std::map, - template class ArrayType = std::vector, - class StringType = std::string, class BooleanType = bool, - class NumberIntegerType = std::int64_t, - class NumberUnsignedType = std::uint64_t, - class NumberFloatType = double, - template class AllocatorType = std::allocator, - template class JSONSerializer = - adl_serializer, - class BinaryType = std::vector, // cppcheck-suppress syntaxError - class CustomBaseClass = void> - class basic_json; - - /// @brief JSON Pointer defines a string syntax for identifying a specific value within a JSON document - /// @sa https://json.nlohmann.me/api/json_pointer/ - template - class json_pointer; - - /*! - @brief default specialization - @sa https://json.nlohmann.me/api/json/ - */ - using json = basic_json<>; - - /// @brief a minimal map-like container that preserves insertion order - /// @sa https://json.nlohmann.me/api/ordered_map/ - template - struct ordered_map; - - /// @brief specialization that maintains the insertion order of object keys - /// @sa https://json.nlohmann.me/api/ordered_json/ - using ordered_json = basic_json; - - NLOHMANN_JSON_NAMESPACE_END - -#endif // INCLUDE_NLOHMANN_JSON_FWD_HPP_ - - -NLOHMANN_JSON_NAMESPACE_BEGIN -/*! -@brief detail namespace with internal helper functions - -This namespace collects functions that should not be exposed, -implementations of some @ref basic_json methods, and meta-programming helpers. - -@since version 2.1.0 -*/ -namespace detail -{ - -///////////// -// helpers // -///////////// - -// Note to maintainers: -// -// Every trait in this file expects a non CV-qualified type. -// The only exceptions are in the 'aliases for detected' section -// (i.e. those of the form: decltype(T::member_function(std::declval()))) -// -// In this case, T has to be properly CV-qualified to constraint the function arguments -// (e.g. to_json(BasicJsonType&, const T&)) - -template struct is_basic_json : std::false_type {}; - -NLOHMANN_BASIC_JSON_TPL_DECLARATION -struct is_basic_json : std::true_type {}; - -// used by exceptions create() member functions -// true_type for pointer to possibly cv-qualified basic_json or std::nullptr_t -// false_type otherwise -template -struct is_basic_json_context : - std::integral_constant < bool, - is_basic_json::type>::type>::value - || std::is_same::value > -{}; - -////////////////////// -// json_ref helpers // -////////////////////// - -template -class json_ref; - -template -struct is_json_ref : std::false_type {}; - -template -struct is_json_ref> : std::true_type {}; - -////////////////////////// -// aliases for detected // -////////////////////////// - -template -using mapped_type_t = typename T::mapped_type; - -template -using key_type_t = typename T::key_type; - -template -using value_type_t = typename T::value_type; - -template -using difference_type_t = typename T::difference_type; - -template -using pointer_t = typename T::pointer; - -template -using reference_t = typename T::reference; - -template -using iterator_category_t = typename T::iterator_category; - -template -using to_json_function = decltype(T::to_json(std::declval()...)); - -template -using from_json_function = decltype(T::from_json(std::declval()...)); - -template -using get_template_function = decltype(std::declval().template get()); - -// trait checking if JSONSerializer::from_json(json const&, udt&) exists -template -struct has_from_json : std::false_type {}; - -// trait checking if j.get is valid -// use this trait instead of std::is_constructible or std::is_convertible, -// both rely on, or make use of implicit conversions, and thus fail when T -// has several constructors/operator= (see https://github.com/nlohmann/json/issues/958) -template -struct is_getable -{ - static constexpr bool value = is_detected::value; -}; - -template -struct has_from_json < BasicJsonType, T, enable_if_t < !is_basic_json::value >> -{ - using serializer = typename BasicJsonType::template json_serializer; - - static constexpr bool value = - is_detected_exact::value; -}; - -// This trait checks if JSONSerializer::from_json(json const&) exists -// this overload is used for non-default-constructible user-defined-types -template -struct has_non_default_from_json : std::false_type {}; - -template -struct has_non_default_from_json < BasicJsonType, T, enable_if_t < !is_basic_json::value >> -{ - using serializer = typename BasicJsonType::template json_serializer; - - static constexpr bool value = - is_detected_exact::value; -}; - -// This trait checks if BasicJsonType::json_serializer::to_json exists -// Do not evaluate the trait when T is a basic_json type, to avoid template instantiation infinite recursion. -template -struct has_to_json : std::false_type {}; - -template -struct has_to_json < BasicJsonType, T, enable_if_t < !is_basic_json::value >> -{ - using serializer = typename BasicJsonType::template json_serializer; - - static constexpr bool value = - is_detected_exact::value; -}; - -template -using detect_key_compare = typename T::key_compare; - -template -struct has_key_compare : std::integral_constant::value> {}; - -// obtains the actual object key comparator -template -struct actual_object_comparator -{ - using object_t = typename BasicJsonType::object_t; - using object_comparator_t = typename BasicJsonType::default_object_comparator_t; - using type = typename std::conditional < has_key_compare::value, - typename object_t::key_compare, object_comparator_t>::type; -}; - -template -using actual_object_comparator_t = typename actual_object_comparator::type; - -///////////////// -// char_traits // -///////////////// - -// Primary template of char_traits calls std char_traits -template -struct char_traits : std::char_traits -{}; - -// Explicitly define char traits for unsigned char since it is not standard -template<> -struct char_traits : std::char_traits -{ - using char_type = unsigned char; - using int_type = uint64_t; - - // Redefine to_int_type function - static int_type to_int_type(char_type c) noexcept - { - return static_cast(c); - } - - static char_type to_char_type(int_type i) noexcept - { - return static_cast(i); - } - - static constexpr int_type eof() noexcept - { - return static_cast(EOF); - } -}; - -// Explicitly define char traits for signed char since it is not standard -template<> -struct char_traits : std::char_traits -{ - using char_type = signed char; - using int_type = uint64_t; - - // Redefine to_int_type function - static int_type to_int_type(char_type c) noexcept - { - return static_cast(c); - } - - static char_type to_char_type(int_type i) noexcept - { - return static_cast(i); - } - - static constexpr int_type eof() noexcept - { - return static_cast(EOF); - } -}; - -/////////////////// -// is_ functions // -/////////////////// - -// https://en.cppreference.com/w/cpp/types/conjunction -template struct conjunction : std::true_type { }; -template struct conjunction : B { }; -template -struct conjunction -: std::conditional(B::value), conjunction, B>::type {}; - -// https://en.cppreference.com/w/cpp/types/negation -template struct negation : std::integral_constant < bool, !B::value > { }; - -// Reimplementation of is_constructible and is_default_constructible, due to them being broken for -// std::pair and std::tuple until LWG 2367 fix (see https://cplusplus.github.io/LWG/lwg-defects.html#2367). -// This causes compile errors in e.g. clang 3.5 or gcc 4.9. -template -struct is_default_constructible : std::is_default_constructible {}; - -template -struct is_default_constructible> - : conjunction, is_default_constructible> {}; - -template -struct is_default_constructible> - : conjunction, is_default_constructible> {}; - -template -struct is_default_constructible> - : conjunction...> {}; - -template -struct is_default_constructible> - : conjunction...> {}; - -template -struct is_constructible : std::is_constructible {}; - -template -struct is_constructible> : is_default_constructible> {}; - -template -struct is_constructible> : is_default_constructible> {}; - -template -struct is_constructible> : is_default_constructible> {}; - -template -struct is_constructible> : is_default_constructible> {}; - -template -struct is_iterator_traits : std::false_type {}; - -template -struct is_iterator_traits> -{ - private: - using traits = iterator_traits; - - public: - static constexpr auto value = - is_detected::value && - is_detected::value && - is_detected::value && - is_detected::value && - is_detected::value; -}; - -template -struct is_range -{ - private: - using t_ref = typename std::add_lvalue_reference::type; - - using iterator = detected_t; - using sentinel = detected_t; - - // to be 100% correct, it should use https://en.cppreference.com/w/cpp/iterator/input_or_output_iterator - // and https://en.cppreference.com/w/cpp/iterator/sentinel_for - // but reimplementing these would be too much work, as a lot of other concepts are used underneath - static constexpr auto is_iterator_begin = - is_iterator_traits>::value; - - public: - static constexpr bool value = !std::is_same::value && !std::is_same::value && is_iterator_begin; -}; - -template -using iterator_t = enable_if_t::value, result_of_begin())>>; - -template -using range_value_t = value_type_t>>; - -// The following implementation of is_complete_type is taken from -// https://blogs.msdn.microsoft.com/vcblog/2015/12/02/partial-support-for-expression-sfinae-in-vs-2015-update-1/ -// and is written by Xiang Fan who agreed to using it in this library. - -template -struct is_complete_type : std::false_type {}; - -template -struct is_complete_type : std::true_type {}; - -template -struct is_compatible_object_type_impl : std::false_type {}; - -template -struct is_compatible_object_type_impl < - BasicJsonType, CompatibleObjectType, - enable_if_t < is_detected::value&& - is_detected::value >> -{ - using object_t = typename BasicJsonType::object_t; - - // macOS's is_constructible does not play well with nonesuch... - static constexpr bool value = - is_constructible::value && - is_constructible::value; -}; - -template -struct is_compatible_object_type - : is_compatible_object_type_impl {}; - -template -struct is_constructible_object_type_impl : std::false_type {}; - -template -struct is_constructible_object_type_impl < - BasicJsonType, ConstructibleObjectType, - enable_if_t < is_detected::value&& - is_detected::value >> -{ - using object_t = typename BasicJsonType::object_t; - - static constexpr bool value = - (is_default_constructible::value && - (std::is_move_assignable::value || - std::is_copy_assignable::value) && - (is_constructible::value && - std::is_same < - typename object_t::mapped_type, - typename ConstructibleObjectType::mapped_type >::value)) || - (has_from_json::value || - has_non_default_from_json < - BasicJsonType, - typename ConstructibleObjectType::mapped_type >::value); -}; - -template -struct is_constructible_object_type - : is_constructible_object_type_impl {}; - -template -struct is_compatible_string_type -{ - static constexpr auto value = - is_constructible::value; -}; - -template -struct is_constructible_string_type -{ - // launder type through decltype() to fix compilation failure on ICPC -#ifdef __INTEL_COMPILER - using laundered_type = decltype(std::declval()); -#else - using laundered_type = ConstructibleStringType; -#endif - - static constexpr auto value = - conjunction < - is_constructible, - is_detected_exact>::value; -}; - -template -struct is_compatible_array_type_impl : std::false_type {}; - -template -struct is_compatible_array_type_impl < - BasicJsonType, CompatibleArrayType, - enable_if_t < - is_detected::value&& - is_iterator_traits>>::value&& -// special case for types like std::filesystem::path whose iterator's value_type are themselves -// c.f. https://github.com/nlohmann/json/pull/3073 - !std::is_same>::value >> -{ - static constexpr bool value = - is_constructible>::value; -}; - -template -struct is_compatible_array_type - : is_compatible_array_type_impl {}; - -template -struct is_constructible_array_type_impl : std::false_type {}; - -template -struct is_constructible_array_type_impl < - BasicJsonType, ConstructibleArrayType, - enable_if_t::value >> - : std::true_type {}; - -template -struct is_constructible_array_type_impl < - BasicJsonType, ConstructibleArrayType, - enable_if_t < !std::is_same::value&& - !is_compatible_string_type::value&& - is_default_constructible::value&& -(std::is_move_assignable::value || - std::is_copy_assignable::value)&& -is_detected::value&& -is_iterator_traits>>::value&& -is_detected::value&& -// special case for types like std::filesystem::path whose iterator's value_type are themselves -// c.f. https://github.com/nlohmann/json/pull/3073 -!std::is_same>::value&& - is_complete_type < - detected_t>::value >> -{ - using value_type = range_value_t; - - static constexpr bool value = - std::is_same::value || - has_from_json::value || - has_non_default_from_json < - BasicJsonType, - value_type >::value; -}; - -template -struct is_constructible_array_type - : is_constructible_array_type_impl {}; - -template -struct is_compatible_integer_type_impl : std::false_type {}; - -template -struct is_compatible_integer_type_impl < - RealIntegerType, CompatibleNumberIntegerType, - enable_if_t < std::is_integral::value&& - std::is_integral::value&& - !std::is_same::value >> -{ - // is there an assert somewhere on overflows? - using RealLimits = std::numeric_limits; - using CompatibleLimits = std::numeric_limits; - - static constexpr auto value = - is_constructible::value && - CompatibleLimits::is_integer && - RealLimits::is_signed == CompatibleLimits::is_signed; -}; - -template -struct is_compatible_integer_type - : is_compatible_integer_type_impl {}; - -template -struct is_compatible_type_impl: std::false_type {}; - -template -struct is_compatible_type_impl < - BasicJsonType, CompatibleType, - enable_if_t::value >> -{ - static constexpr bool value = - has_to_json::value; -}; - -template -struct is_compatible_type - : is_compatible_type_impl {}; - -template -struct is_constructible_tuple : std::false_type {}; - -template -struct is_constructible_tuple> : conjunction...> {}; - -template -struct is_json_iterator_of : std::false_type {}; - -template -struct is_json_iterator_of : std::true_type {}; - -template -struct is_json_iterator_of : std::true_type -{}; - -// checks if a given type T is a template specialization of Primary -template